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