[PATCH] Last DMA_xBIT_MASK cleanups
[linux-2.6.git] / sound / oss / emu10k1 / 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.19a Added Support for Audigy Cards
82  *          Real fix for kernel with highmem support (cast dma_handle to u32).
83  *          Fix recording buffering parameters calculation.
84  *          Use unsigned long for variables in bit ops.
85  *    0.20a Fixed recording startup
86  *          Fixed timer rate setting (it's a 16-bit register)
87  *      0.21 Converted code to use pci_name() instead of accessing slot_name
88  *          directly (Eugene Teo)
89  *********************************************************************/
90
91 /* These are only included once per module */
92 #include <linux/module.h>
93 #include <linux/slab.h>
94 #include <linux/init.h>
95 #include <linux/delay.h>
96 #include <linux/proc_fs.h>
97 #include <linux/dma-mapping.h>
98
99 #include "hwaccess.h"
100 #include "8010.h"
101 #include "efxmgr.h"
102 #include "cardwo.h"
103 #include "cardwi.h"
104 #include "cardmo.h"
105 #include "cardmi.h"
106 #include "recmgr.h"
107 #include "ecard.h"
108
109
110 #ifdef EMU10K1_SEQUENCER
111 #define MIDI_SYNTH_NAME "EMU10K1 MIDI"
112 #define MIDI_SYNTH_CAPS SYNTH_CAP_INPUT
113  
114 #include "../sound_config.h"
115 #include "../midi_synth.h"
116
117 /* this should be in dev_table.h */
118 #define SNDCARD_EMU10K1 46
119 #endif
120  
121
122 /* the emu10k1 _seems_ to only supports 29 bit (512MiB) bit bus master */
123 #define EMU10K1_DMA_MASK DMA_29BIT_MASK /* DMA buffer mask for pci_alloc_consist */
124
125 #ifndef PCI_VENDOR_ID_CREATIVE
126 #define PCI_VENDOR_ID_CREATIVE 0x1102
127 #endif
128
129 #ifndef PCI_DEVICE_ID_CREATIVE_EMU10K1
130 #define PCI_DEVICE_ID_CREATIVE_EMU10K1 0x0002
131 #endif
132 #ifndef PCI_DEVICE_ID_CREATIVE_AUDIGY
133 #define PCI_DEVICE_ID_CREATIVE_AUDIGY 0x0004
134 #endif
135
136 #define EMU_APS_SUBID   0x40011102
137  
138 enum {
139         EMU10K1 = 0,
140         AUDIGY,
141 };
142
143 static char *card_names[] __devinitdata = {
144         "EMU10K1",
145         "Audigy",
146 };
147
148 static struct pci_device_id emu10k1_pci_tbl[] = {
149         {PCI_VENDOR_ID_CREATIVE, PCI_DEVICE_ID_CREATIVE_EMU10K1,
150          PCI_ANY_ID, PCI_ANY_ID, 0, 0, EMU10K1},
151         {PCI_VENDOR_ID_CREATIVE, PCI_DEVICE_ID_CREATIVE_AUDIGY,
152          PCI_ANY_ID, PCI_ANY_ID, 0, 0, AUDIGY},
153         {0,}
154 };
155
156 MODULE_DEVICE_TABLE(pci, emu10k1_pci_tbl);
157
158 /* Global var instantiation */
159
160 LIST_HEAD(emu10k1_devs);
161
162 extern struct file_operations emu10k1_audio_fops;
163 extern struct file_operations emu10k1_mixer_fops;
164 extern struct file_operations emu10k1_midi_fops;
165
166 #ifdef EMU10K1_SEQUENCER
167 static struct midi_operations emu10k1_midi_operations;
168 #endif
169
170 extern irqreturn_t emu10k1_interrupt(int, void *, struct pt_regs *s);
171
172 static int __devinit emu10k1_audio_init(struct emu10k1_card *card)
173 {
174         /* Assign default playback voice parameters */
175         if (card->is_audigy)
176                 card->mchannel_fx = 0;
177         else
178                 card->mchannel_fx = 8;
179
180
181         if (card->is_audigy) {
182                 /* mono voice */
183                 card->waveout.send_dcba[SEND_MONO] = 0xffffffff;
184                 card->waveout.send_hgfe[SEND_MONO] = 0x0000ffff;
185         
186                 /* stereo voice */
187                 /* left */
188                 card->waveout.send_dcba[SEND_LEFT] = 0x00ff00ff;
189                 card->waveout.send_hgfe[SEND_LEFT] = 0x00007f7f;        
190                 /* right */
191                 card->waveout.send_dcba[SEND_RIGHT] = 0xff00ff00;
192                 card->waveout.send_hgfe[SEND_RIGHT] = 0x00007f7f;
193
194                 card->waveout.send_routing[ROUTE_PCM] = 0x03020100; // Regular pcm
195                 card->waveout.send_routing2[ROUTE_PCM] = 0x07060504;
196
197                 card->waveout.send_routing[ROUTE_PT] = 0x3f3f3d3c; // Passthrough
198                 card->waveout.send_routing2[ROUTE_PT] = 0x3f3f3f3f;
199                 
200                 card->waveout.send_routing[ROUTE_PCM1] = 0x03020100; // Spare
201                 card->waveout.send_routing2[ROUTE_PCM1] = 0x07060404;
202                 
203         } else {
204                 /* mono voice */
205                 card->waveout.send_dcba[SEND_MONO] = 0x0000ffff;
206         
207                 /* stereo voice */
208                 /* left */
209                 card->waveout.send_dcba[SEND_LEFT] = 0x000000ff;
210                 /* right */
211                 card->waveout.send_dcba[SEND_RIGHT] = 0x0000ff00;
212
213                 card->waveout.send_routing[ROUTE_PCM] = 0x3210; // pcm
214                 card->waveout.send_routing[ROUTE_PT] = 0x3210; // passthrough
215                 card->waveout.send_routing[ROUTE_PCM1] = 0x7654; // /dev/dsp1
216         }
217
218         /* Assign default recording parameters */
219         /* FIXME */
220         if (card->is_aps)
221                 card->wavein.recsrc = WAVERECORD_FX;
222         else
223                 card->wavein.recsrc = WAVERECORD_AC97;
224
225         card->wavein.fxwc = 0x0003;
226         return 0;
227 }
228
229 static void emu10k1_audio_cleanup(struct emu10k1_card *card)
230 {
231 }
232
233 static int __devinit emu10k1_register_devices(struct emu10k1_card *card)
234 {
235         card->audio_dev = register_sound_dsp(&emu10k1_audio_fops, -1);
236         if (card->audio_dev < 0) {
237                 printk(KERN_ERR "emu10k1: cannot register first audio device!\n");
238                 goto err_dev;
239         }
240
241         card->audio_dev1 = register_sound_dsp(&emu10k1_audio_fops, -1);
242         if (card->audio_dev1 < 0) {
243                 printk(KERN_ERR "emu10k1: cannot register second audio device!\n");
244                 goto err_dev1;
245         }
246
247         card->ac97->dev_mixer = register_sound_mixer(&emu10k1_mixer_fops, -1);
248         if (card->ac97->dev_mixer < 0) {
249                 printk(KERN_ERR "emu10k1: cannot register mixer device\n");
250                 goto err_mixer;
251         }
252
253         card->midi_dev = register_sound_midi(&emu10k1_midi_fops, -1);
254         if (card->midi_dev < 0) {
255                 printk(KERN_ERR "emu10k1: cannot register midi device!\n");
256                 goto err_midi;
257         }
258
259 #ifdef EMU10K1_SEQUENCER
260         card->seq_dev = sound_alloc_mididev();
261         if (card->seq_dev == -1)
262                 printk(KERN_WARNING "emu10k1: unable to register sequencer device!");
263         else {
264                 std_midi_synth.midi_dev = card->seq_dev;
265                 midi_devs[card->seq_dev] = 
266                         (struct midi_operations *)
267                         kmalloc(sizeof(struct midi_operations), GFP_KERNEL);
268
269                 if (midi_devs[card->seq_dev] == NULL) {
270                         printk(KERN_ERR "emu10k1: unable to allocate memory!");
271                         sound_unload_mididev(card->seq_dev);
272                         card->seq_dev = -1;
273                         /* return without error */
274                 } else {
275                         memcpy((char *)midi_devs[card->seq_dev], 
276                                 (char *)&emu10k1_midi_operations, 
277                                 sizeof(struct midi_operations));
278                         midi_devs[card->seq_dev]->devc = card;
279                         sequencer_init();
280                         card->seq_mididev = NULL;
281                 }
282         }
283 #endif
284         return 0;
285
286 err_midi:
287         unregister_sound_mixer(card->ac97->dev_mixer);
288 err_mixer:
289         unregister_sound_dsp(card->audio_dev);
290 err_dev1:
291         unregister_sound_dsp(card->audio_dev);
292 err_dev:
293         return -ENODEV;
294 }
295
296 static void emu10k1_unregister_devices(struct emu10k1_card *card)
297 {
298 #ifdef EMU10K1_SEQUENCER
299         if (card->seq_dev > -1) {
300                 kfree(midi_devs[card->seq_dev]);
301                 midi_devs[card->seq_dev] = NULL;
302                 sound_unload_mididev(card->seq_dev);
303                 card->seq_dev = -1;
304         }
305 #endif
306
307         unregister_sound_midi(card->midi_dev);
308         unregister_sound_mixer(card->ac97->dev_mixer);
309         unregister_sound_dsp(card->audio_dev1);
310         unregister_sound_dsp(card->audio_dev);
311 }
312
313 static int emu10k1_info_proc (char *page, char **start, off_t off,
314                               int count, int *eof, void *data)
315 {
316         struct emu10k1_card *card = data;
317         int len = 0;
318         
319         if (card == NULL)
320                 return -ENODEV;
321
322         len += sprintf (page + len, "Driver Version : %s\n", DRIVER_VERSION);
323         len += sprintf (page + len, "Card type      : %s\n", card->is_aps ? "Aps" : (card->is_audigy ? "Audigy" : "Emu10k1"));
324         len += sprintf (page + len, "Revision       : %d\n", card->chiprev);
325         len += sprintf (page + len, "Model          : %#06x\n", card->model);
326         len += sprintf (page + len, "IO             : %#06lx-%#06lx\n", card->iobase, card->iobase + card->length - 1);
327         len += sprintf (page + len, "IRQ            : %d\n\n", card->irq);
328         
329         len += sprintf (page + len, "Registered /dev Entries:\n");
330         len += sprintf (page + len, "/dev/dsp%d\n", card->audio_dev / 16);
331         len += sprintf (page + len, "/dev/dsp%d\n", card->audio_dev1 / 16);
332         len += sprintf (page + len, "/dev/mixer%d\n", card->ac97->dev_mixer / 16);
333         len += sprintf (page + len, "/dev/midi%d\n", card->midi_dev / 16);
334
335 #ifdef EMU10K1_SEQUENCER
336         len += sprintf (page + len, "/dev/sequencer\n");
337 #endif
338
339         return len;
340 }
341
342 static int __devinit emu10k1_proc_init(struct emu10k1_card *card)
343 {
344         char s[48];
345
346         if (!proc_mkdir ("driver/emu10k1", NULL)) {
347                 printk(KERN_ERR "emu10k1: unable to create proc directory driver/emu10k1\n");
348                 goto err_out;
349         }
350
351         sprintf(s, "driver/emu10k1/%s", pci_name(card->pci_dev));
352         if (!proc_mkdir (s, NULL)) {
353                 printk(KERN_ERR "emu10k1: unable to create proc directory %s\n", s);
354                 goto err_emu10k1_proc;
355         }
356
357         sprintf(s, "driver/emu10k1/%s/info", pci_name(card->pci_dev));
358         if (!create_proc_read_entry (s, 0, NULL, emu10k1_info_proc, card)) {
359                 printk(KERN_ERR "emu10k1: unable to create proc entry %s\n", s);
360                 goto err_dev_proc;
361         }
362
363         if (!card->is_aps) {
364                 sprintf(s, "driver/emu10k1/%s/ac97", pci_name(card->pci_dev));
365                 if (!create_proc_read_entry (s, 0, NULL, ac97_read_proc, card->ac97)) {
366                         printk(KERN_ERR "emu10k1: unable to create proc entry %s\n", s);
367                         goto err_proc_ac97;
368                 }
369         }
370
371         return 0;
372
373 err_proc_ac97:
374         sprintf(s, "driver/emu10k1/%s/info", pci_name(card->pci_dev));
375         remove_proc_entry(s, NULL);
376
377 err_dev_proc:
378         sprintf(s, "driver/emu10k1/%s", pci_name(card->pci_dev));
379         remove_proc_entry(s, NULL);
380
381 err_emu10k1_proc:
382         remove_proc_entry("driver/emu10k1", NULL);
383
384 err_out:
385         return -EIO;
386 }
387
388 static void emu10k1_proc_cleanup(struct emu10k1_card *card)
389 {
390         char s[48];
391
392         if (!card->is_aps) {
393                 sprintf(s, "driver/emu10k1/%s/ac97", pci_name(card->pci_dev));
394                 remove_proc_entry(s, NULL);
395         }
396
397         sprintf(s, "driver/emu10k1/%s/info", pci_name(card->pci_dev));
398         remove_proc_entry(s, NULL);
399
400         sprintf(s, "driver/emu10k1/%s", pci_name(card->pci_dev));
401         remove_proc_entry(s, NULL);
402                 
403         remove_proc_entry("driver/emu10k1", NULL);
404 }
405
406 static int __devinit emu10k1_mixer_init(struct emu10k1_card *card)
407 {
408         struct ac97_codec *codec  = ac97_alloc_codec();
409         
410         if(codec == NULL)
411         {
412                 printk(KERN_ERR "emu10k1: cannot allocate mixer\n");
413                 return -EIO;
414         }
415         card->ac97 = codec;
416         card->ac97->private_data = card;
417
418         if (!card->is_aps) {
419                 card->ac97->id = 0;
420                 card->ac97->codec_read = emu10k1_ac97_read;
421                 card->ac97->codec_write = emu10k1_ac97_write;
422
423                 if (ac97_probe_codec (card->ac97) == 0) {
424                         printk(KERN_ERR "emu10k1: unable to probe AC97 codec\n");
425                         goto err_out;
426                 }
427                 /* 5.1: Enable the additional AC97 Slots and unmute extra channels on AC97 codec */
428                 if (codec->codec_read(codec, AC97_EXTENDED_ID) & 0x0080){
429                         printk(KERN_INFO "emu10k1: SBLive! 5.1 card detected\n"); 
430                         sblive_writeptr(card, AC97SLOT, 0, AC97SLOT_CNTR | AC97SLOT_LFE);
431                         codec->codec_write(codec, AC97_SURROUND_MASTER, 0x0);
432                 }
433
434                 // Force 5bit:              
435                 //card->ac97->bit_resolution=5;
436
437                 /* these will store the original values and never be modified */
438                 card->ac97_supported_mixers = card->ac97->supported_mixers;
439                 card->ac97_stereo_mixers = card->ac97->stereo_mixers;
440         }
441
442         return 0;
443
444  err_out:
445         ac97_release_codec(card->ac97);
446         return -EIO;
447 }
448
449 static void emu10k1_mixer_cleanup(struct emu10k1_card *card)
450 {
451         ac97_release_codec(card->ac97);
452 }
453
454 static int __devinit emu10k1_midi_init(struct emu10k1_card *card)
455 {
456         int ret;
457
458         card->mpuout = kmalloc(sizeof(struct emu10k1_mpuout), GFP_KERNEL);
459         if (card->mpuout == NULL) {
460                 printk(KERN_WARNING "emu10k1: Unable to allocate emu10k1_mpuout: out of memory\n");
461                 ret = -ENOMEM;
462                 goto err_out1;
463         }
464
465         memset(card->mpuout, 0, sizeof(struct emu10k1_mpuout));
466
467         card->mpuout->intr = 1;
468         card->mpuout->status = FLAGS_AVAILABLE;
469         card->mpuout->state = CARDMIDIOUT_STATE_DEFAULT;
470
471         tasklet_init(&card->mpuout->tasklet, emu10k1_mpuout_bh, (unsigned long) card);
472
473         spin_lock_init(&card->mpuout->lock);
474
475         card->mpuin = kmalloc(sizeof(struct emu10k1_mpuin), GFP_KERNEL);
476         if (card->mpuin == NULL) {
477                 printk(KERN_WARNING "emu10k1: Unable to allocate emu10k1_mpuin: out of memory\n");
478                 ret = -ENOMEM;
479                 goto err_out2;
480         }
481
482         memset(card->mpuin, 0, sizeof(struct emu10k1_mpuin));
483
484         card->mpuin->status = FLAGS_AVAILABLE;
485
486         tasklet_init(&card->mpuin->tasklet, emu10k1_mpuin_bh, (unsigned long) card->mpuin);
487
488         spin_lock_init(&card->mpuin->lock);
489
490         /* Reset the MPU port */
491         if (emu10k1_mpu_reset(card) < 0) {
492                 ERROR();
493                 ret = -EIO;
494                 goto err_out3;
495         }
496
497         return 0;
498
499 err_out3:
500         kfree(card->mpuin);
501 err_out2:
502         kfree(card->mpuout);
503 err_out1:
504         return ret;
505 }
506
507 static void emu10k1_midi_cleanup(struct emu10k1_card *card)
508 {
509         tasklet_kill(&card->mpuout->tasklet);
510         kfree(card->mpuout);
511
512         tasklet_kill(&card->mpuin->tasklet);
513         kfree(card->mpuin);
514 }
515
516 static void __devinit voice_init(struct emu10k1_card *card)
517 {
518         int i;
519
520         for (i = 0; i < NUM_G; i++)
521                 card->voicetable[i] = VOICE_USAGE_FREE;
522 }
523
524 static void __devinit timer_init(struct emu10k1_card *card)
525 {
526         INIT_LIST_HEAD(&card->timers);
527         card->timer_delay = TIMER_STOPPED;
528         spin_lock_init(&card->timer_lock);
529 }
530
531 static void __devinit addxmgr_init(struct emu10k1_card *card)
532 {
533         u32 count;
534
535         for (count = 0; count < MAXPAGES; count++)
536                 card->emupagetable[count] = 0;
537
538         /* Mark first page as used */
539         /* This page is reserved by the driver */
540         card->emupagetable[0] = 0x8001;
541         card->emupagetable[1] = MAXPAGES - 1;
542 }
543
544 static void fx_cleanup(struct patch_manager *mgr)
545 {
546         int i;
547         for(i = 0; i < mgr->current_pages; i++)
548                 free_page((unsigned long) mgr->patch[i]);
549 }
550
551 static int __devinit fx_init(struct emu10k1_card *card)
552 {
553         struct patch_manager *mgr = &card->mgr;
554         struct dsp_patch *patch;
555         struct dsp_rpatch *rpatch;
556         s32 left, right;
557         int i;
558         u32 pc = 0;
559         u32 patch_n=0;
560         struct emu_efx_info_t emu_efx_info[2]=
561                 {{ 20, 10, 0x400, 0x100, 0x20 },
562                  { 24, 12, 0x600, 0x400, 0x60 },
563                 }; 
564                         
565
566         for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
567                 mgr->ctrl_gpr[i][0] = -1;
568                 mgr->ctrl_gpr[i][1] = -1;
569         }
570
571
572         if (card->is_audigy)
573                 mgr->current_pages = (2 + PATCHES_PER_PAGE - 1) / PATCHES_PER_PAGE;
574         else
575                 /* !! The number below must equal the number of patches, currently 11 !! */
576                 mgr->current_pages = (11 + PATCHES_PER_PAGE - 1) / PATCHES_PER_PAGE;
577         
578         for (i = 0; i < mgr->current_pages; i++) {
579                 mgr->patch[i] = (void *)__get_free_page(GFP_KERNEL);
580                 if (mgr->patch[i] == NULL) {
581                         mgr->current_pages = i;
582                         fx_cleanup(mgr);
583                         return -ENOMEM;
584                 }
585                 memset(mgr->patch[i], 0, PAGE_SIZE);
586         }
587
588         if (card->is_audigy) {
589                 for (i = 0; i < 1024; i++)
590                         OP(0xf, 0x0c0, 0x0c0, 0x0cf, 0x0c0);
591
592                 for (i = 0; i < 512 ; i++)
593                         sblive_writeptr(card, A_GPR_BASE+i,0,0);
594
595                 pc=0;
596
597                 //Pcm input volume
598                 OP(0, 0x402, 0x0c0, 0x406, 0x000);
599                 OP(0, 0x403, 0x0c0, 0x407, 0x001);
600
601                 //CD-Digital input Volume
602                 OP(0, 0x404, 0x0c0, 0x40d, 0x42);
603                 OP(0, 0x405, 0x0c0, 0x40f, 0x43);
604
605                 // CD + PCM 
606                 OP(6, 0x400, 0x0c0, 0x402, 0x404);
607                 OP(6, 0x401, 0x0c0, 0x403, 0x405);
608                 
609                 // Front Output + Master Volume
610                 OP(0, 0x68, 0x0c0, 0x408, 0x400);
611                 OP(0, 0x69, 0x0c0, 0x409, 0x401);
612
613                 // Add-in analog inputs for other speakers
614                 OP(6, 0x400, 0x40, 0x400, 0xc0);
615                 OP(6, 0x401, 0x41, 0x401, 0xc0);
616
617                 // Digital Front + Master Volume
618                 OP(0, 0x60, 0x0c0, 0x408, 0x400);
619                 OP(0, 0x61, 0x0c0, 0x409, 0x401);
620
621                 // Rear Output + Rear Volume
622                 OP(0, 0x06e, 0x0c0, 0x419, 0x400);
623                 OP(0, 0x06f, 0x0c0, 0x41a, 0x401);              
624
625                 // Digital Rear Output + Rear Volume
626                 OP(0, 0x066, 0x0c0, 0x419, 0x400);
627                 OP(0, 0x067, 0x0c0, 0x41a, 0x401);              
628
629                 // Audigy Drive, Headphone out
630                 OP(6, 0x64, 0x0c0, 0x0c0, 0x400);
631                 OP(6, 0x65, 0x0c0, 0x0c0, 0x401);
632
633                 // ac97 Recording
634                 OP(6, 0x76, 0x0c0, 0x0c0, 0x40);
635                 OP(6, 0x77, 0x0c0, 0x0c0, 0x41);
636                 
637                 // Center = sub = Left/2 + Right/2
638                 OP(0xe, 0x400, 0x401, 0xcd, 0x400);
639
640                 // center/sub  Volume (master)
641                 OP(0, 0x06a, 0x0c0, 0x408, 0x400);
642                 OP(0, 0x06b, 0x0c0, 0x409, 0x400);
643
644                 // Digital center/sub  Volume (master)
645                 OP(0, 0x062, 0x0c0, 0x408, 0x400);
646                 OP(0, 0x063, 0x0c0, 0x409, 0x400);
647
648                 ROUTING_PATCH_START(rpatch, "Routing");
649                 ROUTING_PATCH_END(rpatch);
650
651                 /* delimiter patch */
652                 patch = PATCH(mgr, patch_n);
653                 patch->code_size = 0;
654
655         
656                 sblive_writeptr(card, 0x53, 0, 0);
657         } else {
658                 for (i = 0; i < 512 ; i++)
659                         OP(6, 0x40, 0x40, 0x40, 0x40);
660
661                 for (i = 0; i < 256; i++)
662                         sblive_writeptr_tag(card, 0,
663                                             FXGPREGBASE + i, 0,
664                                             TANKMEMADDRREGBASE + i, 0,
665                                             TAGLIST_END);
666
667                 
668                 pc = 0;
669
670                 //first free GPR = 0x11b
671         
672                 
673                 /* FX volume correction and Volume control*/
674                 INPUT_PATCH_START(patch, "Pcm L vol", 0x0, 0);
675                 GET_OUTPUT_GPR(patch, 0x100, 0x0);
676                 GET_CONTROL_GPR(patch, 0x106, "Vol", 0, 0x7fffffff);
677                 GET_DYNAMIC_GPR(patch, 0x112);
678
679                 OP(4, 0x112, 0x40, PCM_IN_L, 0x44); //*4        
680                 OP(0, 0x100, 0x040, 0x112, 0x106);  //*vol      
681                 INPUT_PATCH_END(patch);
682
683
684                 INPUT_PATCH_START(patch, "Pcm R vol", 0x1, 0);
685                 GET_OUTPUT_GPR(patch, 0x101, 0x1);
686                 GET_CONTROL_GPR(patch, 0x107, "Vol", 0, 0x7fffffff);
687                 GET_DYNAMIC_GPR(patch, 0x112);
688
689                 OP(4, 0x112, 0x40, PCM_IN_R, 0x44); 
690                 OP(0, 0x101, 0x040, 0x112, 0x107);
691
692                 INPUT_PATCH_END(patch);
693
694
695                 // CD-Digital In Volume control 
696                 INPUT_PATCH_START(patch, "CD-Digital Vol L", 0x12, 0);
697                 GET_OUTPUT_GPR(patch, 0x10c, 0x12);
698                 GET_CONTROL_GPR(patch, 0x10d, "Vol", 0, 0x7fffffff);
699
700                 OP(0, 0x10c, 0x040, SPDIF_CD_L, 0x10d);
701                 INPUT_PATCH_END(patch);
702
703                 INPUT_PATCH_START(patch, "CD-Digital Vol R", 0x13, 0);
704                 GET_OUTPUT_GPR(patch, 0x10e, 0x13);
705                 GET_CONTROL_GPR(patch, 0x10f, "Vol", 0, 0x7fffffff);
706
707                 OP(0, 0x10e, 0x040, SPDIF_CD_R, 0x10f);
708                 INPUT_PATCH_END(patch);
709
710                 //Volume Correction for Multi-channel Inputs    
711                 INPUT_PATCH_START(patch, "Multi-Channel Gain", 0x08, 0);
712                 patch->input=patch->output=0x3F00;
713
714                 GET_OUTPUT_GPR(patch, 0x113, MULTI_FRONT_L);
715                 GET_OUTPUT_GPR(patch, 0x114, MULTI_FRONT_R);
716                 GET_OUTPUT_GPR(patch, 0x115, MULTI_REAR_L);
717                 GET_OUTPUT_GPR(patch, 0x116, MULTI_REAR_R);
718                 GET_OUTPUT_GPR(patch, 0x117, MULTI_CENTER);
719                 GET_OUTPUT_GPR(patch, 0x118, MULTI_LFE);
720
721                 OP(4, 0x113, 0x40, MULTI_FRONT_L, 0x44);
722                 OP(4, 0x114, 0x40, MULTI_FRONT_R, 0x44);
723                 OP(4, 0x115, 0x40, MULTI_REAR_L, 0x44);
724                 OP(4, 0x116, 0x40, MULTI_REAR_R, 0x44);
725                 OP(4, 0x117, 0x40, MULTI_CENTER, 0x44);
726                 OP(4, 0x118, 0x40, MULTI_LFE, 0x44);
727         
728                 INPUT_PATCH_END(patch);
729
730
731                 //Routing patch start   
732                 ROUTING_PATCH_START(rpatch, "Routing");
733                 GET_INPUT_GPR(rpatch, 0x100, 0x0);
734                 GET_INPUT_GPR(rpatch, 0x101, 0x1);
735                 GET_INPUT_GPR(rpatch, 0x10c, 0x12);
736                 GET_INPUT_GPR(rpatch, 0x10e, 0x13);
737                 GET_INPUT_GPR(rpatch, 0x113, MULTI_FRONT_L);
738                 GET_INPUT_GPR(rpatch, 0x114, MULTI_FRONT_R);
739                 GET_INPUT_GPR(rpatch, 0x115, MULTI_REAR_L);
740                 GET_INPUT_GPR(rpatch, 0x116, MULTI_REAR_R);
741                 GET_INPUT_GPR(rpatch, 0x117, MULTI_CENTER);
742                 GET_INPUT_GPR(rpatch, 0x118, MULTI_LFE);
743
744                 GET_DYNAMIC_GPR(rpatch, 0x102);
745                 GET_DYNAMIC_GPR(rpatch, 0x103);
746
747                 GET_OUTPUT_GPR(rpatch, 0x104, 0x8);
748                 GET_OUTPUT_GPR(rpatch, 0x105, 0x9);
749                 GET_OUTPUT_GPR(rpatch, 0x10a, 0x2);
750                 GET_OUTPUT_GPR(rpatch, 0x10b, 0x3);
751                 
752                 
753                 /* input buffer */
754                 OP(6, 0x102, AC97_IN_L, 0x40, 0x40);
755                 OP(6, 0x103, AC97_IN_R, 0x40, 0x40);
756
757
758                 /* Digital In + PCM + MULTI_FRONT-> AC97 out (front speakers)*/
759                 OP(6, AC97_FRONT_L, 0x100, 0x10c, 0x113);
760
761                 CONNECT(MULTI_FRONT_L, AC97_FRONT_L);
762                 CONNECT(PCM_IN_L, AC97_FRONT_L);
763                 CONNECT(SPDIF_CD_L, AC97_FRONT_L);
764
765                 OP(6, AC97_FRONT_R, 0x101, 0x10e, 0x114);
766
767                 CONNECT(MULTI_FRONT_R, AC97_FRONT_R);
768                 CONNECT(PCM_IN_R, AC97_FRONT_R);
769                 CONNECT(SPDIF_CD_R, AC97_FRONT_R);
770
771                 /* Digital In + PCM + AC97 In + PCM1 + MULTI_REAR --> Rear Channel */ 
772                 OP(6, 0x104, PCM1_IN_L, 0x100, 0x115);
773                 OP(6, 0x104, 0x104, 0x10c, 0x102);
774
775                 CONNECT(MULTI_REAR_L, ANALOG_REAR_L);
776                 CONNECT(AC97_IN_L, ANALOG_REAR_L);
777                 CONNECT(PCM_IN_L, ANALOG_REAR_L);
778                 CONNECT(SPDIF_CD_L, ANALOG_REAR_L);
779                 CONNECT(PCM1_IN_L, ANALOG_REAR_L);
780
781                 OP(6, 0x105, PCM1_IN_R, 0x101, 0x116);
782                 OP(6, 0x105, 0x105, 0x10e, 0x103);
783
784                 CONNECT(MULTI_REAR_R, ANALOG_REAR_R);
785                 CONNECT(AC97_IN_R, ANALOG_REAR_R);
786                 CONNECT(PCM_IN_R, ANALOG_REAR_R);
787                 CONNECT(SPDIF_CD_R, ANALOG_REAR_R);
788                 CONNECT(PCM1_IN_R, ANALOG_REAR_R);
789
790                 /* Digital In + PCM + AC97 In + MULTI_FRONT --> Digital out */
791                 OP(6, 0x10b, 0x100, 0x102, 0x10c);
792                 OP(6, 0x10b, 0x10b, 0x113, 0x40);
793
794                 CONNECT(MULTI_FRONT_L, DIGITAL_OUT_L);
795                 CONNECT(PCM_IN_L, DIGITAL_OUT_L);
796                 CONNECT(AC97_IN_L, DIGITAL_OUT_L);
797                 CONNECT(SPDIF_CD_L, DIGITAL_OUT_L);
798
799                 OP(6, 0x10a, 0x101, 0x103, 0x10e);
800                 OP(6, 0x10b, 0x10b, 0x114, 0x40);
801
802                 CONNECT(MULTI_FRONT_R, DIGITAL_OUT_R);
803                 CONNECT(PCM_IN_R, DIGITAL_OUT_R);
804                 CONNECT(AC97_IN_R, DIGITAL_OUT_R);
805                 CONNECT(SPDIF_CD_R, DIGITAL_OUT_R);
806
807                 /* AC97 In --> ADC Recording Buffer */
808                 OP(6, ADC_REC_L, 0x102, 0x40, 0x40);
809
810                 CONNECT(AC97_IN_L, ADC_REC_L);
811
812                 OP(6, ADC_REC_R, 0x103, 0x40, 0x40);
813
814                 CONNECT(AC97_IN_R, ADC_REC_R);
815
816
817                 /* fx12:Analog-Center */
818                 OP(6, ANALOG_CENTER, 0x117, 0x40, 0x40);
819                 CONNECT(MULTI_CENTER, ANALOG_CENTER);
820
821                 /* fx11:Analog-LFE */
822                 OP(6, ANALOG_LFE, 0x118, 0x40, 0x40);
823                 CONNECT(MULTI_LFE, ANALOG_LFE);
824
825                 /* fx12:Digital-Center */
826                 OP(6, DIGITAL_CENTER, 0x117, 0x40, 0x40);
827                 CONNECT(MULTI_CENTER, DIGITAL_CENTER);
828                 
829                 /* fx11:Analog-LFE */
830                 OP(6, DIGITAL_LFE, 0x118, 0x40, 0x40);
831                 CONNECT(MULTI_LFE, DIGITAL_LFE);
832         
833                 ROUTING_PATCH_END(rpatch);
834
835
836                 // Rear volume control  
837                 OUTPUT_PATCH_START(patch, "Vol Rear L", 0x8, 0);
838                 GET_INPUT_GPR(patch, 0x104, 0x8);
839                 GET_CONTROL_GPR(patch, 0x119, "Vol", 0, 0x7fffffff);
840
841                 OP(0, ANALOG_REAR_L, 0x040, 0x104, 0x119);
842                 OUTPUT_PATCH_END(patch);
843
844                 OUTPUT_PATCH_START(patch, "Vol Rear R", 0x9, 0);
845                 GET_INPUT_GPR(patch, 0x105, 0x9);
846                 GET_CONTROL_GPR(patch, 0x11a, "Vol", 0, 0x7fffffff);
847
848                 OP(0, ANALOG_REAR_R, 0x040, 0x105, 0x11a);
849                 OUTPUT_PATCH_END(patch);
850
851
852                 //Master volume control on front-digital        
853                 OUTPUT_PATCH_START(patch, "Vol Master L", 0x2, 1);
854                 GET_INPUT_GPR(patch, 0x10a, 0x2);
855                 GET_CONTROL_GPR(patch, 0x108, "Vol", 0, 0x7fffffff);
856
857                 OP(0, DIGITAL_OUT_L, 0x040, 0x10a, 0x108);
858                 OUTPUT_PATCH_END(patch);
859
860
861                 OUTPUT_PATCH_START(patch, "Vol Master R", 0x3, 1);
862                 GET_INPUT_GPR(patch, 0x10b, 0x3);
863                 GET_CONTROL_GPR(patch, 0x109, "Vol", 0, 0x7fffffff);
864
865                 OP(0, DIGITAL_OUT_R, 0x040, 0x10b, 0x109);
866                 OUTPUT_PATCH_END(patch);
867
868
869                 /* delimiter patch */
870                 patch = PATCH(mgr, patch_n);
871                 patch->code_size = 0;
872
873         
874                 sblive_writeptr(card, DBG, 0, 0);
875         }
876
877         spin_lock_init(&mgr->lock);
878
879         // Set up Volume controls, try to keep this the same for both Audigy and Live
880
881         //Master volume
882         mgr->ctrl_gpr[SOUND_MIXER_VOLUME][0] = 8;
883         mgr->ctrl_gpr[SOUND_MIXER_VOLUME][1] = 9;
884
885         left = card->ac97->mixer_state[SOUND_MIXER_VOLUME] & 0xff;
886         right = (card->ac97->mixer_state[SOUND_MIXER_VOLUME] >> 8) & 0xff;
887
888         emu10k1_set_volume_gpr(card, 8, left, 1 << card->ac97->bit_resolution);
889         emu10k1_set_volume_gpr(card, 9, right, 1 << card->ac97->bit_resolution);
890
891         //Rear volume
892         mgr->ctrl_gpr[ SOUND_MIXER_OGAIN ][0] = 0x19;
893         mgr->ctrl_gpr[ SOUND_MIXER_OGAIN ][1] = 0x1a;
894
895         left = right = 67;
896         card->ac97->mixer_state[SOUND_MIXER_OGAIN] = (right << 8) | left;
897
898         card->ac97->supported_mixers |= SOUND_MASK_OGAIN;
899         card->ac97->stereo_mixers |= SOUND_MASK_OGAIN;
900
901         emu10k1_set_volume_gpr(card, 0x19, left, VOL_5BIT);
902         emu10k1_set_volume_gpr(card, 0x1a, right, VOL_5BIT);
903
904         //PCM Volume
905         mgr->ctrl_gpr[SOUND_MIXER_PCM][0] = 6;
906         mgr->ctrl_gpr[SOUND_MIXER_PCM][1] = 7;
907
908         left = card->ac97->mixer_state[SOUND_MIXER_PCM] & 0xff;
909         right = (card->ac97->mixer_state[SOUND_MIXER_PCM] >> 8) & 0xff;
910
911         emu10k1_set_volume_gpr(card, 6, left, VOL_5BIT);
912         emu10k1_set_volume_gpr(card, 7, right, VOL_5BIT);
913
914         //CD-Digital Volume
915         mgr->ctrl_gpr[SOUND_MIXER_DIGITAL1][0] = 0xd;
916         mgr->ctrl_gpr[SOUND_MIXER_DIGITAL1][1] = 0xf;
917
918         left = right = 67;
919         card->ac97->mixer_state[SOUND_MIXER_DIGITAL1] = (right << 8) | left; 
920
921         card->ac97->supported_mixers |= SOUND_MASK_DIGITAL1;
922         card->ac97->stereo_mixers |= SOUND_MASK_DIGITAL1;
923
924         emu10k1_set_volume_gpr(card, 0xd, left, VOL_5BIT);
925         emu10k1_set_volume_gpr(card, 0xf, right, VOL_5BIT);
926
927
928         //hard wire the ac97's pcm, pcm volume is done above using dsp code.
929         if (card->is_audigy)
930                 //for Audigy, we mute it and use the philips 6 channel DAC instead
931                 emu10k1_ac97_write(card->ac97, 0x18, 0x8000);
932         else
933                 //For the Live we hardwire it to full volume
934                 emu10k1_ac97_write(card->ac97, 0x18, 0x0);
935
936         //remove it from the ac97_codec's control
937         card->ac97_supported_mixers &= ~SOUND_MASK_PCM;
938         card->ac97_stereo_mixers &= ~SOUND_MASK_PCM;
939
940         //set Igain to 0dB by default, maybe consider hardwiring it here.
941         emu10k1_ac97_write(card->ac97, AC97_RECORD_GAIN, 0x0000);
942         card->ac97->mixer_state[SOUND_MIXER_IGAIN] = 0x101; 
943
944         return 0;
945 }
946
947 static int __devinit hw_init(struct emu10k1_card *card)
948 {
949         int nCh;
950         u32 pagecount; /* tmp */
951         int ret;
952
953         /* Disable audio and lock cache */
954         emu10k1_writefn0(card, HCFG, HCFG_LOCKSOUNDCACHE | HCFG_LOCKTANKCACHE_MASK | HCFG_MUTEBUTTONENABLE);
955
956         /* Reset recording buffers */
957         sblive_writeptr_tag(card, 0,
958                             MICBS, ADCBS_BUFSIZE_NONE,
959                             MICBA, 0,
960                             FXBS, ADCBS_BUFSIZE_NONE,
961                             FXBA, 0,
962                             ADCBS, ADCBS_BUFSIZE_NONE,
963                             ADCBA, 0,
964                             TAGLIST_END);
965
966         /* Disable channel interrupt */
967         emu10k1_writefn0(card, INTE, 0);
968         sblive_writeptr_tag(card, 0,
969                             CLIEL, 0,
970                             CLIEH, 0,
971                             SOLEL, 0,
972                             SOLEH, 0,
973                             TAGLIST_END);
974
975         if (card->is_audigy) {
976                 sblive_writeptr_tag(card,0,
977                                     0x5e,0xf00,
978                                     0x5f,0x3,
979                                     TAGLIST_END);
980         }
981
982         /* Init envelope engine */
983         for (nCh = 0; nCh < NUM_G; nCh++) {
984                 sblive_writeptr_tag(card, nCh,
985                                     DCYSUSV, 0,
986                                     IP, 0,
987                                     VTFT, 0xffff,
988                                     CVCF, 0xffff,
989                                     PTRX, 0,
990                                     //CPF, 0,
991                                     CCR, 0,
992
993                                     PSST, 0,
994                                     DSL, 0x10,
995                                     CCCA, 0,
996                                     Z1, 0,
997                                     Z2, 0,
998                                     FXRT, 0xd01c0000,
999
1000                                     ATKHLDM, 0,
1001                                     DCYSUSM, 0,
1002                                     IFATN, 0xffff,
1003                                     PEFE, 0,
1004                                     FMMOD, 0,
1005                                     TREMFRQ, 24,        /* 1 Hz */
1006                                     FM2FRQ2, 24,        /* 1 Hz */
1007                                     TEMPENV, 0,
1008
1009                                     /*** These are last so OFF prevents writing ***/
1010                                     LFOVAL2, 0,
1011                                     LFOVAL1, 0,
1012                                     ATKHLDV, 0,
1013                                     ENVVOL, 0,
1014                                     ENVVAL, 0,
1015                                     TAGLIST_END);
1016                 sblive_writeptr(card, CPF, nCh, 0);
1017                 /*
1018                   Audigy FXRT initialization
1019                   reversed eng'd, may not be accurate.
1020                  */
1021                 if (card->is_audigy) {
1022                         sblive_writeptr_tag(card,nCh,
1023                                             0x4c,0x0,
1024                                             0x4d,0x0,
1025                                             0x4e,0x0,
1026                                             0x4f,0x0,
1027                                             A_FXRT1, 0x3f3f3f3f,
1028                                             A_FXRT2, 0x3f3f3f3f,
1029                                             A_SENDAMOUNTS, 0,
1030                                             TAGLIST_END);
1031                 }
1032         }
1033         
1034
1035         /*
1036          ** Init to 0x02109204 :
1037          ** Clock accuracy    = 0     (1000ppm)
1038          ** Sample Rate       = 2     (48kHz)
1039          ** Audio Channel     = 1     (Left of 2)
1040          ** Source Number     = 0     (Unspecified)
1041          ** Generation Status = 1     (Original for Cat Code 12)
1042          ** Cat Code          = 12    (Digital Signal Mixer)
1043          ** Mode              = 0     (Mode 0)
1044          ** Emphasis          = 0     (None)
1045          ** CP                = 1     (Copyright unasserted)
1046          ** AN                = 0     (Digital audio)
1047          ** P                 = 0     (Consumer)
1048          */
1049
1050         sblive_writeptr_tag(card, 0,
1051
1052                             /* SPDIF0 */
1053                             SPCS0, (SPCS_CLKACCY_1000PPM | 0x002000000 |
1054                                     SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC | SPCS_GENERATIONSTATUS | 0x00001200 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT),
1055
1056                             /* SPDIF1 */
1057                             SPCS1, (SPCS_CLKACCY_1000PPM | 0x002000000 |
1058                                     SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC | SPCS_GENERATIONSTATUS | 0x00001200 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT),
1059
1060                             /* SPDIF2 & SPDIF3 */
1061                             SPCS2, (SPCS_CLKACCY_1000PPM | 0x002000000 |
1062                                     SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC | SPCS_GENERATIONSTATUS | 0x00001200 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT),
1063
1064                             TAGLIST_END);
1065
1066         if (card->is_audigy && (card->chiprev == 4)) {
1067                 /* Hacks for Alice3 to work independent of haP16V driver */
1068                 u32 tmp;
1069
1070                 //Setup SRCMulti_I2S SamplingRate
1071                 tmp = sblive_readptr(card, A_SPDIF_SAMPLERATE, 0);
1072                 tmp &= 0xfffff1ff;
1073                 tmp |= (0x2<<9);
1074                 sblive_writeptr(card, A_SPDIF_SAMPLERATE, 0, tmp);
1075
1076                 /* Setup SRCSel (Enable Spdif,I2S SRCMulti) */
1077                 emu10k1_writefn0(card, 0x20, 0x600000);
1078                 emu10k1_writefn0(card, 0x24, 0x14);
1079
1080                 /* Setup SRCMulti Input Audio Enable */
1081                 emu10k1_writefn0(card, 0x20, 0x6E0000);
1082                 emu10k1_writefn0(card, 0x24, 0xFF00FF00);
1083         }
1084
1085         ret = fx_init(card);            /* initialize effects engine */
1086         if (ret < 0)
1087                 return ret;
1088
1089         card->tankmem.size = 0;
1090
1091         card->virtualpagetable.size = MAXPAGES * sizeof(u32);
1092
1093         card->virtualpagetable.addr = pci_alloc_consistent(card->pci_dev, card->virtualpagetable.size, &card->virtualpagetable.dma_handle);
1094         if (card->virtualpagetable.addr == NULL) {
1095                 ERROR();
1096                 ret = -ENOMEM;
1097                 goto err0;
1098         }
1099
1100         card->silentpage.size = EMUPAGESIZE;
1101
1102         card->silentpage.addr = pci_alloc_consistent(card->pci_dev, card->silentpage.size, &card->silentpage.dma_handle);
1103         if (card->silentpage.addr == NULL) {
1104                 ERROR();
1105                 ret = -ENOMEM;
1106                 goto err1;
1107         }
1108
1109         for (pagecount = 0; pagecount < MAXPAGES; pagecount++)
1110                 ((u32 *) card->virtualpagetable.addr)[pagecount] = cpu_to_le32(((u32) card->silentpage.dma_handle * 2) | pagecount);
1111
1112         /* Init page table & tank memory base register */
1113         sblive_writeptr_tag(card, 0,
1114                             PTB, (u32) card->virtualpagetable.dma_handle,
1115                             TCB, 0,
1116                             TCBS, 0,
1117                             TAGLIST_END);
1118
1119         for (nCh = 0; nCh < NUM_G; nCh++) {
1120                 sblive_writeptr_tag(card, nCh,
1121                                     MAPA, MAP_PTI_MASK | ((u32) card->silentpage.dma_handle * 2),
1122                                     MAPB, MAP_PTI_MASK | ((u32) card->silentpage.dma_handle * 2),
1123                                     TAGLIST_END);
1124         }
1125
1126         /* Hokay, now enable the AUD bit */
1127         /* Enable Audio = 1 */
1128         /* Mute Disable Audio = 0 */
1129         /* Lock Tank Memory = 1 */
1130         /* Lock Sound Memory = 0 */
1131         /* Auto Mute = 1 */
1132         if (card->is_audigy) {
1133                 if (card->chiprev == 4)
1134                         emu10k1_writefn0(card, HCFG, HCFG_AUDIOENABLE  | HCFG_AC3ENABLE_CDSPDIF | HCFG_AC3ENABLE_GPSPDIF | HCFG_AUTOMUTE | HCFG_JOYENABLE);
1135                 else
1136                         emu10k1_writefn0(card, HCFG, HCFG_AUDIOENABLE  | HCFG_AUTOMUTE | HCFG_JOYENABLE);
1137         } else {
1138                 if (card->model == 0x20 || card->model == 0xc400 ||
1139                  (card->model == 0x21 && card->chiprev < 6))
1140                         emu10k1_writefn0(card, HCFG, HCFG_AUDIOENABLE  | HCFG_LOCKTANKCACHE_MASK | HCFG_AUTOMUTE);
1141                 else
1142                         emu10k1_writefn0(card, HCFG, HCFG_AUDIOENABLE  | HCFG_LOCKTANKCACHE_MASK | HCFG_AUTOMUTE | HCFG_JOYENABLE);
1143         }
1144         /* Enable Vol_Ctrl irqs */
1145         emu10k1_irq_enable(card, INTE_VOLINCRENABLE | INTE_VOLDECRENABLE | INTE_MUTEENABLE | INTE_FXDSPENABLE);
1146
1147         if (card->is_audigy && (card->chiprev == 4)) {
1148                 /* Unmute Analog now.  Set GPO6 to 1 for Apollo.
1149                  * This has to be done after init ALice3 I2SOut beyond 48KHz.
1150                  * So, sequence is important. */
1151                 u32 tmp = emu10k1_readfn0(card, A_IOCFG);
1152                 tmp |= 0x0040;
1153                 emu10k1_writefn0(card, A_IOCFG, tmp);
1154         }
1155         
1156         /* FIXME: TOSLink detection */
1157         card->has_toslink = 0;
1158
1159         /* Initialize digital passthrough variables */
1160         card->pt.pos_gpr = card->pt.intr_gpr = card->pt.enable_gpr = -1;
1161         card->pt.selected = 0;
1162         card->pt.state = PT_STATE_INACTIVE;
1163         card->pt.spcs_to_use = 0x01;
1164         card->pt.patch_name = "AC3pass";
1165         card->pt.intr_gpr_name = "count";
1166         card->pt.enable_gpr_name = "enable";
1167         card->pt.pos_gpr_name = "ptr";
1168         spin_lock_init(&card->pt.lock);
1169         init_waitqueue_head(&card->pt.wait);
1170
1171 /*      tmp = sblive_readfn0(card, HCFG);
1172         if (tmp & (HCFG_GPINPUT0 | HCFG_GPINPUT1)) {
1173                 sblive_writefn0(card, HCFG, tmp | 0x800);
1174
1175                 udelay(512);
1176
1177                 if (tmp != (sblive_readfn0(card, HCFG) & ~0x800)) {
1178                         card->has_toslink = 1;
1179                         sblive_writefn0(card, HCFG, tmp);
1180                 }
1181         }
1182 */
1183         return 0;
1184
1185   err1:
1186         pci_free_consistent(card->pci_dev, card->virtualpagetable.size, card->virtualpagetable.addr, card->virtualpagetable.dma_handle);
1187   err0:
1188         fx_cleanup(&card->mgr);
1189
1190         return ret;
1191 }
1192
1193 static int __devinit emu10k1_init(struct emu10k1_card *card)
1194 {
1195         /* Init Card */
1196         if (hw_init(card) < 0)
1197                 return -1;
1198
1199         voice_init(card);
1200         timer_init(card);
1201         addxmgr_init(card);
1202
1203         DPD(2, "  hw control register -> %#x\n", emu10k1_readfn0(card, HCFG));
1204
1205         return 0;
1206 }
1207
1208 static void emu10k1_cleanup(struct emu10k1_card *card)
1209 {
1210         int ch;
1211
1212         emu10k1_writefn0(card, INTE, 0);
1213
1214         /** Shutdown the chip **/
1215         for (ch = 0; ch < NUM_G; ch++)
1216                 sblive_writeptr(card, DCYSUSV, ch, 0);
1217
1218         for (ch = 0; ch < NUM_G; ch++) {
1219                 sblive_writeptr_tag(card, ch,
1220                                     VTFT, 0,
1221                                     CVCF, 0,
1222                                     PTRX, 0,
1223                                     //CPF, 0,
1224                                     TAGLIST_END);
1225                 sblive_writeptr(card, CPF, ch, 0);
1226         }
1227
1228         /* Disable audio and lock cache */
1229         emu10k1_writefn0(card, HCFG, HCFG_LOCKSOUNDCACHE | HCFG_LOCKTANKCACHE_MASK | HCFG_MUTEBUTTONENABLE);
1230
1231         sblive_writeptr_tag(card, 0,
1232                             PTB, 0,
1233
1234                             /* Reset recording buffers */
1235                             MICBS, ADCBS_BUFSIZE_NONE,
1236                             MICBA, 0,
1237                             FXBS, ADCBS_BUFSIZE_NONE,
1238                             FXBA, 0,
1239                             FXWC, 0,
1240                             ADCBS, ADCBS_BUFSIZE_NONE,
1241                             ADCBA, 0,
1242                             TCBS, 0,
1243                             TCB, 0,
1244                             DBG, 0x8000,
1245
1246                             /* Disable channel interrupt */
1247                             CLIEL, 0,
1248                             CLIEH, 0,
1249                             SOLEL, 0,
1250                             SOLEH, 0,
1251                             TAGLIST_END);
1252
1253         if (card->is_audigy)
1254                 sblive_writeptr(card, 0, A_DBG,  A_DBG_SINGLE_STEP);
1255
1256         pci_free_consistent(card->pci_dev, card->virtualpagetable.size, card->virtualpagetable.addr, card->virtualpagetable.dma_handle);
1257         pci_free_consistent(card->pci_dev, card->silentpage.size, card->silentpage.addr, card->silentpage.dma_handle);
1258         
1259         if(card->tankmem.size != 0)
1260                 pci_free_consistent(card->pci_dev, card->tankmem.size, card->tankmem.addr, card->tankmem.dma_handle);
1261
1262         /* release patch storage memory */
1263         fx_cleanup(&card->mgr);
1264 }
1265
1266 /* Driver initialization routine */
1267 static int __devinit emu10k1_probe(struct pci_dev *pci_dev, const struct pci_device_id *pci_id)
1268 {
1269         struct emu10k1_card *card;
1270         u32 subsysvid;
1271         int ret;
1272
1273         if (pci_set_dma_mask(pci_dev, EMU10K1_DMA_MASK)) {
1274                 printk(KERN_ERR "emu10k1: architecture does not support 29bit PCI busmaster DMA\n");
1275                 return -ENODEV;
1276         }
1277
1278         if (pci_enable_device(pci_dev))
1279                 return -EIO;
1280
1281         pci_set_master(pci_dev);
1282
1283         if ((card = kmalloc(sizeof(struct emu10k1_card), GFP_KERNEL)) == NULL) {
1284                 printk(KERN_ERR "emu10k1: out of memory\n");
1285                 return -ENOMEM;
1286         }
1287         memset(card, 0, sizeof(struct emu10k1_card));
1288
1289         card->iobase = pci_resource_start(pci_dev, 0);
1290         card->length = pci_resource_len(pci_dev, 0); 
1291
1292         if (request_region(card->iobase, card->length, card_names[pci_id->driver_data]) == NULL) {
1293                 printk(KERN_ERR "emu10k1: IO space in use\n");
1294                 ret = -EBUSY;
1295                 goto err_region;
1296         }
1297
1298         pci_set_drvdata(pci_dev, card);
1299
1300         card->irq = pci_dev->irq;
1301         card->pci_dev = pci_dev;
1302
1303         /* Reserve IRQ Line */
1304         if (request_irq(card->irq, emu10k1_interrupt, SA_SHIRQ, card_names[pci_id->driver_data], card)) {
1305                 printk(KERN_ERR "emu10k1: IRQ in use\n");
1306                 ret = -EBUSY;
1307                 goto err_irq;
1308         }
1309
1310         pci_read_config_byte(pci_dev, PCI_REVISION_ID, &card->chiprev);
1311         pci_read_config_word(pci_dev, PCI_SUBSYSTEM_ID, &card->model);
1312
1313         printk(KERN_INFO "emu10k1: %s rev %d model %#04x found, IO at %#04lx-%#04lx, IRQ %d\n",
1314                 card_names[pci_id->driver_data], card->chiprev, card->model, card->iobase,
1315                 card->iobase + card->length - 1, card->irq);
1316
1317         if (pci_id->device == PCI_DEVICE_ID_CREATIVE_AUDIGY)
1318                 card->is_audigy = 1;
1319
1320         pci_read_config_dword(pci_dev, PCI_SUBSYSTEM_VENDOR_ID, &subsysvid);
1321         card->is_aps = (subsysvid == EMU_APS_SUBID);
1322
1323         spin_lock_init(&card->lock);
1324         mutex_init(&card->open_sem);
1325         card->open_mode = 0;
1326         init_waitqueue_head(&card->open_wait);
1327
1328         ret = emu10k1_audio_init(card);
1329         if (ret < 0) {
1330                 printk(KERN_ERR "emu10k1: cannot initialize audio devices\n");
1331                 goto err_audio;
1332         }
1333
1334         ret = emu10k1_mixer_init(card);
1335         if (ret < 0) {
1336                 printk(KERN_ERR "emu10k1: cannot initialize AC97 codec\n");
1337                 goto err_mixer;
1338         }
1339
1340         ret = emu10k1_midi_init(card);
1341         if (ret < 0) {
1342                 printk(KERN_ERR "emu10k1: cannot register midi device\n");
1343                 goto err_midi;
1344         }
1345
1346         ret = emu10k1_init(card);
1347         if (ret < 0) {
1348                 printk(KERN_ERR "emu10k1: cannot initialize device\n");
1349                 goto err_emu10k1_init;
1350         }
1351
1352         if (card->is_aps)
1353                 emu10k1_ecard_init(card);
1354
1355         ret = emu10k1_register_devices(card);
1356         if (ret < 0)
1357                 goto err_register;
1358
1359         /* proc entries must be created after registering devices, as
1360          * emu10k1_info_proc prints card->audio_dev &co. */
1361         ret = emu10k1_proc_init(card);
1362         if (ret < 0) {
1363                 printk(KERN_ERR "emu10k1: cannot initialize proc directory\n");
1364                 goto err_proc;
1365         }
1366         
1367         list_add(&card->list, &emu10k1_devs);
1368
1369         return 0;
1370
1371 err_proc:
1372         emu10k1_unregister_devices(card);
1373
1374 err_register:
1375         emu10k1_cleanup(card);
1376         
1377 err_emu10k1_init:
1378         emu10k1_midi_cleanup(card);
1379
1380 err_midi:
1381         emu10k1_mixer_cleanup(card);
1382
1383 err_mixer:
1384         emu10k1_audio_cleanup(card);
1385
1386 err_audio:
1387         free_irq(card->irq, card);
1388
1389 err_irq:
1390         release_region(card->iobase, card->length);
1391         pci_set_drvdata(pci_dev, NULL);
1392
1393 err_region:
1394         kfree(card);
1395
1396         return ret;
1397 }
1398
1399 static void __devexit emu10k1_remove(struct pci_dev *pci_dev)
1400 {
1401         struct emu10k1_card *card = pci_get_drvdata(pci_dev);
1402
1403         list_del(&card->list);
1404
1405         emu10k1_unregister_devices(card);
1406         emu10k1_cleanup(card);
1407         emu10k1_midi_cleanup(card);
1408         emu10k1_mixer_cleanup(card);
1409         emu10k1_proc_cleanup(card);
1410         emu10k1_audio_cleanup(card);    
1411         free_irq(card->irq, card);
1412         release_region(card->iobase, card->length);
1413         kfree(card);
1414         pci_set_drvdata(pci_dev, NULL);
1415 }
1416
1417 MODULE_AUTHOR("Bertrand Lee, Cai Ying. (Email to: emu10k1-devel@lists.sourceforge.net)");
1418 MODULE_DESCRIPTION("Creative EMU10K1 PCI Audio Driver v" DRIVER_VERSION "\nCopyright (C) 1999 Creative Technology Ltd.");
1419 MODULE_LICENSE("GPL");
1420
1421 static struct pci_driver emu10k1_pci_driver = {
1422         .name           = "emu10k1",
1423         .id_table       = emu10k1_pci_tbl,
1424         .probe          = emu10k1_probe,
1425         .remove         = __devexit_p(emu10k1_remove),
1426 };
1427
1428 static int __init emu10k1_init_module(void)
1429 {
1430         printk(KERN_INFO "Creative EMU10K1 PCI Audio Driver, version " DRIVER_VERSION ", " __TIME__ " " __DATE__ "\n");
1431
1432         return pci_register_driver(&emu10k1_pci_driver);
1433 }
1434
1435 static void __exit emu10k1_cleanup_module(void)
1436 {
1437         pci_unregister_driver(&emu10k1_pci_driver);
1438
1439         return;
1440 }
1441
1442 module_init(emu10k1_init_module);
1443 module_exit(emu10k1_cleanup_module);
1444
1445 #ifdef EMU10K1_SEQUENCER
1446
1447 /* in midi.c */
1448 extern int emu10k1_seq_midi_open(int dev, int mode, 
1449                                 void (*input)(int dev, unsigned char midi_byte),
1450                                 void (*output)(int dev));
1451 extern void emu10k1_seq_midi_close(int dev);
1452 extern int emu10k1_seq_midi_out(int dev, unsigned char midi_byte);
1453 extern int emu10k1_seq_midi_start_read(int dev);
1454 extern int emu10k1_seq_midi_end_read(int dev);
1455 extern void emu10k1_seq_midi_kick(int dev);
1456 extern int emu10k1_seq_midi_buffer_status(int dev);
1457
1458 static struct midi_operations emu10k1_midi_operations =
1459 {
1460         THIS_MODULE,
1461         {"EMU10K1 MIDI", 0, 0, SNDCARD_EMU10K1},
1462         &std_midi_synth,
1463         {0},
1464         emu10k1_seq_midi_open,
1465         emu10k1_seq_midi_close,
1466         NULL,
1467         emu10k1_seq_midi_out,
1468         emu10k1_seq_midi_start_read,
1469         emu10k1_seq_midi_end_read,
1470         emu10k1_seq_midi_kick,
1471         NULL,
1472         emu10k1_seq_midi_buffer_status,
1473         NULL
1474 };
1475
1476 #endif