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

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

Linux/Unix编程

开发平台：

Unix_Linux

mad16.c：源码内容
  1. /*
  2.  * Copyright (C) by Hannu Savolainen 1993-1997
  3.  *
  4.  * mad16.c
  5.  *
  6.  * Initialization code for OPTi MAD16 compatible audio chips. Including
  7.  *
  8.  *      OPTi 82C928     MAD16           (replaced by C929)
  9.  *      OAK OTI-601D    Mozart
  10.  *      OAK OTI-605 Mozart (later version with MPU401 Midi)
  11.  *      OPTi 82C929     MAD16 Pro
  12.  *      OPTi 82C930
  13.  *      OPTi 82C924
  14.  *
  15.  * These audio interface chips don't produce sound themselves. They just
  16.  * connect some other components (OPL-[234] and a WSS compatible codec)
  17.  * to the PC bus and perform I/O, DMA and IRQ address decoding. There is
  18.  * also a UART for the MPU-401 mode (not 82C928/Mozart).
  19.  * The Mozart chip appears to be compatible with the 82C928, although later
  20.  * issues of the card, using the OTI-605 chip, have an MPU-401 compatable Midi
  21.  * port. This port is configured differently to that of the OPTi audio chips.
  22.  *
  23.  * Changes
  24.  *
  25.  * Alan Cox Clean up, added module selections.
  26.  *
  27.  * A. Wik Added support for Opti924 PnP.
  28.  * Improved debugging support. 16-May-1998
  29.  * Fixed bug. 16-Jun-1998
  30.  *
  31.  *      Torsten Duwe            Made Opti924 PnP support non-destructive
  32.  *                                                              23-Dec-1998
  33.  *
  34.  * Paul Grayson Added support for Midi on later Mozart cards.
  35.  * 25-Nov-1999
  36.  * Christoph Hellwig Adapted to module_init/module_exit.
  37.  * Arnaldo C. de Melo got rid of attach_uart401       21-Sep-2000
  38.  *
  39.  * Pavel Rabel Clean up                           Nov-2000
  40.  */
  42. #include <linux/config.h>
  43. #include <linux/init.h>
  44. #include <linux/module.h>
  45. #include <linux/gameport.h>
  47. #include "sound_config.h"
  49. #include "ad1848.h"
  50. #include "sb.h"
  51. #include "mpu401.h"
  53. static int      mad16_conf;
  54. static int      mad16_cdsel;
  55. static struct gameport gameport;
  57. static int      already_initialized = 0;
  59. #define C928 1
  60. #define MOZART 2
  61. #define C929 3
  62. #define C930 4
  63. #define C924    5
  65. /*
  66.  *    Registers
  67.  *
  68.  *      The MAD16 occupies I/O ports 0xf8d to 0xf93 (fixed locations).
  69.  *      All ports are inactive by default. They can be activated by
  70.  *      writing 0xE2 or 0xE3 to the password register. The password is valid
  71.  *      only until the next I/O read or write.
  72.  *
  73.  *      82C930 uses 0xE4 as the password and indirect addressing to access
  74.  *      the config registers.
  75.  */
  77. #define MC0_PORT 0xf8c /* Dummy port */
  78. #define MC1_PORT 0xf8d /* SB address, CD-ROM interface type, joystick */
  79. #define MC2_PORT 0xf8e /* CD-ROM address, IRQ, DMA, plus OPL4 bit */
  80. #define MC3_PORT 0xf8f
  81. #define PASSWD_REG 0xf8f
  82. #define MC4_PORT 0xf90
  83. #define MC5_PORT 0xf91
  84. #define MC6_PORT 0xf92
  85. #define MC7_PORT 0xf93
  86. #define MC8_PORT 0xf94
  87. #define MC9_PORT 0xf95
  88. #define MC10_PORT 0xf96
  89. #define MC11_PORT 0xf97
  90. #define MC12_PORT 0xf98
  92. static int      board_type = C928;
  94. static int     *mad16_osp;
  95. static int c931_detected; /* minor differences from C930 */
  96. static char c924pnp = 0; /* "     "           "    C924 */
  97. static int debug = 0; /* debugging output */
  99. #ifdef DDB
  100. #undef DDB
  101. #endif
  102. #define DDB(x) {if (debug) x;}
  104. static unsigned char mad_read(int port)
  105. {
  106. unsigned long flags;
  107. unsigned char tmp;
  109. save_flags(flags);
  110. cli();
  112. switch (board_type) /* Output password */
  113. {
  114. case C928:
  115. case MOZART:
  116. outb((0xE2), PASSWD_REG);
  117. break;
  119. case C929:
  120. outb((0xE3), PASSWD_REG);
  121. break;
  123. case C930:
  124. /* outb(( 0xE4),  PASSWD_REG); */
  125. break;
  127. case C924:
  128. /* the c924 has its ports relocated by -128 if
  129.    PnP is enabled  -aw */
  130. if (!c924pnp)
  131. outb((0xE5), PASSWD_REG); else
  132. outb((0xE5), PASSWD_REG - 0x80);
  133. break;
  134. }
  136. if (board_type == C930)
  137. {
  138. outb((port - MC0_PORT), 0xe0e); /* Write to index reg */
  139. tmp = inb(0xe0f); /* Read from data reg */
  140. }
  141. else
  142. if (!c924pnp)
  143. tmp = inb(port); else
  144. tmp = inb(port-0x80);
  145. restore_flags(flags);
  147. return tmp;
  148. }
  150. static void mad_write(int port, int value)
  151. {
  152. unsigned long   flags;
  154. save_flags(flags);
  155. cli();
  157. switch (board_type) /* Output password */
  158. {
  159. case C928:
  160. case MOZART:
  161. outb((0xE2), PASSWD_REG);
  162. break;
  164. case C929:
  165. outb((0xE3), PASSWD_REG);
  166. break;
  168. case C930:
  169. /* outb(( 0xE4),  PASSWD_REG); */
  170. break;
  172. case C924:
  173. if (!c924pnp)
  174. outb((0xE5), PASSWD_REG); else
  175. outb((0xE5), PASSWD_REG - 0x80);
  176. break;
  177. }
  179. if (board_type == C930)
  180. {
  181. outb((port - MC0_PORT), 0xe0e); /* Write to index reg */
  182. outb(((unsigned char) (value & 0xff)), 0xe0f);
  183. }
  184. else
  185. if (!c924pnp)
  186. outb(((unsigned char) (value & 0xff)), port); else
  187. outb(((unsigned char) (value & 0xff)), port-0x80);
  188. restore_flags(flags);
  189. }
  191. static int __init detect_c930(void)
  192. {
  193. unsigned char   tmp = mad_read(MC1_PORT);
  195. if ((tmp & 0x06) != 0x06)
  196. {
  197. DDB(printk("Wrong C930 signature (%x)n", tmp));
  198. /* return 0; */
  199. }
  200. mad_write(MC1_PORT, 0);
  202. if (mad_read(MC1_PORT) != 0x06)
  203. {
  204. DDB(printk("Wrong C930 signature2 (%x)n", tmp));
  205. /* return 0; */
  206. }
  207. mad_write(MC1_PORT, tmp); /* Restore bits */
  209. mad_write(MC7_PORT, 0);
  210. if ((tmp = mad_read(MC7_PORT)) != 0)
  211. {
  212. DDB(printk("MC7 not writable (%x)n", tmp));
  213. return 0;
  214. }
  215. mad_write(MC7_PORT, 0xcb);
  216. if ((tmp = mad_read(MC7_PORT)) != 0xcb)
  217. {
  218. DDB(printk("MC7 not writable2 (%x)n", tmp));
  219. return 0;
  220. }
  222. tmp = mad_read(MC0_PORT+18);
  223. if (tmp == 0xff || tmp == 0x00)
  224. return 1;
  225. /* We probably have a C931 */
  226. DDB(printk("Detected C931 config=0x%02xn", tmp));
  227. c931_detected = 1;
  229. /*
  230.          * We cannot configure the chip if it is in PnP mode.
  231.          * If we have a CSN assigned (bit 8 in MC13) we first try
  232.          * a software reset, then a software power off, finally
  233.          * Clearing PnP mode. The last option is not
  234.  * Bit 8 in MC13 
  235.          */
  236. if ((mad_read(MC0_PORT+13) & 0x80) == 0)
  237. return 1;
  239. /* Software reset */
  240. mad_write(MC9_PORT, 0x02);
  241. mad_write(MC9_PORT, 0x00);
  243. if ((mad_read(MC0_PORT+13) & 0x80) == 0)
  244. return 1;
  246. /* Power off, and on again */
  247. mad_write(MC9_PORT, 0xc2);
  248. mad_write(MC9_PORT, 0xc0);
  250. if ((mad_read(MC0_PORT+13) & 0x80) == 0)
  251. return 1;
  253. #if 0
  254. /* Force off PnP mode. This is not recommended because
  255.  * the PnP bios will not recognize the chip on the next
  256.  * warm boot and may assignd different resources to other
  257.  * PnP/PCI cards.
  258.  */
  259. mad_write(MC0_PORT+17, 0x04);
  260. #endif
  261. return 1;
  262. }
  264. static int __init detect_mad16(void)
  265. {
  266. unsigned char tmp, tmp2, bit;
  267. int i, port;
  269. /*
  270.  * Check that reading a register doesn't return bus float (0xff)
  271.  * when the card is accessed using password. This may fail in case
  272.  * the card is in low power mode. Normally at least the power saving
  273.  * mode bit should be 0.
  274.  */
  276. if ((tmp = mad_read(MC1_PORT)) == 0xff)
  277. {
  278. DDB(printk("MC1_PORT returned 0xffn"));
  279. return 0;
  280. }
  281. for (i = 0xf8d; i <= 0xf98; i++)
  282. if (!c924pnp)
  283. DDB(printk("Port %0x (init value) = %0xn", i, mad_read(i))) else
  284. DDB(printk("Port %0x (init value) = %0xn", i-0x80, mad_read(i)));
  286. if (board_type == C930)
  287. return detect_c930();
  289. /*
  290.  * Now check that the gate is closed on first I/O after writing
  291.  * the password. (This is how a MAD16 compatible card works).
  292.  */
  294. if ((tmp2 = inb(MC1_PORT)) == tmp) /* It didn't close */
  295. {
  296. DDB(printk("MC1_PORT didn't close after read (0x%02x)n", tmp2));
  297. return 0;
  298. }
  300. bit  = (c924pnp) ?     0x20 : 0x80;
  301. port = (c924pnp) ? MC2_PORT : MC1_PORT;
  303. tmp = mad_read(port);
  304. mad_write(port, tmp ^ bit); /* Toggle a bit */
  305. if ((tmp2 = mad_read(port)) != (tmp ^ bit)) /* Compare the bit */
  306. {
  307. mad_write(port, tmp); /* Restore */
  308. DDB(printk("Bit revert test failed (0x%02x, 0x%02x)n", tmp, tmp2));
  309. return 0;
  310. }
  311. mad_write(port, tmp); /* Restore */
  312. return 1; /* Bingo */
  313. }
  315. static int __init wss_init(struct address_info *hw_config)
  316. {
  317. int ad_flags = 0;
  319. /*
  320.  *    Verify the WSS parameters
  321.  */
  323. if (check_region(hw_config->io_base, 8))
  324. {
  325. printk(KERN_ERR "MSS: I/O port conflictn");
  326. return 0;
  327. }
  328. if (!ad1848_detect(hw_config->io_base + 4, &ad_flags, mad16_osp))
  329. return 0;
  330. /*
  331.  * Check if the IO port returns valid signature. The original MS Sound
  332.  * system returns 0x04 while some cards (AudioTrix Pro for example)
  333.  * return 0x00.
  334.  */
  336. if ((inb(hw_config->io_base + 3) & 0x3f) != 0x04 &&
  337.     (inb(hw_config->io_base + 3) & 0x3f) != 0x00)
  338. {
  339. DDB(printk("No MSS signature detected on port 0x%x (0x%x)n", hw_config->io_base, inb(hw_config->io_base + 3)));
  340. return 0;
  341. }
  342. if (hw_config->irq > 11)
  343. {
  344. printk(KERN_ERR "MSS: Bad IRQ %dn", hw_config->irq);
  345. return 0;
  346. }
  347. if (hw_config->dma != 0 && hw_config->dma != 1 && hw_config->dma != 3)
  348. {
  349. printk(KERN_ERR "MSS: Bad DMA %dn", hw_config->dma);
  350. return 0;
  351. }
  352. /*
  353.  * Check that DMA0 is not in use with a 8 bit board.
  354.  */
  356. if (hw_config->dma == 0 && inb(hw_config->io_base + 3) & 0x80)
  357. {
  358. printk("MSS: Can't use DMA0 with a 8 bit card/slotn");
  359. return 0;
  360. }
  361. if (hw_config->irq > 7 && hw_config->irq != 9 && inb(hw_config->io_base + 3) & 0x80)
  362. printk(KERN_ERR "MSS: Can't use IRQ%d with a 8 bit card/slotn", hw_config->irq);
  363. return 1;
  364. }
  366. static int __init init_c930(struct address_info *hw_config)
  367. {
  368. unsigned char cfg = 0;
  370. if(c931_detected)
  371. {
  372. /* Bit 0 has reversd meaning. Bits 1 and 2 sese
  373.    reversed on write.
  374.    Support only IDE cdrom. IDE port programmed
  375.    somewhere else. */
  376. cfg =  (cfg & 0x09) ^ 0x07;
  377. }
  379. switch (hw_config->io_base)
  380. {
  381. case 0x530:
  382. cfg |= 0x00;
  383. break;
  384. case 0xe80:
  385. cfg |= 0x10;
  386. break;
  387. case 0xf40:
  388. cfg |= 0x20;
  389. break;
  390. case 0x604:
  391. cfg |= 0x30;
  392. break;
  393. default:
  394. printk(KERN_ERR "MAD16: Invalid codec port %xn", hw_config->io_base);
  395. return 0;
  396. }
  397. mad_write(MC1_PORT, cfg);
  399. /* MC2 is CD configuration. Don't touch it. */
  401. mad_write(MC3_PORT, 0); /* Disable SB mode IRQ and DMA */
  403. /* bit 2 of MC4 reverses it's meaning between the C930
  404.    and the C931. */
  405. cfg = c931_detected ? 0x04 : 0x00;
  407. mad_write(MC4_PORT, 0x52|cfg);
  409. mad_write(MC5_PORT, 0x3C); /* Init it into mode2 */
  410. mad_write(MC6_PORT, 0x02); /* Enable WSS, Disable MPU and SB */
  411. mad_write(MC7_PORT, 0xCB);
  412. mad_write(MC10_PORT, 0x11);
  414. return wss_init(hw_config);
  415. }
  417. static int __init chip_detect(void)
  418. {
  419. int i;
  421. /*
  422.  *    Then try to detect with the old password
  423.  */
  424. board_type = C924;
  426. DDB(printk("Detect using password = 0xE5n"));
  428. if (detect_mad16()) {
  429. return 1;
  430. }
  432. board_type = C928;
  434. DDB(printk("Detect using password = 0xE2n"));
  436. if (detect_mad16())
  437. {
  438. unsigned char model;
  440. if (((model = mad_read(MC3_PORT)) & 0x03) == 0x03) {
  441. DDB(printk("mad16.c: Mozart detectedn"));
  442. board_type = MOZART;
  443. } else {
  444. DDB(printk("mad16.c: 82C928 detected???n"));
  445. board_type = C928;
  446. }
  447. return 1;
  448. }
  450. board_type = C929;
  452. DDB(printk("Detect using password = 0xE3n"));
  454. if (detect_mad16())
  455. {
  456. DDB(printk("mad16.c: 82C929 detectedn"));
  457. return 1;
  458. }
  460. if (inb(PASSWD_REG) != 0xff)
  461. return 0;
  463. /*
  464.  * First relocate MC# registers to 0xe0e/0xe0f, disable password 
  465.  */
  467. outb((0xE4), PASSWD_REG);
  468. outb((0x80), PASSWD_REG);
  470. board_type = C930;
  472. DDB(printk("Detect using password = 0xE4n"));
  474. for (i = 0xf8d; i <= 0xf93; i++)
  475. DDB(printk("port %03x = %02xn", i, mad_read(i)));
  477.         if(detect_mad16()) {
  478. DDB(printk("mad16.c: 82C930 detectedn"));
  479. return 1;
  480. }
  482. /* The C931 has the password reg at F8D */
  483. outb((0xE4), 0xF8D);
  484. outb((0x80), 0xF8D);
  485. DDB(printk("Detect using password = 0xE4 for C931n"));
  487. if (detect_mad16()) {
  488. return 1;
  489. }
  491. board_type = C924;
  492. c924pnp++;
  493. DDB(printk("Detect using password = 0xE5 (again), port offset -0x80n"));
  494. if (detect_mad16()) {
  495. DDB(printk("mad16.c: 82C924 PnP detectedn"));
  496. return 1;
  497. }
  499. c924pnp=0;
  501. return 0;
  502. }
  504. static int __init probe_mad16(struct address_info *hw_config)
  505. {
  506. int i;
  507. static int valid_ports[] = 
  508. {
  509. 0x530, 0xe80, 0xf40, 0x604
  510. };
  511. unsigned char tmp;
  512. unsigned char cs4231_mode = 0;
  514. int ad_flags = 0;
  516. if (already_initialized)
  517. return 0;
  519. mad16_osp = hw_config->osp;
  521. /*
  522.  *    Check that all ports return 0xff (bus float) when no password
  523.  *      is written to the password register.
  524.  */
  526. DDB(printk("--- Detecting MAD16 / Mozart ---n"));
  527. if (!chip_detect())
  528. return 0;
  530. if (board_type == C930)
  531. return init_c930(hw_config);
  534. for (i = 0xf8d; i <= 0xf93; i++)
  535. if (!c924pnp)
  536. DDB(printk("port %03x = %02xn", i, mad_read(i))) else
  537. DDB(printk("port %03x = %02xn", i-0x80, mad_read(i)));
  539. /*
  540.  * Set the WSS address
  541.  */
  543. tmp = (mad_read(MC1_PORT) & 0x0f) | 0x80; /* Enable WSS, Disable SB */
  545. for (i = 0; i < 5; i++)
  546. {
  547. if (i > 3) /* Not a valid port */
  548. {
  549. printk(KERN_ERR "MAD16/Mozart: Bad WSS base address 0x%xn", hw_config->io_base);
  550. return 0;
  551. }
  552. if (valid_ports[i] == hw_config->io_base)
  553. {
  554. tmp |= i << 4; /* WSS port select bits */
  555. break;
  556. }
  557. }
  559. /*
  560.  * Set optional CD-ROM and joystick settings.
  561.  */
  563. tmp &= ~0x0f;
  564. mad_write(MC1_PORT, tmp);
  566. tmp = mad_read(MC2_PORT);
  568. mad_write(MC2_PORT, tmp);
  569. mad_write(MC3_PORT, 0xf0); /* Disable SB */
  571. if (board_type == C924) /* Specific C924 init values */
  572. {
  573. mad_write(MC4_PORT, 0xA0);
  574. mad_write(MC5_PORT, 0x05);
  575. mad_write(MC6_PORT, 0x03);
  576. }
  577. if (!ad1848_detect(hw_config->io_base + 4, &ad_flags, mad16_osp))
  578. return 0;
  580. if (ad_flags & (AD_F_CS4231 | AD_F_CS4248))
  581. cs4231_mode = 0x02; /* CS4248/CS4231 sync delay switch */
  583. if (board_type == C929)
  584. {
  585. mad_write(MC4_PORT, 0xa2);
  586. mad_write(MC5_PORT, 0xA5 | cs4231_mode);
  587. mad_write(MC6_PORT, 0x03); /* Disable MPU401 */
  588. }
  589. else
  590. {
  591. mad_write(MC4_PORT, 0x02);
  592. mad_write(MC5_PORT, 0x30 | cs4231_mode);
  593. }
  595. for (i = 0xf8d; i <= 0xf93; i++) if (!c924pnp)
  596. DDB(printk("port %03x after init = %02xn", i, mad_read(i))) else
  597. DDB(printk("port %03x after init = %02xn", i-0x80, mad_read(i)));
  598. wss_init(hw_config);
  600. return 1;
  601. }
  603. static void __init attach_mad16(struct address_info *hw_config)
  604. {
  606. static signed char     interrupt_bits[12] = {
  607. -1, -1, -1, -1, -1, -1, -1, 0x08, -1, 0x10, 0x18, 0x20
  608. };
  609. signed char bits;
  611. static char     dma_bits[4] = {
  612. 1, 2, 0, 3
  613. };
  615. int config_port = hw_config->io_base + 0, version_port = hw_config->io_base + 3;
  616. int ad_flags = 0, dma = hw_config->dma, dma2 = hw_config->dma2;
  617. unsigned char dma2_bit = 0;
  619. already_initialized = 1;
  621. if (!ad1848_detect(hw_config->io_base + 4, &ad_flags, mad16_osp))
  622. return;
  624. /*
  625.  * Set the IRQ and DMA addresses.
  626.  */
  628. if (board_type == C930 || c924pnp)
  629. interrupt_bits[5] = 0x28; /* Also IRQ5 is possible on C930 */
  631. bits = interrupt_bits[hw_config->irq];
  632. if (bits == -1)
  633. return;
  635. outb((bits | 0x40), config_port);
  636. if ((inb(version_port) & 0x40) == 0)
  637. printk(KERN_ERR "[IRQ Conflict?]n");
  639. /*
  640.  * Handle the capture DMA channel
  641.  */
  643. if (ad_flags & AD_F_CS4231 && dma2 != -1 && dma2 != dma)
  644. {
  645. if (!((dma == 0 && dma2 == 1) ||
  646. (dma == 1 && dma2 == 0) ||
  647. (dma == 3 && dma2 == 0)))
  648. { /* Unsupported combination. Try to swap channels */
  649. int tmp = dma;
  651. dma = dma2;
  652. dma2 = tmp;
  653. }
  654. if ((dma == 0 && dma2 == 1) || (dma == 1 && dma2 == 0) ||
  655. (dma == 3 && dma2 == 0))
  656. {
  657. dma2_bit = 0x04; /* Enable capture DMA */
  658. }
  659. else
  660. {
  661. printk("MAD16: Invalid capture DMAn");
  662. dma2 = dma;
  663. }
  664. }
  665. else dma2 = dma;
  667. outb((bits | dma_bits[dma] | dma2_bit), config_port); /* Write IRQ+DMA setup */
  669. hw_config->slots[0] = ad1848_init("mad16 WSS", hw_config->io_base + 4,
  670.   hw_config->irq,
  671.   dma,
  672.   dma2, 0,
  673.   hw_config->osp,
  674.   THIS_MODULE);
  675. request_region(hw_config->io_base, 4, "mad16 WSS config");
  676. }
  678. static int __init probe_mad16_mpu(struct address_info *hw_config)
  679. {
  680. static int mpu_attached = 0;
  681. unsigned char tmp;
  683. if (!already_initialized) /* The MSS port must be initialized first */
  684. return 0;
  686. if (mpu_attached) /* Don't let them call this twice */
  687. return 0;
  688. mpu_attached = 1;
  690. if (board_type < C929) /* Early chip. No MPU support. Just SB MIDI */
  691. {
  693. #ifdef CONFIG_MAD16_OLDCARD
  695. tmp = mad_read(MC3_PORT);
  697. /* 
  698.  * MAD16 SB base is defined by the WSS base. It cannot be changed 
  699.  * alone.
  700.  * Ignore configured I/O base. Use the active setting. 
  701.  */
  703. if (mad_read(MC1_PORT) & 0x20)
  704. hw_config->io_base = 0x240;
  705. else
  706. hw_config->io_base = 0x220;
  708. switch (hw_config->irq)
  709. {
  710. case 5:
  711. tmp = (tmp & 0x3f) | 0x80;
  712. break;
  713. case 7:
  714. tmp = (tmp & 0x3f);
  715. break;
  716. case 11:
  717. tmp = (tmp & 0x3f) | 0x40;
  718. break;
  719. default:
  720. printk(KERN_ERR "mad16/Mozart: Invalid MIDI IRQn");
  721. return 0;
  722. }
  724. mad_write(MC3_PORT, tmp | 0x04);
  725. hw_config->driver_use_1 = SB_MIDI_ONLY;
  726. if (!sb_dsp_detect(hw_config, 0, 0, NULL))
  727. return 0;
  729. if (mad_read(MC1_PORT) & 0x20)
  730. hw_config->io_base = 0x240;
  731. else
  732. hw_config->io_base = 0x220;
  734. hw_config->name = "Mad16/Mozart";
  735. sb_dsp_init(hw_config, THIS_MODULE);
  736. return 1;
  737. #else
  738. /* assuming all later Mozart cards are identified as
  739.  * either 82C928 or Mozart. If so, following code attempts
  740.  * to set MPU register. TODO - add probing
  741.  */
  743. tmp = mad_read(MC8_PORT);
  745. switch (hw_config->irq)
  746. {
  747. case 5:
  748. tmp |= 0x08;
  749. break;
  750. case 7:
  751. tmp |= 0x10;
  752. break;
  753. case 9:
  754. tmp |= 0x18;
  755. break;
  756. case 10:
  757. tmp |= 0x20;
  758. break;
  759. case 11:
  760. tmp |= 0x28;
  761. break;
  762. default:
  763. printk(KERN_ERR "mad16/MOZART: invalid mpu_irqn");
  764. return 0;
  765. }
  767. switch (hw_config->io_base)
  768. {
  769. case 0x300:
  770. tmp |= 0x01;
  771. break;
  772. case 0x310:
  773. tmp |= 0x03;
  774. break;
  775. case 0x320:
  776. tmp |= 0x05;
  777. break;
  778. case 0x330:
  779. tmp |= 0x07;
  780. break;
  781. default:
  782. printk(KERN_ERR "mad16/MOZART: invalid mpu_ion");
  783. return 0;
  784. }
  786. mad_write(MC8_PORT, tmp); /* write MPU port parameters */
  787. goto probe_401;
  788. #endif
  789. }
  790. tmp = mad_read(MC6_PORT) & 0x83;
  791. tmp |= 0x80; /* MPU-401 enable */
  793. /* Set the MPU base bits */
  795. switch (hw_config->io_base)
  796. {
  797. case 0x300:
  798. tmp |= 0x60;
  799. break;
  800. case 0x310:
  801. tmp |= 0x40;
  802. break;
  803. case 0x320:
  804. tmp |= 0x20;
  805. break;
  806. case 0x330:
  807. tmp |= 0x00;
  808. break;
  809. default:
  810. printk(KERN_ERR "MAD16: Invalid MIDI port 0x%xn", hw_config->io_base);
  811. return 0;
  812. }
  814. /* Set the MPU IRQ bits */
  816. switch (hw_config->irq)
  817. {
  818. case 5:
  819. tmp |= 0x10;
  820. break;
  821. case 7:
  822. tmp |= 0x18;
  823. break;
  824. case 9:
  825. tmp |= 0x00;
  826. break;
  827. case 10:
  828. tmp |= 0x08;
  829. break;
  830. default:
  831. printk(KERN_ERR "MAD16: Invalid MIDI IRQ %dn", hw_config->irq);
  832. break;
  833. }
  835. mad_write(MC6_PORT, tmp); /* Write MPU401 config */
  837. #ifndef CONFIG_MAD16_OLDCARD
  838. probe_401:
  839. #endif
  840. hw_config->driver_use_1 = SB_MIDI_ONLY;
  841. hw_config->name = "Mad16/Mozart";
  842. return probe_uart401(hw_config, THIS_MODULE);
  843. }
  845. static void __exit unload_mad16(struct address_info *hw_config)
  846. {
  847. ad1848_unload(hw_config->io_base + 4,
  848. hw_config->irq,
  849. hw_config->dma,
  850. hw_config->dma2, 0);
  851. release_region(hw_config->io_base, 4);
  852. sound_unload_audiodev(hw_config->slots[0]);
  853. }
  855. static void __exit unload_mad16_mpu(struct address_info *hw_config)
  856. {
  857. #ifdef CONFIG_MAD16_OLDCARD
  858. if (board_type < C929) /* Early chip. No MPU support. Just SB MIDI */
  859. {
  860. sb_dsp_unload(hw_config, 0);
  861. return;
  862. }
  863. #endif
  865. unload_uart401(hw_config);
  866. }
  868. static struct address_info cfg;
  869. static struct address_info cfg_mpu;
  871. static int found_mpu;
  873. static int __initdata mpu_io = 0;
  874. static int __initdata mpu_irq = 0;
  875. static int __initdata io = -1;
  876. static int __initdata dma = -1;
  877. static int __initdata dma16 = -1; /* Set this for modules that need it */
  878. static int __initdata irq = -1;
  879. static int __initdata cdtype = 0;
  880. static int __initdata cdirq = 0;
  881. static int __initdata cdport = 0x340;
  882. static int __initdata cddma = -1;
  883. static int __initdata opl4 = 0;
  884. static int __initdata joystick = 0;
  886. MODULE_PARM(mpu_io, "i");
  887. MODULE_PARM(mpu_irq, "i");
  888. MODULE_PARM(io,"i");
  889. MODULE_PARM(dma,"i");
  890. MODULE_PARM(dma16,"i");
  891. MODULE_PARM(irq,"i");
  892. MODULE_PARM(cdtype,"i");
  893. MODULE_PARM(cdirq,"i");
  894. MODULE_PARM(cdport,"i");
  895. MODULE_PARM(cddma,"i");
  896. MODULE_PARM(opl4,"i");
  897. MODULE_PARM(joystick,"i");
  898. MODULE_PARM(debug,"i");
  900. static int __initdata dma_map[2][8] =
  901. {
  902. {0x03, -1, -1, -1, -1, 0x00, 0x01, 0x02},
  903. {0x03, -1, 0x01, 0x00, -1, -1, -1, -1}
  904. };
  906. static int __initdata irq_map[16] =
  907. {
  908. 0x00, -1, -1, 0x0A,
  909. -1, 0x04, -1, 0x08,
  910. -1, 0x10, 0x14, 0x18,
  911. -1, -1, -1, -1
  912. };
  914. static int __init init_mad16(void)
  915. {
  916. int dmatype = 0;
  918. printk(KERN_INFO "MAD16 audio driver Copyright (C) by Hannu Savolainen 1993-1996n");
  920. printk(KERN_INFO "CDROM ");
  921. switch (cdtype)
  922. {
  923. case 0x00:
  924. printk("Disabled");
  925. cdirq = 0;
  926. break;
  927. case 0x02:
  928. printk("Sony CDU31A");
  929. dmatype = 1;
  930. if(cddma == -1) cddma = 3;
  931. break;
  932. case 0x04:
  933. printk("Mitsumi");
  934. dmatype = 0;
  935. if(cddma == -1) cddma = 5;
  936. break;
  937. case 0x06:
  938. printk("Panasonic Lasermate");
  939. dmatype = 1;
  940. if(cddma == -1) cddma = 3;
  941. break;
  942. case 0x08:
  943. printk("Secondary IDE");
  944. dmatype = 0;
  945. if(cddma == -1) cddma = 5;
  946. break;
  947. case 0x0A:
  948. printk("Primary IDE");
  949. dmatype = 0;
  950. if(cddma == -1) cddma = 5;
  951. break;
  952. default:
  953. printk("n");
  954. printk(KERN_ERR "Invalid CDROM typen");
  955. return -EINVAL;
  956. }
  958.   /*
  959.          *    Build the config words
  960.          */
  962.         mad16_conf = (joystick ^ 1) | cdtype;
  963. mad16_cdsel = 0;
  964.         if (opl4)
  965.                 mad16_cdsel |= 0x20;
  967. if(cdtype){
  968. if (cddma > 7 || cddma < 0 || dma_map[dmatype][cddma] == -1)
  969. {
  970. printk("n");
  971. printk(KERN_ERR "Invalid CDROM DMAn");
  972. return -EINVAL;
  973. }
  974. if (cddma)
  975. printk(", DMA %d", cddma);
  976. else
  977. printk(", no DMA");
  979. if (!cdirq)
  980. printk(", no IRQ");
  981. else if (cdirq < 0 || cdirq > 15 || irq_map[cdirq] == -1)
  982. {
  983.    printk(", invalid IRQ (disabling)");
  984.    cdirq = 0;
  985. }
  986. else printk(", IRQ %d", cdirq);
  988. mad16_cdsel |= dma_map[dmatype][cddma];
  990. if (cdtype < 0x08)
  991. {
  992. switch (cdport)
  993. {
  994. case 0x340:
  995. mad16_cdsel |= 0x00;
  996. break;
  997. case 0x330:
  998. mad16_cdsel |= 0x40;
  999. break;
  1000. case 0x360:
  1001. mad16_cdsel |= 0x80;
  1002. break;
  1003. case 0x320:
  1004. mad16_cdsel |= 0xC0;
  1005. break;
  1006. default:
  1007. printk(KERN_ERR "Unknown CDROM I/O base %dn", cdport);
  1008. return -EINVAL;
  1009. }
  1010. }
  1011. mad16_cdsel |= irq_map[cdirq];
  1012. }
  1014. printk(".n");
  1016. cfg.io_base = io;
  1017. cfg.irq = irq;
  1018. cfg.dma = dma;
  1019. cfg.dma2 = dma16;
  1021. if (cfg.io_base == -1 || cfg.dma == -1 || cfg.irq == -1) {
  1022. printk(KERN_ERR "I/O, DMA and irq are mandatoryn");
  1023. return -EINVAL;
  1024. }
  1026. if (!probe_mad16(&cfg))
  1027. return -ENODEV;
  1029. cfg_mpu.io_base = mpu_io;
  1030. cfg_mpu.irq = mpu_irq;
  1032. attach_mad16(&cfg);
  1034. found_mpu = probe_mad16_mpu(&cfg_mpu);
  1036. if (joystick == 1) {
  1037.         /* register gameport */
  1038.                 if (!request_region(0x201, 1, "mad16 gameport"))
  1039.                         printk(KERN_ERR "mad16: gameport address 0x201 already in usen");
  1040.                 else {
  1041. printk(KERN_ERR "mad16: gameport enabled at 0x201n");
  1042.                         gameport.io = 0x201;
  1043.         gameport_register_port(&gameport);
  1044.                 }
  1045. }
  1046. else printk(KERN_ERR "mad16: gameport disabled.n");
  1047. return 0;
  1048. }
  1050. static void __exit cleanup_mad16(void)
  1051. {
  1052. if (found_mpu)
  1053. unload_mad16_mpu(&cfg_mpu);
  1054. unload_mad16(&cfg);
  1055. }
  1057. module_init(init_mad16);
  1058. module_exit(cleanup_mad16);
  1060. #ifndef MODULE
  1061. static int __init setup_mad16(char *str)
  1062. {
  1063.         /* io, irq */
  1064. int ints[8];
  1066. str = get_options(str, ARRAY_SIZE(ints), ints);
  1068. io  = ints[1];
  1069. irq  = ints[2];
  1070. dma  = ints[3];
  1071. dma16  = ints[4];
  1072. mpu_io  = ints[5];
  1073. mpu_irq  = ints[6];
  1074. joystick = ints[7];
  1076. return 1;
  1077. }
  1079. __setup("mad16=", setup_mad16);
  1080. #endif
  1081. MODULE_LICENSE("GPL");