source: sbliveos2/trunk/sblive/main.c

Last change on this file was 142, checked in by ktk, 25 years ago

Import
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 22.8 KB
RevLine 
[142]1/* $Id: main.c 142 2000-04-23 14:55:46Z ktk $ */
2
3
4/*
5 **********************************************************************
6 * main.c - Creative EMU10K1 audio driver
7 * Copyright 1999, 2000 Creative Labs, Inc.
8 *
9 **********************************************************************
10 *
11 * Date Author Summary of changes
12 * ---- ------ ------------------
13 * October 20, 1999 Bertrand Lee base code release
14 * November 2, 1999 Alan Cox cleaned up stuff
15 *
16 **********************************************************************
17 *
18 * This program is free software; you can redistribute it and/or
19 * modify it under the terms of the GNU General Public License as
20 * published by the Free Software Foundation; either version 2 of
21 * the License, or (at your option) any later version.
22 *
23 * This program is distributed in the hope that it will be useful,
24 * but WITHOUT ANY WARRANTY; without even the implied warranty of
25 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
26 * GNU General Public License for more details.
27 *
28 * You should have received a copy of the GNU General Public
29 * License along with this program; if not, write to the Free
30 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
31 * USA.
32 *
33 **********************************************************************
34 *
35 * Supported devices:
36 * /dev/dsp: Standard /dev/dsp device, OSS-compatible
37 * /dev/mixer: Standard /dev/mixer device, OSS-compatible
38 * /dev/midi: Raw MIDI UART device, mostly OSS-compatible
39 *
40 * Revision history:
41 * 0.1 beta Initial release
42 * 0.2 Lowered initial mixer vol. Improved on stuttering wave playback. Added MIDI UART support.
43 * 0.3 Fixed mixer routing bug, added APS, joystick support.
44 * 0.4 Added rear-channel, SPDIF support.
45 * 0.5 Source cleanup, SMP fixes, multiopen support, 64 bit arch fixes,
46 * moved bh's to tasklets, moved to the new PCI driver initialization style.
47 **********************************************************************
48 */
49
50/* These are only included once per module */
51#include <linux/module.h>
52#include <linux/init.h>
53
54#include "hwaccess.h"
55#include "efxmgr.h"
56#include "cardwo.h"
57#include "cardwi.h"
58#include "cardmo.h"
59#include "cardmi.h"
60#include "recmgr.h"
61
62#define DRIVER_VERSION "0.5"
63
64/* FIXME: is this right? */
65#define EMU10K1_DMA_MASK 0xffffffff /* DMA buffer mask for pci_alloc_consist */
66
67#ifndef PCI_VENDOR_ID_CREATIVE
68#define PCI_VENDOR_ID_CREATIVE 0x1102
69#endif
70
71#ifndef PCI_DEVICE_ID_CREATIVE_EMU10K1
72#define PCI_DEVICE_ID_CREATIVE_EMU10K1 0x0002
73#endif
74
75#define EMU10K1_EXTENT 0x20 /* 32 byte I/O space */
76
77enum {
78 EMU10K1 = 0,
79};
80
81static char *card_names[] __devinitdata = {
82 "EMU10K1",
83};
84
85static struct pci_device_id emu10k1_pci_tbl[] __initdata = {
86 {PCI_VENDOR_ID_CREATIVE, PCI_DEVICE_ID_CREATIVE_EMU10K1,
87 PCI_ANY_ID, PCI_ANY_ID, 0, 0, EMU10K1},
88 {0,}
89};
90
91MODULE_DEVICE_TABLE(pci, emu10k1_pci_tbl);
92
93/* Global var instantiation */
94
95LIST_HEAD(emu10k1_devs);
96
97extern struct file_operations emu10k1_audio_fops;
98extern struct file_operations emu10k1_mixer_fops;
99extern struct file_operations emu10k1_midi_fops;
100
101extern void emu10k1_interrupt(int, void *, struct pt_regs *s);
102extern int emu10k1_mixer_wrch(struct emu10k1_card *, unsigned int, int);
103
104static int __devinit audio_init(struct emu10k1_card *card)
105{
106 if ((card->waveout = kmalloc(sizeof(struct emu10k1_waveout), GFP_KERNEL)) == NULL) {
107 printk(KERN_WARNING "emu10k1: Unable to allocate emu10k1_waveout: out of memory\n");
108 return CTSTATUS_ERROR;
109 }
110 memset(card->waveout, 0, sizeof(struct emu10k1_waveout));
111
112 /* Assign default global volume, reverb, chorus */
113 card->waveout->globalvol = 0xffffffff;
114 card->waveout->left = 0xffff;
115 card->waveout->right = 0xffff;
116 card->waveout->mute = 0;
117 card->waveout->globalreverb = 0xffffffff;
118 card->waveout->globalchorus = 0xffffffff;
119
120 if ((card->wavein = kmalloc(sizeof(struct emu10k1_wavein), GFP_KERNEL))
121 == NULL) {
122 printk(KERN_WARNING "emu10k1: Unable to allocate emu10k1_wavein: out of memory\n");
123 return CTSTATUS_ERROR;
124 }
125 memset(card->wavein, 0, sizeof(struct emu10k1_wavein));
126
127 card->wavein->recsrc = WAVERECORD_AC97;
128
129 return CTSTATUS_SUCCESS;
130}
131
132static void __devinit mixer_init(struct emu10k1_card *card)
133{
134 int count;
135 struct initvol {
136 int mixch;
137 int vol;
138 } initvol[] = {
139 {
140 SOUND_MIXER_VOLUME, 0x5050}, {
141 SOUND_MIXER_OGAIN, 0x3232}, {
142 SOUND_MIXER_SPEAKER, 0x3232}, {
143 SOUND_MIXER_PHONEIN, 0x3232}, {
144 SOUND_MIXER_MIC, 0x0000}, {
145 SOUND_MIXER_LINE, 0x0000}, {
146 SOUND_MIXER_CD, 0x3232}, {
147 SOUND_MIXER_LINE1, 0x3232}, {
148 SOUND_MIXER_LINE3, 0x3232}, {
149 SOUND_MIXER_DIGITAL1, 0x6464}, {
150 SOUND_MIXER_DIGITAL2, 0x6464}, {
151 SOUND_MIXER_PCM, 0x6464}, {
152 SOUND_MIXER_RECLEV, 0x3232}, {
153 SOUND_MIXER_TREBLE, 0x3232}, {
154 SOUND_MIXER_BASS, 0x3232}, {
155 SOUND_MIXER_LINE2, 0x4b4b}};
156
157 int initdig[] = { 0, 1, 2, 3, 6, 7, 18, 19, 20, 21, 24, 25, 72, 73, 74, 75, 78, 79,
158 94, 95
159 };
160
161 /* Reset */
162 sblive_writeac97(card, AC97_RESET, 0);
163
164
165#if 0
166 /* Check status word */
167 {
168 u16 reg;
169
170 sblive_readac97(card, AC97_RESET, &reg);
171 DPD(2, "RESET 0x%x\n", reg);
172 sblive_readac97(card, AC97_MASTERTONE, &reg);
173 DPD(2, "MASTER_TONE 0x%x\n", reg);
174 }
175#endif
176
177 /* Set default recording source to mic in */
178 sblive_writeac97(card, AC97_RECORDSELECT, 0);
179
180 /* Set default AC97 "PCM" volume to acceptable max */
181 //sblive_writeac97(card, AC97_PCMOUTVOLUME, 0);
182 //sblive_writeac97(card, AC97_LINE2, 0);
183
184 /* Set default volumes for all mixer channels */
185
186 for (count = 0; count < sizeof(card->digmix) / sizeof(card->digmix[0]); count++) {
187 card->digmix[count] = 0x80000000;
188 sblive_writeptr(card, FXGPREGBASE + 0x10 + count, 0, 0);
189 }
190
191 for (count = 0; count < sizeof(initdig) / sizeof(initdig[0]); count++) {
192 card->digmix[initdig[count]] = 0x7fffffff;
193 sblive_writeptr(card, FXGPREGBASE + 0x10 + initdig[count], 0, 0x7fffffff);
194 }
195
196 for (count = 0; count < sizeof(initvol) / sizeof(initvol[0]); count++) {
197 emu10k1_mixer_wrch(card, initvol[count].mixch, initvol[count].vol);
198 }
199
200 card->modcnt = 0; // Should this be here or in open() ?
201
202 return;
203}
204
205static int __devinit midi_init(struct emu10k1_card *card)
206{
207 if ((card->mpuout = kmalloc(sizeof(struct emu10k1_mpuout), GFP_KERNEL))
208 == NULL) {
209 printk(KERN_WARNING "emu10k1: Unable to allocate emu10k1_mpuout: out of memory\n");
210 return CTSTATUS_ERROR;
211 }
212
213 memset(card->mpuout, 0, sizeof(struct emu10k1_mpuout));
214
215 card->mpuout->intr = 1;
216 card->mpuout->status = FLAGS_AVAILABLE;
217 card->mpuout->state = CARDMIDIOUT_STATE_DEFAULT;
218
219 tasklet_init(&card->mpuout->tasklet, emu10k1_mpuout_bh, (unsigned long) card);
220
221 spin_lock_init(&card->mpuout->lock);
222
223 if ((card->mpuin = kmalloc(sizeof(struct emu10k1_mpuin), GFP_KERNEL)) == NULL) {
224 kfree(card->mpuout);
225 printk(KERN_WARNING "emu10k1: Unable to allocate emu10k1_mpuin: out of memory\n");
226 return CTSTATUS_ERROR;
227 }
228
229 memset(card->mpuin, 0, sizeof(struct emu10k1_mpuin));
230
231 card->mpuin->status = FLAGS_AVAILABLE;
232
233 tasklet_init(&card->mpuin->tasklet, emu10k1_mpuin_bh, (unsigned long) card->mpuin);
234
235 spin_lock_init(&card->mpuin->lock);
236
237 /* Reset the MPU port */
238 if (emu10k1_mpu_reset(card) != CTSTATUS_SUCCESS) {
239 ERROR();
240 return CTSTATUS_ERROR;
241 }
242
243 return CTSTATUS_SUCCESS;
244}
245
246static void __devinit voice_init(struct emu10k1_card *card)
247{
248 struct voice_manager *voicemgr = &card->voicemgr;
249 struct emu_voice *voice;
250 int i;
251
252 voicemgr->card = card;
253 voicemgr->lock = SPIN_LOCK_UNLOCKED;
254
255 voice = voicemgr->voice;
256 for (i = 0; i < NUM_G; i++) {
257 voice->card = card;
258 voice->usage = VOICEMGR_USAGE_FREE;
259 voice->num = i;
260 voice->linked_voice = NULL;
261 voice++;
262 }
263
264 return;
265}
266
267static void __devinit timer_init(struct emu10k1_card *card)
268{
269 INIT_LIST_HEAD(&card->timers);
270 card->timer_delay = TIMER_STOPPED;
271 card->timer_lock = SPIN_LOCK_UNLOCKED;
272
273 return;
274}
275
276static void __devinit addxmgr_init(struct emu10k1_card *card)
277{
278 u32 count;
279
280 for (count = 0; count < MAXPAGES; count++)
281 card->emupagetable[count] = 0;
282
283 /* Mark first page as used */
284 /* This page is reserved by the driver */
285 card->emupagetable[0] = 0x8001;
286 card->emupagetable[1] = MAXPAGES - RESERVED - 1;
287
288 return;
289}
290
291static void __devinit fx_init(struct emu10k1_card *card)
292{
293 int i, j, k, l;
294 u32 pc = 0;
295
296 for (i = 0; i < 512; i++)
297 OP(6, 0x40, 0x40, 0x40, 0x40);
298
299 for (i = 0; i < 256; i++)
300 sblive_writeptr(card, FXGPREGBASE + i, 0, 0);
301
302 pc = 0;
303
304 for (j = 0; j < 2; j++) {
305
306 OP(4, 0x100, 0x40, j, 0x44);
307 OP(4, 0x101, 0x40, j + 2, 0x44);
308
309 for (i = 0; i < 6; i++) {
310 k = i * 18 + j;
311 OP(0, 0x102, 0x40, 0x110 + k, 0x100);
312 OP(0, 0x102, 0x102, 0x112 + k, 0x101);
313 OP(0, 0x102, 0x102, 0x114 + k, 0x10 + j);
314 OP(0, 0x102, 0x102, 0x116 + k, 0x12 + j);
315 OP(0, 0x102, 0x102, 0x118 + k, 0x14 + j);
316 OP(0, 0x102, 0x102, 0x11a + k, 0x16 + j);
317 OP(0, 0x102, 0x102, 0x11c + k, 0x18 + j);
318 OP(0, 0x102, 0x102, 0x11e + k, 0x1a + j);
319 OP(0, 0x102, 0x102, 0x120 + k, 0x1c + j);
320
321 k = 0x1a0 + i * 8 + j * 4;
322 OP(0, 0x40, 0x40, 0x102, 0x180 + j);
323 OP(7, k + 1, k, k + 1, 0x184 + j);
324 OP(7, k, 0x102, k, 0x182 + j);
325 OP(7, k + 3, k + 2, k + 3, 0x188 + j);
326 OP(0, k + 2, 0x56, k + 2, 0x186 + j);
327 OP(6, k + 2, k + 2, k + 2, 0x40);
328
329 l = 0x1d0 + i * 8 + j * 4;
330 OP(0, 0x40, 0x40, k + 2, 0x190 + j);
331 OP(7, l + 1, l, l + 1, 0x194 + j);
332 OP(7, l, k + 2, l, 0x192 + j);
333 OP(7, l + 3, l + 2, l + 3, 0x198 + j);
334 OP(0, l + 2, 0x56, l + 2, 0x196 + j);
335 OP(4, l + 2, 0x40, l + 2, 0x46);
336
337 OP(6, 0x20 + (i * 2) + j, l + 2, 0x40, 0x40);
338
339 if (i == 0)
340 OP(0, 0x20 + (i * 2) + j, 0x40, l + 2, 0x4e); /* FIXME: Is this really needed? */
341 else
342 OP(6, 0x20 + (i * 2) + j, l + 2, 0x40, 0x40);
343 }
344 }
345 sblive_writeptr(card, DBG, 0, 0);
346
347 return;
348}
349
350static int __devinit hw_init(struct emu10k1_card *card)
351{
352 int nCh;
353
354#ifdef TANKMEM
355 u32 size = 0;
356#endif
357 u32 sizeIdx = 0;
358 u32 pagecount, tmp;
359
360 /* Disable audio and lock cache */
361 sblive_writefn0(card, HCFG, HCFG_LOCKSOUNDCACHE | HCFG_LOCKTANKCACHE | HCFG_MUTEBUTTONENABLE);
362
363 /* Reset recording buffers */
364 sblive_writeptr(card, MICBS, 0, ADCBS_BUFSIZE_NONE);
365 sblive_writeptr(card, MICBA, 0, 0);
366 sblive_writeptr(card, FXBS, 0, ADCBS_BUFSIZE_NONE);
367 sblive_writeptr(card, FXBA, 0, 0);
368 sblive_writeptr(card, ADCBS, 0, ADCBS_BUFSIZE_NONE);
369 sblive_writeptr(card, ADCBA, 0, 0);
370
371 /* Disable channel interrupt */
372 sblive_writefn0(card, INTE, DISABLE);
373 sblive_writeptr(card, CLIEL, 0, 0);
374 sblive_writeptr(card, CLIEH, 0, 0);
375 sblive_writeptr(card, SOLEL, 0, 0);
376 sblive_writeptr(card, SOLEH, 0, 0);
377
378 /* Init envelope engine */
379 for (nCh = 0; nCh < NUM_G; nCh++) {
380 sblive_writeptr(card, DCYSUSV, nCh, ENV_OFF);
381 sblive_writeptr(card, IP, nCh, 0);
382 sblive_writeptr(card, VTFT, nCh, 0xffff);
383 sblive_writeptr(card, CVCF, nCh, 0xffff);
384 sblive_writeptr(card, PTRX, nCh, 0);
385 sblive_writeptr(card, CPF, nCh, 0);
386 sblive_writeptr(card, CCR, nCh, 0);
387
388 sblive_writeptr(card, PSST, nCh, 0);
389 sblive_writeptr(card, DSL, nCh, 0x10);
390 sblive_writeptr(card, CCCA, nCh, 0);
391 sblive_writeptr(card, Z1, nCh, 0);
392 sblive_writeptr(card, Z2, nCh, 0);
393 sblive_writeptr(card, FXRT, nCh, 0xd01c0000);
394
395 sblive_writeptr(card, ATKHLDM, nCh, 0);
396 sblive_writeptr(card, DCYSUSM, nCh, 0);
397 sblive_writeptr(card, IFATN, nCh, 0xffff);
398 sblive_writeptr(card, PEFE, nCh, 0);
399 sblive_writeptr(card, FMMOD, nCh, 0);
400 sblive_writeptr(card, TREMFRQ, nCh, 24); /* 1 Hz */
401 sblive_writeptr(card, FM2FRQ2, nCh, 24); /* 1 Hz */
402 sblive_writeptr(card, TEMPENV, nCh, 0);
403
404 /*** These are last so OFF prevents writing ***/
405 sblive_writeptr(card, LFOVAL2, nCh, 0);
406 sblive_writeptr(card, LFOVAL1, nCh, 0);
407 sblive_writeptr(card, ATKHLDV, nCh, 0);
408 sblive_writeptr(card, ENVVOL, nCh, 0);
409 sblive_writeptr(card, ENVVAL, nCh, 0);
410 }
411
412 /*
413 ** Init to 0x02109204 :
414 ** Clock accuracy = 0 (1000ppm)
415 ** Sample Rate = 2 (48kHz)
416 ** Audio Channel = 1 (Left of 2)
417 ** Source Number = 0 (Unspecified)
418 ** Generation Status = 1 (Original for Cat Code 12)
419 ** Cat Code = 12 (Digital Signal Mixer)
420 ** Mode = 0 (Mode 0)
421 ** Emphasis = 0 (None)
422 ** CP = 1 (Copyright unasserted)
423 ** AN = 0 (Digital audio)
424 ** P = 0 (Consumer)
425 */
426
427 /* SPDIF0 */
428 sblive_writeptr(card, SPCS0, 0, SPCS_CLKACCY_1000PPM | 0x002000000 |
429 SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC | SPCS_GENERATIONSTATUS | 0x00001200 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT);
430
431 /* SPDIF1 */
432 sblive_writeptr(card, SPCS1, 0, SPCS_CLKACCY_1000PPM | 0x002000000 |
433 SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC | SPCS_GENERATIONSTATUS | 0x00001200 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT);
434
435 /* SPDIF2 & SPDIF3 */
436 sblive_writeptr(card, SPCS2, 0, SPCS_CLKACCY_1000PPM | 0x002000000 |
437 SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC | SPCS_GENERATIONSTATUS | 0x00001200 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT);
438
439 fx_init(card); /* initialize effects engine */
440
441 card->tankmem = NULL;
442
443#ifdef TANKMEM
444 size = TMEMSIZE;
445 sizeIdx = TMEMSIZEREG;
446 while (size > 16384) {
447 if ((card->tankmem = emu10k1_alloc_memphysical(size)) != NULL)
448 break;
449
450 size /= 2;
451 sizeIdx -= 1;
452 }
453
454 if (card->tankmem == NULL) {
455 card->tmemsize = 0;
456 return CTSTATUS_ERROR;
457 }
458
459 card->tmemsize = size;
460#else /* !TANKMEM */
461 card->tmemsize = 0;
462#endif /* TANKMEM */
463
464 if ((card->virtualpagetable = emu10k1_alloc_memphysical((MAXPAGES - RESERVED) * sizeof(u32))) == NULL) {
465 ERROR();
466 emu10k1_free_memphysical(card->tankmem);
467 return CTSTATUS_ERROR;
468 }
469
470 if ((card->silentpage = emu10k1_alloc_memphysical(EMUPAGESIZE)) == NULL) {
471 ERROR();
472 emu10k1_free_memphysical(card->tankmem);
473 emu10k1_free_memphysical(card->virtualpagetable);
474 return CTSTATUS_ERROR;
475 } else
476 memset(card->silentpage->virtaddx, 0, EMUPAGESIZE);
477
478 for (pagecount = 0; pagecount < (MAXPAGES - RESERVED); pagecount++)
479
480 ((u32 *) card->virtualpagetable->virtaddx)[pagecount] = (card->silentpage->busaddx * 2) | pagecount;
481
482 /* Init page table & tank memory base register */
483 sblive_writeptr(card, PTB, 0, card->virtualpagetable->busaddx);
484#ifdef TANKMEM
485 sblive_writeptr(card, TCB, 0, card->tankmem->busaddx);
486#else
487 sblive_writeptr(card, TCB, 0, 0);
488#endif
489 sblive_writeptr(card, TCBS, 0, sizeIdx);
490
491 for (nCh = 0; nCh < NUM_G; nCh++) {
492 sblive_writeptr(card, MAPA, nCh, MAP_PTI_MASK | (card->silentpage->busaddx * 2));
493 sblive_writeptr(card, MAPB, nCh, MAP_PTI_MASK | (card->silentpage->busaddx * 2));
494 }
495
496 /* Hokay, now enable the AUD bit */
497 /* Enable Audio = 1 */
498 /* Mute Disable Audio = 0 */
499 /* Lock Tank Memory = 1 */
500 /* Lock Sound Memory = 0 */
501 /* Auto Mute = 1 */
502
503 sblive_rmwac97(card, AC97_MASTERVOLUME, 0x8000, 0x8000);
504
505 sblive_writeac97(card, AC97_MASTERVOLUME, 0);
506 sblive_writeac97(card, AC97_PCMOUTVOLUME, 0);
507
508 sblive_writefn0(card, HCFG, HCFG_AUDIOENABLE | HCFG_LOCKTANKCACHE | HCFG_AUTOMUTE | HCFG_JOYENABLE);
509
510 /* TOSLink detection */
511 card->has_toslink = 0;
512
513 tmp = sblive_readfn0(card, HCFG);
514 if (tmp & (HCFG_GPINPUT0 | HCFG_GPINPUT1)) {
515 sblive_writefn0(card, HCFG, tmp | 0x800);
516
517 udelay(512);
518
519 if (tmp != (sblive_readfn0(card, HCFG) & ~0x800)) {
520 card->has_toslink = 1;
521 sblive_writefn0(card, HCFG, tmp);
522 }
523 }
524
525 return CTSTATUS_SUCCESS;
526}
527
528static int __devinit emu10k1_init(struct emu10k1_card *card)
529{
530 /* Init Card */
531 if (hw_init(card) != CTSTATUS_SUCCESS)
532 return CTSTATUS_ERROR;
533
534
535 voice_init(card);
536 timer_init(card);
537 addxmgr_init(card);
538
539 DPD(2, " hw control register -> %x\n", sblive_readfn0(card, HCFG));
540
541 return CTSTATUS_SUCCESS;
542}
543
544static void __devexit audio_exit(struct emu10k1_card *card)
545{
546 kfree(card->waveout);
547 kfree(card->wavein);
548 return;
549}
550
551static void __devexit midi_exit(struct emu10k1_card *card)
552{
553 tasklet_unlock_wait(&card->mpuout->tasklet);
554 kfree(card->mpuout);
555
556 tasklet_unlock_wait(&card->mpuin->tasklet);
557 kfree(card->mpuin);
558
559 return;
560}
561
562static void __devexit emu10k1_exit(struct emu10k1_card *card)
563{
564 int ch;
565
566 sblive_writefn0(card, INTE, DISABLE);
567
568 /** Shutdown the chip **/
569 for (ch = 0; ch < NUM_G; ch++)
570 sblive_writeptr(card, DCYSUSV, ch, ENV_OFF);
571
572 for (ch = 0; ch < NUM_G; ch++) {
573 sblive_writeptr(card, VTFT, ch, 0);
574 sblive_writeptr(card, CVCF, ch, 0);
575 sblive_writeptr(card, PTRX, ch, 0);
576 sblive_writeptr(card, CPF, ch, 0);
577 }
578
579 /* Reset recording buffers */
580 sblive_writeptr(card, MICBS, 0, ADCBS_BUFSIZE_NONE);
581 sblive_writeptr(card, MICBA, 0, 0);
582 sblive_writeptr(card, FXBS, 0, ADCBS_BUFSIZE_NONE);
583 sblive_writeptr(card, FXBA, 0, 0);
584 sblive_writeptr(card, FXWC, 0, 0);
585 sblive_writeptr(card, ADCBS, 0, ADCBS_BUFSIZE_NONE);
586 sblive_writeptr(card, ADCBA, 0, 0);
587 sblive_writeptr(card, TCBS, 0, TCBS_BUFFSIZE_16K);
588 sblive_writeptr(card, TCB, 0, 0);
589 sblive_writeptr(card, DBG, 0, 0x8000);
590
591 /* Disable channel interrupt */
592 sblive_writeptr(card, CLIEL, 0, 0);
593 sblive_writeptr(card, CLIEH, 0, 0);
594 sblive_writeptr(card, SOLEL, 0, 0);
595 sblive_writeptr(card, SOLEH, 0, 0);
596
597 /* Disable audio and lock cache */
598 sblive_writefn0(card, HCFG, HCFG_LOCKSOUNDCACHE | HCFG_LOCKTANKCACHE | HCFG_MUTEBUTTONENABLE);
599 sblive_writeptr(card, PTB, 0, 0);
600
601 emu10k1_free_memphysical(card->silentpage);
602 emu10k1_free_memphysical(card->virtualpagetable);
603#ifdef TANKMEM
604 emu10k1_free_memphysical(card->tankmem);
605#endif
606 return;
607}
608
609/* Driver initialization routine */
610static int __devinit emu10k1_probe(struct pci_dev *pci_dev, const struct pci_device_id *pci_id)
611{
612 struct emu10k1_card *card;
613
614 if ((card = kmalloc(sizeof(struct emu10k1_card), GFP_KERNEL)) == NULL) {
615 printk(KERN_ERR "emu10k1: out of memory\n");
616 return -ENOMEM;
617 }
618 memset(card, 0, sizeof(struct emu10k1_card));
619
620#if LINUX_VERSION_CODE > 0x020320
621 if (!pci_dma_supported(pci_dev, EMU10K1_DMA_MASK)) {
622 printk(KERN_ERR "emu10k1: architecture does not support 32bit PCI busmaster DMA\n");
623 kfree(card);
624 return -ENODEV;
625 }
626
627 if (pci_enable_device(pci_dev)) {
628 printk(KERN_ERR "emu10k1: couldn't enable device\n");
629 kfree(card);
630 return -ENODEV;
631 }
632
633 pci_set_master(pci_dev);
634
635 card->iobase = pci_dev->resource[0].start;
636
637 if (request_region(card->iobase, EMU10K1_EXTENT, card_names[pci_id->driver_data]) == NULL) {
638 printk(KERN_ERR "emu10k1: IO space in use\n");
639 kfree(card);
640 return -ENODEV;
641 }
642 pci_dev->driver_data = card;
643 pci_dev->dma_mask = EMU10K1_DMA_MASK;
644#else
645 pci_set_master(pci_dev);
646
647 card->iobase = pci_dev->base_address[0] & PCI_BASE_ADDRESS_IO_MASK;
648
649 if (check_region(card->iobase, EMU10K1_EXTENT)) {
650 printk(KERN_ERR "emu10k1: IO space in use\n");
651 kfree(card);
652 return -ENODEV;
653 }
654
655 request_region(card->iobase, EMU10K1_EXTENT, card_names[pci_id->driver_data]);
656#endif
657 card->irq = pci_dev->irq;
658 card->pci_dev = pci_dev;
659
660 /* Reserve IRQ Line */
661 if (request_irq(card->irq, emu10k1_interrupt, SA_SHIRQ, card_names[pci_id->driver_data], card)) {
662 printk(KERN_ERR "emu10k1: IRQ in use\n");
663 goto err_irq;
664 }
665
666 pci_read_config_byte(pci_dev, PCI_REVISION_ID, &card->chiprev);
667
668 printk(KERN_INFO "emu10k1: %s rev %d found at IO 0x%04lx, IRQ %d\n", card_names[pci_id->driver_data], card->chiprev, card->iobase, card->irq);
669
670 spin_lock_init(&card->lock);
671 card->mixeraddx = card->iobase + AC97DATA;
672 init_MUTEX(&card->open_sem);
673 card->open_mode = 0;
674 init_waitqueue_head(&card->open_wait);
675
676 /* Register devices */
677 if ((card->audio1_num = register_sound_dsp(&emu10k1_audio_fops, -1)) < 0) {
678 printk(KERN_ERR "emu10k1: cannot register first audio device!\n");
679 goto err_dev0;
680 }
681
682 if ((card->audio2_num = register_sound_dsp(&emu10k1_audio_fops, -1)) < 0) {
683 printk(KERN_ERR "emu10k1: cannot register second audio device!\n");
684 goto err_dev1;
685 }
686
687 if ((card->mixer_num = register_sound_mixer(&emu10k1_mixer_fops, -1)) < 0) {
688 printk(KERN_ERR "emu10k1: cannot register mixer device!\n");
689 goto err_dev2;
690 }
691
692 if ((card->midi_num = register_sound_midi(&emu10k1_midi_fops, -1)) < 0) {
693 printk(KERN_ERR "emu10k1: cannot register midi device!\n");
694 goto err_dev3;
695 }
696
697 if (emu10k1_init(card) != CTSTATUS_SUCCESS) {
698 printk(KERN_ERR "emu10k1: cannot initialize device!\n");
699 goto err_emu10k1_init;
700 }
701
702 if (audio_init(card) != CTSTATUS_SUCCESS) {
703 printk(KERN_ERR "emu10k1: cannot initialize audio!\n");
704 goto err_audio_init;
705 }
706
707 if (midi_init(card) != CTSTATUS_SUCCESS) {
708 printk(KERN_ERR "emu10k1: cannot initialize midi!\n");
709 goto err_midi_init;
710 }
711
712 mixer_init(card);
713
714 DPD(2, "Hardware initialized. TRAM allocated: %u bytes\n", (unsigned int) card->tmemsize);
715
716 list_add(&card->list, &emu10k1_devs);
717
718 return 0;
719
720 err_midi_init:
721 audio_exit(card);
722
723 err_audio_init:
724 emu10k1_exit(card);
725
726 err_emu10k1_init:
727 unregister_sound_midi(card->midi_num);
728
729 err_dev3:
730 unregister_sound_mixer(card->mixer_num);
731
732 err_dev2:
733 unregister_sound_dsp(card->audio2_num);
734
735 err_dev1:
736 unregister_sound_dsp(card->audio1_num);
737
738 err_dev0:
739 free_irq(card->irq, card);
740
741 err_irq:
742 release_region(card->iobase, EMU10K1_EXTENT);
743 kfree(card);
744
745 return -ENODEV;
746}
747
748static void __devexit emu10k1_remove(struct pci_dev *pci_dev)
749{
750#if LINUX_VERSION_CODE > 0x020320
751 struct emu10k1_card *card = pci_dev->driver_data;
752#else
753 struct emu10k1_card *card = list_entry(emu10k1_devs.next, struct emu10k1_card, list);
754#endif
755 midi_exit(card);
756 audio_exit(card);
757 emu10k1_exit(card);
758
759 unregister_sound_midi(card->midi_num);
760 unregister_sound_mixer(card->mixer_num);
761 unregister_sound_dsp(card->audio2_num);
762 unregister_sound_dsp(card->audio1_num);
763
764 free_irq(card->irq, card);
765 release_region(card->iobase, EMU10K1_EXTENT);
766
767 list_del(&card->list);
768
769 kfree(card);
770 return;
771}
772
773MODULE_AUTHOR("Bertrand Lee, Cai Ying. (Email to: emu10k1-devel@opensource.creative.com)");
774MODULE_DESCRIPTION("Creative EMU10K1 PCI Audio Driver v" DRIVER_VERSION "\nCopyright (C) 1999 Creative Technology Ltd.");
775
776#ifdef TARGET_OS2
777static struct pci_driver emu10k1_pci_driver = {
778 {0},
779 "emu10k1",
780 emu10k1_pci_tbl,
781 emu10k1_probe,
782 emu10k1_remove,
783 NULL,
784 NULL
785};
786#else
787static struct pci_driver emu10k1_pci_driver __initdata = {
788 name:"emu10k1",
789 id_table:emu10k1_pci_tbl,
790 probe:emu10k1_probe,
791 remove:emu10k1_remove,
792};
793#endif //TARGET_OS2
794
795#if LINUX_VERSION_CODE > 0x020320
796static int __init emu10k1_init_module(void)
797{
798 printk(KERN_INFO "Creative EMU10K1 PCI Audio Driver, version " DRIVER_VERSION ", " __TIME__ " " __DATE__ "\n");
799
800 return pci_module_init(&emu10k1_pci_driver);
801}
802
803static void __exit emu10k1_cleanup_module(void)
804{
805 pci_unregister_driver(&emu10k1_pci_driver);
806 return;
807}
808
809#else
810
811static int __init emu10k1_init_module(void)
812{
813 struct pci_dev *dev = NULL;
814 const struct pci_device_id *pci_id = emu10k1_pci_driver.id_table;
815
816 printk(KERN_INFO "Creative EMU10K1 PCI Audio Driver, version " DRIVER_VERSION ", " __TIME__ " " __DATE__ "\n");
817
818 if (!pci_present())
819 return -ENODEV;
820
821 while (pci_id->vendor) {
822 while ((dev = pci_find_device(pci_id->vendor, pci_id->device, dev)))
823 emu10k1_probe(dev, pci_id);
824
825 pci_id++;
826 }
827 return 0;
828}
829
830static void __exit emu10k1_cleanup_module(void)
831{
832 struct emu10k1_card *card;
833
834 while (!list_empty(&emu10k1_devs)) {
835 card = list_entry(emu10k1_devs.next, struct emu10k1_card, list);
836
837 emu10k1_remove(card->pci_dev);
838 }
839
840 return;
841}
842
843#endif
844
845module_init(emu10k1_init_module);
846module_exit(emu10k1_cleanup_module);
Note: See TracBrowser for help on using the repository browser.