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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
main.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：33k
源码类别：

嵌入式Linux

开发平台：

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.  *
  82.  *********************************************************************/
  84. /* These are only included once per module */
  85. #include <linux/version.h>
  86. #include <linux/module.h>
  87. #include <linux/slab.h>
  88. #include <linux/init.h>
  89. #include <linux/delay.h>
  90. #include <linux/proc_fs.h>
  92. #include "hwaccess.h"
  93. #include "8010.h"
  94. #include "efxmgr.h"
  95. #include "cardwo.h"
  96. #include "cardwi.h"
  97. #include "cardmo.h"
  98. #include "cardmi.h"
  99. #include "recmgr.h"
  100. #include "ecard.h"
  103. #ifdef EMU10K1_SEQUENCER
  104. #define MIDI_SYNTH_NAME "EMU10K1 MIDI"
  105. #define MIDI_SYNTH_CAPS SYNTH_CAP_INPUT
  106.  
  107. #include "../sound_config.h"
  108. #include "../midi_synth.h"
  110. /* this should be in dev_table.h */
  111. #define SNDCARD_EMU10K1 46
  112. #endif
  113.  
  114. #define DRIVER_VERSION "0.18"
  116. /* the emu10k1 _seems_ to only supports 29 bit (512MiB) bit bus master */
  117. #define EMU10K1_DMA_MASK                0x1fffffff /* DMA buffer mask for pci_alloc_consist */
  119. #ifndef PCI_VENDOR_ID_CREATIVE
  120. #define PCI_VENDOR_ID_CREATIVE 0x1102
  121. #endif
  123. #ifndef PCI_DEVICE_ID_CREATIVE_EMU10K1
  124. #define PCI_DEVICE_ID_CREATIVE_EMU10K1 0x0002
  125. #endif
  127. #define EMU_APS_SUBID 0x40011102
  128.  
  129. enum {
  130. EMU10K1 = 0,
  131. };
  133. static char *card_names[] __devinitdata = {
  134. "EMU10K1",
  135. };
  137. static struct pci_device_id emu10k1_pci_tbl[] = {
  138. {PCI_VENDOR_ID_CREATIVE, PCI_DEVICE_ID_CREATIVE_EMU10K1,
  139.  PCI_ANY_ID, PCI_ANY_ID, 0, 0, EMU10K1},
  140. {0,}
  141. };
  143. MODULE_DEVICE_TABLE(pci, emu10k1_pci_tbl);
  145. /* Global var instantiation */
  147. LIST_HEAD(emu10k1_devs);
  149. extern struct file_operations emu10k1_audio_fops;
  150. extern struct file_operations emu10k1_mixer_fops;
  151. extern struct file_operations emu10k1_midi_fops;
  153. #ifdef EMU10K1_SEQUENCER
  154. static struct midi_operations emu10k1_midi_operations;
  155. #endif
  157. extern void emu10k1_interrupt(int, void *, struct pt_regs *s);
  159. static int __devinit emu10k1_audio_init(struct emu10k1_card *card)
  160. {
  161. card->audio_dev = register_sound_dsp(&emu10k1_audio_fops, -1);
  162. if (card->audio_dev < 0) {
  163. printk(KERN_ERR "emu10k1: cannot register first audio device!n");
  164. goto err_dev;
  165. }
  167. card->audio_dev1 = register_sound_dsp(&emu10k1_audio_fops, -1);
  168. if (card->audio_dev1 < 0) {
  169. printk(KERN_ERR "emu10k1: cannot register second audio device!n");
  170. goto err_dev1;
  171. }
  173. /* Assign default playback voice parameters */
  174. card->mchannel_fx = 8;
  175. /* mono voice */
  176. card->waveout.send_a[0] = 0xff;
  177. card->waveout.send_b[0] = 0xff;
  178. card->waveout.send_c[0] = 0x00;
  179. card->waveout.send_d[0] = 0x00;
  180. card->waveout.send_routing[0] = 0x3210;
  182. /* stereo voice */
  183. /* left */
  184. card->waveout.send_a[1] = 0xff;
  185. card->waveout.send_b[1] = 0x00;
  186. card->waveout.send_c[1] = 0x00;
  187. card->waveout.send_d[1] = 0x00;
  188. card->waveout.send_routing[1] = 0x3210;
  190. /* right */
  191. card->waveout.send_a[2] = 0x00;
  192. card->waveout.send_b[2] = 0xff;
  193. card->waveout.send_c[2] = 0x00;
  194. card->waveout.send_d[2] = 0x00;
  195. card->waveout.send_routing[2] = 0x3210;
  197. /* Assign default recording parameters */
  198. /* FIXME */
  199. if(card->isaps)
  200. card->wavein.recsrc = WAVERECORD_FX;
  201. else
  202. card->wavein.recsrc = WAVERECORD_AC97;
  204. card->wavein.fxwc = 0x0003;
  205. return 0;
  207. err_dev1:
  208. unregister_sound_dsp(card->audio_dev);
  209. err_dev:
  210. return -ENODEV;
  211. }
  213. static void __devinit emu10k1_audio_cleanup(struct emu10k1_card *card)
  214. {
  215. unregister_sound_dsp(card->audio_dev1);
  216. unregister_sound_dsp(card->audio_dev);
  217. }
  219. static int __devinit emu10k1_mixer_init(struct emu10k1_card *card)
  220. {
  221. char s[32];
  223. struct ac97_codec *codec = &card->ac97;
  224. card->ac97.dev_mixer = register_sound_mixer(&emu10k1_mixer_fops, -1);
  225. if (card->ac97.dev_mixer < 0) {
  226. printk(KERN_ERR "emu10k1: cannot register mixer devicen");
  227. return -EIO;
  228.         }
  230. card->ac97.private_data = card;
  232. if (!card->isaps) {
  233. card->ac97.id = 0;
  234. card->ac97.codec_read = emu10k1_ac97_read;
  235.          card->ac97.codec_write = emu10k1_ac97_write;
  237. if (ac97_probe_codec (&card->ac97) == 0) {
  238. printk(KERN_ERR "emu10k1: unable to probe AC97 codecn");
  239. goto err_out;
  240. }
  241. /* 5.1: Enable the additional AC97 Slots and unmute extra channels on AC97 codec */
  242. if (codec->codec_read(codec, AC97_EXTENDED_ID) & 0x0080){
  243. printk(KERN_INFO "emu10k1: SBLive! 5.1 card detectedn"); 
  244. sblive_writeptr(card, AC97SLOT, 0, AC97SLOT_CNTR | AC97SLOT_LFE);
  245. codec->codec_write(codec, AC97_SURROUND_MASTER, 0x0);
  246. }
  248. // Force 5bit:     
  249. //card->ac97.bit_resolution=5;
  251. if (!proc_mkdir ("driver/emu10k1", 0)) {
  252. printk(KERN_ERR "emu10k1: unable to create proc directory driver/emu10k1n");
  253. goto err_out;
  254. }
  256. sprintf(s, "driver/emu10k1/%s", card->pci_dev->slot_name);
  257. if (!proc_mkdir (s, 0)) {
  258. printk(KERN_ERR "emu10k1: unable to create proc directory %sn", s);
  259. goto err_emu10k1_proc;
  260. }
  262. sprintf(s, "driver/emu10k1/%s/ac97", card->pci_dev->slot_name);
  263. if (!create_proc_read_entry (s, 0, 0, ac97_read_proc, &card->ac97)) {
  264. printk(KERN_ERR "emu10k1: unable to create proc entry %sn", s);
  265. goto err_ac97_proc;
  266. }
  268. /* these will store the original values and never be modified */
  269. card->ac97_supported_mixers = card->ac97.supported_mixers;
  270. card->ac97_stereo_mixers = card->ac97.stereo_mixers;
  271. }
  273. return 0;
  275.  err_ac97_proc:
  276. sprintf(s, "driver/emu10k1/%s", card->pci_dev->slot_name);
  277. remove_proc_entry(s, NULL);
  279.  err_emu10k1_proc:
  280. remove_proc_entry("driver/emu10k1", NULL);
  281.  err_out:
  282. unregister_sound_mixer (card->ac97.dev_mixer);
  283. return -EIO;
  284. }
  286. static void __devinit emu10k1_mixer_cleanup(struct emu10k1_card *card)
  287. {
  288. char s[32];
  290. if (!card->isaps) {
  291. sprintf(s, "driver/emu10k1/%s/ac97", card->pci_dev->slot_name);
  292. remove_proc_entry(s, NULL);
  294. sprintf(s, "driver/emu10k1/%s", card->pci_dev->slot_name);
  295. remove_proc_entry(s, NULL);
  297. remove_proc_entry("driver/emu10k1", NULL);
  298. }
  300. unregister_sound_mixer (card->ac97.dev_mixer);
  301. }
  303. static int __devinit emu10k1_midi_init(struct emu10k1_card *card)
  304. {
  305. int ret;
  307. card->midi_dev = register_sound_midi(&emu10k1_midi_fops, -1);
  308. if (card->midi_dev < 0) {
  309.                 printk(KERN_ERR "emu10k1: cannot register midi device!n");
  310. return -ENODEV;
  311.         }
  314. card->mpuout = kmalloc(sizeof(struct emu10k1_mpuout), GFP_KERNEL);
  315. if (card->mpuout == NULL) {
  316. printk(KERN_WARNING "emu10k1: Unable to allocate emu10k1_mpuout: out of memoryn");
  317. ret = -ENOMEM;
  318. goto err_out1;
  319. }
  321. memset(card->mpuout, 0, sizeof(struct emu10k1_mpuout));
  323. card->mpuout->intr = 1;
  324. card->mpuout->status = FLAGS_AVAILABLE;
  325. card->mpuout->state = CARDMIDIOUT_STATE_DEFAULT;
  327. tasklet_init(&card->mpuout->tasklet, emu10k1_mpuout_bh, (unsigned long) card);
  329. spin_lock_init(&card->mpuout->lock);
  331. card->mpuin = kmalloc(sizeof(struct emu10k1_mpuin), GFP_KERNEL);
  332. if (card->mpuin == NULL) {
  333. printk(KERN_WARNING "emu10k1: Unable to allocate emu10k1_mpuin: out of memoryn");
  334. ret = -ENOMEM;
  335.                 goto err_out2;
  336. }
  338. memset(card->mpuin, 0, sizeof(struct emu10k1_mpuin));
  340. card->mpuin->status = FLAGS_AVAILABLE;
  342. tasklet_init(&card->mpuin->tasklet, emu10k1_mpuin_bh, (unsigned long) card->mpuin);
  344. spin_lock_init(&card->mpuin->lock);
  346. /* Reset the MPU port */
  347. if (emu10k1_mpu_reset(card) < 0) {
  348. ERROR();
  349. ret = -EIO;
  350. goto err_out3;
  351. }
  353. #ifdef EMU10K1_SEQUENCER
  354. card->seq_dev = sound_alloc_mididev();
  355. if (card->seq_dev == -1)
  356. printk(KERN_WARNING "emu10k1: unable to register sequencer device!");
  357. else {
  358. std_midi_synth.midi_dev = card->seq_dev;
  359. midi_devs[card->seq_dev] = 
  360. (struct midi_operations *)
  361. kmalloc(sizeof(struct midi_operations), GFP_KERNEL);
  363. if (midi_devs[card->seq_dev] == NULL) {
  364. printk(KERN_ERR "emu10k1: unable to allocate memory!");
  365. sound_unload_mididev(card->seq_dev);
  366. card->seq_dev = -1;
  367. return 0;
  368. } else {
  369. memcpy((char *)midi_devs[card->seq_dev], 
  370. (char *)&emu10k1_midi_operations, 
  371. sizeof(struct midi_operations));
  372. midi_devs[card->seq_dev]->devc = card;
  373. sequencer_init();
  374. }
  375. }
  376. card->seq_mididev = 0;
  377. #endif
  378. return 0;
  380. err_out3:
  381. kfree(card->mpuin);
  382. err_out2:
  383. kfree(card->mpuout);
  384. err_out1:
  385. unregister_sound_midi(card->midi_dev);
  386. return ret;
  387. }
  389. static void __devinit emu10k1_midi_cleanup(struct emu10k1_card *card)
  390. {
  391. tasklet_kill(&card->mpuout->tasklet);
  392. kfree(card->mpuout);
  394. tasklet_kill(&card->mpuin->tasklet);
  395. kfree(card->mpuin);
  397. #ifdef EMU10K1_SEQUENCER
  398. if (card->seq_dev > -1) {
  399. kfree(midi_devs[card->seq_dev]);
  400. midi_devs[card->seq_dev] = NULL;
  401. sound_unload_mididev(card->seq_dev);
  402. card->seq_dev = -1;
  403. }
  404. #endif
  406. unregister_sound_midi(card->midi_dev);
  407. }
  409. static void __devinit voice_init(struct emu10k1_card *card)
  410. {
  411. int i;
  413. for (i = 0; i < NUM_G; i++)
  414. card->voicetable[i] = VOICE_USAGE_FREE;
  415. }
  417. static void __devinit timer_init(struct emu10k1_card *card)
  418. {
  419. INIT_LIST_HEAD(&card->timers);
  420. card->timer_delay = TIMER_STOPPED;
  421. card->timer_lock = SPIN_LOCK_UNLOCKED;
  422. }
  424. static void __devinit addxmgr_init(struct emu10k1_card *card)
  425. {
  426. u32 count;
  428. for (count = 0; count < MAXPAGES; count++)
  429. card->emupagetable[count] = 0;
  431. /* Mark first page as used */
  432. /* This page is reserved by the driver */
  433. card->emupagetable[0] = 0x8001;
  434. card->emupagetable[1] = MAXPAGES - 1;
  435. }
  437. static void __devinit fx_cleanup(struct patch_manager *mgr)
  438. {
  439. int i;
  440. for(i = 0; i < mgr->current_pages; i++)
  441. free_page((unsigned long) mgr->patch[i]);
  442. }
  444. static int __devinit fx_init(struct emu10k1_card *card)
  445. {
  446. struct patch_manager *mgr = &card->mgr;
  447. struct dsp_patch *patch;
  448. struct dsp_rpatch *rpatch;
  449. s32 left, right;
  450. int i;
  451. u32 pc = 0;
  452. u32 patch_n;
  454. for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
  455. mgr->ctrl_gpr[i][0] = -1;
  456. mgr->ctrl_gpr[i][1] = -1;
  457. }
  459. for (i = 0; i < 512; i++)
  460. OP(6, 0x40, 0x40, 0x40, 0x40);
  462. for (i = 0; i < 256; i++)
  463. sblive_writeptr_tag(card, 0,
  464.     FXGPREGBASE + i, 0,
  465.     TANKMEMADDRREGBASE + i, 0,
  466.     TAGLIST_END);
  468. /* !! The number bellow must equal the number of patches, currently 11 !! */
  469. mgr->current_pages = (11 + PATCHES_PER_PAGE - 1) / PATCHES_PER_PAGE;
  470. for (i = 0; i < mgr->current_pages; i++) {
  471. mgr->patch[i] = (void *)__get_free_page(GFP_KERNEL);
  472. if (mgr->patch[i] == NULL) {
  473. mgr->current_pages = i;
  474. fx_cleanup(mgr);
  475. return -ENOMEM;
  476. }
  477. memset(mgr->patch[i], 0, PAGE_SIZE);
  478. }
  480. pc = 0;
  481. patch_n = 0;
  482. //first free GPR = 0x11b
  484. /* FX volume correction and Volume control*/
  485. INPUT_PATCH_START(patch, "Pcm L vol", 0x0, 0);
  486. GET_OUTPUT_GPR(patch, 0x100, 0x0);
  487. GET_CONTROL_GPR(patch, 0x106, "Vol", 0, 0x7fffffff);
  488. GET_DYNAMIC_GPR(patch, 0x112);
  490. OP(4, 0x112, 0x40, PCM_IN_L, 0x44); //*4
  491. OP(0, 0x100, 0x040, 0x112, 0x106);  //*vol
  492. INPUT_PATCH_END(patch);
  495. INPUT_PATCH_START(patch, "Pcm R vol", 0x1, 0);
  496. GET_OUTPUT_GPR(patch, 0x101, 0x1);
  497. GET_CONTROL_GPR(patch, 0x107, "Vol", 0, 0x7fffffff);
  498. GET_DYNAMIC_GPR(patch, 0x112);
  500. OP(4, 0x112, 0x40, PCM_IN_R, 0x44); 
  501. OP(0, 0x101, 0x040, 0x112, 0x107);
  503. INPUT_PATCH_END(patch);
  506. // CD-Digital In Volume control
  507. INPUT_PATCH_START(patch, "CD-Digital Vol L", 0x12, 0);
  508. GET_OUTPUT_GPR(patch, 0x10c, 0x12);
  509. GET_CONTROL_GPR(patch, 0x10d, "Vol", 0, 0x7fffffff);
  511. OP(0, 0x10c, 0x040, SPDIF_CD_L, 0x10d);
  512. INPUT_PATCH_END(patch);
  514. INPUT_PATCH_START(patch, "CD-Digital Vol R", 0x13, 0);
  515. GET_OUTPUT_GPR(patch, 0x10e, 0x13);
  516. GET_CONTROL_GPR(patch, 0x10f, "Vol", 0, 0x7fffffff);
  518. OP(0, 0x10e, 0x040, SPDIF_CD_R, 0x10f);
  519. INPUT_PATCH_END(patch);
  521. //Volume Correction for Multi-channel Inputs
  522. INPUT_PATCH_START(patch, "Multi-Channel Gain", 0x08, 0);
  523. patch->input=patch->output=0x3F00;
  525. GET_OUTPUT_GPR(patch, 0x113, MULTI_FRONT_L);
  526. GET_OUTPUT_GPR(patch, 0x114, MULTI_FRONT_R);
  527. GET_OUTPUT_GPR(patch, 0x115, MULTI_REAR_L);
  528. GET_OUTPUT_GPR(patch, 0x116, MULTI_REAR_R);
  529. GET_OUTPUT_GPR(patch, 0x117, MULTI_CENTER);
  530. GET_OUTPUT_GPR(patch, 0x118, MULTI_LFE);
  532. OP(4, 0x113, 0x40, MULTI_FRONT_L, 0x44);
  533. OP(4, 0x114, 0x40, MULTI_FRONT_R, 0x44);
  534. OP(4, 0x115, 0x40, MULTI_REAR_L, 0x44);
  535. OP(4, 0x116, 0x40, MULTI_REAR_R, 0x44);
  536. OP(4, 0x117, 0x40, MULTI_CENTER, 0x44);
  537. OP(4, 0x118, 0x40, MULTI_LFE, 0x44);
  539. INPUT_PATCH_END(patch);
  542. //Routing patch start
  543. ROUTING_PATCH_START(rpatch, "Routing");
  544. GET_INPUT_GPR(rpatch, 0x100, 0x0);
  545. GET_INPUT_GPR(rpatch, 0x101, 0x1);
  546. GET_INPUT_GPR(rpatch, 0x10c, 0x12);
  547. GET_INPUT_GPR(rpatch, 0x10e, 0x13);
  548. GET_INPUT_GPR(rpatch, 0x113, MULTI_FRONT_L);
  549. GET_INPUT_GPR(rpatch, 0x114, MULTI_FRONT_R);
  550. GET_INPUT_GPR(rpatch, 0x115, MULTI_REAR_L);
  551. GET_INPUT_GPR(rpatch, 0x116, MULTI_REAR_R);
  552. GET_INPUT_GPR(rpatch, 0x117, MULTI_CENTER);
  553. GET_INPUT_GPR(rpatch, 0x118, MULTI_LFE);
  555. GET_DYNAMIC_GPR(rpatch, 0x102);
  556. GET_DYNAMIC_GPR(rpatch, 0x103);
  558. GET_OUTPUT_GPR(rpatch, 0x104, 0x8);
  559. GET_OUTPUT_GPR(rpatch, 0x105, 0x9);
  560. GET_OUTPUT_GPR(rpatch, 0x10a, 0x2);
  561. GET_OUTPUT_GPR(rpatch, 0x10b, 0x3);
  564. /* input buffer */
  565. OP(6, 0x102, AC97_IN_L, 0x40, 0x40);
  566. OP(6, 0x103, AC97_IN_R, 0x40, 0x40);
  569. /* Digital In + PCM + MULTI_FRONT-> AC97 out (front speakers)*/
  570. OP(6, AC97_FRONT_L, 0x100, 0x10c, 0x113);
  572. CONNECT(MULTI_FRONT_L, AC97_FRONT_L);
  573. CONNECT(PCM_IN_L, AC97_FRONT_L);
  574. CONNECT(SPDIF_CD_L, AC97_FRONT_L);
  576. OP(6, AC97_FRONT_R, 0x101, 0x10e, 0x114);
  578. CONNECT(MULTI_FRONT_R, AC97_FRONT_R);
  579. CONNECT(PCM_IN_R, AC97_FRONT_R);
  580. CONNECT(SPDIF_CD_R, AC97_FRONT_R);
  582. /* Digital In + PCM + AC97 In + PCM1 + MULTI_REAR --> Rear Channel */ 
  583. OP(6, 0x104, PCM1_IN_L, 0x100, 0x115);
  584. OP(6, 0x104, 0x104, 0x10c, 0x102);
  586. CONNECT(MULTI_REAR_L, ANALOG_REAR_L);
  587. CONNECT(AC97_IN_L, ANALOG_REAR_L);
  588. CONNECT(PCM_IN_L, ANALOG_REAR_L);
  589. CONNECT(SPDIF_CD_L, ANALOG_REAR_L);
  590. CONNECT(PCM1_IN_L, ANALOG_REAR_L);
  592. OP(6, 0x105, PCM1_IN_R, 0x101, 0x116);
  593. OP(6, 0x105, 0x105, 0x10e, 0x103);
  595. CONNECT(MULTI_REAR_R, ANALOG_REAR_R);
  596. CONNECT(AC97_IN_R, ANALOG_REAR_R);
  597. CONNECT(PCM_IN_R, ANALOG_REAR_R);
  598. CONNECT(SPDIF_CD_R, ANALOG_REAR_R);
  599. CONNECT(PCM1_IN_R, ANALOG_REAR_R);
  601. /* Digital In + PCM + AC97 In + MULTI_FRONT --> Digital out */
  602. OP(6, 0x10a, 0x100, 0x102, 0x10c);
  603. OP(6, 0x10a, 0x10a, 0x113, 0x40);
  605. CONNECT(MULTI_FRONT_L, DIGITAL_OUT_L);
  606. CONNECT(PCM_IN_L, DIGITAL_OUT_L);
  607. CONNECT(AC97_IN_L, DIGITAL_OUT_L);
  608. CONNECT(SPDIF_CD_L, DIGITAL_OUT_L);
  610. OP(6, 0x10b, 0x101, 0x103, 0x10e);
  611. OP(6, 0x10b, 0x10b, 0x114, 0x40);
  613. CONNECT(MULTI_FRONT_R, DIGITAL_OUT_R);
  614. CONNECT(PCM_IN_R, DIGITAL_OUT_R);
  615. CONNECT(AC97_IN_R, DIGITAL_OUT_R);
  616. CONNECT(SPDIF_CD_R, DIGITAL_OUT_R);
  618. /* AC97 In --> ADC Recording Buffer */
  619. OP(6, ADC_REC_L, 0x102, 0x40, 0x40);
  621. CONNECT(AC97_IN_L, ADC_REC_L);
  623. OP(6, ADC_REC_R, 0x103, 0x40, 0x40);
  625. CONNECT(AC97_IN_R, ADC_REC_R);
  628. /* fx12:Analog-Center */
  629. OP(6, ANALOG_CENTER, 0x117, 0x40, 0x40);
  630. CONNECT(MULTI_CENTER, ANALOG_CENTER);
  632. /* fx11:Analog-LFE */
  633. OP(6, ANALOG_LFE, 0x118, 0x40, 0x40);
  634. CONNECT(MULTI_LFE, ANALOG_LFE);
  636. /* fx12:Digital-Center */
  637. OP(6, DIGITAL_CENTER, 0x117, 0x40, 0x40);
  638. CONNECT(MULTI_CENTER, DIGITAL_CENTER);
  640. /* fx11:Analog-LFE */
  641. OP(6, DIGITAL_LFE, 0x118, 0x40, 0x40);
  642. CONNECT(MULTI_LFE, DIGITAL_LFE);
  644. ROUTING_PATCH_END(rpatch);
  647. // Rear volume control
  648. OUTPUT_PATCH_START(patch, "Vol Rear L", 0x8, 0);
  649. GET_INPUT_GPR(patch, 0x104, 0x8);
  650. GET_CONTROL_GPR(patch, 0x119, "Vol", 0, 0x7fffffff);
  652. OP(0, ANALOG_REAR_L, 0x040, 0x104, 0x119);
  653. OUTPUT_PATCH_END(patch);
  656. OUTPUT_PATCH_START(patch, "Vol Rear R", 0x9, 0);
  657. GET_INPUT_GPR(patch, 0x105, 0x9);
  658. GET_CONTROL_GPR(patch, 0x11a, "Vol", 0, 0x7fffffff);
  660. OP(0, ANALOG_REAR_R, 0x040, 0x105, 0x11a);
  661. OUTPUT_PATCH_END(patch);
  664. //Master volume control on front-digital
  665. OUTPUT_PATCH_START(patch, "Vol Master L", 0x2, 1);
  666. GET_INPUT_GPR(patch, 0x10a, 0x2);
  667. GET_CONTROL_GPR(patch, 0x108, "Vol", 0, 0x7fffffff);
  669. OP(0, DIGITAL_OUT_L, 0x040, 0x10a, 0x108);
  670. OUTPUT_PATCH_END(patch);
  673. OUTPUT_PATCH_START(patch, "Vol Master R", 0x3, 1);
  674. GET_INPUT_GPR(patch, 0x10b, 0x3);
  675. GET_CONTROL_GPR(patch, 0x109, "Vol", 0, 0x7fffffff);
  677. OP(0, DIGITAL_OUT_R, 0x040, 0x10b, 0x109);
  678. OUTPUT_PATCH_END(patch);
  681. /* delimiter patch */
  682. patch = PATCH(mgr, patch_n);
  683. patch->code_size = 0;
  685. sblive_writeptr(card, DBG, 0, 0);
  687. mgr->lock = SPIN_LOCK_UNLOCKED;
  690. //Master volume
  691. mgr->ctrl_gpr[SOUND_MIXER_VOLUME][0] = 8;
  692. mgr->ctrl_gpr[SOUND_MIXER_VOLUME][1] = 9;
  694. left = card->ac97.mixer_state[SOUND_MIXER_VOLUME] & 0xff;
  695. right = (card->ac97.mixer_state[SOUND_MIXER_VOLUME] >> 8) & 0xff;
  697. emu10k1_set_volume_gpr(card, 8, left, 1 << card->ac97.bit_resolution);
  698. emu10k1_set_volume_gpr(card, 9, right, 1 << card->ac97.bit_resolution);
  700. //Rear volume
  701. mgr->ctrl_gpr[ SOUND_MIXER_OGAIN ][0] = 0x19;
  702. mgr->ctrl_gpr[ SOUND_MIXER_OGAIN ][1] = 0x1a;
  704. left = right = 67;
  705. card->ac97.mixer_state[SOUND_MIXER_OGAIN] = (right << 8) | left;
  707. card->ac97.supported_mixers |= SOUND_MASK_OGAIN;
  708. card->ac97.stereo_mixers |= SOUND_MASK_OGAIN;
  710. emu10k1_set_volume_gpr(card, 0x19, left, VOL_5BIT);
  711. emu10k1_set_volume_gpr(card, 0x1a, right, VOL_5BIT);
  713. //PCM Volume
  714. mgr->ctrl_gpr[SOUND_MIXER_PCM][0] = 6;
  715. mgr->ctrl_gpr[SOUND_MIXER_PCM][1] = 7;
  717. left = card->ac97.mixer_state[SOUND_MIXER_PCM] & 0xff;
  718. right = (card->ac97.mixer_state[SOUND_MIXER_PCM] >> 8) & 0xff;
  720. emu10k1_set_volume_gpr(card, 6, left, VOL_5BIT);
  721. emu10k1_set_volume_gpr(card, 7, right, VOL_5BIT);
  723. //CD-Digital Volume
  724. mgr->ctrl_gpr[SOUND_MIXER_DIGITAL1][0] = 0xd;
  725. mgr->ctrl_gpr[SOUND_MIXER_DIGITAL1][1] = 0xf;
  727. left = right = 67;
  728. card->ac97.mixer_state[SOUND_MIXER_DIGITAL1] = (right << 8) | left; 
  730. card->ac97.supported_mixers |= SOUND_MASK_DIGITAL1;
  731. card->ac97.stereo_mixers |= SOUND_MASK_DIGITAL1;
  733. emu10k1_set_volume_gpr(card, 0xd, left, VOL_5BIT);
  734. emu10k1_set_volume_gpr(card, 0xf, right, VOL_5BIT);
  736. //hard wire the ac97's pcm, we'll do that in dsp code instead.
  737. emu10k1_ac97_write(&card->ac97, 0x18, 0x0);
  738. card->ac97_supported_mixers &= ~SOUND_MASK_PCM;
  739. card->ac97_stereo_mixers &= ~SOUND_MASK_PCM;
  741. //set Igain to 0dB by default, maybe consider hardwiring it here.
  742. emu10k1_ac97_write(&card->ac97, AC97_RECORD_GAIN, 0x0000);
  743. card->ac97.mixer_state[SOUND_MIXER_IGAIN] = 0x101; 
  745. return 0;
  746. }
  748. static int __devinit hw_init(struct emu10k1_card *card)
  749. {
  750. int nCh;
  751. u32 pagecount; /* tmp */
  752. int ret;
  754. /* Disable audio and lock cache */
  755. emu10k1_writefn0(card, HCFG, HCFG_LOCKSOUNDCACHE | HCFG_LOCKTANKCACHE_MASK | HCFG_MUTEBUTTONENABLE);
  757. /* Reset recording buffers */
  758. sblive_writeptr_tag(card, 0,
  759.     MICBS, ADCBS_BUFSIZE_NONE,
  760.     MICBA, 0,
  761.     FXBS, ADCBS_BUFSIZE_NONE,
  762.     FXBA, 0,
  763.     ADCBS, ADCBS_BUFSIZE_NONE,
  764.     ADCBA, 0,
  765.     TAGLIST_END);
  767. /* Disable channel interrupt */
  768. emu10k1_writefn0(card, INTE, 0);
  769. sblive_writeptr_tag(card, 0,
  770.     CLIEL, 0,
  771.     CLIEH, 0,
  772.     SOLEL, 0,
  773.     SOLEH, 0,
  774.     TAGLIST_END);
  776. /* Init envelope engine */
  777. for (nCh = 0; nCh < NUM_G; nCh++) {
  778. sblive_writeptr_tag(card, nCh,
  779.     DCYSUSV, 0,
  780.     IP, 0,
  781.     VTFT, 0xffff,
  782.     CVCF, 0xffff,
  783.     PTRX, 0,
  784.     //CPF, 0,
  785.     CCR, 0,
  787.     PSST, 0,
  788.     DSL, 0x10,
  789.     CCCA, 0,
  790.     Z1, 0,
  791.     Z2, 0,
  792.     FXRT, 0xd01c0000,
  794.     ATKHLDM, 0,
  795.     DCYSUSM, 0,
  796.     IFATN, 0xffff,
  797.     PEFE, 0,
  798.     FMMOD, 0,
  799.     TREMFRQ, 24, /* 1 Hz */
  800.     FM2FRQ2, 24, /* 1 Hz */
  801.     TEMPENV, 0,
  803.     /*** These are last so OFF prevents writing ***/
  804.     LFOVAL2, 0,
  805.     LFOVAL1, 0,
  806.     ATKHLDV, 0,
  807.     ENVVOL, 0,
  808.     ENVVAL, 0,
  809.                                     TAGLIST_END);
  810. sblive_writeptr(card, CPF, nCh, 0);
  811. }
  814. /*
  815.  ** Init to 0x02109204 :
  816.  ** Clock accuracy    = 0     (1000ppm)
  817.  ** Sample Rate       = 2     (48kHz)
  818.  ** Audio Channel     = 1     (Left of 2)
  819.  ** Source Number     = 0     (Unspecified)
  820.  ** Generation Status = 1     (Original for Cat Code 12)
  821.  ** Cat Code          = 12    (Digital Signal Mixer)
  822.  ** Mode              = 0     (Mode 0)
  823.  ** Emphasis          = 0     (None)
  824.  ** CP                = 1     (Copyright unasserted)
  825.  ** AN                = 0     (Digital audio)
  826.  ** P                 = 0     (Consumer)
  827.  */
  829. sblive_writeptr_tag(card, 0,
  831.     /* SPDIF0 */
  832.     SPCS0, (SPCS_CLKACCY_1000PPM | 0x002000000 |
  833.     SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC | SPCS_GENERATIONSTATUS | 0x00001200 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT),
  835.     /* SPDIF1 */
  836.     SPCS1, (SPCS_CLKACCY_1000PPM | 0x002000000 |
  837.     SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC | SPCS_GENERATIONSTATUS | 0x00001200 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT),
  839.     /* SPDIF2 & SPDIF3 */
  840.     SPCS2, (SPCS_CLKACCY_1000PPM | 0x002000000 |
  841.     SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC | SPCS_GENERATIONSTATUS | 0x00001200 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT),
  843.     TAGLIST_END);
  845. ret = fx_init(card); /* initialize effects engine */
  846. if (ret < 0)
  847. return ret;
  849. card->tankmem.size = 0;
  851. card->virtualpagetable.size = MAXPAGES * sizeof(u32);
  853. card->virtualpagetable.addr = pci_alloc_consistent(card->pci_dev, card->virtualpagetable.size, &card->virtualpagetable.dma_handle);
  854. if (card->virtualpagetable.addr == NULL) {
  855. ERROR();
  856. ret = -ENOMEM;
  857. goto err0;
  858. }
  860. card->silentpage.size = EMUPAGESIZE;
  862. card->silentpage.addr = pci_alloc_consistent(card->pci_dev, card->silentpage.size, &card->silentpage.dma_handle);
  863. if (card->silentpage.addr == NULL) {
  864. ERROR();
  865. ret = -ENOMEM;
  866. goto err1;
  867. }
  869. for (pagecount = 0; pagecount < MAXPAGES; pagecount++)
  870. ((u32 *) card->virtualpagetable.addr)[pagecount] = cpu_to_le32((card->silentpage.dma_handle * 2) | pagecount);
  872. /* Init page table & tank memory base register */
  873. sblive_writeptr_tag(card, 0,
  874.     PTB, card->virtualpagetable.dma_handle,
  875.     TCB, 0,
  876.     TCBS, 0,
  877.     TAGLIST_END);
  879. for (nCh = 0; nCh < NUM_G; nCh++) {
  880. sblive_writeptr_tag(card, nCh,
  881.     MAPA, MAP_PTI_MASK | (card->silentpage.dma_handle * 2),
  882.     MAPB, MAP_PTI_MASK | (card->silentpage.dma_handle * 2),
  883.     TAGLIST_END);
  884. }
  886. /* Hokay, now enable the AUD bit */
  887. /* Enable Audio = 1 */
  888. /* Mute Disable Audio = 0 */
  889. /* Lock Tank Memory = 1 */
  890. /* Lock Sound Memory = 0 */
  891. /* Auto Mute = 1 */
  893. if (card->model == 0x20 || card->model == 0xc400 ||
  894.   (card->model == 0x21 && card->chiprev < 6))
  895.         emu10k1_writefn0(card, HCFG, HCFG_AUDIOENABLE  | HCFG_LOCKTANKCACHE_MASK | HCFG_AUTOMUTE);
  896. else
  897. emu10k1_writefn0(card, HCFG, HCFG_AUDIOENABLE  | HCFG_LOCKTANKCACHE_MASK | HCFG_AUTOMUTE | HCFG_JOYENABLE);
  899. /* Enable Vol_Ctrl irqs */
  900. emu10k1_irq_enable(card, INTE_VOLINCRENABLE | INTE_VOLDECRENABLE | INTE_MUTEENABLE | INTE_FXDSPENABLE);
  902. /* FIXME: TOSLink detection */
  903. card->has_toslink = 0;
  905. /* Initialize digital passthrough variables */
  906. card->pt.pos_gpr = card->pt.intr_gpr = card->pt.enable_gpr = -1;
  907. card->pt.selected = 0;
  908. card->pt.state = PT_STATE_INACTIVE;
  909. card->pt.spcs_to_use = 0x01;
  910. card->pt.patch_name = "AC3pass";
  911. card->pt.intr_gpr_name = "count";
  912. card->pt.enable_gpr_name = "enable";
  913. card->pt.pos_gpr_name = "ptr";
  914. spin_lock_init(&card->pt.lock);
  915. init_waitqueue_head(&card->pt.wait);
  917. /* tmp = sblive_readfn0(card, HCFG);
  918. if (tmp & (HCFG_GPINPUT0 | HCFG_GPINPUT1)) {
  919. sblive_writefn0(card, HCFG, tmp | 0x800);
  921. udelay(512);
  923. if (tmp != (sblive_readfn0(card, HCFG) & ~0x800)) {
  924. card->has_toslink = 1;
  925. sblive_writefn0(card, HCFG, tmp);
  926. }
  927. }
  928. */
  929. return 0;
  931.   err1:
  932. pci_free_consistent(card->pci_dev, card->virtualpagetable.size, card->virtualpagetable.addr, card->virtualpagetable.dma_handle);
  933.   err0:
  934. fx_cleanup(&card->mgr);
  936. return ret;
  937. }
  939. static int __devinit emu10k1_init(struct emu10k1_card *card)
  940. {
  941. /* Init Card */
  942. if (hw_init(card) < 0)
  943. return -1;
  945. voice_init(card);
  946. timer_init(card);
  947. addxmgr_init(card);
  949. DPD(2, "  hw control register -> %#xn", emu10k1_readfn0(card, HCFG));
  951. return 0;
  952. }
  954. static void __devinit emu10k1_cleanup(struct emu10k1_card *card)
  955. {
  956. int ch;
  958. emu10k1_writefn0(card, INTE, 0);
  960. /** Shutdown the chip **/
  961. for (ch = 0; ch < NUM_G; ch++)
  962. sblive_writeptr(card, DCYSUSV, ch, 0);
  964. for (ch = 0; ch < NUM_G; ch++) {
  965. sblive_writeptr_tag(card, ch,
  966.     VTFT, 0,
  967.     CVCF, 0,
  968.     PTRX, 0,
  969.     //CPF, 0,
  970.     TAGLIST_END);
  971. sblive_writeptr(card, CPF, ch, 0);
  972. }
  974. /* Disable audio and lock cache */
  975. emu10k1_writefn0(card, HCFG, HCFG_LOCKSOUNDCACHE | HCFG_LOCKTANKCACHE_MASK | HCFG_MUTEBUTTONENABLE);
  977. sblive_writeptr_tag(card, 0,
  978.                             PTB, 0,
  980.     /* Reset recording buffers */
  981.     MICBS, ADCBS_BUFSIZE_NONE,
  982.     MICBA, 0,
  983.     FXBS, ADCBS_BUFSIZE_NONE,
  984.     FXBA, 0,
  985.     FXWC, 0,
  986.     ADCBS, ADCBS_BUFSIZE_NONE,
  987.     ADCBA, 0,
  988.     TCBS, 0,
  989.     TCB, 0,
  990.     DBG, 0x8000,
  992.     /* Disable channel interrupt */
  993.     CLIEL, 0,
  994.     CLIEH, 0,
  995.     SOLEL, 0,
  996.     SOLEH, 0,
  997.     TAGLIST_END);
  1000. pci_free_consistent(card->pci_dev, card->virtualpagetable.size, card->virtualpagetable.addr, card->virtualpagetable.dma_handle);
  1001. pci_free_consistent(card->pci_dev, card->silentpage.size, card->silentpage.addr, card->silentpage.dma_handle);
  1003. if(card->tankmem.size != 0)
  1004. pci_free_consistent(card->pci_dev, card->tankmem.size, card->tankmem.addr, card->tankmem.dma_handle);
  1006. /* release patch storage memory */
  1007. fx_cleanup(&card->mgr);
  1008. }
  1010. /* Driver initialization routine */
  1011. static int __devinit emu10k1_probe(struct pci_dev *pci_dev, const struct pci_device_id *pci_id)
  1012. {
  1013. struct emu10k1_card *card;
  1014. u32 subsysvid;
  1015. int ret;
  1017. if (pci_set_dma_mask(pci_dev, EMU10K1_DMA_MASK)) {
  1018. printk(KERN_ERR "emu10k1: architecture does not support 32bit PCI busmaster DMAn");
  1019. return -ENODEV;
  1020. }
  1022. if (pci_enable_device(pci_dev))
  1023. return -EIO;
  1025. pci_set_master(pci_dev);
  1027. if ((card = kmalloc(sizeof(struct emu10k1_card), GFP_KERNEL)) == NULL) {
  1028.                 printk(KERN_ERR "emu10k1: out of memoryn");
  1029.                 return -ENOMEM;
  1030.         }
  1031.         memset(card, 0, sizeof(struct emu10k1_card));
  1033. card->iobase = pci_resource_start(pci_dev, 0);
  1034. card->length = pci_resource_len(pci_dev, 0); 
  1036. if (request_region(card->iobase, card->length, card_names[pci_id->driver_data]) == NULL) {
  1037. printk(KERN_ERR "emu10k1: IO space in usen");
  1038. ret = -EBUSY;
  1039. goto err_region;
  1040. }
  1042. pci_set_drvdata(pci_dev, card);
  1044. card->irq = pci_dev->irq;
  1045. card->pci_dev = pci_dev;
  1047. /* Reserve IRQ Line */
  1048. if (request_irq(card->irq, emu10k1_interrupt, SA_SHIRQ, card_names[pci_id->driver_data], card)) {
  1049. printk(KERN_ERR "emu10k1: IRQ in usen");
  1050. ret = -EBUSY;
  1051. goto err_irq;
  1052. }
  1054. pci_read_config_byte(pci_dev, PCI_REVISION_ID, &card->chiprev);
  1055. pci_read_config_word(pci_dev, PCI_SUBSYSTEM_ID, &card->model);
  1057. printk(KERN_INFO "emu10k1: %s rev %d model 0x%x found, IO at 0x%04lx-0x%04lx, IRQ %dn",
  1058. card_names[pci_id->driver_data], card->chiprev, card->model, card->iobase,
  1059. card->iobase + card->length - 1, card->irq);
  1061. pci_read_config_dword(pci_dev, PCI_SUBSYSTEM_VENDOR_ID, &subsysvid);
  1062. card->isaps = (subsysvid == EMU_APS_SUBID);
  1064. spin_lock_init(&card->lock);
  1065. init_MUTEX(&card->open_sem);
  1066. card->open_mode = 0;
  1067. init_waitqueue_head(&card->open_wait);
  1069. ret = emu10k1_audio_init(card);
  1070. if(ret < 0) {
  1071.                 printk(KERN_ERR "emu10k1: cannot initialize audio devicesn");
  1072.                 goto err_audio;
  1073.         }
  1075. ret = emu10k1_mixer_init(card);
  1076. if(ret < 0) {
  1077. printk(KERN_ERR "emu10k1: cannot initialize AC97 codecn");
  1078.                 goto err_mixer;
  1079. }
  1081. ret = emu10k1_midi_init(card);
  1082. if (ret < 0) {
  1083. printk(KERN_ERR "emu10k1: cannot register midi devicen");
  1084. goto err_midi;
  1085. }
  1087. ret = emu10k1_init(card);
  1088. if (ret < 0) {
  1089. printk(KERN_ERR "emu10k1: cannot initialize devicen");
  1090. goto err_emu10k1_init;
  1091. }
  1093. if (card->isaps)
  1094. emu10k1_ecard_init(card);
  1096. list_add(&card->list, &emu10k1_devs);
  1098. return 0;
  1100. err_emu10k1_init:
  1101. emu10k1_midi_cleanup(card);
  1103. err_midi:
  1104. emu10k1_mixer_cleanup(card);
  1106. err_mixer:
  1107. emu10k1_audio_cleanup(card);
  1109. err_audio:
  1110. free_irq(card->irq, card);
  1112. err_irq:
  1113. release_region(card->iobase, card->length);
  1114. pci_set_drvdata(pci_dev, NULL);
  1116. err_region:
  1117. kfree(card);
  1119. return ret;
  1120. }
  1122. static void __devexit emu10k1_remove(struct pci_dev *pci_dev)
  1123. {
  1124. struct emu10k1_card *card = pci_get_drvdata(pci_dev);
  1126. list_del(&card->list);
  1128. emu10k1_cleanup(card);
  1129. emu10k1_midi_cleanup(card);
  1130. emu10k1_mixer_cleanup(card);
  1131. emu10k1_audio_cleanup(card);
  1132. free_irq(card->irq, card);
  1133. release_region(card->iobase, card->length);
  1134. kfree(card);
  1135. pci_set_drvdata(pci_dev, NULL);
  1136. }
  1138. MODULE_AUTHOR("Bertrand Lee, Cai Ying. (Email to: emu10k1-devel@opensource.creative.com)");
  1139. MODULE_DESCRIPTION("Creative EMU10K1 PCI Audio Driver v" DRIVER_VERSION "nCopyright (C) 1999 Creative Technology Ltd.");
  1140. MODULE_LICENSE("GPL");
  1142. static struct pci_driver emu10k1_pci_driver = {
  1143. name: "emu10k1",
  1144. id_table: emu10k1_pci_tbl,
  1145. probe: emu10k1_probe,
  1146. remove: __devexit_p(emu10k1_remove),
  1147. };
  1149. static int __init emu10k1_init_module(void)
  1150. {
  1151. printk(KERN_INFO "Creative EMU10K1 PCI Audio Driver, version " DRIVER_VERSION ", " __TIME__ " " __DATE__ "n");
  1153. return pci_module_init(&emu10k1_pci_driver);
  1154. }
  1156. static void __exit emu10k1_cleanup_module(void)
  1157. {
  1158. pci_unregister_driver(&emu10k1_pci_driver);
  1160. return;
  1161. }
  1163. module_init(emu10k1_init_module);
  1164. module_exit(emu10k1_cleanup_module);
  1166. #ifdef EMU10K1_SEQUENCER
  1168. /* in midi.c */
  1169. extern int emu10k1_seq_midi_open(int dev, int mode, 
  1170. void (*input)(int dev, unsigned char midi_byte),
  1171. void (*output)(int dev));
  1172. extern void emu10k1_seq_midi_close(int dev);
  1173. extern int emu10k1_seq_midi_out(int dev, unsigned char midi_byte);
  1174. extern int emu10k1_seq_midi_start_read(int dev);
  1175. extern int emu10k1_seq_midi_end_read(int dev);
  1176. extern void emu10k1_seq_midi_kick(int dev);
  1177. extern int emu10k1_seq_midi_buffer_status(int dev);
  1179. static struct midi_operations emu10k1_midi_operations =
  1180. {
  1181. THIS_MODULE,
  1182. {"EMU10K1 MIDI", 0, 0, SNDCARD_EMU10K1},
  1183. &std_midi_synth,
  1184. {0},
  1185. emu10k1_seq_midi_open,
  1186. emu10k1_seq_midi_close,
  1187. NULL,
  1188. emu10k1_seq_midi_out,
  1189. emu10k1_seq_midi_start_read,
  1190. emu10k1_seq_midi_end_read,
  1191. emu10k1_seq_midi_kick,
  1192. NULL,
  1193. emu10k1_seq_midi_buffer_status,
  1194. NULL
  1195. };
  1197. #endif