开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
waveartist.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：46k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

waveartist.c：源码内容
  1. /*
  2.  * linux/drivers/sound/waveartist.c
  3.  *
  4.  * The low level driver for the RWA010 Rockwell Wave Artist
  5.  * codec chip used in the Rebel.com NetWinder.
  6.  *
  7.  * Cleaned up and integrated into 2.1 by Russell King (rmk@arm.linux.org.uk)
  8.  * and Pat Beirne (patb@corel.ca)
  9.  *
  10.  *
  11.  * Copyright (C) by Rebel.com 1998-1999
  12.  *
  13.  * RWA010 specs received under NDA from Rockwell
  14.  *
  15.  * Copyright (C) by Hannu Savolainen 1993-1997
  16.  *
  17.  * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
  18.  * Version 2 (June 1991). See the "COPYING" file distributed with this software
  19.  * for more info.
  20.  *
  21.  * Changes:
  22.  * 11-10-2000 Bartlomiej Zolnierkiewicz <bkz@linux-ide.org>
  23.  * Added __init to waveartist_init()
  24.  */
  26. /* Debugging */
  27. #define DEBUG_CMD 1
  28. #define DEBUG_OUT 2
  29. #define DEBUG_IN 4
  30. #define DEBUG_INTR 8
  31. #define DEBUG_MIXER 16
  32. #define DEBUG_TRIGGER 32
  34. #define debug_flg (0)
  36. #include <linux/module.h>
  37. #include <linux/init.h>
  38. #include <linux/config.h>
  39. #include <linux/sched.h>
  40. #include <linux/interrupt.h>
  41. #include <linux/delay.h>
  42. #include <linux/spinlock.h>
  43. #include <linux/bitops.h>
  45. #include <asm/system.h>
  47. #include "sound_config.h"
  48. #include "waveartist.h"
  50. #ifdef CONFIG_ARM
  51. #include <asm/hardware.h>
  52. #include <asm/mach-types.h>
  53. #endif
  55. #ifndef NO_DMA
  56. #define NO_DMA 255
  57. #endif
  59. #define SUPPORTED_MIXER_DEVICES (SOUND_MASK_SYNTH      |
  60.  SOUND_MASK_PCM        |
  61.  SOUND_MASK_LINE       |
  62.  SOUND_MASK_MIC        |
  63.  SOUND_MASK_LINE1      |
  64.  SOUND_MASK_RECLEV     |
  65.  SOUND_MASK_VOLUME     |
  66.  SOUND_MASK_IMIX)
  68. static unsigned short levels[SOUND_MIXER_NRDEVICES] = {
  69. 0x5555, /* Master Volume  */
  70. 0x0000, /* Bass  */
  71. 0x0000, /* Treble  */
  72. 0x2323, /* Synth (FM)  */
  73. 0x4b4b, /* PCM  */
  74. 0x6464, /* PC Speaker  */
  75. 0x0000, /* Ext Line  */
  76. 0x0000, /* Mic  */
  77. 0x0000, /* CD  */
  78. 0x6464, /* Recording monitor  */
  79. 0x0000, /* SB PCM (ALT PCM)  */
  80. 0x0000, /* Recording level  */
  81. 0x6464, /* Input gain  */
  82. 0x6464, /* Output gain  */
  83. 0x0000, /* Line1 (Aux1)  */
  84. 0x0000, /* Line2 (Aux2)  */
  85. 0x0000, /* Line3 (Aux3)  */
  86. 0x0000, /* Digital1  */
  87. 0x0000, /* Digital2  */
  88. 0x0000, /* Digital3  */
  89. 0x0000, /* Phone In  */
  90. 0x6464, /* Phone Out  */
  91. 0x0000, /* Video  */
  92. 0x0000, /* Radio  */
  93. 0x0000 /* Monitor  */
  94. };
  96. typedef struct {
  97. struct address_info  hw; /* hardware */
  98. char *chip_name;
  100. int xfer_count;
  101. int audio_mode;
  102. int open_mode;
  103. int audio_flags;
  104. int record_dev;
  105. int playback_dev;
  106. int dev_no;
  108. /* Mixer parameters */
  109. const struct waveartist_mixer_info *mix;
  111. unsigned short *levels;    /* cache of volume settings   */
  112. int recmask;    /* currently enabled recording device! */
  114. #ifdef CONFIG_ARCH_NETWINDER
  115. signed int slider_vol;    /* hardware slider volume     */
  116. unsigned int handset_detect :1;
  117. unsigned int telephone_detect:1;
  118. unsigned int no_autoselect :1;/* handset/telephone autoselects a path */
  119. unsigned int spkr_mute_state :1;/* set by ioctl or autoselect */
  120. unsigned int line_mute_state :1;/* set by ioctl or autoselect */
  121. unsigned int use_slider :1;/* use slider setting for o/p vol */
  122. #endif
  123. } wavnc_info;
  125. /*
  126.  * This is the implementation specific mixer information.
  127.  */
  128. struct waveartist_mixer_info {
  129. unsigned int supported_devs;    /* Supported devices */
  130. unsigned int recording_devs;    /* Recordable devies */
  131. unsigned int stereo_devs;    /* Stereo devices */
  133. unsigned int (*select_input)(wavnc_info *, unsigned int,
  134. unsigned char *, unsigned char *);
  135. int (*decode_mixer)(wavnc_info *, int,
  136. unsigned char, unsigned char);
  137. int (*get_mixer)(wavnc_info *, int);
  138. };
  140. typedef struct wavnc_port_info {
  141. int open_mode;
  142. int speed;
  143. int channels;
  144. int audio_format;
  145. } wavnc_port_info;
  147. static int nr_waveartist_devs;
  148. static wavnc_info adev_info[MAX_AUDIO_DEV];
  149. static spinlock_t waveartist_lock = SPIN_LOCK_UNLOCKED;
  151. #ifndef CONFIG_ARCH_NETWINDER
  152. #define machine_is_netwinder() 0
  153. #else
  154. static struct timer_list vnc_timer;
  155. static void vnc_configure_mixer(wavnc_info *devc, unsigned int input_mask);
  156. static int vnc_private_ioctl(int dev, unsigned int cmd, caddr_t arg);
  157. static void vnc_slider_tick(unsigned long data);
  158. #endif
  160. static inline void
  161. waveartist_set_ctlr(struct address_info *hw, unsigned char clear, unsigned char set)
  162. {
  163. unsigned int ctlr_port = hw->io_base + CTLR;
  165. clear = ~clear & inb(ctlr_port);
  167. outb(clear | set, ctlr_port);
  168. }
  170. /* Toggle IRQ acknowledge line
  171.  */
  172. static inline void
  173. waveartist_iack(wavnc_info *devc)
  174. {
  175. unsigned int ctlr_port = devc->hw.io_base + CTLR;
  176. int old_ctlr;
  178. old_ctlr = inb(ctlr_port) & ~IRQ_ACK;
  180. outb(old_ctlr | IRQ_ACK, ctlr_port);
  181. outb(old_ctlr, ctlr_port);
  182. }
  184. static inline int
  185. waveartist_sleep(int timeout_ms)
  186. {
  187. unsigned int timeout = timeout_ms * 10 * HZ / 100;
  189. do {
  190. set_current_state(TASK_INTERRUPTIBLE);
  191. timeout = schedule_timeout(timeout);
  192. } while (timeout);
  194. return 0;
  195. }
  197. static int
  198. waveartist_reset(wavnc_info *devc)
  199. {
  200. struct address_info *hw = &devc->hw;
  201. unsigned int timeout, res = -1;
  203. waveartist_set_ctlr(hw, -1, RESET);
  204. waveartist_sleep(2);
  205. waveartist_set_ctlr(hw, RESET, 0);
  207. timeout = 500;
  208. do {
  209. mdelay(2);
  211. if (inb(hw->io_base + STATR) & CMD_RF) {
  212. res = inw(hw->io_base + CMDR);
  213. if (res == 0x55aa)
  214. break;
  215. }
  216. } while (--timeout);
  218. if (timeout == 0) {
  219. printk(KERN_WARNING "WaveArtist: reset timeout ");
  220. if (res != (unsigned int)-1)
  221. printk("(res=%04X)", res);
  222. printk("n");
  223. return 1;
  224. }
  225. return 0;
  226. }
  228. /* Helper function to send and receive words
  229.  * from WaveArtist.  It handles all the handshaking
  230.  * and can send or receive multiple words.
  231.  */
  232. static int
  233. waveartist_cmd(wavnc_info *devc,
  234. int nr_cmd, unsigned int *cmd,
  235. int nr_resp, unsigned int *resp)
  236. {
  237. unsigned int io_base = devc->hw.io_base;
  238. unsigned int timed_out = 0;
  239. unsigned int i;
  241. if (debug_flg & DEBUG_CMD) {
  242. printk("waveartist_cmd: cmd=");
  244. for (i = 0; i < nr_cmd; i++)
  245. printk("%04X ", cmd[i]);
  247. printk("n");
  248. }
  250. /*
  251.  * flush any stale command data from the port.
  252.  */
  253. while (inb(io_base + STATR) & CMD_RF) {
  254. unsigned int old_data;
  256. old_data = inw(io_base + CMDR);
  257. printk("waveartist: flushing stale command data: 0x%04x pc=%pn",
  258.        old_data, __builtin_return_address(0));
  259. udelay(10);
  260. }
  262. for (i = 0; !timed_out && i < nr_cmd; i++) {
  263. int count;
  265. for (count = 5000; count; count--)
  266. if (inb(io_base + STATR) & CMD_WE)
  267. break;
  269. if (!count)
  270. timed_out = 1;
  271. else
  272. outw(cmd[i], io_base + CMDR);
  273. }
  275. for (i = 0; !timed_out && i < nr_resp; i++) {
  276. int count;
  278. for (count = 5000; count; count--)
  279. if (inb(io_base + STATR) & CMD_RF)
  280. break;
  282. if (!count)
  283. timed_out = 1;
  284. else
  285. resp[i] = inw(io_base + CMDR);
  286. }
  288. if (debug_flg & DEBUG_CMD && !timed_out) {
  289. printk("waveartist_cmd: resp=");
  291. for (i = 0; i < nr_resp; i++)
  292. printk("%04X ", resp[i]);
  293. printk("n");
  294. }
  296. if (timed_out) {
  297. printk(KERN_ERR "waveartist_cmd: command timed out:");
  298. for (i = 0; i < nr_cmd; i++)
  299. printk(" %04x", cmd[i]);
  300. printk("n");
  301. }
  303. return timed_out ? 1 : 0;
  304. }
  306. /*
  307.  * Send one command word
  308.  */
  309. static inline int
  310. waveartist_cmd1(wavnc_info *devc, unsigned int cmd)
  311. {
  312. return waveartist_cmd(devc, 1, &cmd, 0, NULL);
  313. }
  315. /*
  316.  * Send one command, receive one word
  317.  */
  318. static inline unsigned int
  319. waveartist_cmd1_r(wavnc_info *devc, unsigned int cmd)
  320. {
  321. unsigned int ret;
  323. waveartist_cmd(devc, 1, &cmd, 1, &ret);
  325. return ret;
  326. }
  328. /*
  329.  * Send a double command, receive one
  330.  * word (and throw it away)
  331.  */
  332. static inline int
  333. waveartist_cmd2(wavnc_info *devc, unsigned int cmd, unsigned int arg)
  334. {
  335. unsigned int vals[2];
  337. vals[0] = cmd;
  338. vals[1] = arg;
  340. return waveartist_cmd(devc, 2, vals, 1, vals);
  341. }
  343. /*
  344.  * Send a triple command
  345.  */
  346. static inline int
  347. waveartist_cmd3(wavnc_info *devc, unsigned int cmd,
  348. unsigned int arg1, unsigned int arg2)
  349. {
  350. unsigned int vals[3];
  352. vals[0] = cmd;
  353. vals[1] = arg1;
  354. vals[2] = arg2;
  356. return waveartist_cmd(devc, 3, vals, 0, NULL);
  357. }
  359. static int
  360. waveartist_getrev(wavnc_info *devc, char *rev)
  361. {
  362. unsigned int temp[2];
  363. unsigned int cmd = WACMD_GETREV;
  365. waveartist_cmd(devc, 1, &cmd, 2, temp);
  367. rev[0] = temp[0] >> 8;
  368. rev[1] = temp[0] & 255;
  369. rev[2] = '';
  371. return temp[0];
  372. }
  374. static void waveartist_halt_output(int dev);
  375. static void waveartist_halt_input(int dev);
  376. static void waveartist_halt(int dev);
  377. static void waveartist_trigger(int dev, int state);
  379. static int
  380. waveartist_open(int dev, int mode)
  381. {
  382. wavnc_info *devc;
  383. wavnc_port_info *portc;
  384. unsigned long flags;
  386. if (dev < 0 || dev >= num_audiodevs)
  387. return -ENXIO;
  389. devc  = (wavnc_info *) audio_devs[dev]->devc;
  390. portc = (wavnc_port_info *) audio_devs[dev]->portc;
  392. spin_lock_irqsave(&waveartist_lock, flags);
  393. if (portc->open_mode || (devc->open_mode & mode)) {
  394. spin_unlock_irqrestore(&waveartist_lock, flags);
  395. return -EBUSY;
  396. }
  398. devc->audio_mode  = 0;
  399. devc->open_mode  |= mode;
  400. portc->open_mode  = mode;
  401. waveartist_trigger(dev, 0);
  403. if (mode & OPEN_READ)
  404. devc->record_dev = dev;
  405. if (mode & OPEN_WRITE)
  406. devc->playback_dev = dev;
  407. spin_unlock_irqrestore(&waveartist_lock, flags);
  409. return 0;
  410. }
  412. static void
  413. waveartist_close(int dev)
  414. {
  415. wavnc_info *devc = (wavnc_info *) audio_devs[dev]->devc;
  416. wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
  417. unsigned long flags;
  419. spin_lock_irqsave(&waveartist_lock, flags);
  421. waveartist_halt(dev);
  423. devc->audio_mode = 0;
  424. devc->open_mode &= ~portc->open_mode;
  425. portc->open_mode = 0;
  427. spin_unlock_irqrestore(&waveartist_lock, flags);
  428. }
  430. static void
  431. waveartist_output_block(int dev, unsigned long buf, int __count, int intrflag)
  432. {
  433. wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
  434. wavnc_info *devc = (wavnc_info *) audio_devs[dev]->devc;
  435. unsigned long flags;
  436. unsigned int count = __count; 
  438. if (debug_flg & DEBUG_OUT)
  439. printk("waveartist: output block, buf=0x%lx, count=0x%x...n",
  440. buf, count);
  441. /*
  442.  * 16 bit data
  443.  */
  444. if (portc->audio_format & (AFMT_S16_LE | AFMT_S16_BE))
  445. count >>= 1;
  447. if (portc->channels > 1)
  448. count >>= 1;
  450. count -= 1;
  452. if (devc->audio_mode & PCM_ENABLE_OUTPUT &&
  453.     audio_devs[dev]->flags & DMA_AUTOMODE &&
  454.     intrflag &&
  455.     count == devc->xfer_count) {
  456. devc->audio_mode |= PCM_ENABLE_OUTPUT;
  457. return; /*
  458.  * Auto DMA mode on. No need to react
  459.  */
  460. }
  462. spin_lock_irqsave(&waveartist_lock, flags);
  464. /*
  465.  * set sample count
  466.  */
  467. waveartist_cmd2(devc, WACMD_OUTPUTSIZE, count);
  469. devc->xfer_count = count;
  470. devc->audio_mode |= PCM_ENABLE_OUTPUT;
  472. spin_unlock_irqrestore(&waveartist_lock, flags);
  473. }
  475. static void
  476. waveartist_start_input(int dev, unsigned long buf, int __count, int intrflag)
  477. {
  478. wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
  479. wavnc_info *devc = (wavnc_info *) audio_devs[dev]->devc;
  480. unsigned long flags;
  481. unsigned int count = __count;
  483. if (debug_flg & DEBUG_IN)
  484. printk("waveartist: start input, buf=0x%lx, count=0x%x...n",
  485. buf, count);
  487. if (portc->audio_format & (AFMT_S16_LE | AFMT_S16_BE)) /* 16 bit data */
  488. count >>= 1;
  490. if (portc->channels > 1)
  491. count >>= 1;
  493. count -= 1;
  495. if (devc->audio_mode & PCM_ENABLE_INPUT &&
  496.     audio_devs[dev]->flags & DMA_AUTOMODE &&
  497.     intrflag &&
  498.     count == devc->xfer_count) {
  499. return; /*
  500.  * Auto DMA mode on. No need to react
  501.  */
  502. }
  504. spin_lock_irqsave(&waveartist_lock, flags);
  506. /*
  507.  * set sample count
  508.  */
  509. waveartist_cmd2(devc, WACMD_INPUTSIZE, count);
  511. devc->xfer_count = count;
  512. devc->audio_mode |= PCM_ENABLE_INPUT;
  514. spin_unlock_irqrestore(&waveartist_lock, flags);
  515. }
  517. static int
  518. waveartist_ioctl(int dev, unsigned int cmd, caddr_t arg)
  519. {
  520. return -EINVAL;
  521. }
  523. static unsigned int
  524. waveartist_get_speed(wavnc_port_info *portc)
  525. {
  526. unsigned int speed;
  528. /*
  529.  * program the speed, channels, bits
  530.  */
  531. if (portc->speed == 8000)
  532. speed = 0x2E71;
  533. else if (portc->speed == 11025)
  534. speed = 0x4000;
  535. else if (portc->speed == 22050)
  536. speed = 0x8000;
  537. else if (portc->speed == 44100)
  538. speed = 0x0;
  539. else {
  540. /*
  541.  * non-standard - just calculate
  542.  */
  543. speed = portc->speed << 16;
  545. speed = (speed / 44100) & 65535;
  546. }
  548. return speed;
  549. }
  551. static unsigned int
  552. waveartist_get_bits(wavnc_port_info *portc)
  553. {
  554. unsigned int bits;
  556. if (portc->audio_format == AFMT_S16_LE)
  557. bits = 1;
  558. else if (portc->audio_format == AFMT_S8)
  559. bits = 0;
  560. else
  561. bits = 2; //default AFMT_U8
  563. return bits;
  564. }
  566. static int
  567. waveartist_prepare_for_input(int dev, int bsize, int bcount)
  568. {
  569. unsigned long flags;
  570. wavnc_info *devc = (wavnc_info *) audio_devs[dev]->devc;
  571. wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
  572. unsigned int speed, bits;
  574. speed = waveartist_get_speed(portc);
  575. bits  = waveartist_get_bits(portc);
  577. spin_lock_irqsave(&waveartist_lock, flags);
  579. if (waveartist_cmd2(devc, WACMD_INPUTFORMAT, bits))
  580. printk(KERN_WARNING "waveartist: error setting the "
  581.        "record format to %dn", portc->audio_format);
  583. if (waveartist_cmd2(devc, WACMD_INPUTCHANNELS, portc->channels))
  584. printk(KERN_WARNING "waveartist: error setting record "
  585.        "to %d channelsn", portc->channels);
  587. /*
  588.  * write cmd SetSampleSpeedTimeConstant
  589.  */
  590. if (waveartist_cmd2(devc, WACMD_INPUTSPEED, speed))
  591. printk(KERN_WARNING "waveartist: error setting the record "
  592.        "speed to %dHz.n", portc->speed);
  594. if (waveartist_cmd2(devc, WACMD_INPUTDMA, 1))
  595. printk(KERN_WARNING "waveartist: error setting the record "
  596.        "data path to 0x%Xn", 1);
  598. if (waveartist_cmd2(devc, WACMD_INPUTFORMAT, bits))
  599. printk(KERN_WARNING "waveartist: error setting the record "
  600.        "format to %dn", portc->audio_format);
  602. devc->xfer_count = 0;
  603. spin_unlock_irqrestore(&waveartist_lock, flags);
  604. waveartist_halt_input(dev);
  606. if (debug_flg & DEBUG_INTR) {
  607. printk("WA CTLR reg: 0x%02X.n",
  608.        inb(devc->hw.io_base + CTLR));
  609. printk("WA STAT reg: 0x%02X.n",
  610.        inb(devc->hw.io_base + STATR));
  611. printk("WA IRQS reg: 0x%02X.n",
  612.        inb(devc->hw.io_base + IRQSTAT));
  613. }
  615. return 0;
  616. }
  618. static int
  619. waveartist_prepare_for_output(int dev, int bsize, int bcount)
  620. {
  621. unsigned long flags;
  622. wavnc_info *devc = (wavnc_info *) audio_devs[dev]->devc;
  623. wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
  624. unsigned int speed, bits;
  626. /*
  627.  * program the speed, channels, bits
  628.  */
  629. speed = waveartist_get_speed(portc);
  630. bits  = waveartist_get_bits(portc);
  632. spin_lock_irqsave(&waveartist_lock, flags);
  634. if (waveartist_cmd2(devc, WACMD_OUTPUTSPEED, speed) &&
  635.     waveartist_cmd2(devc, WACMD_OUTPUTSPEED, speed))
  636. printk(KERN_WARNING "waveartist: error setting the playback "
  637.        "speed to %dHz.n", portc->speed);
  639. if (waveartist_cmd2(devc, WACMD_OUTPUTCHANNELS, portc->channels))
  640. printk(KERN_WARNING "waveartist: error setting the playback "
  641.        "to %d channelsn", portc->channels);
  643. if (waveartist_cmd2(devc, WACMD_OUTPUTDMA, 0))
  644. printk(KERN_WARNING "waveartist: error setting the playback "
  645.        "data path to 0x%Xn", 0);
  647. if (waveartist_cmd2(devc, WACMD_OUTPUTFORMAT, bits))
  648. printk(KERN_WARNING "waveartist: error setting the playback "
  649.        "format to %dn", portc->audio_format);
  651. devc->xfer_count = 0;
  652. spin_unlock_irqrestore(&waveartist_lock, flags);
  653. waveartist_halt_output(dev);
  655. if (debug_flg & DEBUG_INTR) {
  656. printk("WA CTLR reg: 0x%02X.n",inb(devc->hw.io_base + CTLR));
  657. printk("WA STAT reg: 0x%02X.n",inb(devc->hw.io_base + STATR));
  658. printk("WA IRQS reg: 0x%02X.n",inb(devc->hw.io_base + IRQSTAT));
  659. }
  661. return 0;
  662. }
  664. static void
  665. waveartist_halt(int dev)
  666. {
  667. wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
  668. wavnc_info *devc;
  670. if (portc->open_mode & OPEN_WRITE)
  671. waveartist_halt_output(dev);
  673. if (portc->open_mode & OPEN_READ)
  674. waveartist_halt_input(dev);
  676. devc = (wavnc_info *) audio_devs[dev]->devc;
  677. devc->audio_mode = 0;
  678. }
  680. static void
  681. waveartist_halt_input(int dev)
  682. {
  683. wavnc_info *devc = (wavnc_info *) audio_devs[dev]->devc;
  684. unsigned long flags;
  686. spin_lock_irqsave(&waveartist_lock, flags);
  688. /*
  689.  * Stop capture
  690.  */
  691. waveartist_cmd1(devc, WACMD_INPUTSTOP);
  693. devc->audio_mode &= ~PCM_ENABLE_INPUT;
  695. /*
  696.  * Clear interrupt by toggling
  697.  * the IRQ_ACK bit in CTRL
  698.  */
  699. if (inb(devc->hw.io_base + STATR) & IRQ_REQ)
  700. waveartist_iack(devc);
  702. // devc->audio_mode &= ~PCM_ENABLE_INPUT;
  704. spin_unlock_irqrestore(&waveartist_lock, flags);
  705. }
  707. static void
  708. waveartist_halt_output(int dev)
  709. {
  710. wavnc_info *devc = (wavnc_info *) audio_devs[dev]->devc;
  711. unsigned long flags;
  713. spin_lock_irqsave(&waveartist_lock, flags);
  715. waveartist_cmd1(devc, WACMD_OUTPUTSTOP);
  717. devc->audio_mode &= ~PCM_ENABLE_OUTPUT;
  719. /*
  720.  * Clear interrupt by toggling
  721.  * the IRQ_ACK bit in CTRL
  722.  */
  723. if (inb(devc->hw.io_base + STATR) & IRQ_REQ)
  724. waveartist_iack(devc);
  726. // devc->audio_mode &= ~PCM_ENABLE_OUTPUT;
  728. spin_unlock_irqrestore(&waveartist_lock, flags);
  729. }
  731. static void
  732. waveartist_trigger(int dev, int state)
  733. {
  734. wavnc_info *devc = (wavnc_info *) audio_devs[dev]->devc;
  735. wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
  736. unsigned long flags;
  738. if (debug_flg & DEBUG_TRIGGER) {
  739. printk("wavnc: audio trigger ");
  740. if (state & PCM_ENABLE_INPUT)
  741. printk("in ");
  742. if (state & PCM_ENABLE_OUTPUT)
  743. printk("out");
  744. printk("n");
  745. }
  747. spin_lock_irqsave(&waveartist_lock, flags);
  749. state &= devc->audio_mode;
  751. if (portc->open_mode & OPEN_READ &&
  752.     state & PCM_ENABLE_INPUT)
  753. /*
  754.  * enable ADC Data Transfer to PC
  755.  */
  756. waveartist_cmd1(devc, WACMD_INPUTSTART);
  758. if (portc->open_mode & OPEN_WRITE &&
  759.     state & PCM_ENABLE_OUTPUT)
  760. /*
  761.  * enable DAC data transfer from PC
  762.  */
  763. waveartist_cmd1(devc, WACMD_OUTPUTSTART);
  765. spin_unlock_irqrestore(&waveartist_lock, flags);
  766. }
  768. static int
  769. waveartist_set_speed(int dev, int arg)
  770. {
  771. wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
  773. if (arg <= 0)
  774. return portc->speed;
  776. if (arg < 5000)
  777. arg = 5000;
  778. if (arg > 44100)
  779. arg = 44100;
  781. portc->speed = arg;
  782. return portc->speed;
  784. }
  786. static short
  787. waveartist_set_channels(int dev, short arg)
  788. {
  789. wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
  791. if (arg != 1 && arg != 2)
  792. return portc->channels;
  794. portc->channels = arg;
  795. return arg;
  796. }
  798. static unsigned int
  799. waveartist_set_bits(int dev, unsigned int arg)
  800. {
  801. wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
  803. if (arg == 0)
  804. return portc->audio_format;
  806. if ((arg != AFMT_U8) && (arg != AFMT_S16_LE) && (arg != AFMT_S8))
  807. arg = AFMT_U8;
  809. portc->audio_format = arg;
  811. return arg;
  812. }
  814. static struct audio_driver waveartist_audio_driver = {
  815. owner: THIS_MODULE,
  816. open: waveartist_open,
  817. close: waveartist_close,
  818. output_block: waveartist_output_block,
  819. start_input: waveartist_start_input,
  820. ioctl: waveartist_ioctl,
  821. prepare_for_input: waveartist_prepare_for_input,
  822. prepare_for_output: waveartist_prepare_for_output,
  823. halt_io: waveartist_halt,
  824. halt_input: waveartist_halt_input,
  825. halt_output: waveartist_halt_output,
  826. trigger: waveartist_trigger,
  827. set_speed: waveartist_set_speed,
  828. set_bits: waveartist_set_bits,
  829. set_channels: waveartist_set_channels
  830. };
  833. static void
  834. waveartist_intr(int irq, void *dev_id, struct pt_regs *regs)
  835. {
  836. wavnc_info *devc = (wavnc_info *)dev_id;
  837. int    irqstatus, status;
  839. irqstatus = inb(devc->hw.io_base + IRQSTAT);
  840. status    = inb(devc->hw.io_base + STATR);
  842. if (debug_flg & DEBUG_INTR)
  843. printk("waveartist_intr: stat=%02x, irqstat=%02xn",
  844.        status, irqstatus);
  846. if (status & IRQ_REQ) /* Clear interrupt */
  847. waveartist_iack(devc);
  848. else
  849. printk(KERN_WARNING "waveartist: unexpected interruptn");
  851. if (irqstatus & 0x01) {
  852. int temp = 1;
  854. /* PCM buffer done
  855.  */
  856. if ((status & DMA0) && (devc->audio_mode & PCM_ENABLE_OUTPUT)) {
  857. DMAbuf_outputintr(devc->playback_dev, 1);
  858. temp = 0;
  859. }
  860. if ((status & DMA1) && (devc->audio_mode & PCM_ENABLE_INPUT)) {
  861. DMAbuf_inputintr(devc->record_dev);
  862. temp = 0;
  863. }
  864. if (temp) //default:
  865. printk(KERN_WARNING "waveartist: Unknown interruptn");
  866. }
  867. if (irqstatus & 0x2)
  868. // We do not use SB mode natively...
  869. printk(KERN_WARNING "waveartist: Unexpected SB interrupt...n");
  870. }
  872. /* -------------------------------------------------------------------------
  873.  * Mixer stuff
  874.  */
  875. struct mix_ent {
  876. unsigned char reg_l;
  877. unsigned char reg_r;
  878. unsigned char shift;
  879. unsigned char max;
  880. };
  882. static const struct mix_ent mix_devs[SOUND_MIXER_NRDEVICES] = {
  883. { 2, 6, 1,  7 }, /* SOUND_MIXER_VOLUME   */
  884. { 0, 0, 0,  0 }, /* SOUND_MIXER_BASS     */
  885. { 0, 0, 0,  0 }, /* SOUND_MIXER_TREBLE   */
  886. { 0, 0, 0,  0 }, /* SOUND_MIXER_SYNTH    */
  887. { 0, 0, 0,  0 }, /* SOUND_MIXER_PCM      */
  888. { 0, 0, 0,  0 }, /* SOUND_MIXER_SPEAKER  */
  889. { 0, 4, 6, 31 }, /* SOUND_MIXER_LINE     */
  890. { 2, 6, 4,  3 }, /* SOUND_MIXER_MIC      */
  891. { 0, 0, 0,  0 }, /* SOUND_MIXER_CD       */
  892. { 0, 0, 0,  0 }, /* SOUND_MIXER_IMIX     */
  893. { 0, 0, 0,  0 }, /* SOUND_MIXER_ALTPCM   */
  894. #if 0
  895. { 3, 7, 0, 10 }, /* SOUND_MIXER_RECLEV   */
  896. { 0, 0, 0,  0 }, /* SOUND_MIXER_IGAIN    */
  897. #else
  898. { 0, 0, 0,  0 }, /* SOUND_MIXER_RECLEV   */
  899. { 3, 7, 0,  7 }, /* SOUND_MIXER_IGAIN    */
  900. #endif
  901. { 0, 0, 0,  0 }, /* SOUND_MIXER_OGAIN    */
  902. { 0, 4, 1, 31 }, /* SOUND_MIXER_LINE1    */
  903. { 1, 5, 6, 31 }, /* SOUND_MIXER_LINE2    */
  904. { 0, 0, 0,  0 }, /* SOUND_MIXER_LINE3    */
  905. { 0, 0, 0,  0 }, /* SOUND_MIXER_DIGITAL1 */
  906. { 0, 0, 0,  0 }, /* SOUND_MIXER_DIGITAL2 */
  907. { 0, 0, 0,  0 }, /* SOUND_MIXER_DIGITAL3 */
  908. { 0, 0, 0,  0 }, /* SOUND_MIXER_PHONEIN  */
  909. { 0, 0, 0,  0 }, /* SOUND_MIXER_PHONEOUT */
  910. { 0, 0, 0,  0 }, /* SOUND_MIXER_VIDEO    */
  911. { 0, 0, 0,  0 }, /* SOUND_MIXER_RADIO    */
  912. { 0, 0, 0,  0 }  /* SOUND_MIXER_MONITOR  */
  913. };
  915. static void
  916. waveartist_mixer_update(wavnc_info *devc, int whichDev)
  917. {
  918. unsigned int lev_left, lev_right;
  920. lev_left  = devc->levels[whichDev] & 0xff;
  921. lev_right = devc->levels[whichDev] >> 8;
  923. if (lev_left > 100)
  924. lev_left = 100;
  925. if (lev_right > 100)
  926. lev_right = 100;
  928. #define SCALE(lev,max) ((lev) * (max) / 100)
  930. if (machine_is_netwinder() && whichDev == SOUND_MIXER_PHONEOUT)
  931. whichDev = SOUND_MIXER_VOLUME;
  933. if (mix_devs[whichDev].reg_l || mix_devs[whichDev].reg_r) {
  934. const struct mix_ent *mix = mix_devs + whichDev;
  935. unsigned int mask, left, right;
  937. mask = mix->max << mix->shift;
  938. lev_left  = SCALE(lev_left,  mix->max) << mix->shift;
  939. lev_right = SCALE(lev_right, mix->max) << mix->shift;
  941. /* read left setting */
  942. left  = waveartist_cmd1_r(devc, WACMD_GET_LEVEL |
  943.        mix->reg_l << 8);
  945. /* read right setting */
  946. right = waveartist_cmd1_r(devc, WACMD_GET_LEVEL |
  947. mix->reg_r << 8);
  949. left  = (left  & ~mask) | (lev_left  & mask);
  950. right = (right & ~mask) | (lev_right & mask);
  952. /* write left,right back */
  953. waveartist_cmd3(devc, WACMD_SET_MIXER, left, right);
  954. } else {
  955. switch(whichDev) {
  956. case SOUND_MIXER_PCM:
  957. waveartist_cmd3(devc, WACMD_SET_LEVEL,
  958. SCALE(lev_left,  32767),
  959. SCALE(lev_right, 32767));
  960. break;
  962. case SOUND_MIXER_SYNTH:
  963. waveartist_cmd3(devc, 0x0100 | WACMD_SET_LEVEL,
  964. SCALE(lev_left,  32767),
  965. SCALE(lev_right, 32767));
  966. break;
  967. }
  968. }
  969. }
  971. /*
  972.  * Set the ADC MUX to the specified values.  We do NOT do any
  973.  * checking of the values passed, since we assume that the
  974.  * relevant *_select_input function has done that for us.
  975.  */
  976. static void
  977. waveartist_set_adc_mux(wavnc_info *devc, char left_dev, char right_dev)
  978. {
  979. unsigned int reg_08, reg_09;
  981. reg_08 = waveartist_cmd1_r(devc, WACMD_GET_LEVEL | 0x0800);
  982. reg_09 = waveartist_cmd1_r(devc, WACMD_GET_LEVEL | 0x0900);
  984. reg_08 = (reg_08 & ~0x3f) | right_dev << 3 | left_dev;
  986. waveartist_cmd3(devc, WACMD_SET_MIXER, reg_08, reg_09);
  987. }
  989. /*
  990.  * Decode a recording mask into a mixer selection as follows:
  991.  *
  992.  *     OSS Source WA Source Actual source
  993.  *  SOUND_MASK_IMIX Mixer Mixer output (same as AD1848)
  994.  *  SOUND_MASK_LINE Line Line in
  995.  *  SOUND_MASK_LINE1 Aux 1 Aux 1 in
  996.  *  SOUND_MASK_LINE2 Aux 2 Aux 2 in
  997.  *  SOUND_MASK_MIC Mic Microphone
  998.  */
  999. static unsigned int
  1000. waveartist_select_input(wavnc_info *devc, unsigned int recmask,
  1001. unsigned char *dev_l, unsigned char *dev_r)
  1002. {
  1003. unsigned int recdev = ADC_MUX_NONE;
  1005. if (recmask & SOUND_MASK_IMIX) {
  1006. recmask = SOUND_MASK_IMIX;
  1007. recdev = ADC_MUX_MIXER;
  1008. } else if (recmask & SOUND_MASK_LINE2) {
  1009. recmask = SOUND_MASK_LINE2;
  1010. recdev = ADC_MUX_AUX2;
  1011. } else if (recmask & SOUND_MASK_LINE1) {
  1012. recmask = SOUND_MASK_LINE1;
  1013. recdev = ADC_MUX_AUX1;
  1014. } else if (recmask & SOUND_MASK_LINE) {
  1015. recmask = SOUND_MASK_LINE;
  1016. recdev = ADC_MUX_LINE;
  1017. } else if (recmask & SOUND_MASK_MIC) {
  1018. recmask = SOUND_MASK_MIC;
  1019. recdev = ADC_MUX_MIC;
  1020. }
  1022. *dev_l = *dev_r = recdev;
  1024. return recmask;
  1025. }
  1027. static int
  1028. waveartist_decode_mixer(wavnc_info *devc, int dev, unsigned char lev_l,
  1029. unsigned char lev_r)
  1030. {
  1031. switch (dev) {
  1032. case SOUND_MIXER_VOLUME:
  1033. case SOUND_MIXER_SYNTH:
  1034. case SOUND_MIXER_PCM:
  1035. case SOUND_MIXER_LINE:
  1036. case SOUND_MIXER_MIC:
  1037. case SOUND_MIXER_IGAIN:
  1038. case SOUND_MIXER_LINE1:
  1039. case SOUND_MIXER_LINE2:
  1040. devc->levels[dev] = lev_l | lev_r << 8;
  1041. break;
  1043. case SOUND_MIXER_IMIX:
  1044. break;
  1046. default:
  1047. dev = -EINVAL;
  1048. break;
  1049. }
  1051. return dev;
  1052. }
  1054. static int waveartist_get_mixer(wavnc_info *devc, int dev)
  1055. {
  1056. return devc->levels[dev];
  1057. }
  1059. static const struct waveartist_mixer_info waveartist_mixer = {
  1060. supported_devs: SUPPORTED_MIXER_DEVICES | SOUND_MASK_IGAIN,
  1061. recording_devs: SOUND_MASK_LINE  | SOUND_MASK_MIC   |
  1062. SOUND_MASK_LINE1 | SOUND_MASK_LINE2 |
  1063. SOUND_MASK_IMIX,
  1064. stereo_devs: (SUPPORTED_MIXER_DEVICES | SOUND_MASK_IGAIN) & ~
  1065. (SOUND_MASK_SPEAKER | SOUND_MASK_IMIX),
  1066. select_input: waveartist_select_input,
  1067. decode_mixer: waveartist_decode_mixer,
  1068. get_mixer: waveartist_get_mixer,
  1069. };
  1071. static void
  1072. waveartist_set_recmask(wavnc_info *devc, unsigned int recmask)
  1073. {
  1074. unsigned char dev_l, dev_r;
  1076. recmask &= devc->mix->recording_devs;
  1078. /*
  1079.  * If more than one recording device selected,
  1080.  * disable the device that is currently in use.
  1081.  */
  1082. if (hweight32(recmask) > 1)
  1083. recmask &= ~devc->recmask;
  1085. /*
  1086.  * Translate the recording device mask into
  1087.  * the ADC multiplexer settings.
  1088.  */
  1089. devc->recmask = devc->mix->select_input(devc, recmask,
  1090. &dev_l, &dev_r);
  1092. waveartist_set_adc_mux(devc, dev_l, dev_r);
  1093. }
  1095. static int
  1096. waveartist_set_mixer(wavnc_info *devc, int dev, unsigned int level)
  1097. {
  1098. unsigned int lev_left  = level & 0x00ff;
  1099. unsigned int lev_right = (level & 0xff00) >> 8;
  1101. if (lev_left > 100)
  1102. lev_left = 100;
  1103. if (lev_right > 100)
  1104. lev_right = 100;
  1106. /*
  1107.  * Mono devices have their right volume forced to their
  1108.  * left volume.  (from ALSA driver OSS emulation).
  1109.  */
  1110. if (!(devc->mix->stereo_devs & (1 << dev)))
  1111. lev_right = lev_left;
  1113. dev = devc->mix->decode_mixer(devc, dev, lev_left, lev_right);
  1115. if (dev >= 0)
  1116. waveartist_mixer_update(devc, dev);
  1118. return dev < 0 ? dev : 0;
  1119. }
  1121. static int
  1122. waveartist_mixer_ioctl(int dev, unsigned int cmd, caddr_t arg)
  1123. {
  1124. wavnc_info *devc = (wavnc_info *)audio_devs[dev]->devc;
  1125. int ret = 0, val, nr;
  1127. /*
  1128.  * All SOUND_MIXER_* ioctls use type 'M'
  1129.  */
  1130. if (((cmd >> 8) & 255) != 'M')
  1131. return -ENOIOCTLCMD;
  1133. #ifdef CONFIG_ARCH_NETWINDER
  1134. if (machine_is_netwinder()) {
  1135. ret = vnc_private_ioctl(dev, cmd, arg);
  1136. if (ret != -ENOIOCTLCMD)
  1137. return ret;
  1138. else
  1139. ret = 0;
  1140. }
  1141. #endif
  1143. nr = cmd & 0xff;
  1145. if (_SIOC_DIR(cmd) & _SIOC_WRITE) {
  1146. if (get_user(val, (int *)arg))
  1147. return -EFAULT;
  1149. switch (nr) {
  1150. case SOUND_MIXER_RECSRC:
  1151. waveartist_set_recmask(devc, val);
  1152. break;
  1154. default:
  1155. ret = -EINVAL;
  1156. if (nr < SOUND_MIXER_NRDEVICES &&
  1157.     devc->mix->supported_devs & (1 << nr))
  1158. ret = waveartist_set_mixer(devc, nr, val);
  1159. }
  1160. }
  1162. if (ret == 0 && _SIOC_DIR(cmd) & _SIOC_READ) {
  1163. ret = -EINVAL;
  1165. switch (nr) {
  1166. case SOUND_MIXER_RECSRC:
  1167. ret = devc->recmask;
  1168. break;
  1170. case SOUND_MIXER_DEVMASK:
  1171. ret = devc->mix->supported_devs;
  1172. break;
  1174. case SOUND_MIXER_STEREODEVS:
  1175. ret = devc->mix->stereo_devs;
  1176. break;
  1178. case SOUND_MIXER_RECMASK:
  1179. ret = devc->mix->recording_devs;
  1180. break;
  1182. case SOUND_MIXER_CAPS:
  1183. ret = SOUND_CAP_EXCL_INPUT;
  1184. break;
  1186. default:
  1187. if (nr < SOUND_MIXER_NRDEVICES)
  1188. ret = devc->mix->get_mixer(devc, nr);
  1189. break;
  1190. }
  1192. if (ret >= 0)
  1193. ret = put_user(ret, (int *)arg) ? -EFAULT : 0;
  1194. }
  1196. return ret;
  1197. }
  1199. static struct mixer_operations waveartist_mixer_operations =
  1200. {
  1201. owner: THIS_MODULE,
  1202. id: "WaveArtist",
  1203. name: "WaveArtist",
  1204. ioctl: waveartist_mixer_ioctl
  1205. };
  1207. static void
  1208. waveartist_mixer_reset(wavnc_info *devc)
  1209. {
  1210. int i;
  1212. if (debug_flg & DEBUG_MIXER)
  1213. printk("%s: mixer_resetn", devc->hw.name);
  1215. /*
  1216.  * reset mixer cmd
  1217.  */
  1218. waveartist_cmd1(devc, WACMD_RST_MIXER);
  1220. /*
  1221.  * set input for ADC to come from 'quiet'
  1222.  * turn on default modes
  1223.  */
  1224. waveartist_cmd3(devc, WACMD_SET_MIXER, 0x9800, 0xa836);
  1226. /*
  1227.  * set mixer input select to none, RX filter gains 0 dB
  1228.  */
  1229. waveartist_cmd3(devc, WACMD_SET_MIXER, 0x4c00, 0x8c00);
  1231. /*
  1232.  * set bit 0 reg 2 to 1 - unmute MonoOut
  1233.  */
  1234. waveartist_cmd3(devc, WACMD_SET_MIXER, 0x2801, 0x6800);
  1236. /* set default input device = internal mic
  1237.  * current recording device = none
  1238.  */
  1239. waveartist_set_recmask(devc, 0);
  1241. for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
  1242. waveartist_mixer_update(devc, i);
  1243. }
  1245. static int __init waveartist_init(wavnc_info *devc)
  1246. {
  1247. wavnc_port_info *portc;
  1248. char rev[3], dev_name[64];
  1249. int my_dev;
  1251. if (waveartist_reset(devc))
  1252. return -ENODEV;
  1254. sprintf(dev_name, "%s (%s", devc->hw.name, devc->chip_name);
  1256. if (waveartist_getrev(devc, rev)) {
  1257. strcat(dev_name, " rev. ");
  1258. strcat(dev_name, rev);
  1259. }
  1260. strcat(dev_name, ")");
  1262. conf_printf2(dev_name, devc->hw.io_base, devc->hw.irq,
  1263.      devc->hw.dma, devc->hw.dma2);
  1265. portc = (wavnc_port_info *)kmalloc(sizeof(wavnc_port_info), GFP_KERNEL);
  1266. if (portc == NULL)
  1267. goto nomem;
  1269. memset(portc, 0, sizeof(wavnc_port_info));
  1271. my_dev = sound_install_audiodrv(AUDIO_DRIVER_VERSION, dev_name,
  1272. &waveartist_audio_driver, sizeof(struct audio_driver),
  1273. devc->audio_flags, AFMT_U8 | AFMT_S16_LE | AFMT_S8,
  1274. devc, devc->hw.dma, devc->hw.dma2);
  1276. if (my_dev < 0)
  1277. goto free;
  1279. audio_devs[my_dev]->portc = portc;
  1281. waveartist_mixer_reset(devc);
  1283. /*
  1284.  * clear any pending interrupt
  1285.  */
  1286. waveartist_iack(devc);
  1288. if (request_irq(devc->hw.irq, waveartist_intr, 0, devc->hw.name, devc) < 0) {
  1289. printk(KERN_ERR "%s: IRQ %d in usen",
  1290. devc->hw.name, devc->hw.irq);
  1291. goto uninstall;
  1292. }
  1294. if (sound_alloc_dma(devc->hw.dma, devc->hw.name)) {
  1295. printk(KERN_ERR "%s: Can't allocate DMA%dn",
  1296. devc->hw.name, devc->hw.dma);
  1297. goto uninstall_irq;
  1298. }
  1300. if (devc->hw.dma != devc->hw.dma2 && devc->hw.dma2 != NO_DMA)
  1301. if (sound_alloc_dma(devc->hw.dma2, devc->hw.name)) {
  1302. printk(KERN_ERR "%s: can't allocate DMA%dn",
  1303. devc->hw.name, devc->hw.dma2);
  1304. goto uninstall_dma;
  1305. }
  1307. waveartist_set_ctlr(&devc->hw, 0, DMA1_IE | DMA0_IE);
  1309. audio_devs[my_dev]->mixer_dev =
  1310. sound_install_mixer(MIXER_DRIVER_VERSION,
  1311. dev_name,
  1312. &waveartist_mixer_operations,
  1313. sizeof(struct mixer_operations),
  1314. devc);
  1316. return my_dev;
  1318. uninstall_dma:
  1319. sound_free_dma(devc->hw.dma);
  1321. uninstall_irq:
  1322. free_irq(devc->hw.irq, devc);
  1324. uninstall:
  1325. sound_unload_audiodev(my_dev);
  1327. free:
  1328. kfree(portc);
  1330. nomem:
  1331. return -1;
  1332. }
  1334. static int __init probe_waveartist(struct address_info *hw_config)
  1335. {
  1336. wavnc_info *devc = &adev_info[nr_waveartist_devs];
  1338. if (nr_waveartist_devs >= MAX_AUDIO_DEV) {
  1339. printk(KERN_WARNING "waveartist: too many audio devicesn");
  1340. return 0;
  1341. }
  1343. if (check_region(hw_config->io_base, 15))  {
  1344. printk(KERN_WARNING "WaveArtist: I/O port conflictn");
  1345. return 0;
  1346. }
  1348. if (hw_config->irq > 15 || hw_config->irq < 0) {
  1349. printk(KERN_WARNING "WaveArtist: Bad IRQ %dn",
  1350.        hw_config->irq);
  1351. return 0;
  1352. }
  1354. if (hw_config->dma != 3) {
  1355. printk(KERN_WARNING "WaveArtist: Bad DMA %dn",
  1356.        hw_config->dma);
  1357. return 0;
  1358. }
  1360. hw_config->name = "WaveArtist";
  1361. devc->hw = *hw_config;
  1362. devc->open_mode = 0;
  1363. devc->chip_name = "RWA-010";
  1365. return 1;
  1366. }
  1368. static void __init
  1369. attach_waveartist(struct address_info *hw, const struct waveartist_mixer_info *mix)
  1370. {
  1371. wavnc_info *devc = &adev_info[nr_waveartist_devs];
  1373. /*
  1374.  * NOTE! If irq < 0, there is another driver which has allocated the
  1375.  *   IRQ so that this driver doesn't need to allocate/deallocate it.
  1376.  *   The actually used IRQ is ABS(irq).
  1377.  */
  1378. devc->hw = *hw;
  1379. devc->hw.irq = (hw->irq > 0) ? hw->irq : 0;
  1380. devc->open_mode = 0;
  1381. devc->playback_dev = 0;
  1382. devc->record_dev = 0;
  1383. devc->audio_flags = DMA_AUTOMODE;
  1384. devc->levels = levels;
  1386. if (hw->dma != hw->dma2 && hw->dma2 != NO_DMA)
  1387. devc->audio_flags |= DMA_DUPLEX;
  1389. request_region(hw->io_base, 15, devc->hw.name);
  1391. devc->mix = mix;
  1392. devc->dev_no = waveartist_init(devc);
  1394. if (devc->dev_no < 0)
  1395. release_region(hw->io_base, 15);
  1396. else {
  1397. #ifdef CONFIG_ARCH_NETWINDER
  1398. if (machine_is_netwinder()) {
  1399. init_timer(&vnc_timer);
  1400. vnc_timer.function = vnc_slider_tick;
  1401. vnc_timer.expires  = jiffies;
  1402. vnc_timer.data     = nr_waveartist_devs;
  1403. add_timer(&vnc_timer);
  1405. vnc_configure_mixer(devc, 0);
  1407. devc->no_autoselect = 1;
  1408. }
  1409. #endif
  1410. nr_waveartist_devs += 1;
  1411. }
  1412. }
  1414. static void __exit unload_waveartist(struct address_info *hw)
  1415. {
  1416. wavnc_info *devc = NULL;
  1417. int i;
  1419. for (i = 0; i < nr_waveartist_devs; i++)
  1420. if (hw->io_base == adev_info[i].hw.io_base) {
  1421. devc = adev_info + i;
  1422. break;
  1423. }
  1425. if (devc != NULL) {
  1426. int mixer;
  1428. #ifdef CONFIG_ARCH_NETWINDER
  1429. if (machine_is_netwinder())
  1430. del_timer(&vnc_timer);
  1431. #endif
  1433. release_region(devc->hw.io_base, 15);
  1435. waveartist_set_ctlr(&devc->hw, DMA1_IE|DMA0_IE, 0);
  1437. if (devc->hw.irq >= 0)
  1438. free_irq(devc->hw.irq, devc);
  1440. sound_free_dma(devc->hw.dma);
  1442. if (devc->hw.dma != devc->hw.dma2 &&
  1443.     devc->hw.dma2 != NO_DMA)
  1444. sound_free_dma(devc->hw.dma2);
  1446. mixer = audio_devs[devc->dev_no]->mixer_dev;
  1448. if (mixer >= 0)
  1449. sound_unload_mixerdev(mixer);
  1451. if (devc->dev_no >= 0)
  1452. sound_unload_audiodev(devc->dev_no);
  1454. nr_waveartist_devs -= 1;
  1456. for (; i < nr_waveartist_devs; i++)
  1457. adev_info[i] = adev_info[i + 1];
  1458. } else
  1459. printk(KERN_WARNING "waveartist: can't find device "
  1460.        "to unloadn");
  1461. }
  1463. #ifdef CONFIG_ARCH_NETWINDER
  1465. /*
  1466.  * Rebel.com Netwinder specifics...
  1467.  */
  1469. #include <asm/hardware/dec21285.h>
  1470.  
  1471. #define VNC_TIMER_PERIOD (HZ/4) //check slider 4 times/sec
  1473. #define MIXER_PRIVATE3_RESET 0x53570000
  1474. #define MIXER_PRIVATE3_READ 0x53570001
  1475. #define MIXER_PRIVATE3_WRITE 0x53570002
  1477. #define VNC_MUTE_INTERNAL_SPKR 0x01 //the sw mute on/off control bit
  1478. #define VNC_MUTE_LINE_OUT 0x10
  1479. #define VNC_PHONE_DETECT 0x20
  1480. #define VNC_HANDSET_DETECT 0x40
  1481. #define VNC_DISABLE_AUTOSWITCH 0x80
  1483. extern spinlock_t gpio_lock;
  1485. static inline void
  1486. vnc_mute_spkr(wavnc_info *devc)
  1487. {
  1488. unsigned long flags;
  1490. spin_lock_irqsave(&gpio_lock, flags);
  1491. cpld_modify(CPLD_UNMUTE, devc->spkr_mute_state ? 0 : CPLD_UNMUTE);
  1492. spin_unlock_irqrestore(&gpio_lock, flags);
  1493. }
  1495. static void
  1496. vnc_mute_lout(wavnc_info *devc)
  1497. {
  1498. unsigned int left, right;
  1500. left  = waveartist_cmd1_r(devc, WACMD_GET_LEVEL);
  1501. right = waveartist_cmd1_r(devc, WACMD_GET_LEVEL | 0x400);
  1503. if (devc->line_mute_state) {
  1504. left &= ~1;
  1505. right &= ~1;
  1506. } else {
  1507. left |= 1;
  1508. right |= 1;
  1509. }
  1510. waveartist_cmd3(devc, WACMD_SET_MIXER, left, right);
  1512. }
  1514. static int
  1515. vnc_volume_slider(wavnc_info *devc)
  1516. {
  1517. static signed int old_slider_volume;
  1518. unsigned long flags;
  1519. signed int volume = 255;
  1521. *CSR_TIMER1_LOAD = 0x00ffffff;
  1523. save_flags(flags);
  1524. cli();
  1526. outb(0xFF, 0x201);
  1527. *CSR_TIMER1_CNTL = TIMER_CNTL_ENABLE | TIMER_CNTL_DIV1;
  1529. while (volume && (inb(0x201) & 0x01))
  1530. volume--;
  1532. *CSR_TIMER1_CNTL = 0;
  1534. restore_flags(flags);
  1536. volume = 0x00ffffff - *CSR_TIMER1_VALUE;
  1539. #ifndef REVERSE
  1540. volume = 150 - (volume >> 5);
  1541. #else
  1542. volume = (volume >> 6) - 25;
  1543. #endif
  1545. if (volume < 0)
  1546. volume = 0;
  1548. if (volume > 100)
  1549. volume = 100;
  1551. /*
  1552.  * slider quite often reads +-8, so debounce this random noise
  1553.  */
  1554. if (abs(volume - old_slider_volume) > 7) {
  1555. old_slider_volume = volume;
  1557. if (debug_flg & DEBUG_MIXER)
  1558. printk(KERN_DEBUG "Slider volume: %d.n", volume);
  1559. }
  1561. return old_slider_volume;
  1562. }
  1564. /*
  1565.  * Decode a recording mask into a mixer selection on the NetWinder
  1566.  * as follows:
  1567.  *
  1568.  *     OSS Source WA Source Actual source
  1569.  *  SOUND_MASK_IMIX Mixer Mixer output (same as AD1848)
  1570.  *  SOUND_MASK_LINE Line Line in
  1571.  *  SOUND_MASK_LINE1 Left Mic Handset
  1572.  *  SOUND_MASK_PHONEIN Left Aux Telephone microphone
  1573.  *  SOUND_MASK_MIC Right Mic Builtin microphone
  1574.  */
  1575. static unsigned int
  1576. netwinder_select_input(wavnc_info *devc, unsigned int recmask,
  1577.        unsigned char *dev_l, unsigned char *dev_r)
  1578. {
  1579. unsigned int recdev_l = ADC_MUX_NONE, recdev_r = ADC_MUX_NONE;
  1581. if (recmask & SOUND_MASK_IMIX) {
  1582. recmask = SOUND_MASK_IMIX;
  1583. recdev_l = ADC_MUX_MIXER;
  1584. recdev_r = ADC_MUX_MIXER;
  1585. } else if (recmask & SOUND_MASK_LINE) {
  1586. recmask = SOUND_MASK_LINE;
  1587. recdev_l = ADC_MUX_LINE;
  1588. recdev_r = ADC_MUX_LINE;
  1589. } else if (recmask & SOUND_MASK_LINE1) {
  1590. recmask = SOUND_MASK_LINE1;
  1591. waveartist_cmd1(devc, WACMD_SET_MONO); /* left */
  1592. recdev_l = ADC_MUX_MIC;
  1593. recdev_r = ADC_MUX_NONE;
  1594. } else if (recmask & SOUND_MASK_PHONEIN) {
  1595. recmask = SOUND_MASK_PHONEIN;
  1596. waveartist_cmd1(devc, WACMD_SET_MONO); /* left */
  1597. recdev_l = ADC_MUX_AUX1;
  1598. recdev_r = ADC_MUX_NONE;
  1599. } else if (recmask & SOUND_MASK_MIC) {
  1600. recmask = SOUND_MASK_MIC;
  1601. waveartist_cmd1(devc, WACMD_SET_MONO | 0x100); /* right */
  1602. recdev_l = ADC_MUX_NONE;
  1603. recdev_r = ADC_MUX_MIC;
  1604. }
  1606. *dev_l = recdev_l;
  1607. *dev_r = recdev_r;
  1609. return recmask;
  1610. }
  1612. static int
  1613. netwinder_decode_mixer(wavnc_info *devc, int dev, unsigned char lev_l,
  1614.        unsigned char lev_r)
  1615. {
  1616. switch (dev) {
  1617. case SOUND_MIXER_VOLUME:
  1618. case SOUND_MIXER_SYNTH:
  1619. case SOUND_MIXER_PCM:
  1620. case SOUND_MIXER_LINE:
  1621. case SOUND_MIXER_IGAIN:
  1622. devc->levels[dev] = lev_l | lev_r << 8;
  1623. break;
  1625. case SOUND_MIXER_MIC: /* right mic only */
  1626. devc->levels[SOUND_MIXER_MIC] &= 0xff;
  1627. devc->levels[SOUND_MIXER_MIC] |= lev_l << 8;
  1628. break;
  1630. case SOUND_MIXER_LINE1: /* left mic only  */
  1631. devc->levels[SOUND_MIXER_MIC] &= 0xff00;
  1632. devc->levels[SOUND_MIXER_MIC] |= lev_l;
  1633. dev = SOUND_MIXER_MIC;
  1634. break;
  1636. case SOUND_MIXER_PHONEIN: /* left aux only  */
  1637. devc->levels[SOUND_MIXER_LINE1] = lev_l;
  1638. dev = SOUND_MIXER_LINE1;
  1639. break;
  1641. case SOUND_MIXER_IMIX:
  1642. case SOUND_MIXER_PHONEOUT:
  1643. break;
  1645. default:
  1646. dev = -EINVAL;
  1647. break;
  1648. }
  1649. return dev;
  1650. }
  1652. static int netwinder_get_mixer(wavnc_info *devc, int dev)
  1653. {
  1654. int levels;
  1656. switch (dev) {
  1657. case SOUND_MIXER_VOLUME:
  1658. case SOUND_MIXER_SYNTH:
  1659. case SOUND_MIXER_PCM:
  1660. case SOUND_MIXER_LINE:
  1661. case SOUND_MIXER_IGAIN:
  1662. levels = devc->levels[dev];
  1663. break;
  1665. case SOUND_MIXER_MIC: /* builtin mic: right mic only */
  1666. levels = devc->levels[SOUND_MIXER_MIC] >> 8;
  1667. levels |= levels << 8;
  1668. break;
  1670. case SOUND_MIXER_LINE1: /* handset mic: left mic only */
  1671. levels = devc->levels[SOUND_MIXER_MIC] & 0xff;
  1672. levels |= levels << 8;
  1673. break;
  1675. case SOUND_MIXER_PHONEIN: /* phone mic: left aux1 only */
  1676. levels = devc->levels[SOUND_MIXER_LINE1] & 0xff;
  1677. levels |= levels << 8;
  1678. break;
  1680. default:
  1681. levels = 0;
  1682. }
  1684. return levels;
  1685. }
  1687. /*
  1688.  * Waveartist specific mixer information.
  1689.  */
  1690. static const struct waveartist_mixer_info netwinder_mixer = {
  1691. supported_devs: SOUND_MASK_VOLUME  | SOUND_MASK_SYNTH   |
  1692. SOUND_MASK_PCM     | SOUND_MASK_SPEAKER |
  1693. SOUND_MASK_LINE    | SOUND_MASK_MIC     |
  1694. SOUND_MASK_IMIX    | SOUND_MASK_LINE1   |
  1695. SOUND_MASK_PHONEIN | SOUND_MASK_PHONEOUT|
  1696. SOUND_MASK_IGAIN,
  1698. recording_devs: SOUND_MASK_LINE    | SOUND_MASK_MIC     |
  1699. SOUND_MASK_IMIX    | SOUND_MASK_LINE1   |
  1700. SOUND_MASK_PHONEIN,
  1702. stereo_devs: SOUND_MASK_VOLUME  | SOUND_MASK_SYNTH   |
  1703. SOUND_MASK_PCM     | SOUND_MASK_LINE    |
  1704. SOUND_MASK_IMIX    | SOUND_MASK_IGAIN,
  1706. select_input: netwinder_select_input,
  1707. decode_mixer: netwinder_decode_mixer,
  1708. get_mixer: netwinder_get_mixer,
  1709. };
  1711. static void
  1712. vnc_configure_mixer(wavnc_info *devc, unsigned int recmask)
  1713. {
  1714. if (!devc->no_autoselect) {
  1715. if (devc->handset_detect) {
  1716. recmask = SOUND_MASK_LINE1;
  1717. devc->spkr_mute_state = devc->line_mute_state = 1;
  1718. } else if (devc->telephone_detect) {
  1719. recmask = SOUND_MASK_PHONEIN;
  1720. devc->spkr_mute_state = devc->line_mute_state = 1;
  1721. } else {
  1722. /* unless someone has asked for LINE-IN,
  1723.  * we default to MIC
  1724.  */
  1725. if ((devc->recmask & SOUND_MASK_LINE) == 0)
  1726. devc->recmask = SOUND_MASK_MIC;
  1727. devc->spkr_mute_state = devc->line_mute_state = 0;
  1728. }
  1729. vnc_mute_spkr(devc);
  1730. vnc_mute_lout(devc);
  1732. if (recmask != devc->recmask)
  1733. waveartist_set_recmask(devc, recmask);
  1734. }
  1735. }
  1737. static int
  1738. vnc_slider(wavnc_info *devc)
  1739. {
  1740. signed int slider_volume;
  1741. unsigned int temp, old_hs, old_td;
  1743. /*
  1744.  * read the "buttons" state.
  1745.  *  Bit 4 = 0 means handset present
  1746.  *  Bit 5 = 1 means phone offhook
  1747.  */
  1748. temp = inb(0x201);
  1750. old_hs = devc->handset_detect;
  1751. old_td = devc->telephone_detect;
  1753. devc->handset_detect = !(temp & 0x10);
  1754. devc->telephone_detect = !!(temp & 0x20);
  1756. if (!devc->no_autoselect &&
  1757.     (old_hs != devc->handset_detect ||
  1758.      old_td != devc->telephone_detect))
  1759. vnc_configure_mixer(devc, devc->recmask);
  1761. slider_volume = vnc_volume_slider(devc);
  1763. /*
  1764.  * If we're using software controlled volume, and
  1765.  * the slider moves by more than 20%, then we
  1766.  * switch back to slider controlled volume.
  1767.  */
  1768. if (abs(devc->slider_vol - slider_volume) > 20)
  1769. devc->use_slider = 1;
  1771. /*
  1772.  * use only left channel
  1773.  */
  1774. temp = levels[SOUND_MIXER_VOLUME] & 0xFF;
  1776. if (slider_volume != temp && devc->use_slider) {
  1777. devc->slider_vol = slider_volume;
  1779. waveartist_set_mixer(devc, SOUND_MIXER_VOLUME,
  1780. slider_volume | slider_volume << 8);
  1782. return 1;
  1783. }
  1785. return 0;
  1786. }
  1788. static void
  1789. vnc_slider_tick(unsigned long data)
  1790. {
  1791. int next_timeout;
  1793. if (vnc_slider(adev_info + data))
  1794. next_timeout = 5; // mixer reported change
  1795. else
  1796. next_timeout = VNC_TIMER_PERIOD;
  1798. mod_timer(&vnc_timer, jiffies + next_timeout);
  1799. }
  1801. static int
  1802. vnc_private_ioctl(int dev, unsigned int cmd, caddr_t arg)
  1803. {
  1804. wavnc_info *devc = (wavnc_info *)audio_devs[dev]->devc;
  1805. int val;
  1807. switch (cmd) {
  1808. case SOUND_MIXER_PRIVATE1:
  1809. {
  1810. u_int prev_spkr_mute, prev_line_mute, prev_auto_state;
  1811. int val;
  1813. if (get_user(val, (int *)arg))
  1814. return -EFAULT;
  1816. /* check if parameter is logical */
  1817. if (val & ~(VNC_MUTE_INTERNAL_SPKR |
  1818.     VNC_MUTE_LINE_OUT |
  1819.     VNC_DISABLE_AUTOSWITCH))
  1820. return -EINVAL;
  1822. prev_auto_state = devc->no_autoselect;
  1823. prev_spkr_mute  = devc->spkr_mute_state;
  1824. prev_line_mute  = devc->line_mute_state;
  1826. devc->no_autoselect   = (val & VNC_DISABLE_AUTOSWITCH) ? 1 : 0;
  1827. devc->spkr_mute_state = (val & VNC_MUTE_INTERNAL_SPKR) ? 1 : 0;
  1828. devc->line_mute_state = (val & VNC_MUTE_LINE_OUT) ? 1 : 0;
  1830. if (prev_spkr_mute != devc->spkr_mute_state)
  1831. vnc_mute_spkr(devc);
  1833. if (prev_line_mute != devc->line_mute_state)
  1834. vnc_mute_lout(devc);
  1836. if (prev_auto_state != devc->no_autoselect)
  1837. vnc_configure_mixer(devc, devc->recmask);
  1839. return 0;
  1840. }
  1842. case SOUND_MIXER_PRIVATE2:
  1843. if (get_user(val, (int *)arg))
  1844. return -EFAULT;
  1846. switch (val) {
  1847. #define VNC_SOUND_PAUSE         0x53    //to pause the DSP
  1848. #define VNC_SOUND_RESUME        0x57    //to unpause the DSP
  1849. case VNC_SOUND_PAUSE:
  1850. waveartist_cmd1(devc, 0x16);
  1851. break;
  1853. case VNC_SOUND_RESUME:
  1854. waveartist_cmd1(devc, 0x18);
  1855. break;
  1857. default:
  1858. return -EINVAL;
  1859. }
  1860. return 0;
  1862. /* private ioctl to allow bulk access to waveartist */
  1863. case SOUND_MIXER_PRIVATE3:
  1864. {
  1865. unsigned long flags;
  1866. int mixer_reg[15], i, val;
  1868. if (get_user(val, (int *)arg))
  1869. return -EFAULT;
  1870. if (copy_from_user(mixer_reg, (void *)val, sizeof(mixer_reg)))
  1871. return -EFAULT;
  1873. switch (mixer_reg[14]) {
  1874. case MIXER_PRIVATE3_RESET:
  1875. waveartist_mixer_reset(devc);
  1876. break;
  1878. case MIXER_PRIVATE3_WRITE:
  1879. waveartist_cmd3(devc, WACMD_SET_MIXER, mixer_reg[0], mixer_reg[4]);
  1880. waveartist_cmd3(devc, WACMD_SET_MIXER, mixer_reg[1], mixer_reg[5]);
  1881. waveartist_cmd3(devc, WACMD_SET_MIXER, mixer_reg[2], mixer_reg[6]);
  1882. waveartist_cmd3(devc, WACMD_SET_MIXER, mixer_reg[3], mixer_reg[7]);
  1883. waveartist_cmd3(devc, WACMD_SET_MIXER, mixer_reg[8], mixer_reg[9]);
  1885. waveartist_cmd3(devc, WACMD_SET_LEVEL, mixer_reg[10], mixer_reg[11]);
  1886. waveartist_cmd3(devc, WACMD_SET_LEVEL, mixer_reg[12], mixer_reg[13]);
  1887. break;
  1889. case MIXER_PRIVATE3_READ:
  1890. spin_lock_irqsave(&waveartist_lock, flags);
  1892. for (i = 0x30; i < 14 << 8; i += 1 << 8)
  1893. waveartist_cmd(devc, 1, &i, 1, mixer_reg + (i >> 8));
  1895. spin_unlock_irqrestore(&waveartist_lock, flags);
  1897. if (copy_to_user((void *)val, mixer_reg, sizeof(mixer_reg)))
  1898. return -EFAULT;
  1899. break;
  1901. default:
  1902. return -EINVAL;
  1903. }
  1904. return 0;
  1905. }
  1907. /* read back the state from PRIVATE1 */
  1908. case SOUND_MIXER_PRIVATE4:
  1909. val = (devc->spkr_mute_state  ? VNC_MUTE_INTERNAL_SPKR : 0) |
  1910.       (devc->line_mute_state  ? VNC_MUTE_LINE_OUT      : 0) |
  1911.       (devc->handset_detect   ? VNC_HANDSET_DETECT     : 0) |
  1912.       (devc->telephone_detect ? VNC_PHONE_DETECT       : 0) |
  1913.       (devc->no_autoselect    ? VNC_DISABLE_AUTOSWITCH : 0);
  1915. return put_user(val, (int *)arg) ? -EFAULT : 0;
  1916. }
  1918. if (_SIOC_DIR(cmd) & _SIOC_WRITE) {
  1919. /*
  1920.  * special case for master volume: if we
  1921.  * received this call - switch from hw
  1922.  * volume control to a software volume
  1923.  * control, till the hw volume is modified
  1924.  * to signal that user wants to be back in
  1925.  * hardware...
  1926.  */
  1927. if ((cmd & 0xff) == SOUND_MIXER_VOLUME)
  1928. devc->use_slider = 0;
  1930. /* speaker output            */
  1931. if ((cmd & 0xff) == SOUND_MIXER_SPEAKER) {
  1932. unsigned int val, l, r;
  1934. if (get_user(val, (int *)arg))
  1935. return -EFAULT;
  1937. l = val & 0x7f;
  1938. r = (val & 0x7f00) >> 8;
  1939. val = (l + r) / 2;
  1940. devc->levels[SOUND_MIXER_SPEAKER] = val | (val << 8);
  1941. devc->spkr_mute_state = (val <= 50);
  1942. vnc_mute_spkr(devc);
  1943. return 0;
  1944. }
  1945. }
  1947. return -ENOIOCTLCMD;
  1948. }
  1950. #endif
  1952. static struct address_info cfg;
  1954. static int attached;
  1956. static int __initdata io = 0;
  1957. static int __initdata irq = 0;
  1958. static int __initdata dma = 0;
  1959. static int __initdata dma2 = 0;
  1962. static int __init init_waveartist(void)
  1963. {
  1964. const struct waveartist_mixer_info *mix;
  1966. if (!io && machine_is_netwinder()) {
  1967. /*
  1968.  * The NetWinder WaveArtist is at a fixed address.
  1969.  * If the user does not supply an address, use the
  1970.  * well-known parameters.
  1971.  */
  1972. io   = 0x250;
  1973. irq  = 12;
  1974. dma  = 3;
  1975. dma2 = 7;
  1976. }
  1978. mix = &waveartist_mixer;
  1979. #ifdef CONFIG_ARCH_NETWINDER
  1980. if (machine_is_netwinder())
  1981. mix = &netwinder_mixer;
  1982. #endif
  1984. cfg.io_base = io;
  1985. cfg.irq = irq;
  1986. cfg.dma = dma;
  1987. cfg.dma2 = dma2;
  1989. if (!probe_waveartist(&cfg))
  1990. return -ENODEV;
  1992. attach_waveartist(&cfg, mix);
  1993. attached = 1;
  1995. return 0;
  1996. }
  1998. static void __exit cleanup_waveartist(void)
  1999. {
  2000. if (attached)
  2001. unload_waveartist(&cfg);
  2002. }
  2004. module_init(init_waveartist);
  2005. module_exit(cleanup_waveartist);
  2007. #ifndef MODULE
  2008. static int __init setup_waveartist(char *str)
  2009. {
  2010. /* io, irq, dma, dma2 */
  2011. int ints[5];
  2013. str = get_options(str, ARRAY_SIZE(ints), ints);
  2015. io = ints[1];
  2016. irq = ints[2];
  2017. dma = ints[3];
  2018. dma2 = ints[4];
  2020. return 1;
  2021. }
  2022. __setup("waveartist=", setup_waveartist);
  2023. #endif
  2025. MODULE_DESCRIPTION("Rockwell WaveArtist RWA-010 sound driver");
  2026. MODULE_PARM(io, "i"); /* IO base */
  2027. MODULE_PARM(irq, "i"); /* IRQ */
  2028. MODULE_PARM(dma, "i"); /* DMA */
  2029. MODULE_PARM(dma2, "i"); /* DMA2 */
  2030. MODULE_LICENSE("GPL");