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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
waveartist.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：46k
源码类别：

Linux/Unix编程

开发平台：

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. if (inb(io_base + STATR) & CMD_RF) {
  251. int old_data;
  253. /* flush the port
  254.  */
  256. old_data = inw(io_base + CMDR);
  258. if (debug_flg & DEBUG_CMD)
  259. printk("flushed %04X...", old_data);
  261. udelay(10);
  262. }
  264. for (i = 0; !timed_out && i < nr_cmd; i++) {
  265. int count;
  267. for (count = 5000; count; count--)
  268. if (inb(io_base + STATR) & CMD_WE)
  269. break;
  271. if (!count)
  272. timed_out = 1;
  273. else
  274. outw(cmd[i], io_base + CMDR);
  275. }
  277. for (i = 0; !timed_out && i < nr_resp; i++) {
  278. int count;
  280. for (count = 5000; count; count--)
  281. if (inb(io_base + STATR) & CMD_RF)
  282. break;
  284. if (!count)
  285. timed_out = 1;
  286. else
  287. resp[i] = inw(io_base + CMDR);
  288. }
  290. if (debug_flg & DEBUG_CMD) {
  291. if (!timed_out) {
  292. printk("waveartist_cmd: resp=");
  294. for (i = 0; i < nr_resp; i++)
  295. printk("%04X ", resp[i]);
  297. printk("n");
  298. } else
  299. printk("waveartist_cmd: timed outn");
  300. }
  302. return timed_out ? 1 : 0;
  303. }
  305. /*
  306.  * Send one command word
  307.  */
  308. static inline int
  309. waveartist_cmd1(wavnc_info *devc, unsigned int cmd)
  310. {
  311. return waveartist_cmd(devc, 1, &cmd, 0, NULL);
  312. }
  314. /*
  315.  * Send one command, receive one word
  316.  */
  317. static inline unsigned int
  318. waveartist_cmd1_r(wavnc_info *devc, unsigned int cmd)
  319. {
  320. unsigned int ret;
  322. waveartist_cmd(devc, 1, &cmd, 1, &ret);
  324. return ret;
  325. }
  327. /*
  328.  * Send a double command, receive one
  329.  * word (and throw it away)
  330.  */
  331. static inline int
  332. waveartist_cmd2(wavnc_info *devc, unsigned int cmd, unsigned int arg)
  333. {
  334. unsigned int vals[2];
  336. vals[0] = cmd;
  337. vals[1] = arg;
  339. return waveartist_cmd(devc, 2, vals, 1, vals);
  340. }
  342. /*
  343.  * Send a triple command
  344.  */
  345. static inline int
  346. waveartist_cmd3(wavnc_info *devc, unsigned int cmd,
  347. unsigned int arg1, unsigned int arg2)
  348. {
  349. unsigned int vals[3];
  351. vals[0] = cmd;
  352. vals[1] = arg1;
  353. vals[2] = arg2;
  355. return waveartist_cmd(devc, 3, vals, 0, NULL);
  356. }
  358. static int
  359. waveartist_getrev(wavnc_info *devc, char *rev)
  360. {
  361. unsigned int temp[2];
  362. unsigned int cmd = WACMD_GETREV;
  364. waveartist_cmd(devc, 1, &cmd, 2, temp);
  366. rev[0] = temp[0] >> 8;
  367. rev[1] = temp[0] & 255;
  368. rev[2] = '';
  370. return temp[0];
  371. }
  373. static void waveartist_halt_output(int dev);
  374. static void waveartist_halt_input(int dev);
  375. static void waveartist_halt(int dev);
  376. static void waveartist_trigger(int dev, int state);
  378. static int
  379. waveartist_open(int dev, int mode)
  380. {
  381. wavnc_info *devc;
  382. wavnc_port_info *portc;
  383. unsigned long flags;
  385. if (dev < 0 || dev >= num_audiodevs)
  386. return -ENXIO;
  388. devc  = (wavnc_info *) audio_devs[dev]->devc;
  389. portc = (wavnc_port_info *) audio_devs[dev]->portc;
  391. spin_lock_irqsave(&waveartist_lock, flags);
  392. if (portc->open_mode || (devc->open_mode & mode)) {
  393. spin_unlock_irqrestore(&waveartist_lock, flags);
  394. return -EBUSY;
  395. }
  397. devc->audio_mode  = 0;
  398. devc->open_mode  |= mode;
  399. portc->open_mode  = mode;
  400. waveartist_trigger(dev, 0);
  402. if (mode & OPEN_READ)
  403. devc->record_dev = dev;
  404. if (mode & OPEN_WRITE)
  405. devc->playback_dev = dev;
  406. spin_unlock_irqrestore(&waveartist_lock, flags);
  408. return 0;
  409. }
  411. static void
  412. waveartist_close(int dev)
  413. {
  414. wavnc_info *devc = (wavnc_info *) audio_devs[dev]->devc;
  415. wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
  416. unsigned long flags;
  418. spin_lock_irqsave(&waveartist_lock, flags);
  420. waveartist_halt(dev);
  422. devc->audio_mode = 0;
  423. devc->open_mode &= ~portc->open_mode;
  424. portc->open_mode = 0;
  426. spin_unlock_irqrestore(&waveartist_lock, flags);
  427. }
  429. static void
  430. waveartist_output_block(int dev, unsigned long buf, int __count, int intrflag)
  431. {
  432. wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
  433. wavnc_info *devc = (wavnc_info *) audio_devs[dev]->devc;
  434. unsigned long flags;
  435. unsigned int count = __count; 
  437. if (debug_flg & DEBUG_OUT)
  438. printk("waveartist: output block, buf=0x%lx, count=0x%x...n",
  439. buf, count);
  440. /*
  441.  * 16 bit data
  442.  */
  443. if (portc->audio_format & (AFMT_S16_LE | AFMT_S16_BE))
  444. count >>= 1;
  446. if (portc->channels > 1)
  447. count >>= 1;
  449. count -= 1;
  451. if (devc->audio_mode & PCM_ENABLE_OUTPUT &&
  452.     audio_devs[dev]->flags & DMA_AUTOMODE &&
  453.     intrflag &&
  454.     count == devc->xfer_count) {
  455. devc->audio_mode |= PCM_ENABLE_OUTPUT;
  456. return; /*
  457.  * Auto DMA mode on. No need to react
  458.  */
  459. }
  461. spin_lock_irqsave(&waveartist_lock, flags);
  463. /*
  464.  * set sample count
  465.  */
  466. waveartist_cmd2(devc, WACMD_OUTPUTSIZE, count);
  468. devc->xfer_count = count;
  469. devc->audio_mode |= PCM_ENABLE_OUTPUT;
  471. spin_unlock_irqrestore(&waveartist_lock, flags);
  472. }
  474. static void
  475. waveartist_start_input(int dev, unsigned long buf, int __count, int intrflag)
  476. {
  477. wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
  478. wavnc_info *devc = (wavnc_info *) audio_devs[dev]->devc;
  479. unsigned long flags;
  480. unsigned int count = __count;
  482. if (debug_flg & DEBUG_IN)
  483. printk("waveartist: start input, buf=0x%lx, count=0x%x...n",
  484. buf, count);
  486. if (portc->audio_format & (AFMT_S16_LE | AFMT_S16_BE)) /* 16 bit data */
  487. count >>= 1;
  489. if (portc->channels > 1)
  490. count >>= 1;
  492. count -= 1;
  494. if (devc->audio_mode & PCM_ENABLE_INPUT &&
  495.     audio_devs[dev]->flags & DMA_AUTOMODE &&
  496.     intrflag &&
  497.     count == devc->xfer_count) {
  498. devc->audio_mode |= PCM_ENABLE_INPUT;
  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. if (devc->audio_mode)
  575. return 0;
  577. speed = waveartist_get_speed(portc);
  578. bits  = waveartist_get_bits(portc);
  580. spin_lock_irqsave(&waveartist_lock, flags);
  582. if (waveartist_cmd2(devc, WACMD_INPUTFORMAT, bits))
  583. printk(KERN_WARNING "waveartist: error setting the "
  584.        "record format to %dn", portc->audio_format);
  586. if (waveartist_cmd2(devc, WACMD_INPUTCHANNELS, portc->channels))
  587. printk(KERN_WARNING "waveartist: error setting record "
  588.        "to %d channelsn", portc->channels);
  590. /*
  591.  * write cmd SetSampleSpeedTimeConstant
  592.  */
  593. if (waveartist_cmd2(devc, WACMD_INPUTSPEED, speed))
  594. printk(KERN_WARNING "waveartist: error setting the record "
  595.        "speed to %dHz.n", portc->speed);
  597. if (waveartist_cmd2(devc, WACMD_INPUTDMA, 1))
  598. printk(KERN_WARNING "waveartist: error setting the record "
  599.        "data path to 0x%Xn", 1);
  601. if (waveartist_cmd2(devc, WACMD_INPUTFORMAT, bits))
  602. printk(KERN_WARNING "waveartist: error setting the record "
  603.        "format to %dn", portc->audio_format);
  605. devc->xfer_count = 0;
  606. spin_unlock_irqrestore(&waveartist_lock, flags);
  607. waveartist_halt_input(dev);
  609. if (debug_flg & DEBUG_INTR) {
  610. printk("WA CTLR reg: 0x%02X.n",
  611.        inb(devc->hw.io_base + CTLR));
  612. printk("WA STAT reg: 0x%02X.n",
  613.        inb(devc->hw.io_base + STATR));
  614. printk("WA IRQS reg: 0x%02X.n",
  615.        inb(devc->hw.io_base + IRQSTAT));
  616. }
  618. return 0;
  619. }
  621. static int
  622. waveartist_prepare_for_output(int dev, int bsize, int bcount)
  623. {
  624. unsigned long flags;
  625. wavnc_info *devc = (wavnc_info *) audio_devs[dev]->devc;
  626. wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
  627. unsigned int speed, bits;
  629. /*
  630.  * program the speed, channels, bits
  631.  */
  632. speed = waveartist_get_speed(portc);
  633. bits  = waveartist_get_bits(portc);
  635. spin_lock_irqsave(&waveartist_lock, flags);
  637. if (waveartist_cmd2(devc, WACMD_OUTPUTSPEED, speed) &&
  638.     waveartist_cmd2(devc, WACMD_OUTPUTSPEED, speed))
  639. printk(KERN_WARNING "waveartist: error setting the playback "
  640.        "speed to %dHz.n", portc->speed);
  642. if (waveartist_cmd2(devc, WACMD_OUTPUTCHANNELS, portc->channels))
  643. printk(KERN_WARNING "waveartist: error setting the playback "
  644.        "to %d channelsn", portc->channels);
  646. if (waveartist_cmd2(devc, WACMD_OUTPUTDMA, 0))
  647. printk(KERN_WARNING "waveartist: error setting the playback "
  648.        "data path to 0x%Xn", 0);
  650. if (waveartist_cmd2(devc, WACMD_OUTPUTFORMAT, bits))
  651. printk(KERN_WARNING "waveartist: error setting the playback "
  652.        "format to %dn", portc->audio_format);
  654. devc->xfer_count = 0;
  655. spin_unlock_irqrestore(&waveartist_lock, flags);
  656. waveartist_halt_output(dev);
  658. if (debug_flg & DEBUG_INTR) {
  659. printk("WA CTLR reg: 0x%02X.n",inb(devc->hw.io_base + CTLR));
  660. printk("WA STAT reg: 0x%02X.n",inb(devc->hw.io_base + STATR));
  661. printk("WA IRQS reg: 0x%02X.n",inb(devc->hw.io_base + IRQSTAT));
  662. }
  664. return 0;
  665. }
  667. static void
  668. waveartist_halt(int dev)
  669. {
  670. wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
  671. wavnc_info *devc;
  673. if (portc->open_mode & OPEN_WRITE)
  674. waveartist_halt_output(dev);
  676. if (portc->open_mode & OPEN_READ)
  677. waveartist_halt_input(dev);
  679. devc = (wavnc_info *) audio_devs[dev]->devc;
  680. devc->audio_mode = 0;
  681. }
  683. static void
  684. waveartist_halt_input(int dev)
  685. {
  686. wavnc_info *devc = (wavnc_info *) audio_devs[dev]->devc;
  687. unsigned long flags;
  689. spin_lock_irqsave(&waveartist_lock, flags);
  691. /*
  692.  * Stop capture
  693.  */
  694. waveartist_cmd1(devc, WACMD_INPUTSTOP);
  696. devc->audio_mode &= ~PCM_ENABLE_INPUT;
  698. /*
  699.  * Clear interrupt by toggling
  700.  * the IRQ_ACK bit in CTRL
  701.  */
  702. if (inb(devc->hw.io_base + STATR) & IRQ_REQ)
  703. waveartist_iack(devc);
  705. // devc->audio_mode &= ~PCM_ENABLE_INPUT;
  707. spin_unlock_irqrestore(&waveartist_lock, flags);
  708. }
  710. static void
  711. waveartist_halt_output(int dev)
  712. {
  713. wavnc_info *devc = (wavnc_info *) audio_devs[dev]->devc;
  714. unsigned long flags;
  716. spin_lock_irqsave(&waveartist_lock, flags);
  718. waveartist_cmd1(devc, WACMD_OUTPUTSTOP);
  720. devc->audio_mode &= ~PCM_ENABLE_OUTPUT;
  722. /*
  723.  * Clear interrupt by toggling
  724.  * the IRQ_ACK bit in CTRL
  725.  */
  726. if (inb(devc->hw.io_base + STATR) & IRQ_REQ)
  727. waveartist_iack(devc);
  729. // devc->audio_mode &= ~PCM_ENABLE_OUTPUT;
  731. spin_unlock_irqrestore(&waveartist_lock, flags);
  732. }
  734. static void
  735. waveartist_trigger(int dev, int state)
  736. {
  737. wavnc_info *devc = (wavnc_info *) audio_devs[dev]->devc;
  738. wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
  739. unsigned long flags;
  741. if (debug_flg & DEBUG_TRIGGER) {
  742. printk("wavnc: audio trigger ");
  743. if (state & PCM_ENABLE_INPUT)
  744. printk("in ");
  745. if (state & PCM_ENABLE_OUTPUT)
  746. printk("out");
  747. printk("n");
  748. }
  750. spin_lock_irqsave(&waveartist_lock, flags);
  752. state &= devc->audio_mode;
  754. if (portc->open_mode & OPEN_READ &&
  755.     state & PCM_ENABLE_INPUT)
  756. /*
  757.  * enable ADC Data Transfer to PC
  758.  */
  759. waveartist_cmd1(devc, WACMD_INPUTSTART);
  761. if (portc->open_mode & OPEN_WRITE &&
  762.     state & PCM_ENABLE_OUTPUT)
  763. /*
  764.  * enable DAC data transfer from PC
  765.  */
  766. waveartist_cmd1(devc, WACMD_OUTPUTSTART);
  768. spin_unlock_irqrestore(&waveartist_lock, flags);
  769. }
  771. static int
  772. waveartist_set_speed(int dev, int arg)
  773. {
  774. wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
  776. if (arg <= 0)
  777. return portc->speed;
  779. if (arg < 5000)
  780. arg = 5000;
  781. if (arg > 44100)
  782. arg = 44100;
  784. portc->speed = arg;
  785. return portc->speed;
  787. }
  789. static short
  790. waveartist_set_channels(int dev, short arg)
  791. {
  792. wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
  794. if (arg != 1 && arg != 2)
  795. return portc->channels;
  797. portc->channels = arg;
  798. return arg;
  799. }
  801. static unsigned int
  802. waveartist_set_bits(int dev, unsigned int arg)
  803. {
  804. wavnc_port_info *portc = (wavnc_port_info *) audio_devs[dev]->portc;
  806. if (arg == 0)
  807. return portc->audio_format;
  809. if ((arg != AFMT_U8) && (arg != AFMT_S16_LE) && (arg != AFMT_S8))
  810. arg = AFMT_U8;
  812. portc->audio_format = arg;
  814. return arg;
  815. }
  817. static struct audio_driver waveartist_audio_driver = {
  818. owner: THIS_MODULE,
  819. open: waveartist_open,
  820. close: waveartist_close,
  821. output_block: waveartist_output_block,
  822. start_input: waveartist_start_input,
  823. ioctl: waveartist_ioctl,
  824. prepare_for_input: waveartist_prepare_for_input,
  825. prepare_for_output: waveartist_prepare_for_output,
  826. halt_io: waveartist_halt,
  827. halt_input: waveartist_halt_input,
  828. halt_output: waveartist_halt_output,
  829. trigger: waveartist_trigger,
  830. set_speed: waveartist_set_speed,
  831. set_bits: waveartist_set_bits,
  832. set_channels: waveartist_set_channels
  833. };
  836. static void
  837. waveartist_intr(int irq, void *dev_id, struct pt_regs *regs)
  838. {
  839. wavnc_info *devc = (wavnc_info *)dev_id;
  840. int    irqstatus, status;
  842. irqstatus = inb(devc->hw.io_base + IRQSTAT);
  843. status    = inb(devc->hw.io_base + STATR);
  845. if (debug_flg & DEBUG_INTR)
  846. printk("waveartist_intr: stat=%02x, irqstat=%02xn",
  847.        status, irqstatus);
  849. if (status & IRQ_REQ) /* Clear interrupt */
  850. waveartist_iack(devc);
  851. else
  852. printk(KERN_WARNING "waveartist: unexpected interruptn");
  854. if (irqstatus & 0x01) {
  855. int temp = 1;
  857. /* PCM buffer done
  858.  */
  859. if ((status & DMA0) && (devc->audio_mode & PCM_ENABLE_OUTPUT)) {
  860. DMAbuf_outputintr(devc->playback_dev, 1);
  861. temp = 0;
  862. }
  863. if ((status & DMA1) && (devc->audio_mode & PCM_ENABLE_INPUT)) {
  864. DMAbuf_inputintr(devc->record_dev);
  865. temp = 0;
  866. }
  867. if (temp) //default:
  868. printk(KERN_WARNING "waveartist: Unknown interruptn");
  869. }
  870. if (irqstatus & 0x2)
  871. // We do not use SB mode natively...
  872. printk(KERN_WARNING "waveartist: Unexpected SB interrupt...n");
  873. }
  875. /* -------------------------------------------------------------------------
  876.  * Mixer stuff
  877.  */
  878. struct mix_ent {
  879. unsigned char reg_l;
  880. unsigned char reg_r;
  881. unsigned char shift;
  882. unsigned char max;
  883. };
  885. static const struct mix_ent mix_devs[SOUND_MIXER_NRDEVICES] = {
  886. { 2, 6, 1,  7 }, /* SOUND_MIXER_VOLUME   */
  887. { 0, 0, 0,  0 }, /* SOUND_MIXER_BASS     */
  888. { 0, 0, 0,  0 }, /* SOUND_MIXER_TREBLE   */
  889. { 0, 0, 0,  0 }, /* SOUND_MIXER_SYNTH    */
  890. { 0, 0, 0,  0 }, /* SOUND_MIXER_PCM      */
  891. { 0, 0, 0,  0 }, /* SOUND_MIXER_SPEAKER  */
  892. { 0, 4, 6, 31 }, /* SOUND_MIXER_LINE     */
  893. { 2, 6, 4,  3 }, /* SOUND_MIXER_MIC      */
  894. { 0, 0, 0,  0 }, /* SOUND_MIXER_CD       */
  895. { 0, 0, 0,  0 }, /* SOUND_MIXER_IMIX     */
  896. { 0, 0, 0,  0 }, /* SOUND_MIXER_ALTPCM   */
  897. #if 0
  898. { 3, 7, 0, 10 }, /* SOUND_MIXER_RECLEV   */
  899. { 0, 0, 0,  0 }, /* SOUND_MIXER_IGAIN    */
  900. #else
  901. { 0, 0, 0,  0 }, /* SOUND_MIXER_RECLEV   */
  902. { 3, 7, 0,  7 }, /* SOUND_MIXER_IGAIN    */
  903. #endif
  904. { 0, 0, 0,  0 }, /* SOUND_MIXER_OGAIN    */
  905. { 0, 4, 1, 31 }, /* SOUND_MIXER_LINE1    */
  906. { 1, 5, 6, 31 }, /* SOUND_MIXER_LINE2    */
  907. { 0, 0, 0,  0 }, /* SOUND_MIXER_LINE3    */
  908. { 0, 0, 0,  0 }, /* SOUND_MIXER_DIGITAL1 */
  909. { 0, 0, 0,  0 }, /* SOUND_MIXER_DIGITAL2 */
  910. { 0, 0, 0,  0 }, /* SOUND_MIXER_DIGITAL3 */
  911. { 0, 0, 0,  0 }, /* SOUND_MIXER_PHONEIN  */
  912. { 0, 0, 0,  0 }, /* SOUND_MIXER_PHONEOUT */
  913. { 0, 0, 0,  0 }, /* SOUND_MIXER_VIDEO    */
  914. { 0, 0, 0,  0 }, /* SOUND_MIXER_RADIO    */
  915. { 0, 0, 0,  0 }  /* SOUND_MIXER_MONITOR  */
  916. };
  918. static void
  919. waveartist_mixer_update(wavnc_info *devc, int whichDev)
  920. {
  921. unsigned int lev_left, lev_right;
  923. lev_left  = devc->levels[whichDev] & 0xff;
  924. lev_right = devc->levels[whichDev] >> 8;
  926. if (lev_left > 100)
  927. lev_left = 100;
  928. if (lev_right > 100)
  929. lev_right = 100;
  931. #define SCALE(lev,max) ((lev) * (max) / 100)
  933. if (machine_is_netwinder() && whichDev == SOUND_MIXER_PHONEOUT)
  934. whichDev = SOUND_MIXER_VOLUME;
  936. if (mix_devs[whichDev].reg_l || mix_devs[whichDev].reg_r) {
  937. const struct mix_ent *mix = mix_devs + whichDev;
  938. unsigned int mask, left, right;
  940. mask = mix->max << mix->shift;
  941. lev_left  = SCALE(lev_left,  mix->max) << mix->shift;
  942. lev_right = SCALE(lev_right, mix->max) << mix->shift;
  944. /* read left setting */
  945. left  = waveartist_cmd1_r(devc, WACMD_GET_LEVEL |
  946.        mix->reg_l << 8);
  948. /* read right setting */
  949. right = waveartist_cmd1_r(devc, WACMD_GET_LEVEL |
  950. mix->reg_r << 8);
  952. left  = (left  & ~mask) | (lev_left  & mask);
  953. right = (right & ~mask) | (lev_right & mask);
  955. /* write left,right back */
  956. waveartist_cmd3(devc, WACMD_SET_MIXER, left, right);
  957. } else {
  958. switch(whichDev) {
  959. case SOUND_MIXER_PCM:
  960. waveartist_cmd3(devc, WACMD_SET_LEVEL,
  961. SCALE(lev_left,  32767),
  962. SCALE(lev_right, 32767));
  963. break;
  965. case SOUND_MIXER_SYNTH:
  966. waveartist_cmd3(devc, 0x0100 | WACMD_SET_LEVEL,
  967. SCALE(lev_left,  32767),
  968. SCALE(lev_right, 32767));
  969. break;
  970. }
  971. }
  972. }
  974. /*
  975.  * Set the ADC MUX to the specified values.  We do NOT do any
  976.  * checking of the values passed, since we assume that the
  977.  * relevant *_select_input function has done that for us.
  978.  */
  979. static void
  980. waveartist_set_adc_mux(wavnc_info *devc, char left_dev, char right_dev)
  981. {
  982. unsigned int reg_08, reg_09;
  984. reg_08 = waveartist_cmd1_r(devc, WACMD_GET_LEVEL | 0x0800);
  985. reg_09 = waveartist_cmd1_r(devc, WACMD_GET_LEVEL | 0x0900);
  987. reg_08 = (reg_08 & ~0x3f) | right_dev << 3 | left_dev;
  989. waveartist_cmd3(devc, WACMD_SET_MIXER, reg_08, reg_09);
  990. }
  992. /*
  993.  * Decode a recording mask into a mixer selection as follows:
  994.  *
  995.  *     OSS Source WA Source Actual source
  996.  *  SOUND_MASK_IMIX Mixer Mixer output (same as AD1848)
  997.  *  SOUND_MASK_LINE Line Line in
  998.  *  SOUND_MASK_LINE1 Aux 1 Aux 1 in
  999.  *  SOUND_MASK_LINE2 Aux 2 Aux 2 in
  1000.  *  SOUND_MASK_MIC Mic Microphone
  1001.  */
  1002. static unsigned int
  1003. waveartist_select_input(wavnc_info *devc, unsigned int recmask,
  1004. unsigned char *dev_l, unsigned char *dev_r)
  1005. {
  1006. unsigned int recdev = ADC_MUX_NONE;
  1008. if (recmask & SOUND_MASK_IMIX) {
  1009. recmask = SOUND_MASK_IMIX;
  1010. recdev = ADC_MUX_MIXER;
  1011. } else if (recmask & SOUND_MASK_LINE2) {
  1012. recmask = SOUND_MASK_LINE2;
  1013. recdev = ADC_MUX_AUX2;
  1014. } else if (recmask & SOUND_MASK_LINE1) {
  1015. recmask = SOUND_MASK_LINE1;
  1016. recdev = ADC_MUX_AUX1;
  1017. } else if (recmask & SOUND_MASK_LINE) {
  1018. recmask = SOUND_MASK_LINE;
  1019. recdev = ADC_MUX_LINE;
  1020. } else if (recmask & SOUND_MASK_MIC) {
  1021. recmask = SOUND_MASK_MIC;
  1022. recdev = ADC_MUX_MIC;
  1023. }
  1025. *dev_l = *dev_r = recdev;
  1027. return recmask;
  1028. }
  1030. static int
  1031. waveartist_decode_mixer(wavnc_info *devc, int dev, unsigned char lev_l,
  1032. unsigned char lev_r)
  1033. {
  1034. switch (dev) {
  1035. case SOUND_MIXER_VOLUME:
  1036. case SOUND_MIXER_SYNTH:
  1037. case SOUND_MIXER_PCM:
  1038. case SOUND_MIXER_LINE:
  1039. case SOUND_MIXER_MIC:
  1040. case SOUND_MIXER_IGAIN:
  1041. case SOUND_MIXER_LINE1:
  1042. case SOUND_MIXER_LINE2:
  1043. devc->levels[dev] = lev_l | lev_r << 8;
  1044. break;
  1046. case SOUND_MIXER_IMIX:
  1047. break;
  1049. default:
  1050. dev = -EINVAL;
  1051. break;
  1052. }
  1054. return dev;
  1055. }
  1057. static int waveartist_get_mixer(wavnc_info *devc, int dev)
  1058. {
  1059. return devc->levels[dev];
  1060. }
  1062. static const struct waveartist_mixer_info waveartist_mixer = {
  1063. supported_devs: SUPPORTED_MIXER_DEVICES | SOUND_MASK_IGAIN,
  1064. recording_devs: SOUND_MASK_LINE  | SOUND_MASK_MIC   |
  1065. SOUND_MASK_LINE1 | SOUND_MASK_LINE2 |
  1066. SOUND_MASK_IMIX,
  1067. stereo_devs: (SUPPORTED_MIXER_DEVICES | SOUND_MASK_IGAIN) & ~
  1068. (SOUND_MASK_SPEAKER | SOUND_MASK_IMIX),
  1069. select_input: waveartist_select_input,
  1070. decode_mixer: waveartist_decode_mixer,
  1071. get_mixer: waveartist_get_mixer,
  1072. };
  1074. static void
  1075. waveartist_set_recmask(wavnc_info *devc, unsigned int recmask)
  1076. {
  1077. unsigned char dev_l, dev_r;
  1079. recmask &= devc->mix->recording_devs;
  1081. /*
  1082.  * If more than one recording device selected,
  1083.  * disable the device that is currently in use.
  1084.  */
  1085. if (hweight32(recmask) > 1)
  1086. recmask &= ~devc->recmask;
  1088. /*
  1089.  * Translate the recording device mask into
  1090.  * the ADC multiplexer settings.
  1091.  */
  1092. devc->recmask = devc->mix->select_input(devc, recmask,
  1093. &dev_l, &dev_r);
  1095. waveartist_set_adc_mux(devc, dev_l, dev_r);
  1096. }
  1098. static int
  1099. waveartist_set_mixer(wavnc_info *devc, int dev, unsigned int level)
  1100. {
  1101. unsigned int lev_left  = level & 0x00ff;
  1102. unsigned int lev_right = (level & 0xff00) >> 8;
  1104. if (lev_left > 100)
  1105. lev_left = 100;
  1106. if (lev_right > 100)
  1107. lev_right = 100;
  1109. /*
  1110.  * Mono devices have their right volume forced to their
  1111.  * left volume.  (from ALSA driver OSS emulation).
  1112.  */
  1113. if (!(devc->mix->stereo_devs & (1 << dev)))
  1114. lev_right = lev_left;
  1116. dev = devc->mix->decode_mixer(devc, dev, lev_left, lev_right);
  1118. if (dev >= 0)
  1119. waveartist_mixer_update(devc, dev);
  1121. return dev < 0 ? dev : 0;
  1122. }
  1124. static int
  1125. waveartist_mixer_ioctl(int dev, unsigned int cmd, caddr_t arg)
  1126. {
  1127. wavnc_info *devc = (wavnc_info *)audio_devs[dev]->devc;
  1128. int ret = 0, val, nr;
  1130. /*
  1131.  * All SOUND_MIXER_* ioctls use type 'M'
  1132.  */
  1133. if (((cmd >> 8) & 255) != 'M')
  1134. return -ENOIOCTLCMD;
  1136. #ifdef CONFIG_ARCH_NETWINDER
  1137. if (machine_is_netwinder()) {
  1138. ret = vnc_private_ioctl(dev, cmd, arg);
  1139. if (ret != -ENOIOCTLCMD)
  1140. return ret;
  1141. else
  1142. ret = 0;
  1143. }
  1144. #endif
  1146. nr = cmd & 0xff;
  1148. if (_SIOC_DIR(cmd) & _SIOC_WRITE) {
  1149. if (get_user(val, (int *)arg))
  1150. return -EFAULT;
  1152. switch (nr) {
  1153. case SOUND_MIXER_RECSRC:
  1154. waveartist_set_recmask(devc, val);
  1155. break;
  1157. default:
  1158. ret = -EINVAL;
  1159. if (nr < SOUND_MIXER_NRDEVICES &&
  1160.     devc->mix->supported_devs & (1 << nr))
  1161. ret = waveartist_set_mixer(devc, nr, val);
  1162. }
  1163. }
  1165. if (ret == 0 && _SIOC_DIR(cmd) & _SIOC_READ) {
  1166. ret = -EINVAL;
  1168. switch (nr) {
  1169. case SOUND_MIXER_RECSRC:
  1170. ret = devc->recmask;
  1171. break;
  1173. case SOUND_MIXER_DEVMASK:
  1174. ret = devc->mix->supported_devs;
  1175. break;
  1177. case SOUND_MIXER_STEREODEVS:
  1178. ret = devc->mix->stereo_devs;
  1179. break;
  1181. case SOUND_MIXER_RECMASK:
  1182. ret = devc->mix->recording_devs;
  1183. break;
  1185. case SOUND_MIXER_CAPS:
  1186. ret = SOUND_CAP_EXCL_INPUT;
  1187. break;
  1189. default:
  1190. if (nr < SOUND_MIXER_NRDEVICES)
  1191. ret = devc->mix->get_mixer(devc, nr);
  1192. break;
  1193. }
  1195. if (ret >= 0)
  1196. ret = put_user(ret, (int *)arg) ? -EFAULT : 0;
  1197. }
  1199. return ret;
  1200. }
  1202. static struct mixer_operations waveartist_mixer_operations =
  1203. {
  1204. owner: THIS_MODULE,
  1205. id: "WaveArtist",
  1206. name: "WaveArtist",
  1207. ioctl: waveartist_mixer_ioctl
  1208. };
  1210. static void
  1211. waveartist_mixer_reset(wavnc_info *devc)
  1212. {
  1213. int i;
  1215. if (debug_flg & DEBUG_MIXER)
  1216. printk("%s: mixer_resetn", devc->hw.name);
  1218. /*
  1219.  * reset mixer cmd
  1220.  */
  1221. waveartist_cmd1(devc, WACMD_RST_MIXER);
  1223. /*
  1224.  * set input for ADC to come from 'quiet'
  1225.  * turn on default modes
  1226.  */
  1227. waveartist_cmd3(devc, WACMD_SET_MIXER, 0x9800, 0xa836);
  1229. /*
  1230.  * set mixer input select to none, RX filter gains 0 dB
  1231.  */
  1232. waveartist_cmd3(devc, WACMD_SET_MIXER, 0x4c00, 0x8c00);
  1234. /*
  1235.  * set bit 0 reg 2 to 1 - unmute MonoOut
  1236.  */
  1237. waveartist_cmd3(devc, WACMD_SET_MIXER, 0x2801, 0x6800);
  1239. /* set default input device = internal mic
  1240.  * current recording device = none
  1241.  */
  1242. waveartist_set_recmask(devc, 0);
  1244. for (i = 0; i < SOUND_MIXER_NRDEVICES; i++)
  1245. waveartist_mixer_update(devc, i);
  1246. }
  1248. static int __init waveartist_init(wavnc_info *devc)
  1249. {
  1250. wavnc_port_info *portc;
  1251. char rev[3], dev_name[64];
  1252. int my_dev;
  1254. if (waveartist_reset(devc))
  1255. return -ENODEV;
  1257. sprintf(dev_name, "%s (%s", devc->hw.name, devc->chip_name);
  1259. if (waveartist_getrev(devc, rev)) {
  1260. strcat(dev_name, " rev. ");
  1261. strcat(dev_name, rev);
  1262. }
  1263. strcat(dev_name, ")");
  1265. conf_printf2(dev_name, devc->hw.io_base, devc->hw.irq,
  1266.      devc->hw.dma, devc->hw.dma2);
  1268. portc = (wavnc_port_info *)kmalloc(sizeof(wavnc_port_info), GFP_KERNEL);
  1269. if (portc == NULL)
  1270. goto nomem;
  1272. memset(portc, 0, sizeof(wavnc_port_info));
  1274. my_dev = sound_install_audiodrv(AUDIO_DRIVER_VERSION, dev_name,
  1275. &waveartist_audio_driver, sizeof(struct audio_driver),
  1276. devc->audio_flags, AFMT_U8 | AFMT_S16_LE | AFMT_S8,
  1277. devc, devc->hw.dma, devc->hw.dma2);
  1279. if (my_dev < 0)
  1280. goto free;
  1282. audio_devs[my_dev]->portc = portc;
  1284. waveartist_mixer_reset(devc);
  1286. /*
  1287.  * clear any pending interrupt
  1288.  */
  1289. waveartist_iack(devc);
  1291. if (request_irq(devc->hw.irq, waveartist_intr, 0, devc->hw.name, devc) < 0) {
  1292. printk(KERN_ERR "%s: IRQ %d in usen",
  1293. devc->hw.name, devc->hw.irq);
  1294. goto uninstall;
  1295. }
  1297. if (sound_alloc_dma(devc->hw.dma, devc->hw.name)) {
  1298. printk(KERN_ERR "%s: Can't allocate DMA%dn",
  1299. devc->hw.name, devc->hw.dma);
  1300. goto uninstall_irq;
  1301. }
  1303. if (devc->hw.dma != devc->hw.dma2 && devc->hw.dma2 != NO_DMA)
  1304. if (sound_alloc_dma(devc->hw.dma2, devc->hw.name)) {
  1305. printk(KERN_ERR "%s: can't allocate DMA%dn",
  1306. devc->hw.name, devc->hw.dma2);
  1307. goto uninstall_dma;
  1308. }
  1310. waveartist_set_ctlr(&devc->hw, 0, DMA1_IE | DMA0_IE);
  1312. audio_devs[my_dev]->mixer_dev =
  1313. sound_install_mixer(MIXER_DRIVER_VERSION,
  1314. dev_name,
  1315. &waveartist_mixer_operations,
  1316. sizeof(struct mixer_operations),
  1317. devc);
  1319. return my_dev;
  1321. uninstall_dma:
  1322. sound_free_dma(devc->hw.dma);
  1324. uninstall_irq:
  1325. free_irq(devc->hw.irq, devc);
  1327. uninstall:
  1328. sound_unload_audiodev(my_dev);
  1330. free:
  1331. kfree(portc);
  1333. nomem:
  1334. return -1;
  1335. }
  1337. static int __init probe_waveartist(struct address_info *hw_config)
  1338. {
  1339. wavnc_info *devc = &adev_info[nr_waveartist_devs];
  1341. if (nr_waveartist_devs >= MAX_AUDIO_DEV) {
  1342. printk(KERN_WARNING "waveartist: too many audio devicesn");
  1343. return 0;
  1344. }
  1346. if (check_region(hw_config->io_base, 15))  {
  1347. printk(KERN_WARNING "WaveArtist: I/O port conflictn");
  1348. return 0;
  1349. }
  1351. if (hw_config->irq > 15 || hw_config->irq < 0) {
  1352. printk(KERN_WARNING "WaveArtist: Bad IRQ %dn",
  1353.        hw_config->irq);
  1354. return 0;
  1355. }
  1357. if (hw_config->dma != 3) {
  1358. printk(KERN_WARNING "WaveArtist: Bad DMA %dn",
  1359.        hw_config->dma);
  1360. return 0;
  1361. }
  1363. hw_config->name = "WaveArtist";
  1364. devc->hw = *hw_config;
  1365. devc->open_mode = 0;
  1366. devc->chip_name = "RWA-010";
  1368. return 1;
  1369. }
  1371. static void __init
  1372. attach_waveartist(struct address_info *hw, const struct waveartist_mixer_info *mix)
  1373. {
  1374. wavnc_info *devc = &adev_info[nr_waveartist_devs];
  1376. /*
  1377.  * NOTE! If irq < 0, there is another driver which has allocated the
  1378.  *   IRQ so that this driver doesn't need to allocate/deallocate it.
  1379.  *   The actually used IRQ is ABS(irq).
  1380.  */
  1381. devc->hw = *hw;
  1382. devc->hw.irq = (hw->irq > 0) ? hw->irq : 0;
  1383. devc->open_mode = 0;
  1384. devc->playback_dev = 0;
  1385. devc->record_dev = 0;
  1386. devc->audio_flags = DMA_AUTOMODE;
  1387. devc->levels = levels;
  1389. if (hw->dma != hw->dma2 && hw->dma2 != NO_DMA)
  1390. devc->audio_flags |= DMA_DUPLEX;
  1392. request_region(hw->io_base, 15, devc->hw.name);
  1394. devc->mix = mix;
  1395. devc->dev_no = waveartist_init(devc);
  1397. if (devc->dev_no < 0)
  1398. release_region(hw->io_base, 15);
  1399. else {
  1400. #ifdef CONFIG_ARCH_NETWINDER
  1401. if (machine_is_netwinder()) {
  1402. init_timer(&vnc_timer);
  1403. vnc_timer.function = vnc_slider_tick;
  1404. vnc_timer.expires  = jiffies;
  1405. vnc_timer.data     = nr_waveartist_devs;
  1406. add_timer(&vnc_timer);
  1408. vnc_configure_mixer(devc, 0);
  1410. devc->no_autoselect = 1;
  1411. }
  1412. #endif
  1413. nr_waveartist_devs += 1;
  1414. }
  1415. }
  1417. static void __exit unload_waveartist(struct address_info *hw)
  1418. {
  1419. wavnc_info *devc = NULL;
  1420. int i;
  1422. for (i = 0; i < nr_waveartist_devs; i++)
  1423. if (hw->io_base == adev_info[i].hw.io_base) {
  1424. devc = adev_info + i;
  1425. break;
  1426. }
  1428. if (devc != NULL) {
  1429. int mixer;
  1431. #ifdef CONFIG_ARCH_NETWINDER
  1432. if (machine_is_netwinder())
  1433. del_timer(&vnc_timer);
  1434. #endif
  1436. release_region(devc->hw.io_base, 15);
  1438. waveartist_set_ctlr(&devc->hw, DMA1_IE|DMA0_IE, 0);
  1440. if (devc->hw.irq >= 0)
  1441. free_irq(devc->hw.irq, devc);
  1443. sound_free_dma(devc->hw.dma);
  1445. if (devc->hw.dma != devc->hw.dma2 &&
  1446.     devc->hw.dma2 != NO_DMA)
  1447. sound_free_dma(devc->hw.dma2);
  1449. mixer = audio_devs[devc->dev_no]->mixer_dev;
  1451. if (mixer >= 0)
  1452. sound_unload_mixerdev(mixer);
  1454. if (devc->dev_no >= 0)
  1455. sound_unload_audiodev(devc->dev_no);
  1457. nr_waveartist_devs -= 1;
  1459. for (; i < nr_waveartist_devs; i++)
  1460. adev_info[i] = adev_info[i + 1];
  1461. } else
  1462. printk(KERN_WARNING "waveartist: can't find device "
  1463.        "to unloadn");
  1464. }
  1466. #ifdef CONFIG_ARCH_NETWINDER
  1468. /*
  1469.  * Rebel.com Netwinder specifics...
  1470.  */
  1472. #include <asm/hardware/dec21285.h>
  1473.  
  1474. #define VNC_TIMER_PERIOD (HZ/4) //check slider 4 times/sec
  1476. #define MIXER_PRIVATE3_RESET 0x53570000
  1477. #define MIXER_PRIVATE3_READ 0x53570001
  1478. #define MIXER_PRIVATE3_WRITE 0x53570002
  1480. #define VNC_MUTE_INTERNAL_SPKR 0x01 //the sw mute on/off control bit
  1481. #define VNC_MUTE_LINE_OUT 0x10
  1482. #define VNC_PHONE_DETECT 0x20
  1483. #define VNC_HANDSET_DETECT 0x40
  1484. #define VNC_DISABLE_AUTOSWITCH 0x80
  1486. extern spinlock_t gpio_lock;
  1488. static inline void
  1489. vnc_mute_spkr(wavnc_info *devc)
  1490. {
  1491. unsigned long flags;
  1493. spin_lock_irqsave(&gpio_lock, flags);
  1494. cpld_modify(CPLD_UNMUTE, devc->spkr_mute_state ? 0 : CPLD_UNMUTE);
  1495. spin_unlock_irqrestore(&gpio_lock, flags);
  1496. }
  1498. static void
  1499. vnc_mute_lout(wavnc_info *devc)
  1500. {
  1501. unsigned int left, right;
  1503. left  = waveartist_cmd1_r(devc, WACMD_GET_LEVEL);
  1504. right = waveartist_cmd1_r(devc, WACMD_GET_LEVEL | 0x400);
  1506. if (devc->line_mute_state) {
  1507. left &= ~1;
  1508. right &= ~1;
  1509. } else {
  1510. left |= 1;
  1511. right |= 1;
  1512. }
  1513. waveartist_cmd3(devc, WACMD_SET_MIXER, left, right);
  1515. }
  1517. static int
  1518. vnc_volume_slider(wavnc_info *devc)
  1519. {
  1520. static signed int old_slider_volume;
  1521. unsigned long flags;
  1522. signed int volume = 255;
  1524. *CSR_TIMER1_LOAD = 0x00ffffff;
  1526. save_flags(flags);
  1527. cli();
  1529. outb(0xFF, 0x201);
  1530. *CSR_TIMER1_CNTL = TIMER_CNTL_ENABLE | TIMER_CNTL_DIV1;
  1532. while (volume && (inb(0x201) & 0x01))
  1533. volume--;
  1535. *CSR_TIMER1_CNTL = 0;
  1537. restore_flags(flags);
  1539. volume = 0x00ffffff - *CSR_TIMER1_VALUE;
  1542. #ifndef REVERSE
  1543. volume = 150 - (volume >> 5);
  1544. #else
  1545. volume = (volume >> 6) - 25;
  1546. #endif
  1548. if (volume < 0)
  1549. volume = 0;
  1551. if (volume > 100)
  1552. volume = 100;
  1554. /*
  1555.  * slider quite often reads +-8, so debounce this random noise
  1556.  */
  1557. if (abs(volume - old_slider_volume) > 7) {
  1558. old_slider_volume = volume;
  1560. if (debug_flg & DEBUG_MIXER)
  1561. printk(KERN_DEBUG "Slider volume: %d.n", volume);
  1562. }
  1564. return old_slider_volume;
  1565. }
  1567. /*
  1568.  * Decode a recording mask into a mixer selection on the NetWinder
  1569.  * as follows:
  1570.  *
  1571.  *     OSS Source WA Source Actual source
  1572.  *  SOUND_MASK_IMIX Mixer Mixer output (same as AD1848)
  1573.  *  SOUND_MASK_LINE Line Line in
  1574.  *  SOUND_MASK_LINE1 Left Mic Handset
  1575.  *  SOUND_MASK_PHONEIN Left Aux Telephone microphone
  1576.  *  SOUND_MASK_MIC Right Mic Builtin microphone
  1577.  */
  1578. static unsigned int
  1579. netwinder_select_input(wavnc_info *devc, unsigned int recmask,
  1580.        unsigned char *dev_l, unsigned char *dev_r)
  1581. {
  1582. unsigned int recdev_l = ADC_MUX_NONE, recdev_r = ADC_MUX_NONE;
  1584. if (recmask & SOUND_MASK_IMIX) {
  1585. recmask = SOUND_MASK_IMIX;
  1586. recdev_l = ADC_MUX_MIXER;
  1587. recdev_r = ADC_MUX_MIXER;
  1588. } else if (recmask & SOUND_MASK_LINE) {
  1589. recmask = SOUND_MASK_LINE;
  1590. recdev_l = ADC_MUX_LINE;
  1591. recdev_r = ADC_MUX_LINE;
  1592. } else if (recmask & SOUND_MASK_LINE1) {
  1593. recmask = SOUND_MASK_LINE1;
  1594. waveartist_cmd1(devc, WACMD_SET_MONO); /* left */
  1595. recdev_l = ADC_MUX_MIC;
  1596. recdev_r = ADC_MUX_NONE;
  1597. } else if (recmask & SOUND_MASK_PHONEIN) {
  1598. recmask = SOUND_MASK_PHONEIN;
  1599. waveartist_cmd1(devc, WACMD_SET_MONO); /* left */
  1600. recdev_l = ADC_MUX_AUX1;
  1601. recdev_r = ADC_MUX_NONE;
  1602. } else if (recmask & SOUND_MASK_MIC) {
  1603. recmask = SOUND_MASK_MIC;
  1604. waveartist_cmd1(devc, WACMD_SET_MONO | 0x100); /* right */
  1605. recdev_l = ADC_MUX_NONE;
  1606. recdev_r = ADC_MUX_MIC;
  1607. }
  1609. *dev_l = recdev_l;
  1610. *dev_r = recdev_r;
  1612. return recmask;
  1613. }
  1615. static int
  1616. netwinder_decode_mixer(wavnc_info *devc, int dev, unsigned char lev_l,
  1617.        unsigned char lev_r)
  1618. {
  1619. switch (dev) {
  1620. case SOUND_MIXER_VOLUME:
  1621. case SOUND_MIXER_SYNTH:
  1622. case SOUND_MIXER_PCM:
  1623. case SOUND_MIXER_LINE:
  1624. case SOUND_MIXER_IGAIN:
  1625. devc->levels[dev] = lev_l | lev_r << 8;
  1626. break;
  1628. case SOUND_MIXER_MIC: /* right mic only */
  1629. devc->levels[SOUND_MIXER_MIC] &= 0xff;
  1630. devc->levels[SOUND_MIXER_MIC] |= lev_l << 8;
  1631. break;
  1633. case SOUND_MIXER_LINE1: /* left mic only  */
  1634. devc->levels[SOUND_MIXER_MIC] &= 0xff00;
  1635. devc->levels[SOUND_MIXER_MIC] |= lev_l;
  1636. dev = SOUND_MIXER_MIC;
  1637. break;
  1639. case SOUND_MIXER_PHONEIN: /* left aux only  */
  1640. devc->levels[SOUND_MIXER_LINE1] = lev_l;
  1641. dev = SOUND_MIXER_LINE1;
  1642. break;
  1644. case SOUND_MIXER_IMIX:
  1645. case SOUND_MIXER_PHONEOUT:
  1646. break;
  1648. default:
  1649. dev = -EINVAL;
  1650. break;
  1651. }
  1652. return dev;
  1653. }
  1655. static int netwinder_get_mixer(wavnc_info *devc, int dev)
  1656. {
  1657. int levels;
  1659. switch (dev) {
  1660. case SOUND_MIXER_VOLUME:
  1661. case SOUND_MIXER_SYNTH:
  1662. case SOUND_MIXER_PCM:
  1663. case SOUND_MIXER_LINE:
  1664. case SOUND_MIXER_IGAIN:
  1665. levels = devc->levels[dev];
  1666. break;
  1668. case SOUND_MIXER_MIC: /* builtin mic: right mic only */
  1669. levels = devc->levels[SOUND_MIXER_MIC] >> 8;
  1670. levels |= levels << 8;
  1671. break;
  1673. case SOUND_MIXER_LINE1: /* handset mic: left mic only */
  1674. levels = devc->levels[SOUND_MIXER_MIC] & 0xff;
  1675. levels |= levels << 8;
  1676. break;
  1678. case SOUND_MIXER_PHONEIN: /* phone mic: left aux1 only */
  1679. levels = devc->levels[SOUND_MIXER_LINE1] & 0xff;
  1680. levels |= levels << 8;
  1681. break;
  1683. default:
  1684. levels = 0;
  1685. }
  1687. return levels;
  1688. }
  1690. /*
  1691.  * Waveartist specific mixer information.
  1692.  */
  1693. static const struct waveartist_mixer_info netwinder_mixer = {
  1694. supported_devs: SOUND_MASK_VOLUME  | SOUND_MASK_SYNTH   |
  1695. SOUND_MASK_PCM     | SOUND_MASK_SPEAKER |
  1696. SOUND_MASK_LINE    | SOUND_MASK_MIC     |
  1697. SOUND_MASK_IMIX    | SOUND_MASK_LINE1   |
  1698. SOUND_MASK_PHONEIN | SOUND_MASK_PHONEOUT|
  1699. SOUND_MASK_IGAIN,
  1701. recording_devs: SOUND_MASK_LINE    | SOUND_MASK_MIC     |
  1702. SOUND_MASK_IMIX    | SOUND_MASK_LINE1   |
  1703. SOUND_MASK_PHONEIN,
  1705. stereo_devs: SOUND_MASK_VOLUME  | SOUND_MASK_SYNTH   |
  1706. SOUND_MASK_PCM     | SOUND_MASK_LINE    |
  1707. SOUND_MASK_IMIX    | SOUND_MASK_IGAIN,
  1709. select_input: netwinder_select_input,
  1710. decode_mixer: netwinder_decode_mixer,
  1711. get_mixer: netwinder_get_mixer,
  1712. };
  1714. static void
  1715. vnc_configure_mixer(wavnc_info *devc, unsigned int recmask)
  1716. {
  1717. if (!devc->no_autoselect) {
  1718. if (devc->handset_detect) {
  1719. recmask = SOUND_MASK_LINE1;
  1720. devc->spkr_mute_state = devc->line_mute_state = 1;
  1721. } else if (devc->telephone_detect) {
  1722. recmask = SOUND_MASK_PHONEIN;
  1723. devc->spkr_mute_state = devc->line_mute_state = 1;
  1724. } else {
  1725. /* unless someone has asked for LINE-IN,
  1726.  * we default to MIC
  1727.  */
  1728. if ((devc->recmask & SOUND_MASK_LINE) == 0)
  1729. devc->recmask = SOUND_MASK_MIC;
  1730. devc->spkr_mute_state = devc->line_mute_state = 0;
  1731. }
  1732. vnc_mute_spkr(devc);
  1733. vnc_mute_lout(devc);
  1735. if (recmask != devc->recmask)
  1736. waveartist_set_recmask(devc, recmask);
  1737. }
  1738. }
  1740. static int
  1741. vnc_slider(wavnc_info *devc)
  1742. {
  1743. signed int slider_volume;
  1744. unsigned int temp, old_hs, old_td;
  1746. /*
  1747.  * read the "buttons" state.
  1748.  *  Bit 4 = 0 means handset present
  1749.  *  Bit 5 = 1 means phone offhook
  1750.  */
  1751. temp = inb(0x201);
  1753. old_hs = devc->handset_detect;
  1754. old_td = devc->telephone_detect;
  1756. devc->handset_detect = !(temp & 0x10);
  1757. devc->telephone_detect = !!(temp & 0x20);
  1759. if (!devc->no_autoselect &&
  1760.     (old_hs != devc->handset_detect ||
  1761.      old_td != devc->telephone_detect))
  1762. vnc_configure_mixer(devc, devc->recmask);
  1764. slider_volume = vnc_volume_slider(devc);
  1766. /*
  1767.  * If we're using software controlled volume, and
  1768.  * the slider moves by more than 20%, then we
  1769.  * switch back to slider controlled volume.
  1770.  */
  1771. if (abs(devc->slider_vol - slider_volume) > 20)
  1772. devc->use_slider = 1;
  1774. /*
  1775.  * use only left channel
  1776.  */
  1777. temp = levels[SOUND_MIXER_VOLUME] & 0xFF;
  1779. if (slider_volume != temp && devc->use_slider) {
  1780. devc->slider_vol = slider_volume;
  1782. waveartist_set_mixer(devc, SOUND_MIXER_VOLUME,
  1783. slider_volume | slider_volume << 8);
  1785. return 1;
  1786. }
  1788. return 0;
  1789. }
  1791. static void
  1792. vnc_slider_tick(unsigned long data)
  1793. {
  1794. int next_timeout;
  1796. if (vnc_slider(adev_info + data))
  1797. next_timeout = 5; // mixer reported change
  1798. else
  1799. next_timeout = VNC_TIMER_PERIOD;
  1801. mod_timer(&vnc_timer, jiffies + next_timeout);
  1802. }
  1804. static int
  1805. vnc_private_ioctl(int dev, unsigned int cmd, caddr_t arg)
  1806. {
  1807. wavnc_info *devc = (wavnc_info *)audio_devs[dev]->devc;
  1808. int val;
  1810. switch (cmd) {
  1811. case SOUND_MIXER_PRIVATE1:
  1812. {
  1813. u_int prev_spkr_mute, prev_line_mute, prev_auto_state;
  1814. int val;
  1816. if (get_user(val, (int *)arg))
  1817. return -EFAULT;
  1819. /* check if parameter is logical */
  1820. if (val & ~(VNC_MUTE_INTERNAL_SPKR |
  1821.     VNC_MUTE_LINE_OUT |
  1822.     VNC_DISABLE_AUTOSWITCH))
  1823. return -EINVAL;
  1825. prev_auto_state = devc->no_autoselect;
  1826. prev_spkr_mute  = devc->spkr_mute_state;
  1827. prev_line_mute  = devc->line_mute_state;
  1829. devc->no_autoselect   = (val & VNC_DISABLE_AUTOSWITCH) ? 1 : 0;
  1830. devc->spkr_mute_state = (val & VNC_MUTE_INTERNAL_SPKR) ? 1 : 0;
  1831. devc->line_mute_state = (val & VNC_MUTE_LINE_OUT) ? 1 : 0;
  1833. if (prev_spkr_mute != devc->spkr_mute_state)
  1834. vnc_mute_spkr(devc);
  1836. if (prev_line_mute != devc->line_mute_state)
  1837. vnc_mute_lout(devc);
  1839. if (prev_auto_state != devc->no_autoselect)
  1840. vnc_configure_mixer(devc, devc->recmask);
  1842. return 0;
  1843. }
  1845. case SOUND_MIXER_PRIVATE2:
  1846. if (get_user(val, (int *)arg))
  1847. return -EFAULT;
  1849. switch (val) {
  1850. #define VNC_SOUND_PAUSE         0x53    //to pause the DSP
  1851. #define VNC_SOUND_RESUME        0x57    //to unpause the DSP
  1852. case VNC_SOUND_PAUSE:
  1853. waveartist_cmd1(devc, 0x16);
  1854. break;
  1856. case VNC_SOUND_RESUME:
  1857. waveartist_cmd1(devc, 0x18);
  1858. break;
  1860. default:
  1861. return -EINVAL;
  1862. }
  1863. return 0;
  1865. /* private ioctl to allow bulk access to waveartist */
  1866. case SOUND_MIXER_PRIVATE3:
  1867. {
  1868. unsigned long flags;
  1869. int mixer_reg[15], i, val;
  1871. if (get_user(val, (int *)arg))
  1872. return -EFAULT;
  1873. if (copy_from_user(mixer_reg, (void *)val, sizeof(mixer_reg)))
  1874. return -EFAULT;
  1876. switch (mixer_reg[14]) {
  1877. case MIXER_PRIVATE3_RESET:
  1878. waveartist_mixer_reset(devc);
  1879. break;
  1881. case MIXER_PRIVATE3_WRITE:
  1882. waveartist_cmd3(devc, WACMD_SET_MIXER, mixer_reg[0], mixer_reg[4]);
  1883. waveartist_cmd3(devc, WACMD_SET_MIXER, mixer_reg[1], mixer_reg[5]);
  1884. waveartist_cmd3(devc, WACMD_SET_MIXER, mixer_reg[2], mixer_reg[6]);
  1885. waveartist_cmd3(devc, WACMD_SET_MIXER, mixer_reg[3], mixer_reg[7]);
  1886. waveartist_cmd3(devc, WACMD_SET_MIXER, mixer_reg[8], mixer_reg[9]);
  1888. waveartist_cmd3(devc, WACMD_SET_LEVEL, mixer_reg[10], mixer_reg[11]);
  1889. waveartist_cmd3(devc, WACMD_SET_LEVEL, mixer_reg[12], mixer_reg[13]);
  1890. break;
  1892. case MIXER_PRIVATE3_READ:
  1893. spin_lock_irqsave(&waveartist_lock, flags);
  1895. for (i = 0x30; i < 14 << 8; i += 1 << 8)
  1896. waveartist_cmd(devc, 1, &i, 1, mixer_reg + (i >> 8));
  1898. spin_unlock_irqrestore(&waveartist_lock, flags);
  1900. if (copy_to_user((void *)val, mixer_reg, sizeof(mixer_reg)))
  1901. return -EFAULT;
  1902. break;
  1904. default:
  1905. return -EINVAL;
  1906. }
  1907. return 0;
  1908. }
  1910. /* read back the state from PRIVATE1 */
  1911. case SOUND_MIXER_PRIVATE4:
  1912. val = (devc->spkr_mute_state  ? VNC_MUTE_INTERNAL_SPKR : 0) |
  1913.       (devc->line_mute_state  ? VNC_MUTE_LINE_OUT      : 0) |
  1914.       (devc->handset_detect   ? VNC_HANDSET_DETECT     : 0) |
  1915.       (devc->telephone_detect ? VNC_PHONE_DETECT       : 0) |
  1916.       (devc->no_autoselect    ? VNC_DISABLE_AUTOSWITCH : 0);
  1918. return put_user(val, (int *)arg) ? -EFAULT : 0;
  1919. }
  1921. if (_SIOC_DIR(cmd) & _SIOC_WRITE) {
  1922. /*
  1923.  * special case for master volume: if we
  1924.  * received this call - switch from hw
  1925.  * volume control to a software volume
  1926.  * control, till the hw volume is modified
  1927.  * to signal that user wants to be back in
  1928.  * hardware...
  1929.  */
  1930. if ((cmd & 0xff) == SOUND_MIXER_VOLUME)
  1931. devc->use_slider = 0;
  1933. /* speaker output            */
  1934. if ((cmd & 0xff) == SOUND_MIXER_SPEAKER) {
  1935. unsigned int val, l, r;
  1937. if (get_user(val, (int *)arg))
  1938. return -EFAULT;
  1940. l = val & 0x7f;
  1941. r = (val & 0x7f00) >> 8;
  1942. val = (l + r) / 2;
  1943. devc->levels[SOUND_MIXER_SPEAKER] = val | (val << 8);
  1944. devc->spkr_mute_state = (val <= 50);
  1945. vnc_mute_spkr(devc);
  1946. return 0;
  1947. }
  1948. }
  1950. return -ENOIOCTLCMD;
  1951. }
  1953. #endif
  1955. static struct address_info cfg;
  1957. static int attached;
  1959. static int __initdata io = 0;
  1960. static int __initdata irq = 0;
  1961. static int __initdata dma = 0;
  1962. static int __initdata dma2 = 0;
  1965. static int __init init_waveartist(void)
  1966. {
  1967. const struct waveartist_mixer_info *mix;
  1969. if (!io && machine_is_netwinder()) {
  1970. /*
  1971.  * The NetWinder WaveArtist is at a fixed address.
  1972.  * If the user does not supply an address, use the
  1973.  * well-known parameters.
  1974.  */
  1975. io   = 0x250;
  1976. irq  = 12;
  1977. dma  = 3;
  1978. dma2 = 7;
  1979. }
  1981. mix = &waveartist_mixer;
  1982. #ifdef CONFIG_ARCH_NETWINDER
  1983. if (machine_is_netwinder())
  1984. mix = &netwinder_mixer;
  1985. #endif
  1987. cfg.io_base = io;
  1988. cfg.irq = irq;
  1989. cfg.dma = dma;
  1990. cfg.dma2 = dma2;
  1992. if (!probe_waveartist(&cfg))
  1993. return -ENODEV;
  1995. attach_waveartist(&cfg, mix);
  1996. attached = 1;
  1998. return 0;
  1999. }
  2001. static void __exit cleanup_waveartist(void)
  2002. {
  2003. if (attached)
  2004. unload_waveartist(&cfg);
  2005. }
  2007. module_init(init_waveartist);
  2008. module_exit(cleanup_waveartist);
  2010. #ifndef MODULE
  2011. static int __init setup_waveartist(char *str)
  2012. {
  2013. /* io, irq, dma, dma2 */
  2014. int ints[5];
  2016. str = get_options(str, ARRAY_SIZE(ints), ints);
  2018. io = ints[1];
  2019. irq = ints[2];
  2020. dma = ints[3];
  2021. dma2 = ints[4];
  2023. return 1;
  2024. }
  2025. __setup("waveartist=", setup_waveartist);
  2026. #endif
  2028. MODULE_DESCRIPTION("Rockwell WaveArtist RWA-010 sound driver");
  2029. MODULE_PARM(io, "i"); /* IO base */
  2030. MODULE_PARM(irq, "i"); /* IRQ */
  2031. MODULE_PARM(dma, "i"); /* DMA */
  2032. MODULE_PARM(dma2, "i"); /* DMA2 */
  2033. MODULE_LICENSE("GPL");