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

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

Linux/Unix编程

开发平台：

Unix_Linux

aedsp16.c：源码内容
  1. /*
  2.    drivers/sound/aedsp16.c
  4.    Audio Excel DSP 16 software configuration routines
  5.    Copyright (C) 1995,1996,1997,1998  Riccardo Facchetti (fizban@tin.it)
  7.    This program is free software; you can redistribute it and/or modify
  8.    it under the terms of the GNU General Public License as published by
  9.    the Free Software Foundation; either version 2 of the License, or
  10.    (at your option) any later version.
  12.    This program is distributed in the hope that it will be useful,
  13.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.    GNU General Public License for more details.
  17.    You should have received a copy of the GNU General Public License
  18.    along with this program; if not, write to the Free Software
  19.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  */
  22. /*
  23.  * Include the main OSS Lite header file. It include all the os, OSS Lite, etc
  24.  * headers needed by this source.
  25.  */
  26. #include <linux/config.h>
  27. #include <linux/delay.h>
  28. #include <linux/module.h>
  29. #include <linux/init.h>
  30. #include "sound_config.h"
  32. /*
  33.  * Sanity checks
  34.  */
  36. #if defined(CONFIG_SOUND_AEDSP16_SBPRO) && defined(CONFIG_SOUND_AEDSP16_MSS)
  37. #error You have to enable only one of the MSS and SBPRO emulations.
  38. #endif
  40. /*
  42.    READ THIS
  44.    This module started to configure the Audio Excel DSP 16 Sound Card.
  45.    Now works with the SC-6000 (old aedsp16) and new SC-6600 based cards.
  47.    NOTE: I have NO idea about Audio Excel DSP 16 III. If someone owns this
  48.    audio card and want to see the kernel support for it, please contact me.
  50.    Audio Excel DSP 16 is an SB pro II, Microsoft Sound System and MPU-401
  51.    compatible card.
  52.    It is software-only configurable (no jumpers to hard-set irq/dma/mpu-irq),
  53.    so before this module, the only way to configure the DSP under linux was
  54.    boot the MS-DOS loading the sound.sys device driver (this driver soft-
  55.    configure the sound board hardware by massaging someone of its registers),
  56.    and then ctrl-alt-del to boot linux with the DSP configured by the DOS
  57.    driver.
  59.    This module works configuring your Audio Excel DSP 16's irq, dma and
  60.    mpu-401-irq. The OSS Lite routines rely on the fact that if the
  61.    hardware is there, they can detect it. The problem with AEDSP16 is
  62.    that no hardware can be found by the probe routines if the sound card
  63.    is not configured properly. Sometimes the kernel probe routines can find
  64.    an SBPRO even when the card is not configured (this is the standard setup
  65.    of the card), but the SBPRO emulation don't work well if the card is not
  66.    properly initialized. For this reason
  68.    aedsp16_init_board()
  70.    routine is called before the OSS Lite probe routines try to detect the
  71.    hardware.
  73.    NOTE (READ THE NOTE TOO, IT CONTAIN USEFUL INFORMATIONS)
  75.    NOTE: Now it works with SC-6000 and SC-6600 based audio cards. The new cards
  76.    have no jumper switch at all. No more WSS or MPU-401 I/O port switches. They
  77.    have to be configured by software.
  79.    NOTE: The driver is merged with the new OSS Lite sound driver. It works
  80.    as a lowlevel driver.
  82.    The Audio Excel DSP 16 Sound Card emulates both SBPRO and MSS;
  83.    the OSS Lite sound driver can be configured for SBPRO and MSS cards
  84.    at the same time, but the aedsp16 can't be two cards!!
  85.    When we configure it, we have to choose the SBPRO or the MSS emulation
  86.    for AEDSP16. We also can install a *REAL* card of the other type (see [1]).
  88.    NOTE: If someone can test the combination AEDSP16+MSS or AEDSP16+SBPRO
  89.    please let me know if it works.
  91.    The MPU-401 support can be compiled in together with one of the other
  92.    two operating modes.
  94.    NOTE: This is something like plug-and-play: we have only to plug
  95.    the AEDSP16 board in the socket, and then configure and compile
  96.    a kernel that uses the AEDSP16 software configuration capability.
  97.    No jumper setting is needed!
  99.    For example, if you want AEDSP16 to be an SBPro, on irq 10, dma 3
  100.    you have just to make config the OSS Lite package, configuring
  101.    the AEDSP16 sound card, then activating the SBPro emulation mode
  102.    and at last configuring IRQ and DMA.
  103.    Compile the kernel and run it.
  105.    NOTE: This means for SC-6000 cards that you can choose irq and dma,
  106.    but not the I/O addresses. To change I/O addresses you have to set
  107.    them with jumpers. For SC-6600 cards you have no jumpers so you have
  108.    to set up your full card configuration in the make config.
  110.    You can change the irq/dma/mirq settings WITHOUT THE NEED to open
  111.    your computer and massage the jumpers (there are no irq/dma/mirq
  112.    jumpers to be configured anyway, only I/O BASE values have to be
  113.    configured with jumpers)
  115.    For some ununderstandable reason, the card default of irq 7, dma 1,
  116.    don't work for me. Seems to be an IRQ or DMA conflict. Under heavy
  117.    HDD work, the kernel start to erupt out a lot of messages like:
  119.    'Sound: DMA timed out - IRQ/DRQ config error?'
  121.    For what I can say, I have NOT any conflict at irq 7 (under linux I'm
  122.    using the lp polling driver), and dma line 1 is unused as stated by
  123.    /proc/dma. I can suppose this is a bug of AEDSP16. I know my hardware so
  124.    I'm pretty sure I have not any conflict, but may be I'm wrong. Who knows!
  125.    Anyway a setting of irq 10, dma 3 works really fine.
  127.    NOTE: if someone can use AEDSP16 with irq 7, dma 1, please let me know
  128.    the emulation mode, all the installed hardware and the hardware
  129.    configuration (irq and dma settings of all the hardware).
  131.    This init module should work with SBPRO+MSS, when one of the two is
  132.    the AEDSP16 emulation and the other the real card. (see [1])
  133.    For example:
  135.    AEDSP16 (0x220) in SBPRO emu (0x220) + real MSS + other
  136.    AEDSP16 (0x220) in MSS emu + real SBPRO (0x240) + other
  138.    MPU401 should work. (see [2])
  140.    [1]
  141.        ---
  142.        Date: Mon, 29 Jul 1997 08:35:40 +0100
  143.        From: Mr S J Greenaway <sjg95@unixfe.rl.ac.uk>
  145.        [...]
  146.        Just to let you know got my Audio Excel (emulating a MSS) working
  147.        with my original SB16, thanks for the driver!
  148.        [...]
  149.        ---
  151.    [2] Not tested by me for lack of hardware.
  153.    TODO, WISHES AND TECH
  155.    - About I/O ports allocation -
  157.    Request the 2x0h region (port base) in any case if we are using this card.
  159.    NOTE: the "aedsp16 (base)" string with which we are requesting the aedsp16
  160.    port base region (see code) does not mean necessarily that we are emulating
  161.    sbpro.  Even if this region is the sbpro I/O ports region, we use this
  162.    region to access the control registers of the card, and if emulating
  163.    sbpro, I/O sbpro registers too. If we are emulating MSS, the sbpro
  164.    registers are not used, in no way, to emulate an sbpro: they are
  165.    used only for configuration purposes.
  167.    Started Fri Mar 17 16:13:18 MET 1995
  169.    v0.1 (ALPHA, was an user-level program called AudioExcelDSP16.c)
  170.    - Initial code.
  171.    v0.2 (ALPHA)
  172.    - Cleanups.
  173.    - Integrated with Linux voxware v 2.90-2 kernel sound driver.
  174.    - SoundBlaster Pro mode configuration.
  175.    - Microsoft Sound System mode configuration.
  176.    - MPU-401 mode configuration.
  177.    v0.3 (ALPHA)
  178.    - Cleanups.
  179.    - Rearranged the code to let aedsp16_init_board be more general.
  180.    - Erased the REALLY_SLOW_IO. We don't need it. Erased the linux/io.h
  181.    inclusion too. We rely on os.h
  182.    - Used the  to get a variable
  183.    len string (we are not sure about the len of Copyright string).
  184.    This works with any SB and compatible.
  185.    - Added the code to request_region at device init (should go in
  186.    the main body of voxware).
  187.    v0.4 (BETA)
  188.    - Better configure.c patch for aedsp16 configuration (better
  189.    logic of inclusion of AEDSP16 support)
  190.    - Modified the conditional compilation to better support more than
  191.    one sound card of the emulated type (read the NOTES above)
  192.    - Moved the sb init routine from the attach to the very first
  193.    probe in sb_card.c
  194.    - Rearrangements and cleanups
  195.    - Wiped out some unnecessary code and variables: this is kernel
  196.    code so it is better save some TEXT and DATA
  197.    - Fixed the request_region code. We must allocate the aedsp16 (sbpro)
  198.    I/O ports in any case because they are used to access the DSP
  199.    configuration registers and we can not allow anyone to get them.
  200.    v0.5
  201.    - cleanups on comments
  202.    - prep for diffs against v3.0-proto-950402
  203.    v0.6
  204.    - removed the request_region()s when compiling the MODULE sound.o
  205.    because we are not allowed (by the actual voxware structure) to
  206.    release_region()
  207.    v0.7 (pre ALPHA, not distributed)
  208.    - started porting this module to kernel 1.3.84. Dummy probe/attach
  209.    routines.
  210.    v0.8 (ALPHA)
  211.    - attached all the init routines.
  212.    v0.9 (BETA)
  213.    - Integrated with linux-pre2.0.7
  214.    - Integrated with configuration scripts.
  215.    - Cleaned up and beautyfied the code.
  216.    v0.9.9 (BETA)
  217.    - Thanks to Piercarlo Grandi: corrected the conditonal compilation code.
  218.      Now only the code configured is compiled in, with some memory saving.
  219.    v0.9.10
  220.    - Integration into the sound/lowlevel/ section of the sound driver.
  221.    - Re-organized the code.
  222.    v0.9.11 (not distributed)
  223.    - Rewritten the init interface-routines to initialize the AEDSP16 in
  224.      one shot.
  225.    - More cosmetics.
  226.    - SC-6600 support.
  227.    - More soft/hard configuration.
  228.    v0.9.12
  229.    - Refined the v0.9.11 code with conditional compilation to distinguish
  230.      between SC-6000 and SC-6600 code.
  231.    v1.0.0
  232.    - Prep for merging with OSS Lite and Linux kernel 2.1.13
  233.    - Corrected a bug in request/check/release region calls (thanks to the
  234.      new kernel exception handling).
  235.    v1.1
  236.    - Revamped for integration with new modularized sound drivers: to enhance
  237.      the flexibility of modular version, I have removed all the conditional
  238.      compilation for SBPRO, MPU and MSS code. Now it is all managed with
  239.      the ae_config structure.
  240.    v1.2
  241.    - Module informations added.
  242.    - Removed aedsp16_delay_10msec(), now using mdelay(10)
  243.    - All data and funcs moved to .*.init section.
  244.    v1.3
  245.    Arnaldo Carvalho de Melo <acme@conectiva.com.br> - 2000/09/27
  246.    - got rid of check_region
  248.    Known Problems:
  249.    - Audio Excel DSP 16 III don't work with this driver.
  251.    Credits:
  252.    Many thanks to Gerald Britton <gbritton@CapAccess.org>. He helped me a
  253.    lot in testing the 0.9.11 and 0.9.12 versions of this driver.
  255.  */
  258. #define VERSION "1.3" /* Version of Audio Excel DSP 16 driver */
  260. #undef AEDSP16_DEBUG  /* Define this to 1 to enable debug code     */
  261. #undef AEDSP16_DEBUG_MORE  /* Define this to 1 to enable more debug     */
  262. #undef AEDSP16_INFO  /* Define this to 1 to enable info code      */
  264. #if defined(AEDSP16_DEBUG)
  265. # define DBG(x)  printk x
  266. # if defined(AEDSP16_DEBUG_MORE)
  267. #  define DBG1(x) printk x
  268. # else
  269. #  define DBG1(x)
  270. # endif
  271. #else
  272. # define DBG(x)
  273. # define DBG1(x)
  274. #endif
  276. /*
  277.  * Misc definitions
  278.  */
  279. #define TRUE 1
  280. #define FALSE 0
  282. /*
  283.  * Region Size for request/check/release region.
  284.  */
  285. #define IOBASE_REGION_SIZE 0x10
  287. /*
  288.  * Hardware related defaults
  289.  */
  290. #define DEF_AEDSP16_IOB 0x220   /* 0x220(default) 0x240                 */
  291. #define DEF_AEDSP16_IRQ 7 /* 5 7(default) 9 10 11                 */
  292. #define DEF_AEDSP16_MRQ 0 /* 5 7 9 10 0(default), 0 means disable */
  293. #define DEF_AEDSP16_DMA 1 /* 0 1(default) 3                       */
  295. /*
  296.  * Commands of AEDSP16's DSP (SBPRO+special).
  297.  * Some of them are COMMAND_xx, in the future they may change.
  298.  */
  299. #define WRITE_MDIRQ_CFG   0x50 /* Set M&I&DRQ mask (the real config)   */
  300. #define COMMAND_52        0x52 /*                                      */
  301. #define READ_HARD_CFG     0x58 /* Read Hardware Config (I/O base etc)  */
  302. #define COMMAND_5C        0x5c /*                                      */
  303. #define COMMAND_60        0x60 /*                                      */
  304. #define COMMAND_66        0x66 /*                                      */
  305. #define COMMAND_6C        0x6c /*                                      */
  306. #define COMMAND_6E        0x6e /*                                      */
  307. #define COMMAND_88        0x88 /*                                      */
  308. #define DSP_INIT_MSS      0x8c /* Enable Microsoft Sound System mode   */
  309. #define COMMAND_C5        0xc5 /*                                      */
  310. #define GET_DSP_VERSION   0xe1 /* Get DSP Version                      */
  311. #define GET_DSP_COPYRIGHT 0xe3 /* Get DSP Copyright                    */
  313. /*
  314.  * Offsets of AEDSP16 DSP I/O ports. The offset is added to base I/O port
  315.  * to have the actual I/O port.
  316.  * Register permissions are:
  317.  * (wo) == Write Only
  318.  * (ro) == Read  Only
  319.  * (w-) == Write
  320.  * (r-) == Read
  321.  */
  322. #define DSP_RESET    0x06 /* offset of DSP RESET             (wo) */
  323. #define DSP_READ     0x0a /* offset of DSP READ              (ro) */
  324. #define DSP_WRITE    0x0c /* offset of DSP WRITE             (w-) */
  325. #define DSP_COMMAND  0x0c /* offset of DSP COMMAND           (w-) */
  326. #define DSP_STATUS   0x0c /* offset of DSP STATUS            (r-) */
  327. #define DSP_DATAVAIL 0x0e /* offset of DSP DATA AVAILABLE    (ro) */
  330. #define RETRY           10 /* Various retry values on I/O opera-   */
  331. #define STATUSRETRY   1000 /* tions. Sometimes we have to          */
  332. #define HARDRETRY   500000 /* wait for previous cmd to complete    */
  334. /*
  335.  * Size of character arrays that store name and version of sound card
  336.  */
  337. #define CARDNAMELEN 15 /* Size of the card's name in chars     */
  338. #define CARDVERLEN  2 /* Size of the card's version in chars  */
  340. #if defined(CONFIG_SC6600)
  341. /*
  342.  * Bitmapped flags of hard configuration
  343.  */
  344. /*
  345.  * Decode macros (xl == low byte, xh = high byte)
  346.  */
  347. #define IOBASE(xl) ((xl & 0x01)?0x240:0x220)
  348. #define JOY(xl)   (xl & 0x02)
  349. #define MPUADDR(xl) ( 
  350. (xl & 0x0C)?0x330:
  351. (xl & 0x08)?0x320:
  352. (xl & 0x04)?0x310:
  353. 0x300)
  354. #define WSSADDR(xl) ((xl & 0x10)?0xE80:0x530)
  355. #define CDROM(xh) (xh & 0x20)
  356. #define CDROMADDR(xh) (((xh & 0x1F) << 4) + 0x200)
  357. /*
  358.  * Encode macros
  359.  */
  360. #define BLDIOBASE(xl, val) {
  361. xl &= ~0x01; 
  362. if (val == 0x240)
  363. xl |= 0x01;
  364. }
  365. #define BLDJOY(xl, val) {
  366. xl &= ~0x02; 
  367. if (val == 1)
  368. xl |= 0x02;
  369. }
  370. #define BLDMPUADDR(xl, val) {
  371. xl &= ~0x0C;
  372. switch (val) {
  373. case 0x330:
  374. xl |= 0x0C;
  375. break;
  376. case 0x320:
  377. xl |= 0x08;
  378. break;
  379. case 0x310:
  380. xl |= 0x04;
  381. break;
  382. case 0x300:
  383. xl |= 0x00;
  384. break;
  385. default:
  386. xl |= 0x00;
  387. break;
  388. }
  389. }
  390. #define BLDWSSADDR(xl, val) {
  391. xl &= ~0x10; 
  392. if (val == 0xE80)
  393. xl |= 0x10;
  394. }
  395. #define BLDCDROM(xh, val) {
  396. xh &= ~0x20; 
  397. if (val == 1)
  398. xh |= 0x20;
  399. }
  400. #define BLDCDROMADDR(xh, val) {
  401. int tmp = val;
  402. tmp -= 0x200;
  403. tmp >>= 4;
  404. tmp &= 0x1F;
  405. xh |= tmp;
  406. xh &= 0x7F;
  407. xh |= 0x40;
  408. }
  409. #endif /* CONFIG_SC6600 */
  411. /*
  412.  * Bit mapped flags for calling aedsp16_init_board(), and saving the current
  413.  * emulation mode.
  414.  */
  415. #define INIT_NONE   (0   )
  416. #define INIT_SBPRO  (1<<0)
  417. #define INIT_MSS    (1<<1)
  418. #define INIT_MPU401 (1<<2)
  420. static int      soft_cfg __initdata = 0; /* bitmapped config */
  421. static int      soft_cfg_mss __initdata = 0; /* bitmapped mss config */
  422. static int      ver[CARDVERLEN] __initdata = {0, 0}; /* DSP Ver:
  423.    hi->ver[0] lo->ver[1] */
  425. #if defined(CONFIG_SC6600)
  426. static int hard_cfg[2]     /* lo<-hard_cfg[0] hi<-hard_cfg[1]      */
  427.                      __initdata = { 0, 0};
  428. #endif /* CONFIG_SC6600 */
  430. #if defined(CONFIG_SC6600)
  431. /* Decoded hard configuration */
  432. struct d_hcfg {
  433. int iobase;
  434. int joystick;
  435. int mpubase;
  436. int wssbase;
  437. int cdrom;
  438. int cdrombase;
  439. };
  441. struct d_hcfg decoded_hcfg __initdata = {0, };
  443. #endif /* CONFIG_SC6600 */
  445. /* orVals contain the values to be or'ed        */
  446. struct orVals {
  447. int val; /* irq|mirq|dma                         */
  448. int or; /* soft_cfg |= TheStruct.or             */
  449. };
  451. /* aedsp16_info contain the audio card configuration                  */
  452. struct aedsp16_info {
  453. int base_io;            /* base I/O address for accessing card  */
  454. int irq;                /* irq value for DSP I/O                */
  455. int mpu_irq;            /* irq for mpu401 interface I/O         */
  456. int dma;                /* dma value for DSP I/O                */
  457. int mss_base;           /* base I/O for Microsoft Sound System  */
  458. int mpu_base;           /* base I/O for MPU-401 emulation       */
  459. int init;               /* Initialization status of the card    */
  460. };
  462. /*
  463.  * Magic values that the DSP will eat when configuring irq/mirq/dma
  464.  */
  465. /* DSP IRQ conversion array             */
  466. static struct orVals orIRQ[] __initdata = {
  467. {0x05, 0x28},
  468. {0x07, 0x08},
  469. {0x09, 0x10},
  470. {0x0a, 0x18},
  471. {0x0b, 0x20},
  472. {0x00, 0x00}
  473. };
  475. /* MPU-401 IRQ conversion array         */
  476. static struct orVals orMIRQ[] __initdata = {
  477. {0x05, 0x04},
  478. {0x07, 0x44},
  479. {0x09, 0x84},
  480. {0x0a, 0xc4},
  481. {0x00, 0x00}
  482. };
  484. /* DMA Channels conversion array        */
  485. static struct orVals orDMA[] __initdata = {
  486. {0x00, 0x01},
  487. {0x01, 0x02},
  488. {0x03, 0x03},
  489. {0x00, 0x00}
  490. };
  492. static struct aedsp16_info ae_config __initdata = {
  493. DEF_AEDSP16_IOB,
  494. DEF_AEDSP16_IRQ,
  495. DEF_AEDSP16_MRQ,
  496. DEF_AEDSP16_DMA,
  497. -1,
  498. -1,
  499. INIT_NONE
  500. };
  502. /*
  503.  * Buffers to store audio card informations
  504.  */
  505. static char     DSPCopyright[CARDNAMELEN + 1] __initdata = {0, };
  506. static char     DSPVersion[CARDVERLEN + 1] __initdata = {0, };
  508. static int __init aedsp16_wait_data(int port)
  509. {
  510. int             loop = STATUSRETRY;
  511. unsigned char   ret = 0;
  513. DBG1(("aedsp16_wait_data (0x%x): ", port));
  515. do {
  516.   ret = inb(port + DSP_DATAVAIL);
  517. /*
  518.  * Wait for data available (bit 7 of ret == 1)
  519.  */
  520.   } while (!(ret & 0x80) && loop--);
  522. if (ret & 0x80) {
  523. DBG1(("success.n"));
  524. return TRUE;
  525. }
  527. DBG1(("failure.n"));
  528. return FALSE;
  529. }
  531. static int __init aedsp16_read(int port)
  532. {
  533. int inbyte;
  535. DBG(("    Read DSP Byte (0x%x): ", port));
  537. if (aedsp16_wait_data(port) == FALSE) {
  538. DBG(("failure.n"));
  539. return -1;
  540. }
  542. inbyte = inb(port + DSP_READ);
  544. DBG(("read [0x%x]/{%c}.n", inbyte, inbyte));
  546. return inbyte;
  547. }
  549. static int __init aedsp16_test_dsp(int port)
  550. {
  551. return ((aedsp16_read(port) == 0xaa) ? TRUE : FALSE);
  552. }
  554. static int __init aedsp16_dsp_reset(int port)
  555. {
  556. /*
  557.  * Reset DSP
  558.  */
  560. DBG(("Reset DSP:n"));
  562. outb(1, (port + DSP_RESET));
  563. udelay(10);
  564. outb(0, (port + DSP_RESET));
  565. udelay(10);
  566. udelay(10);
  567. if (aedsp16_test_dsp(port) == TRUE) {
  568. DBG(("success.n"));
  569. return TRUE;
  570. } else
  571. DBG(("failure.n"));
  572. return FALSE;
  573. }
  575. static int __init aedsp16_write(int port, int cmd)
  576. {
  577. unsigned char   ret;
  578. int             loop = HARDRETRY;
  580. DBG(("    Write DSP Byte (0x%x) [0x%x]: ", port, cmd));
  582. do {
  583. ret = inb(port + DSP_STATUS);
  584. /*
  585.  * DSP ready to receive data if bit 7 of ret == 0
  586.  */
  587. if (!(ret & 0x80)) {
  588. outb(cmd, port + DSP_COMMAND);
  589. DBG(("success.n"));
  590. return 0;
  591. }
  592. } while (loop--);
  594. DBG(("timeout.n"));
  595. printk("[AEDSP16] DSP Command (0x%x) timeout.n", cmd);
  597. return -1;
  598. }
  600. #if defined(CONFIG_SC6600)
  602. #if defined(AEDSP16_INFO) || defined(AEDSP16_DEBUG)
  603. void __init aedsp16_pinfo(void) {
  604. DBG(("n Base address:  %xn", decoded_hcfg.iobase));
  605. DBG((" Joystick    : %s presentn", decoded_hcfg.joystick?"":" not"));
  606. DBG((" WSS addr    :  %xn", decoded_hcfg.wssbase));
  607. DBG((" MPU-401 addr:  %xn", decoded_hcfg.mpubase));
  608. DBG((" CDROM       : %s presentn", (decoded_hcfg.cdrom!=4)?"":" not"));
  609. DBG((" CDROMADDR   :  %xnn", decoded_hcfg.cdrombase));
  610. }
  611. #endif
  613. void __init aedsp16_hard_decode(void) {
  615. DBG((" aedsp16_hard_decode: 0x%x, 0x%xn", hard_cfg[0], hard_cfg[1]));
  617. /*
  618.  * Decode Cfg Bytes.
  619.  */
  620. decoded_hcfg.iobase = IOBASE(hard_cfg[0]);
  621. decoded_hcfg.joystick = JOY(hard_cfg[0]);
  622. decoded_hcfg.wssbase = WSSADDR(hard_cfg[0]);
  623. decoded_hcfg.mpubase = MPUADDR(hard_cfg[0]);
  624. decoded_hcfg.cdrom = CDROM(hard_cfg[1]);
  625. decoded_hcfg.cdrombase = CDROMADDR(hard_cfg[1]);
  627. #if defined(AEDSP16_INFO) || defined(AEDSP16_DEBUG)
  628. printk(" Original sound card configuration:n");
  629. aedsp16_pinfo();
  630. #endif
  632. /*
  633.  * Now set up the real kernel configuration.
  634.  */
  635. decoded_hcfg.iobase = ae_config.base_io;
  636. decoded_hcfg.wssbase = ae_config.mss_base;
  637. decoded_hcfg.mpubase = ae_config.mpu_base;
  639. #if defined(CONFIG_SC6600_JOY)
  640.   decoded_hcfg.joystick = CONFIG_SC6600_JOY; /* Enable */
  641. #endif
  642. #if defined(CONFIG_SC6600_CDROM)
  643. decoded_hcfg.cdrom = CONFIG_SC6600_CDROM; /* 4:N-3:I-2:G-1:P-0:S */
  644. #endif
  645. #if defined(CONFIG_SC6600_CDROMBASE)
  646. decoded_hcfg.cdrombase = CONFIG_SC6600_CDROMBASE; /* 0 Disable */
  647. #endif
  649. #if defined(AEDSP16_DEBUG)
  650. DBG((" New Values:n"));
  651. aedsp16_pinfo();
  652. #endif
  654. DBG(("success.n"));
  655. }
  657. void __init aedsp16_hard_encode(void) {
  659. DBG((" aedsp16_hard_encode: 0x%x, 0x%xn", hard_cfg[0], hard_cfg[1]));
  661. hard_cfg[0] = 0;
  662. hard_cfg[1] = 0;
  664. hard_cfg[0] |= 0x20;
  666. BLDIOBASE (hard_cfg[0], decoded_hcfg.iobase);
  667. BLDWSSADDR(hard_cfg[0], decoded_hcfg.wssbase);
  668. BLDMPUADDR(hard_cfg[0], decoded_hcfg.mpubase);
  669. BLDJOY(hard_cfg[0], decoded_hcfg.joystick);
  670. BLDCDROM(hard_cfg[1], decoded_hcfg.cdrom);
  671. BLDCDROMADDR(hard_cfg[1], decoded_hcfg.cdrombase);
  673. #if defined(AEDSP16_DEBUG)
  674. aedsp16_pinfo();
  675. #endif
  677. DBG((" aedsp16_hard_encode: 0x%x, 0x%xn", hard_cfg[0], hard_cfg[1]));
  678. DBG(("success.n"));
  680. }
  682. static int __init aedsp16_hard_write(int port) {
  684. DBG(("aedsp16_hard_write:n"));
  686. if (aedsp16_write(port, COMMAND_6C)) {
  687. printk("[AEDSP16] CMD 0x%x: failed!n", COMMAND_6C);
  688. DBG(("failure.n"));
  689. return FALSE;
  690. }
  691. if (aedsp16_write(port, COMMAND_5C)) {
  692. printk("[AEDSP16] CMD 0x%x: failed!n", COMMAND_5C);
  693. DBG(("failure.n"));
  694. return FALSE;
  695. }
  696. if (aedsp16_write(port, hard_cfg[0])) {
  697. printk("[AEDSP16] DATA 0x%x: failed!n", hard_cfg[0]);
  698. DBG(("failure.n"));
  699. return FALSE;
  700. }
  701. if (aedsp16_write(port, hard_cfg[1])) {
  702. printk("[AEDSP16] DATA 0x%x: failed!n", hard_cfg[1]);
  703. DBG(("failure.n"));
  704. return FALSE;
  705. }
  706. if (aedsp16_write(port, COMMAND_C5)) {
  707. printk("[AEDSP16] CMD 0x%x: failed!n", COMMAND_C5);
  708. DBG(("failure.n"));
  709. return FALSE;
  710. }
  712. DBG(("success.n"));
  714. return TRUE;
  715. }
  717. static int __init aedsp16_hard_read(int port) {
  719. DBG(("aedsp16_hard_read:n"));
  721. if (aedsp16_write(port, READ_HARD_CFG)) {
  722. printk("[AEDSP16] CMD 0x%x: failed!n", READ_HARD_CFG);
  723. DBG(("failure.n"));
  724. return FALSE;
  725. }
  727. if ((hard_cfg[0] = aedsp16_read(port)) == -1) {
  728. printk("[AEDSP16] aedsp16_read after CMD 0x%x: failedn",
  729. READ_HARD_CFG);
  730. DBG(("failure.n"));
  731. return FALSE;
  732. }
  733. if ((hard_cfg[1] = aedsp16_read(port)) == -1) {
  734. printk("[AEDSP16] aedsp16_read after CMD 0x%x: failedn",
  735. READ_HARD_CFG);
  736. DBG(("failure.n"));
  737. return FALSE;
  738. }
  739. if (aedsp16_read(port) == -1) {
  740. printk("[AEDSP16] aedsp16_read after CMD 0x%x: failedn",
  741. READ_HARD_CFG);
  742. DBG(("failure.n"));
  743. return FALSE;
  744. }
  746. DBG(("success.n"));
  748. return TRUE;
  749. }
  751. static int __init aedsp16_ext_cfg_write(int port) {
  753. int extcfg, val;
  755. if (aedsp16_write(port, COMMAND_66)) {
  756. printk("[AEDSP16] CMD 0x%x: failed!n", COMMAND_66);
  757. return FALSE;
  758. }
  760. extcfg = 7;
  761. if (decoded_hcfg.cdrom != 2)
  762. extcfg = 0x0F;
  763. if ((decoded_hcfg.cdrom == 4) ||
  764.     (decoded_hcfg.cdrom == 3))
  765. extcfg &= ~2;
  766. if (decoded_hcfg.cdrombase == 0)
  767. extcfg &= ~2;
  768. if (decoded_hcfg.mpubase == 0)
  769. extcfg &= ~1;
  771. if (aedsp16_write(port, extcfg)) {
  772. printk("[AEDSP16] Write extcfg: failed!n");
  773. return FALSE;
  774. }
  775. if (aedsp16_write(port, 0)) {
  776. printk("[AEDSP16] Write extcfg: failed!n");
  777. return FALSE;
  778. }
  779. if (decoded_hcfg.cdrom == 3) {
  780. if (aedsp16_write(port, COMMAND_52)) {
  781. printk("[AEDSP16] CMD 0x%x: failed!n", COMMAND_52);
  782. return FALSE;
  783. }
  784. if ((val = aedsp16_read(port)) == -1) {
  785. printk("[AEDSP16] aedsp16_read after CMD 0x%x: failedn"
  786. , COMMAND_52);
  787. return FALSE;
  788. }
  789. val &= 0x7F;
  790. if (aedsp16_write(port, COMMAND_60)) {
  791. printk("[AEDSP16] CMD 0x%x: failed!n", COMMAND_60);
  792. return FALSE;
  793. }
  794. if (aedsp16_write(port, val)) {
  795. printk("[AEDSP16] Write val: failed!n");
  796. return FALSE;
  797. }
  798. }
  800. return TRUE;
  801. }
  803. #endif /* CONFIG_SC6600 */
  805. static int __init aedsp16_cfg_write(int port) {
  806. if (aedsp16_write(port, WRITE_MDIRQ_CFG)) {
  807. printk("[AEDSP16] CMD 0x%x: failed!n", WRITE_MDIRQ_CFG);
  808. return FALSE;
  809. }
  810. if (aedsp16_write(port, soft_cfg)) {
  811. printk("[AEDSP16] Initialization of (M)IRQ and DMA: failed!n");
  812. return FALSE;
  813. }
  814. return TRUE;
  815. }
  817. static int __init aedsp16_init_mss(int port)
  818. {
  819. DBG(("aedsp16_init_mss:n"));
  821. mdelay(10);
  823. if (aedsp16_write(port, DSP_INIT_MSS)) {
  824. printk("[AEDSP16] aedsp16_init_mss [0x%x]: failed!n",
  825. DSP_INIT_MSS);
  826. DBG(("failure.n"));
  827. return FALSE;
  828. }
  830. mdelay(10);
  832. if (aedsp16_cfg_write(port) == FALSE)
  833. return FALSE;
  835. outb(soft_cfg_mss, ae_config.mss_base);
  837. DBG(("success.n"));
  839. return TRUE;
  840. }
  842. static int __init aedsp16_setup_board(int port) {
  843. int loop = RETRY;
  845. #if defined(CONFIG_SC6600)
  846. int val = 0;
  848. if (aedsp16_hard_read(port) == FALSE) {
  849. printk("[AEDSP16] aedsp16_hard_read: failed!n");
  850. return FALSE;
  851. }
  853. if (aedsp16_write(port, COMMAND_52)) {
  854. printk("[AEDSP16] CMD 0x%x: failed!n", COMMAND_52);
  855. return FALSE;
  856. }
  858. if ((val = aedsp16_read(port)) == -1) {
  859. printk("[AEDSP16] aedsp16_read after CMD 0x%x: failedn",
  860. COMMAND_52);
  861. return FALSE;
  862. }
  863. #endif
  865. do {
  866. if (aedsp16_write(port, COMMAND_88)) {
  867. printk("[AEDSP16] CMD 0x%x: failed!n", COMMAND_88);
  868. return FALSE;
  869. }
  870. mdelay(10);
  871. } while ((aedsp16_wait_data(port) == FALSE) && loop--);
  873. if (aedsp16_read(port) == -1) {
  874. printk("[AEDSP16] aedsp16_read after CMD 0x%x: failedn",
  875. COMMAND_88);
  876. return FALSE;
  877. }
  879. #if !defined(CONFIG_SC6600)
  880. if (aedsp16_write(port, COMMAND_5C)) {
  881. printk("[AEDSP16] CMD 0x%x: failed!n", COMMAND_5C);
  882. return FALSE;
  883. }
  884. #endif
  886. if (aedsp16_cfg_write(port) == FALSE)
  887. return FALSE;
  889. #if defined(CONFIG_SC6600)
  890. if (aedsp16_write(port, COMMAND_60)) {
  891. printk("[AEDSP16] CMD 0x%x: failed!n", COMMAND_60);
  892. return FALSE;
  893. }
  894. if (aedsp16_write(port, val)) {
  895. printk("[AEDSP16] DATA 0x%x: failed!n", val);
  896. return FALSE;
  897. }
  898. if (aedsp16_write(port, COMMAND_6E)) {
  899. printk("[AEDSP16] CMD 0x%x: failed!n", COMMAND_6E);
  900. return FALSE;
  901. }
  902. if (aedsp16_write(port, ver[0])) {
  903. printk("[AEDSP16] DATA 0x%x: failed!n", ver[0]);
  904. return FALSE;
  905. }
  906. if (aedsp16_write(port, ver[1])) {
  907. printk("[AEDSP16] DATA 0x%x: failed!n", ver[1]);
  908. return FALSE;
  909. }
  911. if (aedsp16_hard_write(port) == FALSE) {
  912. printk("[AEDSP16] aedsp16_hard_write: failed!n");
  913. return FALSE;
  914. }
  916. if (aedsp16_write(port, COMMAND_5C)) {
  917. printk("[AEDSP16] CMD 0x%x: failed!n", COMMAND_5C);
  918. return FALSE;
  919. }
  921. #if defined(THIS_IS_A_THING_I_HAVE_NOT_TESTED_YET)
  922. if (aedsp16_cfg_write(port) == FALSE)
  923. return FALSE;
  924. #endif
  926. #endif
  928. return TRUE;
  929. }
  931. static int __init aedsp16_stdcfg(int port) {
  932. if (aedsp16_write(port, WRITE_MDIRQ_CFG)) {
  933. printk("[AEDSP16] CMD 0x%x: failed!n", WRITE_MDIRQ_CFG);
  934. return FALSE;
  935. }
  936. /*
  937.  * 0x0A == (IRQ 7, DMA 1, MIRQ 0)
  938.  */
  939. if (aedsp16_write(port, 0x0A)) {
  940. printk("[AEDSP16] aedsp16_stdcfg: failed!n");
  941. return FALSE;
  942. }
  943. return TRUE;
  944. }
  946. static int __init aedsp16_dsp_version(int port)
  947. {
  948. int             len = 0;
  949. int             ret;
  951. DBG(("Get DSP Version:n"));
  953. if (aedsp16_write(ae_config.base_io, GET_DSP_VERSION)) {
  954. printk("[AEDSP16] CMD 0x%x: failed!n", GET_DSP_VERSION);
  955. DBG(("failed.n"));
  956. return FALSE;
  957. }
  959. do {
  960. if ((ret = aedsp16_read(port)) == -1) {
  961. DBG(("failed.n"));
  962. return FALSE;
  963. }
  964. /*
  965.  * We already know how many int are stored (2), so we know when the
  966.  * string is finished.
  967.  */
  968. ver[len++] = ret;
  969.   } while (len < CARDVERLEN);
  970. sprintf(DSPVersion, "%d.%d", ver[0], ver[1]);
  972. DBG(("success.n"));
  974. return TRUE;
  975. }
  977. static int __init aedsp16_dsp_copyright(int port)
  978. {
  979. int             len = 0;
  980. int             ret;
  982. DBG(("Get DSP Copyright:n"));
  984. if (aedsp16_write(ae_config.base_io, GET_DSP_COPYRIGHT)) {
  985. printk("[AEDSP16] CMD 0x%x: failed!n", GET_DSP_COPYRIGHT);
  986. DBG(("failed.n"));
  987. return FALSE;
  988. }
  990. do {
  991. if ((ret = aedsp16_read(port)) == -1) {
  992. /*
  993.  * If no more data available, return to the caller, no error if len>0.
  994.  * We have no other way to know when the string is finished.
  995.  */
  996. if (len)
  997. break;
  998. else {
  999. DBG(("failed.n"));
  1000. return FALSE;
  1001. }
  1002. }
  1004. DSPCopyright[len++] = ret;
  1006.   } while (len < CARDNAMELEN);
  1008. DBG(("success.n"));
  1010. return TRUE;
  1011. }
  1013. static void __init aedsp16_init_tables(void)
  1014. {
  1015. int i = 0;
  1017. memset(DSPCopyright, 0, CARDNAMELEN + 1);
  1018. memset(DSPVersion, 0, CARDVERLEN + 1);
  1020. for (i = 0; orIRQ[i].or; i++)
  1021. if (orIRQ[i].val == ae_config.irq) {
  1022. soft_cfg |= orIRQ[i].or;
  1023. soft_cfg_mss |= orIRQ[i].or;
  1024. }
  1026. for (i = 0; orMIRQ[i].or; i++)
  1027. if (orMIRQ[i].or == ae_config.mpu_irq)
  1028. soft_cfg |= orMIRQ[i].or;
  1030. for (i = 0; orDMA[i].or; i++)
  1031. if (orDMA[i].val == ae_config.dma) {
  1032. soft_cfg |= orDMA[i].or;
  1033. soft_cfg_mss |= orDMA[i].or;
  1034. }
  1035. }
  1037. static int __init aedsp16_init_board(void)
  1038. {
  1039. aedsp16_init_tables();
  1041. if (aedsp16_dsp_reset(ae_config.base_io) == FALSE) {
  1042. printk("[AEDSP16] aedsp16_dsp_reset: failed!n");
  1043. return FALSE;
  1044. }
  1045. if (aedsp16_dsp_copyright(ae_config.base_io) == FALSE) {
  1046. printk("[AEDSP16] aedsp16_dsp_copyright: failed!n");
  1047. return FALSE;
  1048. }
  1050. /*
  1051.  * My AEDSP16 card return SC-6000 in DSPCopyright, so
  1052.  * if we have something different, we have to be warned.
  1053.  */
  1054. if (strcmp("SC-6000", DSPCopyright))
  1055. printk("[AEDSP16] Warning: non SC-6000 audio card!n");
  1057. if (aedsp16_dsp_version(ae_config.base_io) == FALSE) {
  1058. printk("[AEDSP16] aedsp16_dsp_version: failed!n");
  1059. return FALSE;
  1060. }
  1062. if (aedsp16_stdcfg(ae_config.base_io) == FALSE) {
  1063. printk("[AEDSP16] aedsp16_stdcfg: failed!n");
  1064. return FALSE;
  1065. }
  1067. #if defined(CONFIG_SC6600)
  1068. if (aedsp16_hard_read(ae_config.base_io) == FALSE) {
  1069. printk("[AEDSP16] aedsp16_hard_read: failed!n");
  1070. return FALSE;
  1071. }
  1073. aedsp16_hard_decode();
  1075. aedsp16_hard_encode();
  1077. if (aedsp16_hard_write(ae_config.base_io) == FALSE) {
  1078. printk("[AEDSP16] aedsp16_hard_write: failed!n");
  1079. return FALSE;
  1080. }
  1082. if (aedsp16_ext_cfg_write(ae_config.base_io) == FALSE) {
  1083. printk("[AEDSP16] aedsp16_ext_cfg_write: failed!n");
  1084. return FALSE;
  1085. }
  1086. #endif /* CONFIG_SC6600 */
  1088. if (aedsp16_setup_board(ae_config.base_io) == FALSE) {
  1089. printk("[AEDSP16] aedsp16_setup_board: failed!n");
  1090. return FALSE;
  1091. }
  1093. if (ae_config.mss_base != -1) {
  1094. if (ae_config.init & INIT_MSS) {
  1095. if (aedsp16_init_mss(ae_config.base_io) == FALSE) {
  1096. printk("[AEDSP16] Can not initialize"
  1097.        "Microsoft Sound System mode.n");
  1098. return FALSE;
  1099. }
  1100. }
  1101. }
  1103. #if !defined(MODULE) || defined(AEDSP16_INFO) || defined(AEDSP16_DEBUG)
  1105. printk("Audio Excel DSP 16 init v%s (%s %s) [",
  1106. VERSION, DSPCopyright,
  1107. DSPVersion);
  1109. if (ae_config.mpu_base != -1) {
  1110. if (ae_config.init & INIT_MPU401) {
  1111. printk("MPU401");
  1112. if ((ae_config.init & INIT_MSS) ||
  1113.     (ae_config.init & INIT_SBPRO))
  1114. printk(" ");
  1115. }
  1116. }
  1118. if (ae_config.mss_base == -1) {
  1119. if (ae_config.init & INIT_SBPRO) {
  1120. printk("SBPro");
  1121. if (ae_config.init & INIT_MSS)
  1122. printk(" ");
  1123. }
  1124. }
  1126. if (ae_config.mss_base != -1)
  1127. if (ae_config.init & INIT_MSS)
  1128. printk("MSS");
  1130. printk("]n");
  1131. #endif /* MODULE || AEDSP16_INFO || AEDSP16_DEBUG */
  1133. mdelay(10);
  1135. return TRUE;
  1136. }
  1138. static int __init init_aedsp16_sb(void)
  1139. {
  1140. DBG(("init_aedsp16_sb: "));
  1142. /*
  1143.  * If the card is already init'ed MSS, we can not init it to SBPRO too
  1144.  * because the board can not emulate simultaneously MSS and SBPRO.
  1145.  */
  1146. if (ae_config.init & INIT_MSS)
  1147. return FALSE;
  1148. if (ae_config.init & INIT_SBPRO)
  1149. return FALSE;
  1151. ae_config.init |= INIT_SBPRO;
  1153. DBG(("done.n"));
  1155. return TRUE;
  1156. }
  1158. static void __init uninit_aedsp16_sb(void)
  1159. {
  1160. DBG(("uninit_aedsp16_sb: "));
  1162. ae_config.init &= ~INIT_SBPRO;
  1164. DBG(("done.n"));
  1165. }
  1167. static int __init init_aedsp16_mss(void)
  1168. {
  1169. DBG(("init_aedsp16_mss: "));
  1171. /*
  1172.  * If the card is already init'ed SBPRO, we can not init it to MSS too
  1173.  * because the board can not emulate simultaneously MSS and SBPRO.
  1174.  */
  1175. if (ae_config.init & INIT_SBPRO)
  1176. return FALSE;
  1177. if (ae_config.init & INIT_MSS)
  1178. return FALSE;
  1179. /*
  1180.  * We must allocate the CONFIG_AEDSP16_BASE region too because these are the 
  1181.  * I/O ports to access card's control registers.
  1182.  */
  1183. if (!(ae_config.init & INIT_MPU401)) {
  1184. if (!request_region(ae_config.base_io, IOBASE_REGION_SIZE,
  1185. "aedsp16 (base)")) {
  1186. printk(
  1187. "AEDSP16 BASE I/O port region is already in use.n");
  1188. return FALSE;
  1189. }
  1190. }
  1192. ae_config.init |= INIT_MSS;
  1194. DBG(("done.n"));
  1196. return TRUE;
  1197. }
  1199. static void __init uninit_aedsp16_mss(void)
  1200. {
  1201. DBG(("uninit_aedsp16_mss: "));
  1203. if ((!(ae_config.init & INIT_MPU401)) &&
  1204.    (ae_config.init & INIT_MSS)) {
  1205. release_region(ae_config.base_io, IOBASE_REGION_SIZE);
  1206. DBG(("AEDSP16 base region released.n"));
  1207. }
  1209. ae_config.init &= ~INIT_MSS;
  1210. DBG(("done.n"));
  1211. }
  1213. static int __init init_aedsp16_mpu(void)
  1214. {
  1215. DBG(("init_aedsp16_mpu: "));
  1217. if (ae_config.init & INIT_MPU401)
  1218. return FALSE;
  1220. /*
  1221.  * We must request the CONFIG_AEDSP16_BASE region too because these are the I/O 
  1222.  * ports to access card's control registers.
  1223.  */
  1224. if (!(ae_config.init & (INIT_MSS | INIT_SBPRO))) {
  1225. if (!request_region(ae_config.base_io, IOBASE_REGION_SIZE,
  1226. "aedsp16 (base)")) {
  1227. printk(
  1228. "AEDSP16 BASE I/O port region is already in use.n");
  1229. return FALSE;
  1230. }
  1231. }
  1233. ae_config.init |= INIT_MPU401;
  1235. DBG(("done.n"));
  1237. return TRUE;
  1238. }
  1240. static void __init uninit_aedsp16_mpu(void)
  1241. {
  1242. DBG(("uninit_aedsp16_mpu: "));
  1244. if ((!(ae_config.init & (INIT_MSS | INIT_SBPRO))) &&
  1245.    (ae_config.init & INIT_MPU401)) {
  1246. release_region(ae_config.base_io, IOBASE_REGION_SIZE);
  1247. DBG(("AEDSP16 base region released.n"));
  1248. }
  1250. ae_config.init &= ~INIT_MPU401;
  1252. DBG(("done.n"));
  1253. }
  1255. int __init init_aedsp16(void)
  1256. {
  1257. int initialized = FALSE;
  1259. DBG(("Initializing BASE[0x%x] IRQ[%d] DMA[%d] MIRQ[%d]n",
  1260.      ae_config.base_io,ae_config.irq,ae_config.dma,ae_config.mpu_irq));
  1262. if (ae_config.mss_base == -1) {
  1263. if (init_aedsp16_sb() == FALSE) {
  1264. uninit_aedsp16_sb();
  1265. } else {
  1266. initialized = TRUE;
  1267. }
  1268. }
  1270. if (ae_config.mpu_base != -1) {
  1271. if (init_aedsp16_mpu() == FALSE) {
  1272. uninit_aedsp16_mpu();
  1273. } else {
  1274. initialized = TRUE;
  1275. }
  1276. }
  1278. /*
  1279.  * In the sequence of init routines, the MSS init MUST be the last!
  1280.  * This because of the special register programming the MSS mode needs.
  1281.  * A board reset would disable the MSS mode restoring the default SBPRO
  1282.  * mode.
  1283.  */
  1284. if (ae_config.mss_base != -1) {
  1285. if (init_aedsp16_mss() == FALSE) {
  1286. uninit_aedsp16_mss();
  1287. } else {
  1288. initialized = TRUE;
  1289. }
  1290. }
  1292. if (initialized)
  1293. initialized = aedsp16_init_board();
  1294. return initialized;
  1295. }
  1297. void __init uninit_aedsp16(void)
  1298. {
  1299. if (ae_config.mss_base != -1)
  1300. uninit_aedsp16_mss();
  1301. else
  1302. uninit_aedsp16_sb();
  1303. if (ae_config.mpu_base != -1)
  1304. uninit_aedsp16_mpu();
  1305. }
  1307. static int __initdata io = -1;
  1308. static int __initdata irq = -1;
  1309. static int __initdata dma = -1;
  1310. static int __initdata mpu_irq = -1;
  1311. static int __initdata mss_base = -1;
  1312. static int __initdata mpu_base = -1;
  1314. MODULE_PARM(io, "i");
  1315. MODULE_PARM_DESC(io, "I/O base address (0x220 0x240)");
  1316. MODULE_PARM(irq, "i");
  1317. MODULE_PARM_DESC(irq, "IRQ line (5 7 9 10 11)");
  1318. MODULE_PARM(dma, "i");
  1319. MODULE_PARM_DESC(dma, "dma line (0 1 3)");
  1320. MODULE_PARM(mpu_irq, "i");
  1321. MODULE_PARM_DESC(mpu_irq, "MPU-401 IRQ line (5 7 9 10 0)");
  1322. MODULE_PARM(mss_base, "i");
  1323. MODULE_PARM_DESC(mss_base, "MSS emulation I/O base address (0x530 0xE80)");
  1324. MODULE_PARM(mpu_base, "i");
  1325. MODULE_PARM_DESC(mpu_base,"MPU-401 I/O base address (0x300 0x310 0x320 0x330)");
  1326. MODULE_AUTHOR("Riccardo Facchetti <fizban@tin.it>");
  1327. MODULE_DESCRIPTION("Audio Excel DSP 16 Driver Version " VERSION);
  1328. MODULE_LICENSE("GPL");
  1330. static int __init do_init_aedsp16(void) {
  1331. printk("Audio Excel DSP 16 init driver Copyright (C) Riccardo Facchetti 1995-98n");
  1332. if (io == -1 || dma == -1 || irq == -1) {
  1333. printk(KERN_INFO "aedsp16: I/O, IRQ and DMA are mandatoryn");
  1334. return -EINVAL;
  1335. }
  1337. ae_config.base_io = io;
  1338. ae_config.irq = irq;
  1339. ae_config.dma = dma;
  1341. ae_config.mss_base = mss_base;
  1342. ae_config.mpu_base = mpu_base;
  1343. ae_config.mpu_irq = mpu_irq;
  1345. if (init_aedsp16() == FALSE) {
  1346. printk(KERN_ERR "aedsp16: initialization failedn");
  1347. /*
  1348.  * XXX
  1349.  * What error should we return here ?
  1350.  */
  1351. return -EINVAL;
  1352. }
  1353. return 0;
  1354. }
  1356. static void __exit cleanup_aedsp16(void) {
  1357. uninit_aedsp16();
  1358. }
  1360. module_init(do_init_aedsp16);
  1361. module_exit(cleanup_aedsp16);
  1363. #ifndef MODULE
  1364. static int __init setup_aedsp16(char *str)
  1365. {
  1366. /* io, irq, dma, mss_io, mpu_io, mpu_irq */
  1367. int ints[7];
  1369. str = get_options(str, ARRAY_SIZE(ints), ints);
  1371. io  = ints[1];
  1372. irq  = ints[2];
  1373. dma  = ints[3];
  1374. mss_base = ints[4];
  1375. mpu_base = ints[5];
  1376. mpu_irq  = ints[6];
  1377. return 1;
  1378. }
  1380. __setup("aedsp16=", setup_aedsp16);
  1381. #endif