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

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

Linux/Unix编程

开发平台：

Unix_Linux

main.c：源码内容
  1.  /*
  2.  **********************************************************************
  3.  *     main.c - Creative EMU10K1 audio driver
  4.  *     Copyright 1999, 2000 Creative Labs, Inc.
  5.  *
  6.  **********************************************************************
  7.  *
  8.  *     Date                 Author          Summary of changes
  9.  *     ----                 ------          ------------------
  10.  *     October 20, 1999     Bertrand Lee    base code release
  11.  *     November 2, 1999     Alan Cox        cleaned up stuff
  12.  *
  13.  **********************************************************************
  14.  *
  15.  *     This program is free software; you can redistribute it and/or
  16.  *     modify it under the terms of the GNU General Public License as
  17.  *     published by the Free Software Foundation; either version 2 of
  18.  *     the License, or (at your option) any later version.
  19.  *
  20.  *     This program is distributed in the hope that it will be useful,
  21.  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
  22.  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23.  *     GNU General Public License for more details.
  24.  *
  25.  *     You should have received a copy of the GNU General Public
  26.  *     License along with this program; if not, write to the Free
  27.  *     Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
  28.  *     USA.
  29.  *
  30.  **********************************************************************
  31.  *
  32.  *      Supported devices:
  33.  *      /dev/dsp:        Standard /dev/dsp device, OSS-compatible
  34.  *      /dev/dsp1:       Routes to rear speakers only  
  35.  *      /dev/mixer:      Standard /dev/mixer device, OSS-compatible
  36.  *      /dev/midi:       Raw MIDI UART device, mostly OSS-compatible
  37.  * /dev/sequencer:  Sequencer Interface (requires sound.o)
  38.  *
  39.  *      Revision history:
  40.  *      0.1 beta Initial release
  41.  *      0.2 Lowered initial mixer vol. Improved on stuttering wave playback. Added MIDI UART support.
  42.  *      0.3 Fixed mixer routing bug, added APS, joystick support.
  43.  *      0.4 Added rear-channel, SPDIF support.
  44.  * 0.5 Source cleanup, SMP fixes, multiopen support, 64 bit arch fixes,
  45.  *     moved bh's to tasklets, moved to the new PCI driver initialization style.
  46.  * 0.6 Make use of pci_alloc_consistent, improve compatibility layer for 2.2 kernels,
  47.  *     code reorganization and cleanup.
  48.  * 0.7 Support for the Emu-APS. Bug fixes for voice cache setup, mmaped sound + poll().
  49.  *          Support for setting external TRAM size.
  50.  *      0.8 Make use of the kernel ac97 interface. Support for a dsp patch manager.
  51.  *      0.9 Re-enables rear speakers volume controls
  52.  *     0.10 Initializes rear speaker volume.
  53.  *     Dynamic patch storage allocation.
  54.  *     New private ioctls to change control gpr values.
  55.  *     Enable volume control interrupts.
  56.  *     By default enable dsp routes to digital out. 
  57.  *     0.11 Fixed fx / 4 problem.
  58.  *     0.12 Implemented mmaped for recording.
  59.  *     Fixed bug: not unreserving mmaped buffer pages.
  60.  *     IRQ handler cleanup.
  61.  *     0.13 Fixed problem with dsp1
  62.  *          Simplified dsp patch writing (inside the driver)
  63.  *     Fixed several bugs found by the Stanford tools
  64.  *     0.14 New control gpr to oss mixer mapping feature (Chris Purnell)
  65.  *          Added AC3 Passthrough Support (Juha Yrjola)
  66.  *          Added Support for 5.1 cards (digital out and the third analog out)
  67.  *     0.15 Added Sequencer Support (Daniel Mack)
  68.  *          Support for multichannel pcm playback (Eduard Hasenleithner)
  69.  *     0.16 Mixer improvements, added old treble/bass support (Daniel Bertrand)
  70.  *          Small code format cleanup.
  71.  *          Deadlock bug fix for emu10k1_volxxx_irqhandler().
  72.  *     0.17 Fix for mixer SOUND_MIXER_INFO ioctl.
  73.  *     Fix for HIGHMEM machines (emu10k1 can only do 31 bit bus master) 
  74.  *     midi poll initial implementation.
  75.  *     Small mixer fixes/cleanups.
  76.  *     Improved support for 5.1 cards.
  77.  *     0.18 Fix for possible leak in pci_alloc_consistent()
  78.  *          Cleaned up poll() functions (audio and midi). Don't start input.
  79.  *     Restrict DMA pages used to 512Mib range.
  80.  *     New AC97_BOOST mixer ioctl.
  81.  *     0.19 Real fix for kernel with highmem support (cast dma_handle to u32).
  82.  *     Fix recording buffering parameters calculation.
  83.  *     Use unsigned long for variables in bit ops.
  84.  *     0.20 Fixed recording startup
  85.  *     Fixed timer rate setting (it's a 16-bit register)
  86.  *********************************************************************/
  88. /* These are only included once per module */
  89. #include <linux/version.h>
  90. #include <linux/module.h>
  91. #include <linux/slab.h>
  92. #include <linux/init.h>
  93. #include <linux/delay.h>
  94. #include <linux/proc_fs.h>
  96. #include "hwaccess.h"
  97. #include "8010.h"
  98. #include "efxmgr.h"
  99. #include "cardwo.h"
  100. #include "cardwi.h"
  101. #include "cardmo.h"
  102. #include "cardmi.h"
  103. #include "recmgr.h"
  104. #include "ecard.h"
  107. #ifdef EMU10K1_SEQUENCER
  108. #define MIDI_SYNTH_NAME "EMU10K1 MIDI"
  109. #define MIDI_SYNTH_CAPS SYNTH_CAP_INPUT
  110.  
  111. #include "../sound_config.h"
  112. #include "../midi_synth.h"
  114. /* this should be in dev_table.h */
  115. #define SNDCARD_EMU10K1 46
  116. #endif
  117.  
  118. #define DRIVER_VERSION "0.20"
  120. /* the emu10k1 _seems_ to only supports 29 bit (512MiB) bit bus master */
  121. #define EMU10K1_DMA_MASK                0x1fffffff /* DMA buffer mask for pci_alloc_consist */
  123. #ifndef PCI_VENDOR_ID_CREATIVE
  124. #define PCI_VENDOR_ID_CREATIVE 0x1102
  125. #endif
  127. #ifndef PCI_DEVICE_ID_CREATIVE_EMU10K1
  128. #define PCI_DEVICE_ID_CREATIVE_EMU10K1 0x0002
  129. #endif
  131. #define EMU_APS_SUBID 0x40011102
  132.  
  133. enum {
  134. EMU10K1 = 0,
  135. };
  137. static char *card_names[] __devinitdata = {
  138. "EMU10K1",
  139. };
  141. static struct pci_device_id emu10k1_pci_tbl[] = {
  142. {PCI_VENDOR_ID_CREATIVE, PCI_DEVICE_ID_CREATIVE_EMU10K1,
  143.  PCI_ANY_ID, PCI_ANY_ID, 0, 0, EMU10K1},
  144. {0,}
  145. };
  147. MODULE_DEVICE_TABLE(pci, emu10k1_pci_tbl);
  149. /* Global var instantiation */
  151. LIST_HEAD(emu10k1_devs);
  153. extern struct file_operations emu10k1_audio_fops;
  154. extern struct file_operations emu10k1_mixer_fops;
  155. extern struct file_operations emu10k1_midi_fops;
  157. #ifdef EMU10K1_SEQUENCER
  158. static struct midi_operations emu10k1_midi_operations;
  159. #endif
  161. extern void emu10k1_interrupt(int, void *, struct pt_regs *s);
  163. static int __devinit emu10k1_audio_init(struct emu10k1_card *card)
  164. {
  165. card->audio_dev = register_sound_dsp(&emu10k1_audio_fops, -1);
  166. if (card->audio_dev < 0) {
  167. printk(KERN_ERR "emu10k1: cannot register first audio device!n");
  168. goto err_dev;
  169. }
  171. card->audio_dev1 = register_sound_dsp(&emu10k1_audio_fops, -1);
  172. if (card->audio_dev1 < 0) {
  173. printk(KERN_ERR "emu10k1: cannot register second audio device!n");
  174. goto err_dev1;
  175. }
  177. /* Assign default playback voice parameters */
  178. card->mchannel_fx = 8;
  179. /* mono voice */
  180. card->waveout.send_a[0] = 0xff;
  181. card->waveout.send_b[0] = 0xff;
  182. card->waveout.send_c[0] = 0x00;
  183. card->waveout.send_d[0] = 0x00;
  184. card->waveout.send_routing[0] = 0x3210;
  186. /* stereo voice */
  187. /* left */
  188. card->waveout.send_a[1] = 0xff;
  189. card->waveout.send_b[1] = 0x00;
  190. card->waveout.send_c[1] = 0x00;
  191. card->waveout.send_d[1] = 0x00;
  192. card->waveout.send_routing[1] = 0x3210;
  194. /* right */
  195. card->waveout.send_a[2] = 0x00;
  196. card->waveout.send_b[2] = 0xff;
  197. card->waveout.send_c[2] = 0x00;
  198. card->waveout.send_d[2] = 0x00;
  199. card->waveout.send_routing[2] = 0x3210;
  201. /* Assign default recording parameters */
  202. /* FIXME */
  203. if (card->is_aps)
  204. card->wavein.recsrc = WAVERECORD_FX;
  205. else
  206. card->wavein.recsrc = WAVERECORD_AC97;
  208. card->wavein.fxwc = 0x0003;
  209. return 0;
  211. err_dev1:
  212. unregister_sound_dsp(card->audio_dev);
  213. err_dev:
  214. return -ENODEV;
  215. }
  217. static void __devinit emu10k1_audio_cleanup(struct emu10k1_card *card)
  218. {
  219. unregister_sound_dsp(card->audio_dev1);
  220. unregister_sound_dsp(card->audio_dev);
  221. }
  223. static int __devinit emu10k1_mixer_init(struct emu10k1_card *card)
  224. {
  225. char s[32];
  227. struct ac97_codec *codec = &card->ac97;
  228. card->ac97.dev_mixer = register_sound_mixer(&emu10k1_mixer_fops, -1);
  229. if (card->ac97.dev_mixer < 0) {
  230. printk(KERN_ERR "emu10k1: cannot register mixer devicen");
  231. return -EIO;
  232.         }
  234. card->ac97.private_data = card;
  236. if (!card->is_aps) {
  237. card->ac97.id = 0;
  238. card->ac97.codec_read = emu10k1_ac97_read;
  239.          card->ac97.codec_write = emu10k1_ac97_write;
  241. if (ac97_probe_codec (&card->ac97) == 0) {
  242. printk(KERN_ERR "emu10k1: unable to probe AC97 codecn");
  243. goto err_out;
  244. }
  245. /* 5.1: Enable the additional AC97 Slots and unmute extra channels on AC97 codec */
  246. if (codec->codec_read(codec, AC97_EXTENDED_ID) & 0x0080){
  247. printk(KERN_INFO "emu10k1: SBLive! 5.1 card detectedn"); 
  248. sblive_writeptr(card, AC97SLOT, 0, AC97SLOT_CNTR | AC97SLOT_LFE);
  249. codec->codec_write(codec, AC97_SURROUND_MASTER, 0x0);
  250. }
  252. // Force 5bit:     
  253. //card->ac97.bit_resolution=5;
  255. if (!proc_mkdir ("driver/emu10k1", 0)) {
  256. printk(KERN_ERR "emu10k1: unable to create proc directory driver/emu10k1n");
  257. goto err_out;
  258. }
  260. sprintf(s, "driver/emu10k1/%s", card->pci_dev->slot_name);
  261. if (!proc_mkdir (s, 0)) {
  262. printk(KERN_ERR "emu10k1: unable to create proc directory %sn", s);
  263. goto err_emu10k1_proc;
  264. }
  266. sprintf(s, "driver/emu10k1/%s/ac97", card->pci_dev->slot_name);
  267. if (!create_proc_read_entry (s, 0, 0, ac97_read_proc, &card->ac97)) {
  268. printk(KERN_ERR "emu10k1: unable to create proc entry %sn", s);
  269. goto err_ac97_proc;
  270. }
  272. /* these will store the original values and never be modified */
  273. card->ac97_supported_mixers = card->ac97.supported_mixers;
  274. card->ac97_stereo_mixers = card->ac97.stereo_mixers;
  275. }
  277. return 0;
  279.  err_ac97_proc:
  280. sprintf(s, "driver/emu10k1/%s", card->pci_dev->slot_name);
  281. remove_proc_entry(s, NULL);
  283.  err_emu10k1_proc:
  284. remove_proc_entry("driver/emu10k1", NULL);
  285.  err_out:
  286. unregister_sound_mixer (card->ac97.dev_mixer);
  287. return -EIO;
  288. }
  290. static void __devinit emu10k1_mixer_cleanup(struct emu10k1_card *card)
  291. {
  292. char s[32];
  294. if (!card->is_aps) {
  295. sprintf(s, "driver/emu10k1/%s/ac97", card->pci_dev->slot_name);
  296. remove_proc_entry(s, NULL);
  298. sprintf(s, "driver/emu10k1/%s", card->pci_dev->slot_name);
  299. remove_proc_entry(s, NULL);
  301. remove_proc_entry("driver/emu10k1", NULL);
  302. }
  304. unregister_sound_mixer (card->ac97.dev_mixer);
  305. }
  307. static int __devinit emu10k1_midi_init(struct emu10k1_card *card)
  308. {
  309. int ret;
  311. card->midi_dev = register_sound_midi(&emu10k1_midi_fops, -1);
  312. if (card->midi_dev < 0) {
  313.                 printk(KERN_ERR "emu10k1: cannot register midi device!n");
  314. return -ENODEV;
  315.         }
  318. card->mpuout = kmalloc(sizeof(struct emu10k1_mpuout), GFP_KERNEL);
  319. if (card->mpuout == NULL) {
  320. printk(KERN_WARNING "emu10k1: Unable to allocate emu10k1_mpuout: out of memoryn");
  321. ret = -ENOMEM;
  322. goto err_out1;
  323. }
  325. memset(card->mpuout, 0, sizeof(struct emu10k1_mpuout));
  327. card->mpuout->intr = 1;
  328. card->mpuout->status = FLAGS_AVAILABLE;
  329. card->mpuout->state = CARDMIDIOUT_STATE_DEFAULT;
  331. tasklet_init(&card->mpuout->tasklet, emu10k1_mpuout_bh, (unsigned long) card);
  333. spin_lock_init(&card->mpuout->lock);
  335. card->mpuin = kmalloc(sizeof(struct emu10k1_mpuin), GFP_KERNEL);
  336. if (card->mpuin == NULL) {
  337. printk(KERN_WARNING "emu10k1: Unable to allocate emu10k1_mpuin: out of memoryn");
  338. ret = -ENOMEM;
  339.                 goto err_out2;
  340. }
  342. memset(card->mpuin, 0, sizeof(struct emu10k1_mpuin));
  344. card->mpuin->status = FLAGS_AVAILABLE;
  346. tasklet_init(&card->mpuin->tasklet, emu10k1_mpuin_bh, (unsigned long) card->mpuin);
  348. spin_lock_init(&card->mpuin->lock);
  350. /* Reset the MPU port */
  351. if (emu10k1_mpu_reset(card) < 0) {
  352. ERROR();
  353. ret = -EIO;
  354. goto err_out3;
  355. }
  357. #ifdef EMU10K1_SEQUENCER
  358. card->seq_dev = sound_alloc_mididev();
  359. if (card->seq_dev == -1)
  360. printk(KERN_WARNING "emu10k1: unable to register sequencer device!");
  361. else {
  362. std_midi_synth.midi_dev = card->seq_dev;
  363. midi_devs[card->seq_dev] = 
  364. (struct midi_operations *)
  365. kmalloc(sizeof(struct midi_operations), GFP_KERNEL);
  367. if (midi_devs[card->seq_dev] == NULL) {
  368. printk(KERN_ERR "emu10k1: unable to allocate memory!");
  369. sound_unload_mididev(card->seq_dev);
  370. card->seq_dev = -1;
  371. return 0;
  372. } else {
  373. memcpy((char *)midi_devs[card->seq_dev], 
  374. (char *)&emu10k1_midi_operations, 
  375. sizeof(struct midi_operations));
  376. midi_devs[card->seq_dev]->devc = card;
  377. sequencer_init();
  378. }
  379. }
  380. card->seq_mididev = 0;
  381. #endif
  382. return 0;
  384. err_out3:
  385. kfree(card->mpuin);
  386. err_out2:
  387. kfree(card->mpuout);
  388. err_out1:
  389. unregister_sound_midi(card->midi_dev);
  390. return ret;
  391. }
  393. static void __devinit emu10k1_midi_cleanup(struct emu10k1_card *card)
  394. {
  395. tasklet_kill(&card->mpuout->tasklet);
  396. kfree(card->mpuout);
  398. tasklet_kill(&card->mpuin->tasklet);
  399. kfree(card->mpuin);
  401. #ifdef EMU10K1_SEQUENCER
  402. if (card->seq_dev > -1) {
  403. kfree(midi_devs[card->seq_dev]);
  404. midi_devs[card->seq_dev] = NULL;
  405. sound_unload_mididev(card->seq_dev);
  406. card->seq_dev = -1;
  407. }
  408. #endif
  410. unregister_sound_midi(card->midi_dev);
  411. }
  413. static void __devinit voice_init(struct emu10k1_card *card)
  414. {
  415. int i;
  417. for (i = 0; i < NUM_G; i++)
  418. card->voicetable[i] = VOICE_USAGE_FREE;
  419. }
  421. static void __devinit timer_init(struct emu10k1_card *card)
  422. {
  423. INIT_LIST_HEAD(&card->timers);
  424. card->timer_delay = TIMER_STOPPED;
  425. card->timer_lock = SPIN_LOCK_UNLOCKED;
  426. }
  428. static void __devinit addxmgr_init(struct emu10k1_card *card)
  429. {
  430. u32 count;
  432. for (count = 0; count < MAXPAGES; count++)
  433. card->emupagetable[count] = 0;
  435. /* Mark first page as used */
  436. /* This page is reserved by the driver */
  437. card->emupagetable[0] = 0x8001;
  438. card->emupagetable[1] = MAXPAGES - 1;
  439. }
  441. static void __devinit fx_cleanup(struct patch_manager *mgr)
  442. {
  443. int i;
  444. for(i = 0; i < mgr->current_pages; i++)
  445. free_page((unsigned long) mgr->patch[i]);
  446. }
  448. static int __devinit fx_init(struct emu10k1_card *card)
  449. {
  450. struct patch_manager *mgr = &card->mgr;
  451. struct dsp_patch *patch;
  452. struct dsp_rpatch *rpatch;
  453. s32 left, right;
  454. int i;
  455. u32 pc = 0;
  456. u32 patch_n;
  458. for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
  459. mgr->ctrl_gpr[i][0] = -1;
  460. mgr->ctrl_gpr[i][1] = -1;
  461. }
  463. for (i = 0; i < 512; i++)
  464. OP(6, 0x40, 0x40, 0x40, 0x40);
  466. for (i = 0; i < 256; i++)
  467. sblive_writeptr_tag(card, 0,
  468.     FXGPREGBASE + i, 0,
  469.     TANKMEMADDRREGBASE + i, 0,
  470.     TAGLIST_END);
  472. /* !! The number bellow must equal the number of patches, currently 11 !! */
  473. mgr->current_pages = (11 + PATCHES_PER_PAGE - 1) / PATCHES_PER_PAGE;
  474. for (i = 0; i < mgr->current_pages; i++) {
  475. mgr->patch[i] = (void *)__get_free_page(GFP_KERNEL);
  476. if (mgr->patch[i] == NULL) {
  477. mgr->current_pages = i;
  478. fx_cleanup(mgr);
  479. return -ENOMEM;
  480. }
  481. memset(mgr->patch[i], 0, PAGE_SIZE);
  482. }
  484. pc = 0;
  485. patch_n = 0;
  486. //first free GPR = 0x11b
  488. /* FX volume correction and Volume control*/
  489. INPUT_PATCH_START(patch, "Pcm L vol", 0x0, 0);
  490. GET_OUTPUT_GPR(patch, 0x100, 0x0);
  491. GET_CONTROL_GPR(patch, 0x106, "Vol", 0, 0x7fffffff);
  492. GET_DYNAMIC_GPR(patch, 0x112);
  494. OP(4, 0x112, 0x40, PCM_IN_L, 0x44); //*4
  495. OP(0, 0x100, 0x040, 0x112, 0x106);  //*vol
  496. INPUT_PATCH_END(patch);
  499. INPUT_PATCH_START(patch, "Pcm R vol", 0x1, 0);
  500. GET_OUTPUT_GPR(patch, 0x101, 0x1);
  501. GET_CONTROL_GPR(patch, 0x107, "Vol", 0, 0x7fffffff);
  502. GET_DYNAMIC_GPR(patch, 0x112);
  504. OP(4, 0x112, 0x40, PCM_IN_R, 0x44); 
  505. OP(0, 0x101, 0x040, 0x112, 0x107);
  507. INPUT_PATCH_END(patch);
  510. // CD-Digital In Volume control
  511. INPUT_PATCH_START(patch, "CD-Digital Vol L", 0x12, 0);
  512. GET_OUTPUT_GPR(patch, 0x10c, 0x12);
  513. GET_CONTROL_GPR(patch, 0x10d, "Vol", 0, 0x7fffffff);
  515. OP(0, 0x10c, 0x040, SPDIF_CD_L, 0x10d);
  516. INPUT_PATCH_END(patch);
  518. INPUT_PATCH_START(patch, "CD-Digital Vol R", 0x13, 0);
  519. GET_OUTPUT_GPR(patch, 0x10e, 0x13);
  520. GET_CONTROL_GPR(patch, 0x10f, "Vol", 0, 0x7fffffff);
  522. OP(0, 0x10e, 0x040, SPDIF_CD_R, 0x10f);
  523. INPUT_PATCH_END(patch);
  525. //Volume Correction for Multi-channel Inputs
  526. INPUT_PATCH_START(patch, "Multi-Channel Gain", 0x08, 0);
  527. patch->input=patch->output=0x3F00;
  529. GET_OUTPUT_GPR(patch, 0x113, MULTI_FRONT_L);
  530. GET_OUTPUT_GPR(patch, 0x114, MULTI_FRONT_R);
  531. GET_OUTPUT_GPR(patch, 0x115, MULTI_REAR_L);
  532. GET_OUTPUT_GPR(patch, 0x116, MULTI_REAR_R);
  533. GET_OUTPUT_GPR(patch, 0x117, MULTI_CENTER);
  534. GET_OUTPUT_GPR(patch, 0x118, MULTI_LFE);
  536. OP(4, 0x113, 0x40, MULTI_FRONT_L, 0x44);
  537. OP(4, 0x114, 0x40, MULTI_FRONT_R, 0x44);
  538. OP(4, 0x115, 0x40, MULTI_REAR_L, 0x44);
  539. OP(4, 0x116, 0x40, MULTI_REAR_R, 0x44);
  540. OP(4, 0x117, 0x40, MULTI_CENTER, 0x44);
  541. OP(4, 0x118, 0x40, MULTI_LFE, 0x44);
  543. INPUT_PATCH_END(patch);
  546. //Routing patch start
  547. ROUTING_PATCH_START(rpatch, "Routing");
  548. GET_INPUT_GPR(rpatch, 0x100, 0x0);
  549. GET_INPUT_GPR(rpatch, 0x101, 0x1);
  550. GET_INPUT_GPR(rpatch, 0x10c, 0x12);
  551. GET_INPUT_GPR(rpatch, 0x10e, 0x13);
  552. GET_INPUT_GPR(rpatch, 0x113, MULTI_FRONT_L);
  553. GET_INPUT_GPR(rpatch, 0x114, MULTI_FRONT_R);
  554. GET_INPUT_GPR(rpatch, 0x115, MULTI_REAR_L);
  555. GET_INPUT_GPR(rpatch, 0x116, MULTI_REAR_R);
  556. GET_INPUT_GPR(rpatch, 0x117, MULTI_CENTER);
  557. GET_INPUT_GPR(rpatch, 0x118, MULTI_LFE);
  559. GET_DYNAMIC_GPR(rpatch, 0x102);
  560. GET_DYNAMIC_GPR(rpatch, 0x103);
  562. GET_OUTPUT_GPR(rpatch, 0x104, 0x8);
  563. GET_OUTPUT_GPR(rpatch, 0x105, 0x9);
  564. GET_OUTPUT_GPR(rpatch, 0x10a, 0x2);
  565. GET_OUTPUT_GPR(rpatch, 0x10b, 0x3);
  568. /* input buffer */
  569. OP(6, 0x102, AC97_IN_L, 0x40, 0x40);
  570. OP(6, 0x103, AC97_IN_R, 0x40, 0x40);
  573. /* Digital In + PCM + MULTI_FRONT-> AC97 out (front speakers)*/
  574. OP(6, AC97_FRONT_L, 0x100, 0x10c, 0x113);
  576. CONNECT(MULTI_FRONT_L, AC97_FRONT_L);
  577. CONNECT(PCM_IN_L, AC97_FRONT_L);
  578. CONNECT(SPDIF_CD_L, AC97_FRONT_L);
  580. OP(6, AC97_FRONT_R, 0x101, 0x10e, 0x114);
  582. CONNECT(MULTI_FRONT_R, AC97_FRONT_R);
  583. CONNECT(PCM_IN_R, AC97_FRONT_R);
  584. CONNECT(SPDIF_CD_R, AC97_FRONT_R);
  586. /* Digital In + PCM + AC97 In + PCM1 + MULTI_REAR --> Rear Channel */ 
  587. OP(6, 0x104, PCM1_IN_L, 0x100, 0x115);
  588. OP(6, 0x104, 0x104, 0x10c, 0x102);
  590. CONNECT(MULTI_REAR_L, ANALOG_REAR_L);
  591. CONNECT(AC97_IN_L, ANALOG_REAR_L);
  592. CONNECT(PCM_IN_L, ANALOG_REAR_L);
  593. CONNECT(SPDIF_CD_L, ANALOG_REAR_L);
  594. CONNECT(PCM1_IN_L, ANALOG_REAR_L);
  596. OP(6, 0x105, PCM1_IN_R, 0x101, 0x116);
  597. OP(6, 0x105, 0x105, 0x10e, 0x103);
  599. CONNECT(MULTI_REAR_R, ANALOG_REAR_R);
  600. CONNECT(AC97_IN_R, ANALOG_REAR_R);
  601. CONNECT(PCM_IN_R, ANALOG_REAR_R);
  602. CONNECT(SPDIF_CD_R, ANALOG_REAR_R);
  603. CONNECT(PCM1_IN_R, ANALOG_REAR_R);
  605. /* Digital In + PCM + AC97 In + MULTI_FRONT --> Digital out */
  606. OP(6, 0x10a, 0x100, 0x102, 0x10c);
  607. OP(6, 0x10a, 0x10a, 0x113, 0x40);
  609. CONNECT(MULTI_FRONT_L, DIGITAL_OUT_L);
  610. CONNECT(PCM_IN_L, DIGITAL_OUT_L);
  611. CONNECT(AC97_IN_L, DIGITAL_OUT_L);
  612. CONNECT(SPDIF_CD_L, DIGITAL_OUT_L);
  614. OP(6, 0x10b, 0x101, 0x103, 0x10e);
  615. OP(6, 0x10b, 0x10b, 0x114, 0x40);
  617. CONNECT(MULTI_FRONT_R, DIGITAL_OUT_R);
  618. CONNECT(PCM_IN_R, DIGITAL_OUT_R);
  619. CONNECT(AC97_IN_R, DIGITAL_OUT_R);
  620. CONNECT(SPDIF_CD_R, DIGITAL_OUT_R);
  622. /* AC97 In --> ADC Recording Buffer */
  623. OP(6, ADC_REC_L, 0x102, 0x40, 0x40);
  625. CONNECT(AC97_IN_L, ADC_REC_L);
  627. OP(6, ADC_REC_R, 0x103, 0x40, 0x40);
  629. CONNECT(AC97_IN_R, ADC_REC_R);
  632. /* fx12:Analog-Center */
  633. OP(6, ANALOG_CENTER, 0x117, 0x40, 0x40);
  634. CONNECT(MULTI_CENTER, ANALOG_CENTER);
  636. /* fx11:Analog-LFE */
  637. OP(6, ANALOG_LFE, 0x118, 0x40, 0x40);
  638. CONNECT(MULTI_LFE, ANALOG_LFE);
  640. /* fx12:Digital-Center */
  641. OP(6, DIGITAL_CENTER, 0x117, 0x40, 0x40);
  642. CONNECT(MULTI_CENTER, DIGITAL_CENTER);
  644. /* fx11:Analog-LFE */
  645. OP(6, DIGITAL_LFE, 0x118, 0x40, 0x40);
  646. CONNECT(MULTI_LFE, DIGITAL_LFE);
  648. ROUTING_PATCH_END(rpatch);
  651. // Rear volume control
  652. OUTPUT_PATCH_START(patch, "Vol Rear L", 0x8, 0);
  653. GET_INPUT_GPR(patch, 0x104, 0x8);
  654. GET_CONTROL_GPR(patch, 0x119, "Vol", 0, 0x7fffffff);
  656. OP(0, ANALOG_REAR_L, 0x040, 0x104, 0x119);
  657. OUTPUT_PATCH_END(patch);
  660. OUTPUT_PATCH_START(patch, "Vol Rear R", 0x9, 0);
  661. GET_INPUT_GPR(patch, 0x105, 0x9);
  662. GET_CONTROL_GPR(patch, 0x11a, "Vol", 0, 0x7fffffff);
  664. OP(0, ANALOG_REAR_R, 0x040, 0x105, 0x11a);
  665. OUTPUT_PATCH_END(patch);
  668. //Master volume control on front-digital
  669. OUTPUT_PATCH_START(patch, "Vol Master L", 0x2, 1);
  670. GET_INPUT_GPR(patch, 0x10a, 0x2);
  671. GET_CONTROL_GPR(patch, 0x108, "Vol", 0, 0x7fffffff);
  673. OP(0, DIGITAL_OUT_L, 0x040, 0x10a, 0x108);
  674. OUTPUT_PATCH_END(patch);
  677. OUTPUT_PATCH_START(patch, "Vol Master R", 0x3, 1);
  678. GET_INPUT_GPR(patch, 0x10b, 0x3);
  679. GET_CONTROL_GPR(patch, 0x109, "Vol", 0, 0x7fffffff);
  681. OP(0, DIGITAL_OUT_R, 0x040, 0x10b, 0x109);
  682. OUTPUT_PATCH_END(patch);
  685. /* delimiter patch */
  686. patch = PATCH(mgr, patch_n);
  687. patch->code_size = 0;
  689. sblive_writeptr(card, DBG, 0, 0);
  691. mgr->lock = SPIN_LOCK_UNLOCKED;
  694. //Master volume
  695. mgr->ctrl_gpr[SOUND_MIXER_VOLUME][0] = 8;
  696. mgr->ctrl_gpr[SOUND_MIXER_VOLUME][1] = 9;
  698. left = card->ac97.mixer_state[SOUND_MIXER_VOLUME] & 0xff;
  699. right = (card->ac97.mixer_state[SOUND_MIXER_VOLUME] >> 8) & 0xff;
  701. emu10k1_set_volume_gpr(card, 8, left, 1 << card->ac97.bit_resolution);
  702. emu10k1_set_volume_gpr(card, 9, right, 1 << card->ac97.bit_resolution);
  704. //Rear volume
  705. mgr->ctrl_gpr[ SOUND_MIXER_OGAIN ][0] = 0x19;
  706. mgr->ctrl_gpr[ SOUND_MIXER_OGAIN ][1] = 0x1a;
  708. left = right = 67;
  709. card->ac97.mixer_state[SOUND_MIXER_OGAIN] = (right << 8) | left;
  711. card->ac97.supported_mixers |= SOUND_MASK_OGAIN;
  712. card->ac97.stereo_mixers |= SOUND_MASK_OGAIN;
  714. emu10k1_set_volume_gpr(card, 0x19, left, VOL_5BIT);
  715. emu10k1_set_volume_gpr(card, 0x1a, right, VOL_5BIT);
  717. //PCM Volume
  718. mgr->ctrl_gpr[SOUND_MIXER_PCM][0] = 6;
  719. mgr->ctrl_gpr[SOUND_MIXER_PCM][1] = 7;
  721. left = card->ac97.mixer_state[SOUND_MIXER_PCM] & 0xff;
  722. right = (card->ac97.mixer_state[SOUND_MIXER_PCM] >> 8) & 0xff;
  724. emu10k1_set_volume_gpr(card, 6, left, VOL_5BIT);
  725. emu10k1_set_volume_gpr(card, 7, right, VOL_5BIT);
  727. //CD-Digital Volume
  728. mgr->ctrl_gpr[SOUND_MIXER_DIGITAL1][0] = 0xd;
  729. mgr->ctrl_gpr[SOUND_MIXER_DIGITAL1][1] = 0xf;
  731. left = right = 67;
  732. card->ac97.mixer_state[SOUND_MIXER_DIGITAL1] = (right << 8) | left; 
  734. card->ac97.supported_mixers |= SOUND_MASK_DIGITAL1;
  735. card->ac97.stereo_mixers |= SOUND_MASK_DIGITAL1;
  737. emu10k1_set_volume_gpr(card, 0xd, left, VOL_5BIT);
  738. emu10k1_set_volume_gpr(card, 0xf, right, VOL_5BIT);
  740. //hard wire the ac97's pcm, we'll do that in dsp code instead.
  741. emu10k1_ac97_write(&card->ac97, 0x18, 0x0);
  742. card->ac97_supported_mixers &= ~SOUND_MASK_PCM;
  743. card->ac97_stereo_mixers &= ~SOUND_MASK_PCM;
  745. //set Igain to 0dB by default, maybe consider hardwiring it here.
  746. emu10k1_ac97_write(&card->ac97, AC97_RECORD_GAIN, 0x0000);
  747. card->ac97.mixer_state[SOUND_MIXER_IGAIN] = 0x101; 
  749. return 0;
  750. }
  752. static int __devinit hw_init(struct emu10k1_card *card)
  753. {
  754. int nCh;
  755. u32 pagecount; /* tmp */
  756. int ret;
  758. /* Disable audio and lock cache */
  759. emu10k1_writefn0(card, HCFG, HCFG_LOCKSOUNDCACHE | HCFG_LOCKTANKCACHE_MASK | HCFG_MUTEBUTTONENABLE);
  761. /* Reset recording buffers */
  762. sblive_writeptr_tag(card, 0,
  763.     MICBS, ADCBS_BUFSIZE_NONE,
  764.     MICBA, 0,
  765.     FXBS, ADCBS_BUFSIZE_NONE,
  766.     FXBA, 0,
  767.     ADCBS, ADCBS_BUFSIZE_NONE,
  768.     ADCBA, 0,
  769.     TAGLIST_END);
  771. /* Disable channel interrupt */
  772. emu10k1_writefn0(card, INTE, 0);
  773. sblive_writeptr_tag(card, 0,
  774.     CLIEL, 0,
  775.     CLIEH, 0,
  776.     SOLEL, 0,
  777.     SOLEH, 0,
  778.     TAGLIST_END);
  780. /* Init envelope engine */
  781. for (nCh = 0; nCh < NUM_G; nCh++) {
  782. sblive_writeptr_tag(card, nCh,
  783.     DCYSUSV, 0,
  784.     IP, 0,
  785.     VTFT, 0xffff,
  786.     CVCF, 0xffff,
  787.     PTRX, 0,
  788.     //CPF, 0,
  789.     CCR, 0,
  791.     PSST, 0,
  792.     DSL, 0x10,
  793.     CCCA, 0,
  794.     Z1, 0,
  795.     Z2, 0,
  796.     FXRT, 0xd01c0000,
  798.     ATKHLDM, 0,
  799.     DCYSUSM, 0,
  800.     IFATN, 0xffff,
  801.     PEFE, 0,
  802.     FMMOD, 0,
  803.     TREMFRQ, 24, /* 1 Hz */
  804.     FM2FRQ2, 24, /* 1 Hz */
  805.     TEMPENV, 0,
  807.     /*** These are last so OFF prevents writing ***/
  808.     LFOVAL2, 0,
  809.     LFOVAL1, 0,
  810.     ATKHLDV, 0,
  811.     ENVVOL, 0,
  812.     ENVVAL, 0,
  813.                                     TAGLIST_END);
  814. sblive_writeptr(card, CPF, nCh, 0);
  815. }
  818. /*
  819.  ** Init to 0x02109204 :
  820.  ** Clock accuracy    = 0     (1000ppm)
  821.  ** Sample Rate       = 2     (48kHz)
  822.  ** Audio Channel     = 1     (Left of 2)
  823.  ** Source Number     = 0     (Unspecified)
  824.  ** Generation Status = 1     (Original for Cat Code 12)
  825.  ** Cat Code          = 12    (Digital Signal Mixer)
  826.  ** Mode              = 0     (Mode 0)
  827.  ** Emphasis          = 0     (None)
  828.  ** CP                = 1     (Copyright unasserted)
  829.  ** AN                = 0     (Digital audio)
  830.  ** P                 = 0     (Consumer)
  831.  */
  833. sblive_writeptr_tag(card, 0,
  835.     /* SPDIF0 */
  836.     SPCS0, (SPCS_CLKACCY_1000PPM | 0x002000000 |
  837.     SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC | SPCS_GENERATIONSTATUS | 0x00001200 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT),
  839.     /* SPDIF1 */
  840.     SPCS1, (SPCS_CLKACCY_1000PPM | 0x002000000 |
  841.     SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC | SPCS_GENERATIONSTATUS | 0x00001200 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT),
  843.     /* SPDIF2 & SPDIF3 */
  844.     SPCS2, (SPCS_CLKACCY_1000PPM | 0x002000000 |
  845.     SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC | SPCS_GENERATIONSTATUS | 0x00001200 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT),
  847.     TAGLIST_END);
  849. ret = fx_init(card); /* initialize effects engine */
  850. if (ret < 0)
  851. return ret;
  853. card->tankmem.size = 0;
  855. card->virtualpagetable.size = MAXPAGES * sizeof(u32);
  857. card->virtualpagetable.addr = pci_alloc_consistent(card->pci_dev, card->virtualpagetable.size, &card->virtualpagetable.dma_handle);
  858. if (card->virtualpagetable.addr == NULL) {
  859. ERROR();
  860. ret = -ENOMEM;
  861. goto err0;
  862. }
  864. card->silentpage.size = EMUPAGESIZE;
  866. card->silentpage.addr = pci_alloc_consistent(card->pci_dev, card->silentpage.size, &card->silentpage.dma_handle);
  867. if (card->silentpage.addr == NULL) {
  868. ERROR();
  869. ret = -ENOMEM;
  870. goto err1;
  871. }
  873. for (pagecount = 0; pagecount < MAXPAGES; pagecount++)
  874. ((u32 *) card->virtualpagetable.addr)[pagecount] = cpu_to_le32(((u32) card->silentpage.dma_handle * 2) | pagecount);
  876. /* Init page table & tank memory base register */
  877. sblive_writeptr_tag(card, 0,
  878.     PTB, (u32) card->virtualpagetable.dma_handle,
  879.     TCB, 0,
  880.     TCBS, 0,
  881.     TAGLIST_END);
  883. for (nCh = 0; nCh < NUM_G; nCh++) {
  884. sblive_writeptr_tag(card, nCh,
  885.     MAPA, MAP_PTI_MASK | ((u32) card->silentpage.dma_handle * 2),
  886.     MAPB, MAP_PTI_MASK | ((u32) card->silentpage.dma_handle * 2),
  887.     TAGLIST_END);
  888. }
  890. /* Hokay, now enable the AUD bit */
  891. /* Enable Audio = 1 */
  892. /* Mute Disable Audio = 0 */
  893. /* Lock Tank Memory = 1 */
  894. /* Lock Sound Memory = 0 */
  895. /* Auto Mute = 1 */
  897. if (card->model == 0x20 || card->model == 0xc400 ||
  898.   (card->model == 0x21 && card->chiprev < 6))
  899.         emu10k1_writefn0(card, HCFG, HCFG_AUDIOENABLE  | HCFG_LOCKTANKCACHE_MASK | HCFG_AUTOMUTE);
  900. else
  901. emu10k1_writefn0(card, HCFG, HCFG_AUDIOENABLE  | HCFG_LOCKTANKCACHE_MASK | HCFG_AUTOMUTE | HCFG_JOYENABLE);
  903. /* Enable Vol_Ctrl irqs */
  904. emu10k1_irq_enable(card, INTE_VOLINCRENABLE | INTE_VOLDECRENABLE | INTE_MUTEENABLE | INTE_FXDSPENABLE);
  906. /* FIXME: TOSLink detection */
  907. card->has_toslink = 0;
  909. /* Initialize digital passthrough variables */
  910. card->pt.pos_gpr = card->pt.intr_gpr = card->pt.enable_gpr = -1;
  911. card->pt.selected = 0;
  912. card->pt.state = PT_STATE_INACTIVE;
  913. card->pt.spcs_to_use = 0x01;
  914. card->pt.patch_name = "AC3pass";
  915. card->pt.intr_gpr_name = "count";
  916. card->pt.enable_gpr_name = "enable";
  917. card->pt.pos_gpr_name = "ptr";
  918. spin_lock_init(&card->pt.lock);
  919. init_waitqueue_head(&card->pt.wait);
  921. /* tmp = sblive_readfn0(card, HCFG);
  922. if (tmp & (HCFG_GPINPUT0 | HCFG_GPINPUT1)) {
  923. sblive_writefn0(card, HCFG, tmp | 0x800);
  925. udelay(512);
  927. if (tmp != (sblive_readfn0(card, HCFG) & ~0x800)) {
  928. card->has_toslink = 1;
  929. sblive_writefn0(card, HCFG, tmp);
  930. }
  931. }
  932. */
  933. return 0;
  935.   err1:
  936. pci_free_consistent(card->pci_dev, card->virtualpagetable.size, card->virtualpagetable.addr, card->virtualpagetable.dma_handle);
  937.   err0:
  938. fx_cleanup(&card->mgr);
  940. return ret;
  941. }
  943. static int __devinit emu10k1_init(struct emu10k1_card *card)
  944. {
  945. /* Init Card */
  946. if (hw_init(card) < 0)
  947. return -1;
  949. voice_init(card);
  950. timer_init(card);
  951. addxmgr_init(card);
  953. DPD(2, "  hw control register -> %#xn", emu10k1_readfn0(card, HCFG));
  955. return 0;
  956. }
  958. static void __devinit emu10k1_cleanup(struct emu10k1_card *card)
  959. {
  960. int ch;
  962. emu10k1_writefn0(card, INTE, 0);
  964. /** Shutdown the chip **/
  965. for (ch = 0; ch < NUM_G; ch++)
  966. sblive_writeptr(card, DCYSUSV, ch, 0);
  968. for (ch = 0; ch < NUM_G; ch++) {
  969. sblive_writeptr_tag(card, ch,
  970.     VTFT, 0,
  971.     CVCF, 0,
  972.     PTRX, 0,
  973.     //CPF, 0,
  974.     TAGLIST_END);
  975. sblive_writeptr(card, CPF, ch, 0);
  976. }
  978. /* Disable audio and lock cache */
  979. emu10k1_writefn0(card, HCFG, HCFG_LOCKSOUNDCACHE | HCFG_LOCKTANKCACHE_MASK | HCFG_MUTEBUTTONENABLE);
  981. sblive_writeptr_tag(card, 0,
  982.                             PTB, 0,
  984.     /* Reset recording buffers */
  985.     MICBS, ADCBS_BUFSIZE_NONE,
  986.     MICBA, 0,
  987.     FXBS, ADCBS_BUFSIZE_NONE,
  988.     FXBA, 0,
  989.     FXWC, 0,
  990.     ADCBS, ADCBS_BUFSIZE_NONE,
  991.     ADCBA, 0,
  992.     TCBS, 0,
  993.     TCB, 0,
  994.     DBG, 0x8000,
  996.     /* Disable channel interrupt */
  997.     CLIEL, 0,
  998.     CLIEH, 0,
  999.     SOLEL, 0,
  1000.     SOLEH, 0,
  1001.     TAGLIST_END);
  1004. pci_free_consistent(card->pci_dev, card->virtualpagetable.size, card->virtualpagetable.addr, card->virtualpagetable.dma_handle);
  1005. pci_free_consistent(card->pci_dev, card->silentpage.size, card->silentpage.addr, card->silentpage.dma_handle);
  1007. if(card->tankmem.size != 0)
  1008. pci_free_consistent(card->pci_dev, card->tankmem.size, card->tankmem.addr, card->tankmem.dma_handle);
  1010. /* release patch storage memory */
  1011. fx_cleanup(&card->mgr);
  1012. }
  1014. /* Driver initialization routine */
  1015. static int __devinit emu10k1_probe(struct pci_dev *pci_dev, const struct pci_device_id *pci_id)
  1016. {
  1017. struct emu10k1_card *card;
  1018. u32 subsysvid;
  1019. int ret;
  1021. if (pci_set_dma_mask(pci_dev, EMU10K1_DMA_MASK)) {
  1022. printk(KERN_ERR "emu10k1: architecture does not support 29bit PCI busmaster DMAn");
  1023. return -ENODEV;
  1024. }
  1026. if (pci_enable_device(pci_dev))
  1027. return -EIO;
  1029. pci_set_master(pci_dev);
  1031. if ((card = kmalloc(sizeof(struct emu10k1_card), GFP_KERNEL)) == NULL) {
  1032.                 printk(KERN_ERR "emu10k1: out of memoryn");
  1033.                 return -ENOMEM;
  1034.         }
  1035.         memset(card, 0, sizeof(struct emu10k1_card));
  1037. card->iobase = pci_resource_start(pci_dev, 0);
  1038. card->length = pci_resource_len(pci_dev, 0); 
  1040. if (request_region(card->iobase, card->length, card_names[pci_id->driver_data]) == NULL) {
  1041. printk(KERN_ERR "emu10k1: IO space in usen");
  1042. ret = -EBUSY;
  1043. goto err_region;
  1044. }
  1046. pci_set_drvdata(pci_dev, card);
  1048. card->irq = pci_dev->irq;
  1049. card->pci_dev = pci_dev;
  1051. /* Reserve IRQ Line */
  1052. if (request_irq(card->irq, emu10k1_interrupt, SA_SHIRQ, card_names[pci_id->driver_data], card)) {
  1053. printk(KERN_ERR "emu10k1: IRQ in usen");
  1054. ret = -EBUSY;
  1055. goto err_irq;
  1056. }
  1058. pci_read_config_byte(pci_dev, PCI_REVISION_ID, &card->chiprev);
  1059. pci_read_config_word(pci_dev, PCI_SUBSYSTEM_ID, &card->model);
  1061. printk(KERN_INFO "emu10k1: %s rev %d model %#04x found, IO at %#04lx-%#04lx, IRQ %dn",
  1062. card_names[pci_id->driver_data], card->chiprev, card->model, card->iobase,
  1063. card->iobase + card->length - 1, card->irq);
  1065. pci_read_config_dword(pci_dev, PCI_SUBSYSTEM_VENDOR_ID, &subsysvid);
  1066. card->is_aps = (subsysvid == EMU_APS_SUBID);
  1068. spin_lock_init(&card->lock);
  1069. init_MUTEX(&card->open_sem);
  1070. card->open_mode = 0;
  1071. init_waitqueue_head(&card->open_wait);
  1073. ret = emu10k1_audio_init(card);
  1074. if(ret < 0) {
  1075.                 printk(KERN_ERR "emu10k1: cannot initialize audio devicesn");
  1076.                 goto err_audio;
  1077.         }
  1079. ret = emu10k1_mixer_init(card);
  1080. if(ret < 0) {
  1081. printk(KERN_ERR "emu10k1: cannot initialize AC97 codecn");
  1082.                 goto err_mixer;
  1083. }
  1085. ret = emu10k1_midi_init(card);
  1086. if (ret < 0) {
  1087. printk(KERN_ERR "emu10k1: cannot register midi devicen");
  1088. goto err_midi;
  1089. }
  1091. ret = emu10k1_init(card);
  1092. if (ret < 0) {
  1093. printk(KERN_ERR "emu10k1: cannot initialize devicen");
  1094. goto err_emu10k1_init;
  1095. }
  1097. if (card->is_aps)
  1098. emu10k1_ecard_init(card);
  1100. list_add(&card->list, &emu10k1_devs);
  1102. return 0;
  1104. err_emu10k1_init:
  1105. emu10k1_midi_cleanup(card);
  1107. err_midi:
  1108. emu10k1_mixer_cleanup(card);
  1110. err_mixer:
  1111. emu10k1_audio_cleanup(card);
  1113. err_audio:
  1114. free_irq(card->irq, card);
  1116. err_irq:
  1117. release_region(card->iobase, card->length);
  1118. pci_set_drvdata(pci_dev, NULL);
  1120. err_region:
  1121. kfree(card);
  1123. return ret;
  1124. }
  1126. static void __devexit emu10k1_remove(struct pci_dev *pci_dev)
  1127. {
  1128. struct emu10k1_card *card = pci_get_drvdata(pci_dev);
  1130. list_del(&card->list);
  1132. emu10k1_cleanup(card);
  1133. emu10k1_midi_cleanup(card);
  1134. emu10k1_mixer_cleanup(card);
  1135. emu10k1_audio_cleanup(card);
  1136. free_irq(card->irq, card);
  1137. release_region(card->iobase, card->length);
  1138. kfree(card);
  1139. pci_set_drvdata(pci_dev, NULL);
  1140. }
  1142. MODULE_AUTHOR("Bertrand Lee, Cai Ying. (Email to: emu10k1-devel@lists.sourceforge.net)");
  1143. MODULE_DESCRIPTION("Creative EMU10K1 PCI Audio Driver v" DRIVER_VERSION "nCopyright (C) 1999 Creative Technology Ltd.");
  1144. MODULE_LICENSE("GPL");
  1146. static struct pci_driver emu10k1_pci_driver = {
  1147. name: "emu10k1",
  1148. id_table: emu10k1_pci_tbl,
  1149. probe: emu10k1_probe,
  1150. remove: __devexit_p(emu10k1_remove),
  1151. };
  1153. static int __init emu10k1_init_module(void)
  1154. {
  1155. printk(KERN_INFO "Creative EMU10K1 PCI Audio Driver, version " DRIVER_VERSION ", " __TIME__ " " __DATE__ "n");
  1157. return pci_module_init(&emu10k1_pci_driver);
  1158. }
  1160. static void __exit emu10k1_cleanup_module(void)
  1161. {
  1162. pci_unregister_driver(&emu10k1_pci_driver);
  1164. return;
  1165. }
  1167. module_init(emu10k1_init_module);
  1168. module_exit(emu10k1_cleanup_module);
  1170. #ifdef EMU10K1_SEQUENCER
  1172. /* in midi.c */
  1173. extern int emu10k1_seq_midi_open(int dev, int mode, 
  1174. void (*input)(int dev, unsigned char midi_byte),
  1175. void (*output)(int dev));
  1176. extern void emu10k1_seq_midi_close(int dev);
  1177. extern int emu10k1_seq_midi_out(int dev, unsigned char midi_byte);
  1178. extern int emu10k1_seq_midi_start_read(int dev);
  1179. extern int emu10k1_seq_midi_end_read(int dev);
  1180. extern void emu10k1_seq_midi_kick(int dev);
  1181. extern int emu10k1_seq_midi_buffer_status(int dev);
  1183. static struct midi_operations emu10k1_midi_operations =
  1184. {
  1185. THIS_MODULE,
  1186. {"EMU10K1 MIDI", 0, 0, SNDCARD_EMU10K1},
  1187. &std_midi_synth,
  1188. {0},
  1189. emu10k1_seq_midi_open,
  1190. emu10k1_seq_midi_close,
  1191. NULL,
  1192. emu10k1_seq_midi_out,
  1193. emu10k1_seq_midi_start_read,
  1194. emu10k1_seq_midi_end_read,
  1195. emu10k1_seq_midi_kick,
  1196. NULL,
  1197. emu10k1_seq_midi_buffer_status,
  1198. NULL
  1199. };
  1201. #endif