git.oblomov.eu Git - linux-2.6/blob - 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