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

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

Linux/Unix编程

开发平台：

Unix_Linux

sscape.c：源码内容
  1. /*
  2.  * sound/sscape.c
  3.  *
  4.  * Low level driver for Ensoniq SoundScape
  5.  *
  6.  *
  7.  * Copyright (C) by Hannu Savolainen 1993-1997
  8.  *
  9.  * OSS/Free for Linux is distributed under the GNU GENERAL PUBLIC LICENSE (GPL)
  10.  * Version 2 (June 1991). See the "COPYING" file distributed with this software
  11.  * for more info.
  12.  *
  13.  *
  14.  * Thomas Sailer    : ioctl code reworked (vmalloc/vfree removed)
  15.  * Sergey Smitienko : ensoniq p'n'p support
  16.  * Christoph Hellwig : adapted to module_init/module_exit
  17.  * Bartlomiej Zolnierkiewicz : added __init to attach_sscape()
  18.  * Chris Rankin : Specify that this module owns the coprocessor
  19.  * Arnaldo C. de Melo : added missing restore_flags in sscape_pnp_upload_file
  20.  */
  22. #include <linux/init.h>
  23. #include <linux/module.h>
  25. #include "sound_config.h"
  26. #include "sound_firmware.h"
  28. #include <linux/types.h>
  29. #include <linux/errno.h>
  30. #include <linux/signal.h>
  31. #include <linux/fcntl.h>
  32. #include <linux/ctype.h>
  33. #include <linux/stddef.h>
  34. #include <linux/kmod.h>
  35. #include <asm/dma.h>
  36. #include <asm/io.h>
  37. #include <asm/segment.h>
  38. #include <linux/wait.h>
  39. #include <linux/slab.h>
  40. #include <linux/ioport.h>
  41. #include <linux/delay.h>
  42. #include <linux/proc_fs.h>
  43. #include <linux/wrapper.h>
  45. #include "coproc.h"
  47. #include "ad1848.h"
  48. #include "mpu401.h"
  50. /*
  51.  *    I/O ports
  52.  */
  53. #define MIDI_DATA       0
  54. #define MIDI_CTRL       1
  55. #define HOST_CTRL       2
  56. #define TX_READY 0x02
  57. #define RX_READY 0x01
  58. #define HOST_DATA       3
  59. #define ODIE_ADDR       4
  60. #define ODIE_DATA       5
  62. /*
  63.  *    Indirect registers
  64.  */
  66. #define GA_INTSTAT_REG 0
  67. #define GA_INTENA_REG 1
  68. #define GA_DMAA_REG 2
  69. #define GA_DMAB_REG 3
  70. #define GA_INTCFG_REG 4
  71. #define GA_DMACFG_REG 5
  72. #define GA_CDCFG_REG 6
  73. #define GA_SMCFGA_REG 7
  74. #define GA_SMCFGB_REG 8
  75. #define GA_HMCTL_REG 9
  77. /*
  78.  * DMA channel identifiers (A and B)
  79.  */
  81. #define SSCAPE_DMA_A 0
  82. #define SSCAPE_DMA_B 1
  84. #define PORT(name) (devc->base+name)
  86. /*
  87.  * Host commands recognized by the OBP microcode
  88.  */
  89.  
  90. #define CMD_GEN_HOST_ACK 0x80
  91. #define CMD_GEN_MPU_ACK 0x81
  92. #define CMD_GET_BOARD_TYPE 0x82
  93. #define CMD_SET_CONTROL 0x88 /* Old firmware only */
  94. #define CMD_GET_CONTROL 0x89 /* Old firmware only */
  95. #define CTL_MASTER_VOL 0
  96. #define CTL_MIC_MODE 2
  97. #define CTL_SYNTH_VOL 4
  98. #define CTL_WAVE_VOL 7
  99. #define CMD_SET_EXTMIDI 0x8a
  100. #define CMD_GET_EXTMIDI 0x8b
  101. #define CMD_SET_MT32 0x8c
  102. #define CMD_GET_MT32 0x8d
  104. #define CMD_ACK 0x80
  106. #define IC_ODIE 1
  107. #define IC_OPUS 2
  109. typedef struct sscape_info
  110. {
  111. int base, irq, dma;
  113. int codec, codec_irq; /* required to setup pnp cards*/
  114. int codec_type;
  115. int ic_type;
  116. char* raw_buf;
  117. unsigned long raw_buf_phys;
  118. int buffsize; /* -------------------------- */
  120. int ok; /* Properly detected */
  121. int failed;
  122. int dma_allocated;
  123. int codec_audiodev;
  124. int opened;
  125. int *osp;
  126. int my_audiodev;
  127. } sscape_info;
  129. static struct sscape_info adev_info = {
  130. 0
  131. };
  133. static struct sscape_info *devc = &adev_info;
  134. static int sscape_mididev = -1;
  136. /* Some older cards have assigned interrupt bits differently than new ones */
  137. static char valid_interrupts_old[] = {
  138. 9, 7, 5, 15
  139. };
  141. static char valid_interrupts_new[] = {
  142. 9, 5, 7, 10
  143. };
  145. static char *valid_interrupts = valid_interrupts_new;
  147. /*
  148.  * See the bottom of the driver. This can be set by spea =0/1.
  149.  */
  150.  
  151. #ifdef REVEAL_SPEA
  152. static char old_hardware = 1;
  153. #else
  154. static char old_hardware = 0;
  155. #endif
  157. static void sleep(unsigned howlong)
  158. {
  159. current->state = TASK_INTERRUPTIBLE;
  160. schedule_timeout(howlong);
  161. }
  163. static unsigned char sscape_read(struct sscape_info *devc, int reg)
  164. {
  165. unsigned long flags;
  166. unsigned char val;
  168. save_flags(flags);
  169. cli();
  170. outb(reg, PORT(ODIE_ADDR));
  171. val = inb(PORT(ODIE_DATA));
  172. restore_flags(flags);
  173. return val;
  174. }
  176. static void sscape_write(struct sscape_info *devc, int reg, int data)
  177. {
  178. unsigned long flags;
  180. save_flags(flags);
  181. cli();
  182. outb(reg, PORT(ODIE_ADDR));
  183. outb(data, PORT(ODIE_DATA));
  184. restore_flags(flags);
  185. }
  187. static unsigned char sscape_pnp_read_codec(sscape_info* devc, unsigned char reg)
  188. {
  189. unsigned char res;
  190. unsigned long flags;
  192. save_flags(flags);
  193. cli();
  194. outb( reg, devc -> codec);
  195. res = inb (devc -> codec + 1);
  196. restore_flags(flags);
  197. return res;
  199. }
  201. static void sscape_pnp_write_codec(sscape_info* devc, unsigned char reg, unsigned char data)
  202. {
  203. unsigned long flags;
  205. save_flags(flags);
  206. cli();
  207. outb( reg, devc -> codec);
  208. outb( data, devc -> codec + 1);
  209. restore_flags(flags);
  210. }
  212. static void host_open(struct sscape_info *devc)
  213. {
  214. outb((0x00), PORT(HOST_CTRL)); /* Put the board to the host mode */
  215. }
  217. static void host_close(struct sscape_info *devc)
  218. {
  219. outb((0x03), PORT(HOST_CTRL)); /* Put the board to the MIDI mode */
  220. }
  222. static int host_write(struct sscape_info *devc, unsigned char *data, int count)
  223. {
  224. unsigned long flags;
  225. int i, timeout_val;
  227. save_flags(flags);
  228. cli();
  230. /*
  231.  * Send the command and data bytes
  232.  */
  234. for (i = 0; i < count; i++)
  235. {
  236. for (timeout_val = 10000; timeout_val > 0; timeout_val--)
  237. if (inb(PORT(HOST_CTRL)) & TX_READY)
  238. break;
  240. if (timeout_val <= 0)
  241. {
  242.     restore_flags(flags);
  243.     return 0;
  244. }
  245. outb(data[i], PORT(HOST_DATA));
  246. }
  247. restore_flags(flags);
  248. return 1;
  249. }
  251. static int host_read(struct sscape_info *devc)
  252. {
  253. unsigned long flags;
  254. int timeout_val;
  255. unsigned char data;
  257. save_flags(flags);
  258. cli();
  260. /*
  261.  * Read a byte
  262.  */
  264. for (timeout_val = 10000; timeout_val > 0; timeout_val--)
  265. if (inb(PORT(HOST_CTRL)) & RX_READY)
  266. break;
  268. if (timeout_val <= 0)
  269. {
  270. restore_flags(flags);
  271. return -1;
  272. }
  273. data = inb(PORT(HOST_DATA));
  274. restore_flags(flags);
  275. return data;
  276. }
  278. #if 0 /* unused */
  279. static int host_command1(struct sscape_info *devc, int cmd)
  280. {
  281. unsigned char buf[10];
  282. buf[0] = (unsigned char) (cmd & 0xff);
  283. return host_write(devc, buf, 1);
  284. }
  285. #endif /* unused */
  288. static int host_command2(struct sscape_info *devc, int cmd, int parm1)
  289. {
  290. unsigned char buf[10];
  292. buf[0] = (unsigned char) (cmd & 0xff);
  293. buf[1] = (unsigned char) (parm1 & 0xff);
  295. return host_write(devc, buf, 2);
  296. }
  298. static int host_command3(struct sscape_info *devc, int cmd, int parm1, int parm2)
  299. {
  300. unsigned char buf[10];
  302. buf[0] = (unsigned char) (cmd & 0xff);
  303. buf[1] = (unsigned char) (parm1 & 0xff);
  304. buf[2] = (unsigned char) (parm2 & 0xff);
  305. return host_write(devc, buf, 3);
  306. }
  308. static void set_mt32(struct sscape_info *devc, int value)
  309. {
  310. host_open(devc);
  311. host_command2(devc, CMD_SET_MT32, value ? 1 : 0);
  312. if (host_read(devc) != CMD_ACK)
  313. {
  314. /* printk( "SNDSCAPE: Setting MT32 mode failedn"); */
  315. }
  316. host_close(devc);
  317. }
  319. static void set_control(struct sscape_info *devc, int ctrl, int value)
  320. {
  321. host_open(devc);
  322. host_command3(devc, CMD_SET_CONTROL, ctrl, value);
  323. if (host_read(devc) != CMD_ACK)
  324. {
  325. /* printk( "SNDSCAPE: Setting control (%d) failedn",  ctrl); */
  326. }
  327. host_close(devc);
  328. }
  330. static void do_dma(struct sscape_info *devc, int dma_chan, unsigned long buf, int blk_size, int mode)
  331. {
  332. unsigned char temp;
  334. if (dma_chan != SSCAPE_DMA_A)
  335. {
  336. printk(KERN_WARNING "soundscape: Tried to use DMA channel  != A. Why?n");
  337. return;
  338. }
  339. audio_devs[devc->codec_audiodev]->flags &= ~DMA_AUTOMODE;
  340. DMAbuf_start_dma(devc->codec_audiodev, buf, blk_size, mode);
  341. audio_devs[devc->codec_audiodev]->flags |= DMA_AUTOMODE;
  343. temp = devc->dma << 4; /* Setup DMA channel select bits */
  344. if (devc->dma <= 3)
  345. temp |= 0x80; /* 8 bit DMA channel */
  347. temp |= 1; /* Trigger DMA */
  348. sscape_write(devc, GA_DMAA_REG, temp);
  349. temp &= 0xfe; /* Clear DMA trigger */
  350. sscape_write(devc, GA_DMAA_REG, temp);
  351. }
  353. static int verify_mpu(struct sscape_info *devc)
  354. {
  355. /*
  356.  * The SoundScape board could be in three modes (MPU, 8250 and host).
  357.  * If the card is not in the MPU mode, enabling the MPU driver will
  358.  * cause infinite loop (the driver believes that there is always some
  359.  * received data in the buffer.
  360.  *
  361.  * Detect this by looking if there are more than 10 received MIDI bytes
  362.  * (0x00) in the buffer.
  363.  */
  365. int i;
  367. for (i = 0; i < 10; i++)
  368. {
  369. if (inb(devc->base + HOST_CTRL) & 0x80)
  370. return 1;
  372. if (inb(devc->base) != 0x00)
  373. return 1;
  374. }
  375. printk(KERN_WARNING "SoundScape: The device is not in the MPU-401 moden");
  376. return 0;
  377. }
  379. static int sscape_coproc_open(void *dev_info, int sub_device)
  380. {
  381. if (sub_device == COPR_MIDI)
  382. {
  383. set_mt32(devc, 0);
  384. if (!verify_mpu(devc))
  385. return -EIO;
  386. }
  387. return 0;
  388. }
  390. static void sscape_coproc_close(void *dev_info, int sub_device)
  391. {
  392. struct sscape_info *devc = dev_info;
  393. unsigned long   flags;
  395. save_flags(flags);
  396. cli();
  397. if (devc->dma_allocated)
  398. {
  399. sscape_write(devc, GA_DMAA_REG, 0x20); /* DMA channel disabled */
  400. devc->dma_allocated = 0;
  401. }
  402. restore_flags(flags);
  403. return;
  404. }
  406. static void sscape_coproc_reset(void *dev_info)
  407. {
  408. }
  410. static int sscape_download_boot(struct sscape_info *devc, unsigned char *block, int size, int flag)
  411. {
  412. unsigned long flags;
  413. unsigned char temp;
  414. volatile int done, timeout_val;
  415. static unsigned char codec_dma_bits = 0;
  417. if (flag & CPF_FIRST)
  418. {
  419. /*
  420.  * First block. Have to allocate DMA and to reset the board
  421.  * before continuing.
  422.  */
  424. save_flags(flags);
  425. cli();
  426. codec_dma_bits = sscape_read(devc, GA_CDCFG_REG);
  428. if (devc->dma_allocated == 0)
  429. devc->dma_allocated = 1;
  431. restore_flags(flags);
  433. sscape_write(devc, GA_HMCTL_REG, 
  434. (temp = sscape_read(devc, GA_HMCTL_REG)) & 0x3f); /*Reset */
  436. for (timeout_val = 10000; timeout_val > 0; timeout_val--)
  437. sscape_read(devc, GA_HMCTL_REG); /* Delay */
  439. /* Take board out of reset */
  440. sscape_write(devc, GA_HMCTL_REG,
  441. (temp = sscape_read(devc, GA_HMCTL_REG)) | 0x80);
  442. }
  443. /*
  444.  * Transfer one code block using DMA
  445.  */
  446. if (audio_devs[devc->codec_audiodev]->dmap_out->raw_buf == NULL)
  447. {
  448. printk(KERN_WARNING "soundscape: DMA buffer not availablen");
  449. return 0;
  450. }
  451. memcpy(audio_devs[devc->codec_audiodev]->dmap_out->raw_buf, block, size);
  453. save_flags(flags);
  454. cli();
  456. /******** INTERRUPTS DISABLED NOW ********/
  458. do_dma(devc, SSCAPE_DMA_A,
  459.        audio_devs[devc->codec_audiodev]->dmap_out->raw_buf_phys,
  460.        size, DMA_MODE_WRITE);
  462. /*
  463.  * Wait until transfer completes.
  464.  */
  466. done = 0;
  467. timeout_val = 30;
  468. while (!done && timeout_val-- > 0)
  469. {
  470. int resid;
  472. if (HZ / 50)
  473. sleep(HZ / 50);
  474. clear_dma_ff(devc->dma);
  475. if ((resid = get_dma_residue(devc->dma)) == 0)
  476. done = 1;
  477. }
  479. restore_flags(flags);
  480. if (!done)
  481. return 0;
  483. if (flag & CPF_LAST)
  484. {
  485. /*
  486.  * Take the board out of reset
  487.  */
  488. outb((0x00), PORT(HOST_CTRL));
  489. outb((0x00), PORT(MIDI_CTRL));
  491. temp = sscape_read(devc, GA_HMCTL_REG);
  492. temp |= 0x40;
  493. sscape_write(devc, GA_HMCTL_REG, temp); /* Kickstart the board */
  495. /*
  496.  * Wait until the ODB wakes up
  497.  */
  499. save_flags(flags);
  500. cli();
  501. done = 0;
  502. timeout_val = 5 * HZ;
  503. while (!done && timeout_val-- > 0)
  504. {
  505. unsigned char x;
  507. sleep(1);
  508. x = inb(PORT(HOST_DATA));
  509. if (x == 0xff || x == 0xfe) /* OBP startup acknowledge */
  510. {
  511. DDB(printk("Soundscape: Acknowledge = %xn", x));
  512. done = 1;
  513. }
  514. }
  515. sscape_write(devc, GA_CDCFG_REG, codec_dma_bits);
  517. restore_flags(flags);
  518. if (!done)
  519. {
  520. printk(KERN_ERR "soundscape: The OBP didn't respond after code downloadn");
  521. return 0;
  522. }
  523. save_flags(flags);
  524. cli();
  525. done = 0;
  526. timeout_val = 5 * HZ;
  527. while (!done && timeout_val-- > 0)
  528. {
  529. sleep(1);
  530. if (inb(PORT(HOST_DATA)) == 0xfe) /* Host startup acknowledge */
  531. done = 1;
  532. }
  533. restore_flags(flags);
  534. if (!done)
  535. {
  536. printk(KERN_ERR "soundscape: OBP Initialization failed.n");
  537. return 0;
  538. }
  539. printk(KERN_INFO "SoundScape board initialized OKn");
  540. set_control(devc, CTL_MASTER_VOL, 100);
  541. set_control(devc, CTL_SYNTH_VOL, 100);
  543. #ifdef SSCAPE_DEBUG3
  544. /*
  545.  * Temporary debugging aid. Print contents of the registers after
  546.  * downloading the code.
  547.  */
  548. {
  549. int i;
  551. for (i = 0; i < 13; i++)
  552. printk("I%d = %02x (new value)n", i, sscape_read(devc, i));
  553. }
  554. #endif
  556. }
  557. return 1;
  558. }
  560. static int download_boot_block(void *dev_info, copr_buffer * buf)
  561. {
  562. if (buf->len <= 0 || buf->len > sizeof(buf->data))
  563. return -EINVAL;
  565. if (!sscape_download_boot(devc, buf->data, buf->len, buf->flags))
  566. {
  567. printk(KERN_ERR "soundscape: Unable to load microcode block to the OBP.n");
  568. return -EIO;
  569. }
  570. return 0;
  571. }
  573. static int sscape_coproc_ioctl(void *dev_info, unsigned int cmd, caddr_t arg, int local)
  574. {
  575. copr_buffer *buf;
  576. int err;
  578. switch (cmd) 
  579. {
  580. case SNDCTL_COPR_RESET:
  581. sscape_coproc_reset(dev_info);
  582. return 0;
  584. case SNDCTL_COPR_LOAD:
  585. buf = (copr_buffer *) vmalloc(sizeof(copr_buffer));
  586. if (buf == NULL)
  587. return -ENOSPC;
  588. if (copy_from_user(buf, arg, sizeof(copr_buffer))) 
  589. {
  590. vfree(buf);
  591. return -EFAULT;
  592. }
  593. err = download_boot_block(dev_info, buf);
  594. vfree(buf);
  595. return err;
  597. default:
  598. return -EINVAL;
  599. }
  600. }
  602. static coproc_operations sscape_coproc_operations =
  603. {
  604. "SoundScape M68K",
  605. THIS_MODULE,
  606. sscape_coproc_open,
  607. sscape_coproc_close,
  608. sscape_coproc_ioctl,
  609. sscape_coproc_reset,
  610. &adev_info
  611. };
  613. static int sscape_detected = 0;
  614. static int sscape_is_pnp   = 0;
  616. void __init attach_sscape(struct address_info *hw_config)
  617. {
  618. #ifndef SSCAPE_REGS
  619. /*
  620.  * Config register values for Spea/V7 Media FX and Ensoniq S-2000.
  621.  * These values are card
  622.  * dependent. If you have another SoundScape based card, you have to
  623.  * find the correct values. Do the following:
  624.  *  - Compile this driver with SSCAPE_DEBUG1 defined.
  625.  *  - Shut down and power off your machine.
  626.  *  - Boot with DOS so that the SSINIT.EXE program is run.
  627.  *  - Warm boot to {Linux|SYSV|BSD} and write down the lines displayed
  628.  *    when detecting the SoundScape.
  629.  *  - Modify the following list to use the values printed during boot.
  630.  *    Undefine the SSCAPE_DEBUG1
  631.  */
  632. #define SSCAPE_REGS { 
  633. /* I0 */ 0x00, 
  634. /* I1 */ 0xf0, /* Note! Ignored. Set always to 0xf0 */ 
  635. /* I2 */ 0x20, /* Note! Ignored. Set always to 0x20 */ 
  636. /* I3 */ 0x20, /* Note! Ignored. Set always to 0x20 */ 
  637. /* I4 */ 0xf5, /* Ignored */ 
  638. /* I5 */ 0x10, 
  639. /* I6 */ 0x00, 
  640. /* I7 */ 0x2e, /* I7 MEM config A. Likely to vary between models */ 
  641. /* I8 */ 0x00, /* I8 MEM config B. Likely to vary between models */ 
  642. /* I9 */ 0x40 /* Ignored */ 
  643. }
  644. #endif
  646. unsigned long   flags;
  647. static unsigned char regs[10] = SSCAPE_REGS;
  649. int i, irq_bits = 0xff;
  651. if (sscape_detected != hw_config->io_base)
  652. return;
  654. request_region(devc->base + 2, 6, "SoundScape");
  655. if (old_hardware)
  656. {
  657. valid_interrupts = valid_interrupts_old;
  658. conf_printf("Ensoniq SoundScape (old)", hw_config);
  659. }
  660. else
  661. conf_printf("Ensoniq SoundScape", hw_config);
  663. for (i = 0; i < sizeof(valid_interrupts); i++)
  664. {
  665. if (hw_config->irq == valid_interrupts[i])
  666. {
  667. irq_bits = i;
  668. break;
  669. }
  670. }
  671. if (hw_config->irq > 15 || (regs[4] = irq_bits == 0xff))
  672. {
  673. printk(KERN_ERR "Invalid IRQ%dn", hw_config->irq);
  674. return;
  675. }
  677. if (!sscape_is_pnp) {
  679.     save_flags(flags);
  680.     cli();
  681.     for (i = 1; i < 10; i++)
  682.     {
  683. switch (i)
  684. {
  685. case 1: /* Host interrupt enable */
  686. sscape_write(devc, i, 0xf0); /* All interrupts enabled */
  687. break;
  689. case 2: /* DMA A status/trigger register */
  690. case 3: /* DMA B status/trigger register */
  691. sscape_write(devc, i, 0x20); /* DMA channel disabled */
  692. break;
  694. case 4: /* Host interrupt config reg */
  695. sscape_write(devc, i, 0xf0 | (irq_bits << 2) | irq_bits);
  696. break;
  698. case 5: /* Don't destroy CD-ROM DMA config bits (0xc0) */
  699. sscape_write(devc, i, (regs[i] & 0x3f) | (sscape_read(devc, i) & 0xc0));
  700. break;
  702. case 6: /* CD-ROM config (WSS codec actually) */
  703. sscape_write(devc, i, regs[i]);
  704. break;
  706. case 9: /* Master control reg. Don't modify CR-ROM bits. Disable SB emul */
  707. sscape_write(devc, i, (sscape_read(devc, i) & 0xf0) | 0x08);
  708. break;
  710. default:
  711. sscape_write(devc, i, regs[i]);
  712. }
  713.     }
  714.     restore_flags(flags);
  715. }
  716. #ifdef SSCAPE_DEBUG2
  717. /*
  718.  * Temporary debugging aid. Print contents of the registers after
  719.  * changing them.
  720.  */
  721. {
  722. int i;
  724. for (i = 0; i < 13; i++)
  725. printk("I%d = %02x (new value)n", i, sscape_read(devc, i));
  726. }
  727. #endif
  729. if (probe_mpu401(hw_config))
  730. hw_config->always_detect = 1;
  731. hw_config->name = "SoundScape";
  733. hw_config->irq *= -1; /* Negative value signals IRQ sharing */
  734. attach_mpu401(hw_config, THIS_MODULE);
  735. hw_config->irq *= -1; /* Restore it */
  737. if (hw_config->slots[1] != -1) /* The MPU driver installed itself */
  738. {
  739. sscape_mididev = hw_config->slots[1];
  740. midi_devs[hw_config->slots[1]]->coproc = &sscape_coproc_operations;
  741. }
  742. sscape_write(devc, GA_INTENA_REG, 0x80); /* Master IRQ enable */
  743. devc->ok = 1;
  744. devc->failed = 0;
  745. }
  747. static int detect_ga(sscape_info * devc)
  748. {
  749. unsigned char save;
  751. DDB(printk("Entered Soundscape detect_ga(%x)n", devc->base));
  753. if (check_region(devc->base, 8))
  754. return 0;
  756. /*
  757.  * First check that the address register of "ODIE" is
  758.  * there and that it has exactly 4 writable bits.
  759.  * First 4 bits
  760.  */
  762. if ((save = inb(PORT(ODIE_ADDR))) & 0xf0)
  763. {
  764. DDB(printk("soundscape: Detect error An"));
  765. return 0;
  766. }
  767. outb((0x00), PORT(ODIE_ADDR));
  768. if (inb(PORT(ODIE_ADDR)) != 0x00)
  769. {
  770. DDB(printk("soundscape: Detect error Bn"));
  771. return 0;
  772. }
  773. outb((0xff), PORT(ODIE_ADDR));
  774. if (inb(PORT(ODIE_ADDR)) != 0x0f)
  775. {
  776. DDB(printk("soundscape: Detect error Cn"));
  777. return 0;
  778. }
  779. outb((save), PORT(ODIE_ADDR));
  781. /*
  782.  * Now verify that some indirect registers return zero on some bits.
  783.  * This may break the driver with some future revisions of "ODIE" but...
  784.  */
  786. if (sscape_read(devc, 0) & 0x0c)
  787. {
  788. DDB(printk("soundscape: Detect error D (%x)n", sscape_read(devc, 0)));
  789. return 0;
  790. }
  791. if (sscape_read(devc, 1) & 0x0f)
  792. {
  793. DDB(printk("soundscape: Detect error En"));
  794. return 0;
  795. }
  796. if (sscape_read(devc, 5) & 0x0f)
  797. {
  798. DDB(printk("soundscape: Detect error Fn"));
  799. return 0;
  800. }
  801. return 1;
  802. }
  804. static int sscape_read_host_ctrl(sscape_info* devc)
  805. {
  806. return host_read(devc);
  807. }
  809. static void sscape_write_host_ctrl2(sscape_info *devc, int a, int b)
  810. {
  811. host_command2(devc, a, b);
  812. }
  814. static int sscape_alloc_dma(sscape_info *devc)
  815. {
  816. char *start_addr, *end_addr;
  817. int dma_pagesize;
  818. int sz, size;
  819. struct page *page;
  821. if (devc->raw_buf != NULL) return 0; /* Already done */
  822. dma_pagesize = (devc->dma < 4) ? (64 * 1024) : (128 * 1024);
  823. devc->raw_buf = NULL;
  824. devc->buffsize = 8192*4;
  825. if (devc->buffsize > dma_pagesize) devc->buffsize = dma_pagesize;
  826. start_addr = NULL;
  827. /*
  828.  * Now loop until we get a free buffer. Try to get smaller buffer if
  829.  * it fails. Don't accept smaller than 8k buffer for performance
  830.  * reasons.
  831.  */
  832. while (start_addr == NULL && devc->buffsize > PAGE_SIZE) {
  833. for (sz = 0, size = PAGE_SIZE; size < devc->buffsize; sz++, size <<= 1);
  834. devc->buffsize = PAGE_SIZE * (1 << sz);
  835. start_addr = (char *) __get_free_pages(GFP_ATOMIC|GFP_DMA, sz);
  836. if (start_addr == NULL) devc->buffsize /= 2;
  837. }
  839. if (start_addr == NULL) {
  840. printk(KERN_ERR "sscape pnp init error: Couldn't allocate DMA buffern");
  841. return 0;
  842. } else {
  843. /* make some checks */
  844. end_addr = start_addr + devc->buffsize - 1;
  845. /* now check if it fits into the same dma-pagesize */
  847. if (((long) start_addr & ~(dma_pagesize - 1)) != ((long) end_addr & ~(dma_pagesize - 1))
  848.     || end_addr >= (char *) (MAX_DMA_ADDRESS)) {
  849. printk(KERN_ERR "sscape pnp: Got invalid address 0x%lx for %db DMA-buffern", (long) start_addr, devc->buffsize);
  850. return 0;
  851. }
  852. }
  853. devc->raw_buf = start_addr;
  854. devc->raw_buf_phys = virt_to_bus(start_addr);
  856. for (page = virt_to_page(start_addr); page <= virt_to_page(end_addr); page++)
  857. mem_map_reserve(page);
  858. return 1;
  859. }
  861. static void sscape_free_dma(sscape_info *devc)
  862. {
  863. int sz, size;
  864. unsigned long start_addr, end_addr;
  865. struct page *page;
  867. if (devc->raw_buf == NULL) return;
  868. for (sz = 0, size = PAGE_SIZE; size < devc->buffsize; sz++, size <<= 1);
  869. start_addr = (unsigned long) devc->raw_buf;
  870. end_addr = start_addr + devc->buffsize;
  872. for (page = virt_to_page(start_addr); page <= virt_to_page(end_addr); page++)
  873. mem_map_unreserve(page);
  875. free_pages((unsigned long) devc->raw_buf, sz);
  876. devc->raw_buf = NULL;
  877. }
  879. /* Intel version !!!!!!!!! */
  881. static int sscape_start_dma(int chan, unsigned long physaddr, int count, int dma_mode)
  882. {
  883. unsigned long flags;
  885. flags = claim_dma_lock();
  886. disable_dma(chan);
  887. clear_dma_ff(chan);
  888. set_dma_mode(chan, dma_mode);
  889. set_dma_addr(chan, physaddr);
  890. set_dma_count(chan, count);
  891. enable_dma(chan);
  892. release_dma_lock(flags);
  893. return 0;
  894. }
  896. static void sscape_pnp_start_dma(sscape_info* devc, int arg )
  897. {
  898. int reg;
  899. if (arg == 0) reg = 2;
  900. else reg = 3;
  902. sscape_write(devc, reg, sscape_read( devc, reg) | 0x01);
  903. sscape_write(devc, reg, sscape_read( devc, reg) & 0xFE);
  904. }
  906. static int sscape_pnp_wait_dma (sscape_info* devc, int arg )
  907. {
  908. int reg;
  909. unsigned long i;
  910. unsigned char d;
  912. if (arg == 0) reg = 2;
  913. else reg = 3;
  915. sleep ( 1 );
  916. i = 0;
  917. do {
  918. d = sscape_read(devc, reg) & 1;
  919. if ( d == 1)  break;
  920. i++;
  921. } while (i < 500000);
  922. d = sscape_read(devc, reg) & 1; 
  923. return d;
  924. }
  926. static int sscape_pnp_alloc_dma(sscape_info* devc)
  927. {
  928. /* printk(KERN_INFO "sscape: requesting dman"); */
  929. if (request_dma(devc -> dma, "sscape")) return 0;
  930. /* printk(KERN_INFO "sscape: dma channel allocatedn"); */
  931. if (!sscape_alloc_dma(devc)) {
  932. free_dma(devc -> dma);
  933. return 0;
  934. };
  935. return 1;
  936. }
  938. static void sscape_pnp_free_dma(sscape_info* devc)
  939. {
  940. sscape_free_dma( devc);
  941. free_dma(devc -> dma );
  942. /* printk(KERN_INFO "sscape: dma releasedn"); */
  943. }
  945. static int sscape_pnp_upload_file(sscape_info* devc, char* fn)
  946. {
  947. int       done = 0;
  948. int       timeout_val;
  949. char*       data,*dt;
  950. int       len,l;
  951. unsigned long flags;
  953. sscape_write( devc, 9, sscape_read(devc, 9 )  & 0x3F );
  954. sscape_write( devc, 2, (devc -> dma << 4) | 0x80 );
  955. sscape_write( devc, 3, 0x20 );
  956. sscape_write( devc, 9, sscape_read( devc, 9 )  | 0x80 );
  958. len = mod_firmware_load(fn, &data);
  959. if (len == 0) {
  960.     printk(KERN_ERR "sscape: file not found: %sn", fn);
  961.     return 0;
  962. }
  963. dt = data;
  964. save_flags(flags);
  965. cli();
  966. while ( len > 0 ) {
  967. if (len > devc -> buffsize) l = devc->buffsize;
  968. else l = len;
  969. len -= l;
  970. memcpy(devc->raw_buf, dt, l); dt += l;
  971. sscape_start_dma(devc->dma, devc->raw_buf_phys, l, 0x48);
  972. sscape_pnp_start_dma ( devc, 0 );
  973. if (sscape_pnp_wait_dma ( devc, 0 ) == 0) {
  974. restore_flags(flags);     
  975. return 0;
  976. }
  977. }
  979. restore_flags(flags);     
  980. vfree(data);
  982. outb(0, devc -> base + 2);
  983. outb(0, devc -> base);
  985. sscape_write ( devc, 9, sscape_read( devc, 9 ) | 0x40);
  987. timeout_val = 5 * HZ; 
  988. while (!done && timeout_val-- > 0)
  989. {
  990. unsigned char x;
  991. sleep(1);
  992. x = inb( devc -> base + 3);
  993. if (x == 0xff || x == 0xfe) /* OBP startup acknowledge */
  994. {
  995. //printk(KERN_ERR "Soundscape: Acknowledge = %xn", x);
  996. done = 1;
  997. }
  998. }
  999. timeout_val = 5 * HZ;
  1000. done = 0;
  1001. while (!done && timeout_val-- > 0)
  1002. {
  1003. unsigned char x;
  1004. sleep(1);
  1005. x = inb( devc -> base + 3);
  1006. if (x == 0xfe) /* OBP startup acknowledge */
  1007. {
  1008. //printk(KERN_ERR "Soundscape: Acknowledge = %xn", x);
  1009. done = 1;
  1010. }
  1011. }
  1013. if ( !done ) printk(KERN_ERR "soundscape: OBP Initialization failed.n");
  1015. sscape_write( devc, 2, devc->ic_type == IC_ODIE ? 0x70 : 0x40);
  1016. sscape_write( devc, 3, (devc -> dma << 4) + 0x80);
  1017. return 1;
  1018. }
  1020. static void __init sscape_pnp_init_hw(sscape_info* devc)
  1021. {
  1022. unsigned char midi_irq = 0, sb_irq = 0;
  1023. unsigned i;
  1024. static char code_file_name[23] = "/sndscape/sndscape.cox";
  1026. int sscape_sb_enable = 0;
  1027. int sscape_joystic_enable = 0x7f;
  1028. int sscape_mic_enable = 0;
  1029. int sscape_ext_midi = 0;
  1031. if ( !sscape_pnp_alloc_dma(devc) ) {
  1032. printk(KERN_ERR "sscape: faild to allocate dman");
  1033. return;
  1034. }
  1036. for (i = 0; i < 4; i++) {
  1037. if ( devc -> irq   == valid_interrupts[i] ) 
  1038. midi_irq = i;
  1039. if ( devc -> codec_irq == valid_interrupts[i] ) 
  1040. sb_irq = i;
  1041. }
  1043. sscape_write( devc, 5, 0x50);
  1044. sscape_write( devc, 7, 0x2e);
  1045. sscape_write( devc, 8, 0x00);
  1047. sscape_write( devc, 2, devc->ic_type == IC_ODIE ? 0x70 : 0x40);
  1048. sscape_write( devc, 3, ( devc -> dma << 4) | 0x80);
  1050. if ( sscape_sb_enable )
  1051. sscape_write (devc, 4, 0xF0 | (sb_irq << 2) | midi_irq);
  1052. else
  1053. sscape_write (devc, 4, 0xF0 | (midi_irq<<2) | midi_irq);
  1055. i = 0x10; //sscape_read(devc, 9) & (devc->ic_type == IC_ODIE ? 0xf0 : 0xc0);
  1056. if ( sscape_sb_enable )
  1057. i |= devc->ic_type == IC_ODIE ? 0x05 : 0x07;     
  1058. if (sscape_joystic_enable) i |= 8;
  1060. sscape_write (devc, 9, i);
  1061. sscape_write (devc, 6, 0x80);
  1062. sscape_write (devc, 1, 0x80);
  1064. if (devc -> codec_type == 2) {
  1065. sscape_pnp_write_codec( devc, 0x0C, 0x50);
  1066. sscape_pnp_write_codec( devc, 0x10, sscape_pnp_read_codec( devc, 0x10) & 0x3F);
  1067. sscape_pnp_write_codec( devc, 0x11, sscape_pnp_read_codec( devc, 0x11) | 0xC0);
  1068. sscape_pnp_write_codec( devc, 29, 0x20);
  1069. }
  1071. if (sscape_pnp_upload_file(devc, "/sndscape/scope.cod") == 0 ) {
  1072. printk(KERN_ERR "sscape: faild to upload file /sndscape/scope.codn");
  1073. sscape_pnp_free_dma(devc);
  1074. return;
  1075. }
  1077. i = sscape_read_host_ctrl( devc );
  1079. if ( (i & 0x0F) >  7 ) {
  1080. printk(KERN_ERR "sscape: scope.cod faildn");
  1081. sscape_pnp_free_dma(devc);
  1082. return;
  1083. }
  1084. if ( i & 0x10 ) sscape_write( devc, 7, 0x2F);
  1085. code_file_name[21] = (char) ( i & 0x0F) + 0x30;
  1086. if (sscape_pnp_upload_file( devc, code_file_name) == 0) {
  1087. printk(KERN_ERR "sscape: faild to upload file %sn", code_file_name);
  1088. sscape_pnp_free_dma(devc);
  1089. return;
  1090. }
  1092. if (devc->ic_type != IC_ODIE) {
  1093. sscape_pnp_write_codec( devc, 10, (sscape_pnp_read_codec(devc, 10) & 0x7f) |
  1094.  ( sscape_mic_enable == 0 ? 0x00 : 0x80) );
  1095. }
  1096. sscape_write_host_ctrl2( devc, 0x84, 0x64 );  /* MIDI volume */
  1097. sscape_write_host_ctrl2( devc, 0x86, 0x64 );  /* MIDI volume?? */
  1098. sscape_write_host_ctrl2( devc, 0x8A, sscape_ext_midi);
  1100. sscape_pnp_write_codec ( devc, 6, 0x3f ); //WAV_VOL
  1101. sscape_pnp_write_codec ( devc, 7, 0x3f ); //WAV_VOL
  1102. sscape_pnp_write_codec ( devc, 2, 0x1F ); //WD_CDXVOLL
  1103. sscape_pnp_write_codec ( devc, 3, 0x1F ); //WD_CDXVOLR
  1105. if (devc -> codec_type == 1) {
  1106. sscape_pnp_write_codec ( devc, 4, 0x1F );
  1107. sscape_pnp_write_codec ( devc, 5, 0x1F );
  1108. sscape_write_host_ctrl2( devc, 0x88, sscape_mic_enable);
  1109. } else {
  1110. int t;
  1111. sscape_pnp_write_codec ( devc, 0x10, 0x1F << 1);
  1112. sscape_pnp_write_codec ( devc, 0x11, 0xC0 | (0x1F << 1));
  1114. t = sscape_pnp_read_codec( devc, 0x00) & 0xDF;
  1115. if ( (sscape_mic_enable == 0)) t |= 0;
  1116. else t |= 0x20;
  1117. sscape_pnp_write_codec ( devc, 0x00, t);
  1118. t = sscape_pnp_read_codec( devc, 0x01) & 0xDF;
  1119. if ( (sscape_mic_enable == 0) ) t |= 0;
  1120. else t |= 0x20;
  1121. sscape_pnp_write_codec ( devc, 0x01, t);
  1122. sscape_pnp_write_codec ( devc, 0x40 | 29 , 0x20);
  1123. outb(0, devc -> codec);
  1124. }
  1125. if (devc -> ic_type == IC_OPUS ) {
  1126. int i = sscape_read( devc, 9 );
  1127. sscape_write( devc, 9, i | 3 );
  1128. sscape_write( devc, 3, 0x40);
  1130. if (check_region(0x228, 1)) {
  1131.          outb(0, 0x228);
  1132.     release_region(0x228,1);
  1133. }
  1134. sscape_write( devc, 3, (devc -> dma << 4) | 0x80);
  1135. sscape_write( devc, 9, i );
  1136. }
  1138. host_close ( devc );
  1139. sscape_pnp_free_dma(devc);
  1140. }
  1142. static int __init detect_sscape_pnp(sscape_info* devc)
  1143. {
  1144. long  i, irq_bits = 0xff;
  1145. unsigned int d;
  1147. DDB(printk("Entered detect_sscape_pnp(%x)n", devc->base));
  1149. if (check_region(devc->base, 8)) {
  1150. printk(KERN_ERR "detect_sscape_pnp: port %x is not freen", devc->base);
  1151. return 0;
  1152. }
  1154. if (check_region(devc->codec, 2)) {
  1155. printk(KERN_ERR "detect_sscape_pnp: port %x is not freen", devc->codec);
  1156. return 0;
  1157. }
  1159. if ( (inb( devc -> base + 2) & 0x78) != 0) return 0;
  1161. d = inb ( devc -> base + 4) & 0xF0;
  1162. if (  (d & 0x80) != 0)  return 0;
  1164. if (d == 0) {
  1165. devc->codec_type = 1;
  1166. devc->ic_type = IC_ODIE;
  1167. }
  1168. else if ( (d & 0x60) != 0) {
  1169. devc->codec_type = 2;
  1170. devc->ic_type = IC_OPUS;
  1171. }
  1172. else if ( (d & 0x40) != 0) {
  1173. devc->codec_type = 2;
  1174. devc->ic_type = IC_ODIE;
  1175. } 
  1176. else return 0;
  1178. sscape_is_pnp = 1;
  1180. outb(0xFA, devc -> base+4);
  1181. if  ((inb( devc -> base+4) & 0x9F) != 0x0A)
  1182. return 0;
  1183. outb(0xFE, devc -> base+4);
  1184. if  ( (inb(devc -> base+4) & 0x9F) != 0x0E)
  1185. return 0;
  1186. if  ( (inb(devc -> base+5) & 0x9F) != 0x0E)
  1187. return 0;
  1189. if (devc->codec_type == 2) {
  1190. if (devc -> codec != devc -> base + 8)
  1191. printk("soundscape warning: incorrect codec port specifiedn");
  1192. devc -> codec = devc -> base + 8;
  1193. d = 0x10 | (sscape_read(devc, 9)  & 0xCF);
  1194. sscape_write(devc, 9, d);
  1195. sscape_write(devc, 6, 0x80);
  1196. } else {
  1197. //todo: check codec is not base + 8
  1198. }
  1200. d  = (sscape_read(devc, 9) & 0x3F) | 0xC0;
  1201. sscape_write(devc, 9, d);
  1203. for (i = 0; i < 550000; i++)
  1204. if ( !(inb(devc -> codec) & 0x80) ) break;
  1206. d = inb(devc -> codec);
  1207. if (d & 0x80)
  1208. return 0;
  1209. if ( inb(devc -> codec + 2) == 0xFF)
  1210. return 0;
  1212. sscape_write(devc, 9, sscape_read(devc, 9)  & 0x3F );
  1214. d  = inb(devc -> codec) & 0x80;
  1215. if ( d == 0) {
  1216. printk(KERN_INFO "soundscape: hardware detectedn");
  1217. valid_interrupts = valid_interrupts_new;
  1218. } else {
  1219. printk(KERN_INFO "soundscape: board looks like media fxn");
  1220. valid_interrupts = valid_interrupts_old;
  1221. old_hardware = 1;
  1222. }
  1224. sscape_write( devc, 9, 0xC0 | (sscape_read(devc, 9)  & 0x3F) );
  1226. for (i = 0; i < 550000; i++)
  1227. if ( !(inb(devc -> codec) & 0x80)) 
  1228. break;
  1230. sscape_pnp_init_hw(devc);
  1232. for (i = 0; i < sizeof(valid_interrupts); i++)
  1233. {
  1234. if (devc->codec_irq == valid_interrupts[i]) {
  1235. irq_bits = i;
  1236. break;
  1237. }
  1238. }
  1239. sscape_write(devc, GA_INTENA_REG, 0x00);
  1240. sscape_write(devc, GA_DMACFG_REG, 0x50);
  1241. sscape_write(devc, GA_DMAA_REG, 0x70);
  1242. sscape_write(devc, GA_DMAB_REG, 0x20);
  1243. sscape_write(devc, GA_INTCFG_REG, 0xf0);
  1244. sscape_write(devc, GA_CDCFG_REG, 0x89 | (devc->dma << 4) | (irq_bits << 1));
  1246. sscape_pnp_write_codec( devc, 0, sscape_pnp_read_codec( devc, 0) | 0x20);
  1247. sscape_pnp_write_codec( devc, 0, sscape_pnp_read_codec( devc, 1) | 0x20);
  1249. return 1;
  1250. }
  1252. static int __init probe_sscape(struct address_info *hw_config)
  1253. {
  1255. if (sscape_detected != 0 && sscape_detected != hw_config->io_base)
  1256. return 0;
  1258. devc->base = hw_config->io_base;
  1259. devc->irq = hw_config->irq;
  1260. devc->dma = hw_config->dma;
  1261. devc->osp = hw_config->osp;
  1263. #ifdef SSCAPE_DEBUG1
  1264. /*
  1265.  * Temporary debugging aid. Print contents of the registers before
  1266.  * changing them.
  1267.  */
  1268. {
  1269. int i;
  1271. for (i = 0; i < 13; i++)
  1272. printk("I%d = %02x (old value)n", i, sscape_read(devc, i));
  1273. }
  1274. #endif
  1275. devc->failed = 1;
  1277. if (!detect_ga(devc)) {
  1278. if (detect_sscape_pnp(devc)) {         
  1279. sscape_detected = hw_config->io_base;
  1280. return 1;
  1281. } 
  1282. else return 0;
  1283. }
  1285. if (old_hardware) /* Check that it's really an old Spea/Reveal card. */
  1286. {
  1287. unsigned char   tmp;
  1288. int             cc;
  1290. if (!((tmp = sscape_read(devc, GA_HMCTL_REG)) & 0xc0))
  1291. {
  1292. sscape_write(devc, GA_HMCTL_REG, tmp | 0x80);
  1293. for (cc = 0; cc < 200000; ++cc)
  1294. inb(devc->base + ODIE_ADDR);
  1295. }
  1296. }
  1297. sscape_detected = hw_config->io_base;
  1298. return 1;
  1299. }
  1301. static int __init probe_ss_ms_sound(struct address_info *hw_config)
  1302. {
  1303. int i, irq_bits = 0xff;
  1304. int ad_flags = 0;
  1306. if (devc->failed)
  1307. {
  1308. printk(KERN_ERR "soundscape: Card not detectedn");
  1309. return 0;
  1310. }
  1311. if (devc->ok == 0)
  1312. {
  1313. printk(KERN_ERR "soundscape: Invalid initialization order.n");
  1314. return 0;
  1315. }
  1316. for (i = 0; i < sizeof(valid_interrupts); i++)
  1317. {
  1318. if (hw_config->irq == valid_interrupts[i])
  1319. {
  1320. irq_bits = i;
  1321. break;
  1322. }
  1323. }
  1324. if (hw_config->irq > 15 || irq_bits == 0xff)
  1325. {
  1326. printk(KERN_ERR "soundscape: Invalid MSS IRQ%dn", hw_config->irq);
  1327. return 0;
  1328. }
  1330. if (!sscape_is_pnp) {
  1331. if (old_hardware)
  1332. ad_flags = 0x12345677; /* Tell that we may have a CS4248 chip (Spea-V7 Media FX) */
  1333. return ad1848_detect(hw_config->io_base, &ad_flags, hw_config->osp);
  1334. } 
  1335. else {
  1336. if (old_hardware)
  1337. ad_flags = 0x12345677; /* Tell that we may have a CS4248 chip (Spea-V7 Media FX) */
  1338. else
  1339. ad_flags = 0x87654321;  /* Tell that we have a soundscape pnp with 1845 chip */
  1340. return ad1848_detect(hw_config->io_base, &ad_flags, hw_config->osp);
  1341. }
  1342. }
  1344. static void __init attach_ss_ms_sound(struct address_info *hw_config)
  1345. {
  1346. /*
  1347.  * This routine configures the SoundScape card for use with the
  1348.  * Win Sound System driver. The AD1848 codec interface uses the CD-ROM
  1349.  * config registers of the "ODIE".
  1350.  */
  1352. int i, irq_bits = 0xff;
  1354.  
  1355.   if (!sscape_is_pnp)  /*pnp is already setup*/
  1356.   {
  1357.   /*
  1358.        * Setup the DMA polarity.
  1359.         */
  1360.   sscape_write(devc, GA_DMACFG_REG, 0x50);
  1361.  
  1362.   /*
  1363.    * Take the gate-array off of the DMA channel.
  1364.    */
  1365.   sscape_write(devc, GA_DMAB_REG, 0x20);
  1366.  
  1367.   /*
  1368.    * Init the AD1848 (CD-ROM) config reg.
  1369.    */
  1370.   for (i = 0; i < sizeof(valid_interrupts); i++)
  1371.   {
  1372.   if (hw_config->irq == valid_interrupts[i])
  1373.   {
  1374.   irq_bits = i;
  1375.   break;
  1376.   }
  1377.   }
  1378.   sscape_write(devc, GA_CDCFG_REG, 0x89 | (hw_config->dma << 4) | (irq_bits << 1));
  1379.   }
  1380.  
  1381.   if (hw_config->irq == devc->irq)
  1382.   printk(KERN_WARNING "soundscape: Warning! The WSS mode can't share IRQ with MIDIn");
  1383.  
  1384. hw_config->slots[0] = ad1848_init(
  1385. sscape_is_pnp ? "SoundScape" : "SoundScape PNP",
  1386. hw_config->io_base,
  1387. hw_config->irq,
  1388. hw_config->dma,
  1389. hw_config->dma,
  1390. 0,
  1391. devc->osp,
  1392. THIS_MODULE);
  1394.     
  1395. if (hw_config->slots[0] != -1) /* The AD1848 driver installed itself */
  1396. {
  1397. audio_devs[hw_config->slots[0]]->coproc = &sscape_coproc_operations;
  1398. devc->codec_audiodev = hw_config->slots[0];
  1399. devc->my_audiodev = hw_config->slots[0];
  1401. /* Set proper routings here (what are they) */
  1402. AD1848_REROUTE(SOUND_MIXER_LINE1, SOUND_MIXER_LINE);
  1403. }
  1405. #ifdef SSCAPE_DEBUG5
  1406. /*
  1407.  * Temporary debugging aid. Print contents of the registers
  1408.  * after the AD1848 device has been initialized.
  1409.  */
  1410. {
  1411. int i;
  1413. for (i = 0; i < 13; i++)
  1414. printk("I%d = %02xn", i, sscape_read(devc, i));
  1415. }
  1416. #endif
  1418. }
  1420. static void __exit unload_sscape(struct address_info *hw_config)
  1421. {
  1422. release_region(devc->base + 2, 6);
  1423. unload_mpu401(hw_config);
  1424. }
  1426. static void __exit unload_ss_ms_sound(struct address_info *hw_config)
  1427. {
  1428. ad1848_unload(hw_config->io_base,
  1429.       hw_config->irq,
  1430.       devc->dma,
  1431.       devc->dma,
  1432.       0);
  1433. sound_unload_audiodev(hw_config->slots[0]);
  1434. }
  1436. static struct address_info cfg;
  1437. static struct address_info cfg_mpu;
  1439. static int __initdata spea = -1;
  1440. static int __initdata mss = 0;
  1441. static int __initdata dma = -1;
  1442. static int __initdata irq = -1;
  1443. static int __initdata io = -1;
  1444. static int __initdata mpu_irq = -1;
  1445. static int __initdata mpu_io = -1;
  1447. MODULE_PARM(dma, "i");
  1448. MODULE_PARM(irq, "i");
  1449. MODULE_PARM(io, "i");
  1450. MODULE_PARM(spea, "i"); /* spea=0/1 set the old_hardware */
  1451. MODULE_PARM(mpu_irq, "i");
  1452. MODULE_PARM(mpu_io, "i");
  1453. MODULE_PARM(mss, "i");
  1455. static int __init init_sscape(void)
  1456. {
  1457. printk(KERN_INFO "Soundscape driver Copyright (C) by Hannu Savolainen 1993-1996n");
  1459. cfg.irq = irq;
  1460. cfg.dma = dma;
  1461. cfg.io_base = io;
  1463. cfg_mpu.irq = mpu_irq;
  1464. cfg_mpu.io_base = mpu_io;
  1465. /* WEH - Try to get right dma channel */
  1466.         cfg_mpu.dma = dma;
  1468. devc->codec = cfg.io_base;
  1469. devc->codec_irq = cfg.irq;
  1470. devc->codec_type = 0;
  1471. devc->ic_type = 0;
  1472. devc->raw_buf = NULL;
  1474. if (cfg.dma == -1 || cfg.irq == -1 || cfg.io_base == -1) {
  1475. printk(KERN_ERR "DMA, IRQ, and IO port must be specified.n");
  1476. return -EINVAL;
  1477. }
  1479. if (cfg_mpu.irq == -1 && cfg_mpu.io_base != -1) {
  1480. printk(KERN_ERR "MPU_IRQ must be specified if MPU_IO is set.n");
  1481. return -EINVAL;
  1482. }
  1484. if(spea != -1) {
  1485. old_hardware = spea;
  1486. printk(KERN_INFO "Forcing %s hardware support.n",
  1487. spea?"new":"old");
  1488. }
  1489. if (probe_sscape(&cfg_mpu) == 0)
  1490. return -ENODEV;
  1492. attach_sscape(&cfg_mpu);
  1494. mss = probe_ss_ms_sound(&cfg);
  1496. if (mss)
  1497. attach_ss_ms_sound(&cfg);
  1499. return 0;
  1500. }
  1502. static void __exit cleanup_sscape(void)
  1503. {
  1504. if (mss)
  1505. unload_ss_ms_sound(&cfg);
  1506. unload_sscape(&cfg_mpu);
  1507. }
  1509. module_init(init_sscape);
  1510. module_exit(cleanup_sscape);
  1512. #ifndef MODULE
  1513. static int __init setup_sscape(char *str)
  1514. {
  1515. /* io, irq, dma, mpu_io, mpu_irq */
  1516. int ints[6];
  1518. str = get_options(str, ARRAY_SIZE(ints), ints);
  1520. io = ints[1];
  1521. irq = ints[2];
  1522. dma = ints[3];
  1523. mpu_io = ints[4];
  1524. mpu_irq = ints[5];
  1526. return 1;
  1527. }
  1529. __setup("sscape=", setup_sscape);
  1530. #endif
  1531. MODULE_LICENSE("GPL");