[PATCH] OSS: replace kmalloc()+memset() combos with kzalloc()
[linux-2.6] / 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 *);
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 = kzalloc(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         card->mpuout->intr = 1;
466         card->mpuout->status = FLAGS_AVAILABLE;
467         card->mpuout->state = CARDMIDIOUT_STATE_DEFAULT;
468
469         tasklet_init(&card->mpuout->tasklet, emu10k1_mpuout_bh, (unsigned long) card);
470
471         spin_lock_init(&card->mpuout->lock);
472
473         card->mpuin = kzalloc(sizeof(struct emu10k1_mpuin), GFP_KERNEL);
474         if (card->mpuin == NULL) {
475                 printk(KERN_WARNING "emu10k1: Unable to allocate emu10k1_mpuin: out of memory\n");
476                 ret = -ENOMEM;
477                 goto err_out2;
478         }
479
480         card->mpuin->status = FLAGS_AVAILABLE;
481
482         tasklet_init(&card->mpuin->tasklet, emu10k1_mpuin_bh, (unsigned long) card->mpuin);
483
484         spin_lock_init(&card->mpuin->lock);
485
486         /* Reset the MPU port */
487         if (emu10k1_mpu_reset(card) < 0) {
488                 ERROR();
489                 ret = -EIO;
490                 goto err_out3;
491         }
492
493         return 0;
494
495 err_out3:
496         kfree(card->mpuin);
497 err_out2:
498         kfree(card->mpuout);
499 err_out1:
500         return ret;
501 }
502
503 static void emu10k1_midi_cleanup(struct emu10k1_card *card)
504 {
505         tasklet_kill(&card->mpuout->tasklet);
506         kfree(card->mpuout);
507
508         tasklet_kill(&card->mpuin->tasklet);
509         kfree(card->mpuin);
510 }
511
512 static void __devinit voice_init(struct emu10k1_card *card)
513 {
514         int i;
515
516         for (i = 0; i < NUM_G; i++)
517                 card->voicetable[i] = VOICE_USAGE_FREE;
518 }
519
520 static void __devinit timer_init(struct emu10k1_card *card)
521 {
522         INIT_LIST_HEAD(&card->timers);
523         card->timer_delay = TIMER_STOPPED;
524         spin_lock_init(&card->timer_lock);
525 }
526
527 static void __devinit addxmgr_init(struct emu10k1_card *card)
528 {
529         u32 count;
530
531         for (count = 0; count < MAXPAGES; count++)
532                 card->emupagetable[count] = 0;
533
534         /* Mark first page as used */
535         /* This page is reserved by the driver */
536         card->emupagetable[0] = 0x8001;
537         card->emupagetable[1] = MAXPAGES - 1;
538 }
539
540 static void fx_cleanup(struct patch_manager *mgr)
541 {
542         int i;
543         for(i = 0; i < mgr->current_pages; i++)
544                 free_page((unsigned long) mgr->patch[i]);
545 }
546
547 static int __devinit fx_init(struct emu10k1_card *card)
548 {
549         struct patch_manager *mgr = &card->mgr;
550         struct dsp_patch *patch;
551         struct dsp_rpatch *rpatch;
552         s32 left, right;
553         int i;
554         u32 pc = 0;
555         u32 patch_n=0;
556         struct emu_efx_info_t emu_efx_info[2]=
557                 {{ 20, 10, 0x400, 0x100, 0x20 },
558                  { 24, 12, 0x600, 0x400, 0x60 },
559                 }; 
560                         
561
562         for (i = 0; i < SOUND_MIXER_NRDEVICES; i++) {
563                 mgr->ctrl_gpr[i][0] = -1;
564                 mgr->ctrl_gpr[i][1] = -1;
565         }
566
567
568         if (card->is_audigy)
569                 mgr->current_pages = (2 + PATCHES_PER_PAGE - 1) / PATCHES_PER_PAGE;
570         else
571                 /* !! The number below must equal the number of patches, currently 11 !! */
572                 mgr->current_pages = (11 + PATCHES_PER_PAGE - 1) / PATCHES_PER_PAGE;
573         
574         for (i = 0; i < mgr->current_pages; i++) {
575                 mgr->patch[i] = (void *)__get_free_page(GFP_KERNEL);
576                 if (mgr->patch[i] == NULL) {
577                         mgr->current_pages = i;
578                         fx_cleanup(mgr);
579                         return -ENOMEM;
580                 }
581                 memset(mgr->patch[i], 0, PAGE_SIZE);
582         }
583
584         if (card->is_audigy) {
585                 for (i = 0; i < 1024; i++)
586                         OP(0xf, 0x0c0, 0x0c0, 0x0cf, 0x0c0);
587
588                 for (i = 0; i < 512 ; i++)
589                         sblive_writeptr(card, A_GPR_BASE+i,0,0);
590
591                 pc=0;
592
593                 //Pcm input volume
594                 OP(0, 0x402, 0x0c0, 0x406, 0x000);
595                 OP(0, 0x403, 0x0c0, 0x407, 0x001);
596
597                 //CD-Digital input Volume
598                 OP(0, 0x404, 0x0c0, 0x40d, 0x42);
599                 OP(0, 0x405, 0x0c0, 0x40f, 0x43);
600
601                 // CD + PCM 
602                 OP(6, 0x400, 0x0c0, 0x402, 0x404);
603                 OP(6, 0x401, 0x0c0, 0x403, 0x405);
604                 
605                 // Front Output + Master Volume
606                 OP(0, 0x68, 0x0c0, 0x408, 0x400);
607                 OP(0, 0x69, 0x0c0, 0x409, 0x401);
608
609                 // Add-in analog inputs for other speakers
610                 OP(6, 0x400, 0x40, 0x400, 0xc0);
611                 OP(6, 0x401, 0x41, 0x401, 0xc0);
612
613                 // Digital Front + Master Volume
614                 OP(0, 0x60, 0x0c0, 0x408, 0x400);
615                 OP(0, 0x61, 0x0c0, 0x409, 0x401);
616
617                 // Rear Output + Rear Volume
618                 OP(0, 0x06e, 0x0c0, 0x419, 0x400);
619                 OP(0, 0x06f, 0x0c0, 0x41a, 0x401);              
620
621                 // Digital Rear Output + Rear Volume
622                 OP(0, 0x066, 0x0c0, 0x419, 0x400);
623                 OP(0, 0x067, 0x0c0, 0x41a, 0x401);              
624
625                 // Audigy Drive, Headphone out
626                 OP(6, 0x64, 0x0c0, 0x0c0, 0x400);
627                 OP(6, 0x65, 0x0c0, 0x0c0, 0x401);
628
629                 // ac97 Recording
630                 OP(6, 0x76, 0x0c0, 0x0c0, 0x40);
631                 OP(6, 0x77, 0x0c0, 0x0c0, 0x41);
632                 
633                 // Center = sub = Left/2 + Right/2
634                 OP(0xe, 0x400, 0x401, 0xcd, 0x400);
635
636                 // center/sub  Volume (master)
637                 OP(0, 0x06a, 0x0c0, 0x408, 0x400);
638                 OP(0, 0x06b, 0x0c0, 0x409, 0x400);
639
640                 // Digital center/sub  Volume (master)
641                 OP(0, 0x062, 0x0c0, 0x408, 0x400);
642                 OP(0, 0x063, 0x0c0, 0x409, 0x400);
643
644                 ROUTING_PATCH_START(rpatch, "Routing");
645                 ROUTING_PATCH_END(rpatch);
646
647                 /* delimiter patch */
648                 patch = PATCH(mgr, patch_n);
649                 patch->code_size = 0;
650
651         
652                 sblive_writeptr(card, 0x53, 0, 0);
653         } else {
654                 for (i = 0; i < 512 ; i++)
655                         OP(6, 0x40, 0x40, 0x40, 0x40);
656
657                 for (i = 0; i < 256; i++)
658                         sblive_writeptr_tag(card, 0,
659                                             FXGPREGBASE + i, 0,
660                                             TANKMEMADDRREGBASE + i, 0,
661                                             TAGLIST_END);
662
663                 
664                 pc = 0;
665
666                 //first free GPR = 0x11b
667         
668                 
669                 /* FX volume correction and Volume control*/
670                 INPUT_PATCH_START(patch, "Pcm L vol", 0x0, 0);
671                 GET_OUTPUT_GPR(patch, 0x100, 0x0);
672                 GET_CONTROL_GPR(patch, 0x106, "Vol", 0, 0x7fffffff);
673                 GET_DYNAMIC_GPR(patch, 0x112);
674
675                 OP(4, 0x112, 0x40, PCM_IN_L, 0x44); //*4        
676                 OP(0, 0x100, 0x040, 0x112, 0x106);  //*vol      
677                 INPUT_PATCH_END(patch);
678
679
680                 INPUT_PATCH_START(patch, "Pcm R vol", 0x1, 0);
681                 GET_OUTPUT_GPR(patch, 0x101, 0x1);
682                 GET_CONTROL_GPR(patch, 0x107, "Vol", 0, 0x7fffffff);
683                 GET_DYNAMIC_GPR(patch, 0x112);
684
685                 OP(4, 0x112, 0x40, PCM_IN_R, 0x44); 
686                 OP(0, 0x101, 0x040, 0x112, 0x107);
687
688                 INPUT_PATCH_END(patch);
689
690
691                 // CD-Digital In Volume control 
692                 INPUT_PATCH_START(patch, "CD-Digital Vol L", 0x12, 0);
693                 GET_OUTPUT_GPR(patch, 0x10c, 0x12);
694                 GET_CONTROL_GPR(patch, 0x10d, "Vol", 0, 0x7fffffff);
695
696                 OP(0, 0x10c, 0x040, SPDIF_CD_L, 0x10d);
697                 INPUT_PATCH_END(patch);
698
699                 INPUT_PATCH_START(patch, "CD-Digital Vol R", 0x13, 0);
700                 GET_OUTPUT_GPR(patch, 0x10e, 0x13);
701                 GET_CONTROL_GPR(patch, 0x10f, "Vol", 0, 0x7fffffff);
702
703                 OP(0, 0x10e, 0x040, SPDIF_CD_R, 0x10f);
704                 INPUT_PATCH_END(patch);
705
706                 //Volume Correction for Multi-channel Inputs    
707                 INPUT_PATCH_START(patch, "Multi-Channel Gain", 0x08, 0);
708                 patch->input=patch->output=0x3F00;
709
710                 GET_OUTPUT_GPR(patch, 0x113, MULTI_FRONT_L);
711                 GET_OUTPUT_GPR(patch, 0x114, MULTI_FRONT_R);
712                 GET_OUTPUT_GPR(patch, 0x115, MULTI_REAR_L);
713                 GET_OUTPUT_GPR(patch, 0x116, MULTI_REAR_R);
714                 GET_OUTPUT_GPR(patch, 0x117, MULTI_CENTER);
715                 GET_OUTPUT_GPR(patch, 0x118, MULTI_LFE);
716
717                 OP(4, 0x113, 0x40, MULTI_FRONT_L, 0x44);
718                 OP(4, 0x114, 0x40, MULTI_FRONT_R, 0x44);
719                 OP(4, 0x115, 0x40, MULTI_REAR_L, 0x44);
720                 OP(4, 0x116, 0x40, MULTI_REAR_R, 0x44);
721                 OP(4, 0x117, 0x40, MULTI_CENTER, 0x44);
722                 OP(4, 0x118, 0x40, MULTI_LFE, 0x44);
723         
724                 INPUT_PATCH_END(patch);
725
726
727                 //Routing patch start   
728                 ROUTING_PATCH_START(rpatch, "Routing");
729                 GET_INPUT_GPR(rpatch, 0x100, 0x0);
730                 GET_INPUT_GPR(rpatch, 0x101, 0x1);
731                 GET_INPUT_GPR(rpatch, 0x10c, 0x12);
732                 GET_INPUT_GPR(rpatch, 0x10e, 0x13);
733                 GET_INPUT_GPR(rpatch, 0x113, MULTI_FRONT_L);
734                 GET_INPUT_GPR(rpatch, 0x114, MULTI_FRONT_R);
735                 GET_INPUT_GPR(rpatch, 0x115, MULTI_REAR_L);
736                 GET_INPUT_GPR(rpatch, 0x116, MULTI_REAR_R);
737                 GET_INPUT_GPR(rpatch, 0x117, MULTI_CENTER);
738                 GET_INPUT_GPR(rpatch, 0x118, MULTI_LFE);
739
740                 GET_DYNAMIC_GPR(rpatch, 0x102);
741                 GET_DYNAMIC_GPR(rpatch, 0x103);
742
743                 GET_OUTPUT_GPR(rpatch, 0x104, 0x8);
744                 GET_OUTPUT_GPR(rpatch, 0x105, 0x9);
745                 GET_OUTPUT_GPR(rpatch, 0x10a, 0x2);
746                 GET_OUTPUT_GPR(rpatch, 0x10b, 0x3);
747                 
748                 
749                 /* input buffer */
750                 OP(6, 0x102, AC97_IN_L, 0x40, 0x40);
751                 OP(6, 0x103, AC97_IN_R, 0x40, 0x40);
752
753
754                 /* Digital In + PCM + MULTI_FRONT-> AC97 out (front speakers)*/
755                 OP(6, AC97_FRONT_L, 0x100, 0x10c, 0x113);
756
757                 CONNECT(MULTI_FRONT_L, AC97_FRONT_L);
758                 CONNECT(PCM_IN_L, AC97_FRONT_L);
759                 CONNECT(SPDIF_CD_L, AC97_FRONT_L);
760
761                 OP(6, AC97_FRONT_R, 0x101, 0x10e, 0x114);
762
763                 CONNECT(MULTI_FRONT_R, AC97_FRONT_R);
764                 CONNECT(PCM_IN_R, AC97_FRONT_R);
765                 CONNECT(SPDIF_CD_R, AC97_FRONT_R);
766
767                 /* Digital In + PCM + AC97 In + PCM1 + MULTI_REAR --> Rear Channel */ 
768                 OP(6, 0x104, PCM1_IN_L, 0x100, 0x115);
769                 OP(6, 0x104, 0x104, 0x10c, 0x102);
770
771                 CONNECT(MULTI_REAR_L, ANALOG_REAR_L);
772                 CONNECT(AC97_IN_L, ANALOG_REAR_L);
773                 CONNECT(PCM_IN_L, ANALOG_REAR_L);
774                 CONNECT(SPDIF_CD_L, ANALOG_REAR_L);
775                 CONNECT(PCM1_IN_L, ANALOG_REAR_L);
776
777                 OP(6, 0x105, PCM1_IN_R, 0x101, 0x116);
778                 OP(6, 0x105, 0x105, 0x10e, 0x103);
779
780                 CONNECT(MULTI_REAR_R, ANALOG_REAR_R);
781                 CONNECT(AC97_IN_R, ANALOG_REAR_R);
782                 CONNECT(PCM_IN_R, ANALOG_REAR_R);
783                 CONNECT(SPDIF_CD_R, ANALOG_REAR_R);
784                 CONNECT(PCM1_IN_R, ANALOG_REAR_R);
785
786                 /* Digital In + PCM + AC97 In + MULTI_FRONT --> Digital out */
787                 OP(6, 0x10b, 0x100, 0x102, 0x10c);
788                 OP(6, 0x10b, 0x10b, 0x113, 0x40);
789
790                 CONNECT(MULTI_FRONT_L, DIGITAL_OUT_L);
791                 CONNECT(PCM_IN_L, DIGITAL_OUT_L);
792                 CONNECT(AC97_IN_L, DIGITAL_OUT_L);
793                 CONNECT(SPDIF_CD_L, DIGITAL_OUT_L);
794
795                 OP(6, 0x10a, 0x101, 0x103, 0x10e);
796                 OP(6, 0x10b, 0x10b, 0x114, 0x40);
797
798                 CONNECT(MULTI_FRONT_R, DIGITAL_OUT_R);
799                 CONNECT(PCM_IN_R, DIGITAL_OUT_R);
800                 CONNECT(AC97_IN_R, DIGITAL_OUT_R);
801                 CONNECT(SPDIF_CD_R, DIGITAL_OUT_R);
802
803                 /* AC97 In --> ADC Recording Buffer */
804                 OP(6, ADC_REC_L, 0x102, 0x40, 0x40);
805
806                 CONNECT(AC97_IN_L, ADC_REC_L);
807
808                 OP(6, ADC_REC_R, 0x103, 0x40, 0x40);
809
810                 CONNECT(AC97_IN_R, ADC_REC_R);
811
812
813                 /* fx12:Analog-Center */
814                 OP(6, ANALOG_CENTER, 0x117, 0x40, 0x40);
815                 CONNECT(MULTI_CENTER, ANALOG_CENTER);
816
817                 /* fx11:Analog-LFE */
818                 OP(6, ANALOG_LFE, 0x118, 0x40, 0x40);
819                 CONNECT(MULTI_LFE, ANALOG_LFE);
820
821                 /* fx12:Digital-Center */
822                 OP(6, DIGITAL_CENTER, 0x117, 0x40, 0x40);
823                 CONNECT(MULTI_CENTER, DIGITAL_CENTER);
824                 
825                 /* fx11:Analog-LFE */
826                 OP(6, DIGITAL_LFE, 0x118, 0x40, 0x40);
827                 CONNECT(MULTI_LFE, DIGITAL_LFE);
828         
829                 ROUTING_PATCH_END(rpatch);
830
831
832                 // Rear volume control  
833                 OUTPUT_PATCH_START(patch, "Vol Rear L", 0x8, 0);
834                 GET_INPUT_GPR(patch, 0x104, 0x8);
835                 GET_CONTROL_GPR(patch, 0x119, "Vol", 0, 0x7fffffff);
836
837                 OP(0, ANALOG_REAR_L, 0x040, 0x104, 0x119);
838                 OUTPUT_PATCH_END(patch);
839
840                 OUTPUT_PATCH_START(patch, "Vol Rear R", 0x9, 0);
841                 GET_INPUT_GPR(patch, 0x105, 0x9);
842                 GET_CONTROL_GPR(patch, 0x11a, "Vol", 0, 0x7fffffff);
843
844                 OP(0, ANALOG_REAR_R, 0x040, 0x105, 0x11a);
845                 OUTPUT_PATCH_END(patch);
846
847
848                 //Master volume control on front-digital        
849                 OUTPUT_PATCH_START(patch, "Vol Master L", 0x2, 1);
850                 GET_INPUT_GPR(patch, 0x10a, 0x2);
851                 GET_CONTROL_GPR(patch, 0x108, "Vol", 0, 0x7fffffff);
852
853                 OP(0, DIGITAL_OUT_L, 0x040, 0x10a, 0x108);
854                 OUTPUT_PATCH_END(patch);
855
856
857                 OUTPUT_PATCH_START(patch, "Vol Master R", 0x3, 1);
858                 GET_INPUT_GPR(patch, 0x10b, 0x3);
859                 GET_CONTROL_GPR(patch, 0x109, "Vol", 0, 0x7fffffff);
860
861                 OP(0, DIGITAL_OUT_R, 0x040, 0x10b, 0x109);
862                 OUTPUT_PATCH_END(patch);
863
864
865                 /* delimiter patch */
866                 patch = PATCH(mgr, patch_n);
867                 patch->code_size = 0;
868
869         
870                 sblive_writeptr(card, DBG, 0, 0);
871         }
872
873         spin_lock_init(&mgr->lock);
874
875         // Set up Volume controls, try to keep this the same for both Audigy and Live
876
877         //Master volume
878         mgr->ctrl_gpr[SOUND_MIXER_VOLUME][0] = 8;
879         mgr->ctrl_gpr[SOUND_MIXER_VOLUME][1] = 9;
880
881         left = card->ac97->mixer_state[SOUND_MIXER_VOLUME] & 0xff;
882         right = (card->ac97->mixer_state[SOUND_MIXER_VOLUME] >> 8) & 0xff;
883
884         emu10k1_set_volume_gpr(card, 8, left, 1 << card->ac97->bit_resolution);
885         emu10k1_set_volume_gpr(card, 9, right, 1 << card->ac97->bit_resolution);
886
887         //Rear volume
888         mgr->ctrl_gpr[ SOUND_MIXER_OGAIN ][0] = 0x19;
889         mgr->ctrl_gpr[ SOUND_MIXER_OGAIN ][1] = 0x1a;
890
891         left = right = 67;
892         card->ac97->mixer_state[SOUND_MIXER_OGAIN] = (right << 8) | left;
893
894         card->ac97->supported_mixers |= SOUND_MASK_OGAIN;
895         card->ac97->stereo_mixers |= SOUND_MASK_OGAIN;
896
897         emu10k1_set_volume_gpr(card, 0x19, left, VOL_5BIT);
898         emu10k1_set_volume_gpr(card, 0x1a, right, VOL_5BIT);
899
900         //PCM Volume
901         mgr->ctrl_gpr[SOUND_MIXER_PCM][0] = 6;
902         mgr->ctrl_gpr[SOUND_MIXER_PCM][1] = 7;
903
904         left = card->ac97->mixer_state[SOUND_MIXER_PCM] & 0xff;
905         right = (card->ac97->mixer_state[SOUND_MIXER_PCM] >> 8) & 0xff;
906
907         emu10k1_set_volume_gpr(card, 6, left, VOL_5BIT);
908         emu10k1_set_volume_gpr(card, 7, right, VOL_5BIT);
909
910         //CD-Digital Volume
911         mgr->ctrl_gpr[SOUND_MIXER_DIGITAL1][0] = 0xd;
912         mgr->ctrl_gpr[SOUND_MIXER_DIGITAL1][1] = 0xf;
913
914         left = right = 67;
915         card->ac97->mixer_state[SOUND_MIXER_DIGITAL1] = (right << 8) | left; 
916
917         card->ac97->supported_mixers |= SOUND_MASK_DIGITAL1;
918         card->ac97->stereo_mixers |= SOUND_MASK_DIGITAL1;
919
920         emu10k1_set_volume_gpr(card, 0xd, left, VOL_5BIT);
921         emu10k1_set_volume_gpr(card, 0xf, right, VOL_5BIT);
922
923
924         //hard wire the ac97's pcm, pcm volume is done above using dsp code.
925         if (card->is_audigy)
926                 //for Audigy, we mute it and use the philips 6 channel DAC instead
927                 emu10k1_ac97_write(card->ac97, 0x18, 0x8000);
928         else
929                 //For the Live we hardwire it to full volume
930                 emu10k1_ac97_write(card->ac97, 0x18, 0x0);
931
932         //remove it from the ac97_codec's control
933         card->ac97_supported_mixers &= ~SOUND_MASK_PCM;
934         card->ac97_stereo_mixers &= ~SOUND_MASK_PCM;
935
936         //set Igain to 0dB by default, maybe consider hardwiring it here.
937         emu10k1_ac97_write(card->ac97, AC97_RECORD_GAIN, 0x0000);
938         card->ac97->mixer_state[SOUND_MIXER_IGAIN] = 0x101; 
939
940         return 0;
941 }
942
943 static int __devinit hw_init(struct emu10k1_card *card)
944 {
945         int nCh;
946         u32 pagecount; /* tmp */
947         int ret;
948
949         /* Disable audio and lock cache */
950         emu10k1_writefn0(card, HCFG, HCFG_LOCKSOUNDCACHE | HCFG_LOCKTANKCACHE_MASK | HCFG_MUTEBUTTONENABLE);
951
952         /* Reset recording buffers */
953         sblive_writeptr_tag(card, 0,
954                             MICBS, ADCBS_BUFSIZE_NONE,
955                             MICBA, 0,
956                             FXBS, ADCBS_BUFSIZE_NONE,
957                             FXBA, 0,
958                             ADCBS, ADCBS_BUFSIZE_NONE,
959                             ADCBA, 0,
960                             TAGLIST_END);
961
962         /* Disable channel interrupt */
963         emu10k1_writefn0(card, INTE, 0);
964         sblive_writeptr_tag(card, 0,
965                             CLIEL, 0,
966                             CLIEH, 0,
967                             SOLEL, 0,
968                             SOLEH, 0,
969                             TAGLIST_END);
970
971         if (card->is_audigy) {
972                 sblive_writeptr_tag(card,0,
973                                     0x5e,0xf00,
974                                     0x5f,0x3,
975                                     TAGLIST_END);
976         }
977
978         /* Init envelope engine */
979         for (nCh = 0; nCh < NUM_G; nCh++) {
980                 sblive_writeptr_tag(card, nCh,
981                                     DCYSUSV, 0,
982                                     IP, 0,
983                                     VTFT, 0xffff,
984                                     CVCF, 0xffff,
985                                     PTRX, 0,
986                                     //CPF, 0,
987                                     CCR, 0,
988
989                                     PSST, 0,
990                                     DSL, 0x10,
991                                     CCCA, 0,
992                                     Z1, 0,
993                                     Z2, 0,
994                                     FXRT, 0xd01c0000,
995
996                                     ATKHLDM, 0,
997                                     DCYSUSM, 0,
998                                     IFATN, 0xffff,
999                                     PEFE, 0,
1000                                     FMMOD, 0,
1001                                     TREMFRQ, 24,        /* 1 Hz */
1002                                     FM2FRQ2, 24,        /* 1 Hz */
1003                                     TEMPENV, 0,
1004
1005                                     /*** These are last so OFF prevents writing ***/
1006                                     LFOVAL2, 0,
1007                                     LFOVAL1, 0,
1008                                     ATKHLDV, 0,
1009                                     ENVVOL, 0,
1010                                     ENVVAL, 0,
1011                                     TAGLIST_END);
1012                 sblive_writeptr(card, CPF, nCh, 0);
1013                 /*
1014                   Audigy FXRT initialization
1015                   reversed eng'd, may not be accurate.
1016                  */
1017                 if (card->is_audigy) {
1018                         sblive_writeptr_tag(card,nCh,
1019                                             0x4c,0x0,
1020                                             0x4d,0x0,
1021                                             0x4e,0x0,
1022                                             0x4f,0x0,
1023                                             A_FXRT1, 0x3f3f3f3f,
1024                                             A_FXRT2, 0x3f3f3f3f,
1025                                             A_SENDAMOUNTS, 0,
1026                                             TAGLIST_END);
1027                 }
1028         }
1029         
1030
1031         /*
1032          ** Init to 0x02109204 :
1033          ** Clock accuracy    = 0     (1000ppm)
1034          ** Sample Rate       = 2     (48kHz)
1035          ** Audio Channel     = 1     (Left of 2)
1036          ** Source Number     = 0     (Unspecified)
1037          ** Generation Status = 1     (Original for Cat Code 12)
1038          ** Cat Code          = 12    (Digital Signal Mixer)
1039          ** Mode              = 0     (Mode 0)
1040          ** Emphasis          = 0     (None)
1041          ** CP                = 1     (Copyright unasserted)
1042          ** AN                = 0     (Digital audio)
1043          ** P                 = 0     (Consumer)
1044          */
1045
1046         sblive_writeptr_tag(card, 0,
1047
1048                             /* SPDIF0 */
1049                             SPCS0, (SPCS_CLKACCY_1000PPM | 0x002000000 |
1050                                     SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC | SPCS_GENERATIONSTATUS | 0x00001200 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT),
1051
1052                             /* SPDIF1 */
1053                             SPCS1, (SPCS_CLKACCY_1000PPM | 0x002000000 |
1054                                     SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC | SPCS_GENERATIONSTATUS | 0x00001200 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT),
1055
1056                             /* SPDIF2 & SPDIF3 */
1057                             SPCS2, (SPCS_CLKACCY_1000PPM | 0x002000000 |
1058                                     SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC | SPCS_GENERATIONSTATUS | 0x00001200 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT),
1059
1060                             TAGLIST_END);
1061
1062         if (card->is_audigy && (card->chiprev == 4)) {
1063                 /* Hacks for Alice3 to work independent of haP16V driver */
1064                 u32 tmp;
1065
1066                 //Setup SRCMulti_I2S SamplingRate
1067                 tmp = sblive_readptr(card, A_SPDIF_SAMPLERATE, 0);
1068                 tmp &= 0xfffff1ff;
1069                 tmp |= (0x2<<9);
1070                 sblive_writeptr(card, A_SPDIF_SAMPLERATE, 0, tmp);
1071
1072                 /* Setup SRCSel (Enable Spdif,I2S SRCMulti) */
1073                 emu10k1_writefn0(card, 0x20, 0x600000);
1074                 emu10k1_writefn0(card, 0x24, 0x14);
1075
1076                 /* Setup SRCMulti Input Audio Enable */
1077                 emu10k1_writefn0(card, 0x20, 0x6E0000);
1078                 emu10k1_writefn0(card, 0x24, 0xFF00FF00);
1079         }
1080
1081         ret = fx_init(card);            /* initialize effects engine */
1082         if (ret < 0)
1083                 return ret;
1084
1085         card->tankmem.size = 0;
1086
1087         card->virtualpagetable.size = MAXPAGES * sizeof(u32);
1088
1089         card->virtualpagetable.addr = pci_alloc_consistent(card->pci_dev, card->virtualpagetable.size, &card->virtualpagetable.dma_handle);
1090         if (card->virtualpagetable.addr == NULL) {
1091                 ERROR();
1092                 ret = -ENOMEM;
1093                 goto err0;
1094         }
1095
1096         card->silentpage.size = EMUPAGESIZE;
1097
1098         card->silentpage.addr = pci_alloc_consistent(card->pci_dev, card->silentpage.size, &card->silentpage.dma_handle);
1099         if (card->silentpage.addr == NULL) {
1100                 ERROR();
1101                 ret = -ENOMEM;
1102                 goto err1;
1103         }
1104
1105         for (pagecount = 0; pagecount < MAXPAGES; pagecount++)
1106                 ((u32 *) card->virtualpagetable.addr)[pagecount] = cpu_to_le32(((u32) card->silentpage.dma_handle * 2) | pagecount);
1107
1108         /* Init page table & tank memory base register */
1109         sblive_writeptr_tag(card, 0,
1110                             PTB, (u32) card->virtualpagetable.dma_handle,
1111                             TCB, 0,
1112                             TCBS, 0,
1113                             TAGLIST_END);
1114
1115         for (nCh = 0; nCh < NUM_G; nCh++) {
1116                 sblive_writeptr_tag(card, nCh,
1117                                     MAPA, MAP_PTI_MASK | ((u32) card->silentpage.dma_handle * 2),
1118                                     MAPB, MAP_PTI_MASK | ((u32) card->silentpage.dma_handle * 2),
1119                                     TAGLIST_END);
1120         }
1121
1122         /* Hokay, now enable the AUD bit */
1123         /* Enable Audio = 1 */
1124         /* Mute Disable Audio = 0 */
1125         /* Lock Tank Memory = 1 */
1126         /* Lock Sound Memory = 0 */
1127         /* Auto Mute = 1 */
1128         if (card->is_audigy) {
1129                 if (card->chiprev == 4)
1130                         emu10k1_writefn0(card, HCFG, HCFG_AUDIOENABLE  | HCFG_AC3ENABLE_CDSPDIF | HCFG_AC3ENABLE_GPSPDIF | HCFG_AUTOMUTE | HCFG_JOYENABLE);
1131                 else
1132                         emu10k1_writefn0(card, HCFG, HCFG_AUDIOENABLE  | HCFG_AUTOMUTE | HCFG_JOYENABLE);
1133         } else {
1134                 if (card->model == 0x20 || card->model == 0xc400 ||
1135                  (card->model == 0x21 && card->chiprev < 6))
1136                         emu10k1_writefn0(card, HCFG, HCFG_AUDIOENABLE  | HCFG_LOCKTANKCACHE_MASK | HCFG_AUTOMUTE);
1137                 else
1138                         emu10k1_writefn0(card, HCFG, HCFG_AUDIOENABLE  | HCFG_LOCKTANKCACHE_MASK | HCFG_AUTOMUTE | HCFG_JOYENABLE);
1139         }
1140         /* Enable Vol_Ctrl irqs */
1141         emu10k1_irq_enable(card, INTE_VOLINCRENABLE | INTE_VOLDECRENABLE | INTE_MUTEENABLE | INTE_FXDSPENABLE);
1142
1143         if (card->is_audigy && (card->chiprev == 4)) {
1144                 /* Unmute Analog now.  Set GPO6 to 1 for Apollo.
1145                  * This has to be done after init ALice3 I2SOut beyond 48KHz.
1146                  * So, sequence is important. */
1147                 u32 tmp = emu10k1_readfn0(card, A_IOCFG);
1148                 tmp |= 0x0040;
1149                 emu10k1_writefn0(card, A_IOCFG, tmp);
1150         }
1151         
1152         /* FIXME: TOSLink detection */
1153         card->has_toslink = 0;
1154
1155         /* Initialize digital passthrough variables */
1156         card->pt.pos_gpr = card->pt.intr_gpr = card->pt.enable_gpr = -1;
1157         card->pt.selected = 0;
1158         card->pt.state = PT_STATE_INACTIVE;
1159         card->pt.spcs_to_use = 0x01;
1160         card->pt.patch_name = "AC3pass";
1161         card->pt.intr_gpr_name = "count";
1162         card->pt.enable_gpr_name = "enable";
1163         card->pt.pos_gpr_name = "ptr";
1164         spin_lock_init(&card->pt.lock);
1165         init_waitqueue_head(&card->pt.wait);
1166
1167 /*      tmp = sblive_readfn0(card, HCFG);
1168         if (tmp & (HCFG_GPINPUT0 | HCFG_GPINPUT1)) {
1169                 sblive_writefn0(card, HCFG, tmp | 0x800);
1170
1171                 udelay(512);
1172
1173                 if (tmp != (sblive_readfn0(card, HCFG) & ~0x800)) {
1174                         card->has_toslink = 1;
1175                         sblive_writefn0(card, HCFG, tmp);
1176                 }
1177         }
1178 */
1179         return 0;
1180
1181   err1:
1182         pci_free_consistent(card->pci_dev, card->virtualpagetable.size, card->virtualpagetable.addr, card->virtualpagetable.dma_handle);
1183   err0:
1184         fx_cleanup(&card->mgr);
1185
1186         return ret;
1187 }
1188
1189 static int __devinit emu10k1_init(struct emu10k1_card *card)
1190 {
1191         /* Init Card */
1192         if (hw_init(card) < 0)
1193                 return -1;
1194
1195         voice_init(card);
1196         timer_init(card);
1197         addxmgr_init(card);
1198
1199         DPD(2, "  hw control register -> %#x\n", emu10k1_readfn0(card, HCFG));
1200
1201         return 0;
1202 }
1203
1204 static void emu10k1_cleanup(struct emu10k1_card *card)
1205 {
1206         int ch;
1207
1208         emu10k1_writefn0(card, INTE, 0);
1209
1210         /** Shutdown the chip **/
1211         for (ch = 0; ch < NUM_G; ch++)
1212                 sblive_writeptr(card, DCYSUSV, ch, 0);
1213
1214         for (ch = 0; ch < NUM_G; ch++) {
1215                 sblive_writeptr_tag(card, ch,
1216                                     VTFT, 0,
1217                                     CVCF, 0,
1218                                     PTRX, 0,
1219                                     //CPF, 0,
1220                                     TAGLIST_END);
1221                 sblive_writeptr(card, CPF, ch, 0);
1222         }
1223
1224         /* Disable audio and lock cache */
1225         emu10k1_writefn0(card, HCFG, HCFG_LOCKSOUNDCACHE | HCFG_LOCKTANKCACHE_MASK | HCFG_MUTEBUTTONENABLE);
1226
1227         sblive_writeptr_tag(card, 0,
1228                             PTB, 0,
1229
1230                             /* Reset recording buffers */
1231                             MICBS, ADCBS_BUFSIZE_NONE,
1232                             MICBA, 0,
1233                             FXBS, ADCBS_BUFSIZE_NONE,
1234                             FXBA, 0,
1235                             FXWC, 0,
1236                             ADCBS, ADCBS_BUFSIZE_NONE,
1237                             ADCBA, 0,
1238                             TCBS, 0,
1239                             TCB, 0,
1240                             DBG, 0x8000,
1241
1242                             /* Disable channel interrupt */
1243                             CLIEL, 0,
1244                             CLIEH, 0,
1245                             SOLEL, 0,
1246                             SOLEH, 0,
1247                             TAGLIST_END);
1248
1249         if (card->is_audigy)
1250                 sblive_writeptr(card, 0, A_DBG,  A_DBG_SINGLE_STEP);
1251
1252         pci_free_consistent(card->pci_dev, card->virtualpagetable.size, card->virtualpagetable.addr, card->virtualpagetable.dma_handle);
1253         pci_free_consistent(card->pci_dev, card->silentpage.size, card->silentpage.addr, card->silentpage.dma_handle);
1254         
1255         if(card->tankmem.size != 0)
1256                 pci_free_consistent(card->pci_dev, card->tankmem.size, card->tankmem.addr, card->tankmem.dma_handle);
1257
1258         /* release patch storage memory */
1259         fx_cleanup(&card->mgr);
1260 }
1261
1262 /* Driver initialization routine */
1263 static int __devinit emu10k1_probe(struct pci_dev *pci_dev, const struct pci_device_id *pci_id)
1264 {
1265         struct emu10k1_card *card;
1266         u32 subsysvid;
1267         int ret;
1268
1269         if (pci_set_dma_mask(pci_dev, EMU10K1_DMA_MASK)) {
1270                 printk(KERN_ERR "emu10k1: architecture does not support 29bit PCI busmaster DMA\n");
1271                 return -ENODEV;
1272         }
1273
1274         if (pci_enable_device(pci_dev))
1275                 return -EIO;
1276
1277         pci_set_master(pci_dev);
1278
1279         if ((card = kzalloc(sizeof(struct emu10k1_card), GFP_KERNEL)) == NULL) {
1280                 printk(KERN_ERR "emu10k1: out of memory\n");
1281                 return -ENOMEM;
1282         }
1283
1284         card->iobase = pci_resource_start(pci_dev, 0);
1285         card->length = pci_resource_len(pci_dev, 0); 
1286
1287         if (request_region(card->iobase, card->length, card_names[pci_id->driver_data]) == NULL) {
1288                 printk(KERN_ERR "emu10k1: IO space in use\n");
1289                 ret = -EBUSY;
1290                 goto err_region;
1291         }
1292
1293         pci_set_drvdata(pci_dev, card);
1294
1295         card->irq = pci_dev->irq;
1296         card->pci_dev = pci_dev;
1297
1298         /* Reserve IRQ Line */
1299         if (request_irq(card->irq, emu10k1_interrupt, IRQF_SHARED, card_names[pci_id->driver_data], card)) {
1300                 printk(KERN_ERR "emu10k1: IRQ in use\n");
1301                 ret = -EBUSY;
1302                 goto err_irq;
1303         }
1304
1305         pci_read_config_byte(pci_dev, PCI_REVISION_ID, &card->chiprev);
1306         pci_read_config_word(pci_dev, PCI_SUBSYSTEM_ID, &card->model);
1307
1308         printk(KERN_INFO "emu10k1: %s rev %d model %#04x found, IO at %#04lx-%#04lx, IRQ %d\n",
1309                 card_names[pci_id->driver_data], card->chiprev, card->model, card->iobase,
1310                 card->iobase + card->length - 1, card->irq);
1311
1312         if (pci_id->device == PCI_DEVICE_ID_CREATIVE_AUDIGY)
1313                 card->is_audigy = 1;
1314
1315         pci_read_config_dword(pci_dev, PCI_SUBSYSTEM_VENDOR_ID, &subsysvid);
1316         card->is_aps = (subsysvid == EMU_APS_SUBID);
1317
1318         spin_lock_init(&card->lock);
1319         mutex_init(&card->open_sem);
1320         card->open_mode = 0;
1321         init_waitqueue_head(&card->open_wait);
1322
1323         ret = emu10k1_audio_init(card);
1324         if (ret < 0) {
1325                 printk(KERN_ERR "emu10k1: cannot initialize audio devices\n");
1326                 goto err_audio;
1327         }
1328
1329         ret = emu10k1_mixer_init(card);
1330         if (ret < 0) {
1331                 printk(KERN_ERR "emu10k1: cannot initialize AC97 codec\n");
1332                 goto err_mixer;
1333         }
1334
1335         ret = emu10k1_midi_init(card);
1336         if (ret < 0) {
1337                 printk(KERN_ERR "emu10k1: cannot register midi device\n");
1338                 goto err_midi;
1339         }
1340
1341         ret = emu10k1_init(card);
1342         if (ret < 0) {
1343                 printk(KERN_ERR "emu10k1: cannot initialize device\n");
1344                 goto err_emu10k1_init;
1345         }
1346
1347         if (card->is_aps)
1348                 emu10k1_ecard_init(card);
1349
1350         ret = emu10k1_register_devices(card);
1351         if (ret < 0)
1352                 goto err_register;
1353
1354         /* proc entries must be created after registering devices, as
1355          * emu10k1_info_proc prints card->audio_dev &co. */
1356         ret = emu10k1_proc_init(card);
1357         if (ret < 0) {
1358                 printk(KERN_ERR "emu10k1: cannot initialize proc directory\n");
1359                 goto err_proc;
1360         }
1361         
1362         list_add(&card->list, &emu10k1_devs);
1363
1364         return 0;
1365
1366 err_proc:
1367         emu10k1_unregister_devices(card);
1368
1369 err_register:
1370         emu10k1_cleanup(card);
1371         
1372 err_emu10k1_init:
1373         emu10k1_midi_cleanup(card);
1374
1375 err_midi:
1376         emu10k1_mixer_cleanup(card);
1377
1378 err_mixer:
1379         emu10k1_audio_cleanup(card);
1380
1381 err_audio:
1382         free_irq(card->irq, card);
1383
1384 err_irq:
1385         release_region(card->iobase, card->length);
1386         pci_set_drvdata(pci_dev, NULL);
1387
1388 err_region:
1389         kfree(card);
1390
1391         return ret;
1392 }
1393
1394 static void __devexit emu10k1_remove(struct pci_dev *pci_dev)
1395 {
1396         struct emu10k1_card *card = pci_get_drvdata(pci_dev);
1397
1398         list_del(&card->list);
1399
1400         emu10k1_unregister_devices(card);
1401         emu10k1_cleanup(card);
1402         emu10k1_midi_cleanup(card);
1403         emu10k1_mixer_cleanup(card);
1404         emu10k1_proc_cleanup(card);
1405         emu10k1_audio_cleanup(card);    
1406         free_irq(card->irq, card);
1407         release_region(card->iobase, card->length);
1408         kfree(card);
1409         pci_set_drvdata(pci_dev, NULL);
1410 }
1411
1412 MODULE_AUTHOR("Bertrand Lee, Cai Ying. (Email to: emu10k1-devel@lists.sourceforge.net)");
1413 MODULE_DESCRIPTION("Creative EMU10K1 PCI Audio Driver v" DRIVER_VERSION "\nCopyright (C) 1999 Creative Technology Ltd.");
1414 MODULE_LICENSE("GPL");
1415
1416 static struct pci_driver emu10k1_pci_driver = {
1417         .name           = "emu10k1",
1418         .id_table       = emu10k1_pci_tbl,
1419         .probe          = emu10k1_probe,
1420         .remove         = __devexit_p(emu10k1_remove),
1421 };
1422
1423 static int __init emu10k1_init_module(void)
1424 {
1425         printk(KERN_INFO "Creative EMU10K1 PCI Audio Driver, version " DRIVER_VERSION ", " __TIME__ " " __DATE__ "\n");
1426
1427         return pci_register_driver(&emu10k1_pci_driver);
1428 }
1429
1430 static void __exit emu10k1_cleanup_module(void)
1431 {
1432         pci_unregister_driver(&emu10k1_pci_driver);
1433
1434         return;
1435 }
1436
1437 module_init(emu10k1_init_module);
1438 module_exit(emu10k1_cleanup_module);
1439
1440 #ifdef EMU10K1_SEQUENCER
1441
1442 /* in midi.c */
1443 extern int emu10k1_seq_midi_open(int dev, int mode, 
1444                                 void (*input)(int dev, unsigned char midi_byte),
1445                                 void (*output)(int dev));
1446 extern void emu10k1_seq_midi_close(int dev);
1447 extern int emu10k1_seq_midi_out(int dev, unsigned char midi_byte);
1448 extern int emu10k1_seq_midi_start_read(int dev);
1449 extern int emu10k1_seq_midi_end_read(int dev);
1450 extern void emu10k1_seq_midi_kick(int dev);
1451 extern int emu10k1_seq_midi_buffer_status(int dev);
1452
1453 static struct midi_operations emu10k1_midi_operations =
1454 {
1455         THIS_MODULE,
1456         {"EMU10K1 MIDI", 0, 0, SNDCARD_EMU10K1},
1457         &std_midi_synth,
1458         {0},
1459         emu10k1_seq_midi_open,
1460         emu10k1_seq_midi_close,
1461         NULL,
1462         emu10k1_seq_midi_out,
1463         emu10k1_seq_midi_start_read,
1464         emu10k1_seq_midi_end_read,
1465         emu10k1_seq_midi_kick,
1466         NULL,
1467         emu10k1_seq_midi_buffer_status,
1468         NULL
1469 };
1470
1471 #endif