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