projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[ALSA] snd-ca0106: Add support for X-Fi Extreme Audio.
[deliverable/linux.git] / sound / pci / ca0106 / ca0106_main.c
1 /*
2 * Copyright (c) 2004 James Courtier-Dutton <James@superbug.demon.co.uk>
3 * Driver CA0106 chips. e.g. Sound Blaster Audigy LS and Live 24bit
4 * Version: 0.0.23
5 *
6 * FEATURES currently supported:
7 * Front, Rear and Center/LFE.
8 * Surround40 and Surround51.
9 * Capture from MIC an LINE IN input.
10 * SPDIF digital playback of PCM stereo and AC3/DTS works.
11 * (One can use a standard mono mini-jack to one RCA plugs cable.
12 * or one can use a standard stereo mini-jack to two RCA plugs cable.
13 * Plug one of the RCA plugs into the Coax input of the external decoder/receiver.)
14 * ( In theory one could output 3 different AC3 streams at once, to 3 different SPDIF outputs. )
15 * Notes on how to capture sound:
16 * The AC97 is used in the PLAYBACK direction.
17 * The output from the AC97 chip, instead of reaching the speakers, is fed into the Philips 1361T ADC.
18 * So, to record from the MIC, set the MIC Playback volume to max,
19 * unmute the MIC and turn up the MASTER Playback volume.
20 * So, to prevent feedback when capturing, minimise the "Capture feedback into Playback" volume.
21 *
22 * The only playback controls that currently do anything are: -
23 * Analog Front
24 * Analog Rear
25 * Analog Center/LFE
26 * SPDIF Front
27 * SPDIF Rear
28 * SPDIF Center/LFE
29 *
30 * For capture from Mic in or Line in.
31 * Digital/Analog ( switch must be in Analog mode for CAPTURE. )
32 *
33 * CAPTURE feedback into PLAYBACK
34 *
35 * Changelog:
36 * Support interrupts per period.
37 * Removed noise from Center/LFE channel when in Analog mode.
38 * Rename and remove mixer controls.
39 * 0.0.6
40 * Use separate card based DMA buffer for periods table list.
41 * 0.0.7
42 * Change remove and rename ctrls into lists.
43 * 0.0.8
44 * Try to fix capture sources.
45 * 0.0.9
46 * Fix AC3 output.
47 * Enable S32_LE format support.
48 * 0.0.10
49 * Enable playback 48000 and 96000 rates. (Rates other that these do not work, even with "plug:front".)
50 * 0.0.11
51 * Add Model name recognition.
52 * 0.0.12
53 * Correct interrupt timing. interrupt at end of period, instead of in the middle of a playback period.
54 * Remove redundent "voice" handling.
55 * 0.0.13
56 * Single trigger call for multi channels.
57 * 0.0.14
58 * Set limits based on what the sound card hardware can do.
59 * playback periods_min=2, periods_max=8
60 * capture hw constraints require period_size = n * 64 bytes.
61 * playback hw constraints require period_size = n * 64 bytes.
62 * 0.0.15
63 * Minor updates.
64 * 0.0.16
65 * Implement 192000 sample rate.
66 * 0.0.17
67 * Add support for SB0410 and SB0413.
68 * 0.0.18
69 * Modified Copyright message.
70 * 0.0.19
71 * Finally fix support for SB Live 24 bit. SB0410 and SB0413.
72 * The output codec needs resetting, otherwise all output is muted.
73 * 0.0.20
74 * Merge "pci_disable_device(pci);" fixes.
75 * 0.0.21
76 * Add 4 capture channels. (SPDIF only comes in on channel 0. )
77 * Add SPDIF capture using optional digital I/O module for SB Live 24bit. (Analog capture does not yet work.)
78 * 0.0.22
79 * Add support for MSI K8N Diamond Motherboard with onboard SB Live 24bit without AC97. From kiksen, bug #901
80 * 0.0.23
81 * Implement support for Line-in capture on SB Live 24bit.
82 *
83 * BUGS:
84 * Some stability problems when unloading the snd-ca0106 kernel module.
85 * --
86 *
87 * TODO:
88 * 4 Capture channels, only one implemented so far.
89 * Other capture rates apart from 48khz not implemented.
90 * MIDI
91 * --
92 * GENERAL INFO:
93 * Model: SB0310
94 * P17 Chip: CA0106-DAT
95 * AC97 Codec: STAC 9721
96 * ADC: Philips 1361T (Stereo 24bit)
97 * DAC: WM8746EDS (6-channel, 24bit, 192Khz)
98 *
99 * GENERAL INFO:
100 * Model: SB0410
101 * P17 Chip: CA0106-DAT
102 * AC97 Codec: None
103 * ADC: WM8775EDS (4 Channel)
104 * DAC: CS4382 (114 dB, 24-Bit, 192 kHz, 8-Channel D/A Converter with DSD Support)
105 * SPDIF Out control switches between Mic in and SPDIF out.
106 * No sound out or mic input working yet.
107 *
108 * GENERAL INFO:
109 * Model: SB0413
110 * P17 Chip: CA0106-DAT
111 * AC97 Codec: None.
112 * ADC: Unknown
113 * DAC: Unknown
114 * Trying to handle it like the SB0410.
115 *
116 * This code was initally based on code from ALSA's emu10k1x.c which is:
117 * Copyright (c) by Francisco Moraes <fmoraes@nc.rr.com>
118 *
119 * This program is free software; you can redistribute it and/or modify
120 * it under the terms of the GNU General Public License as published by
121 * the Free Software Foundation; either version 2 of the License, or
122 * (at your option) any later version.
123 *
124 * This program is distributed in the hope that it will be useful,
125 * but WITHOUT ANY WARRANTY; without even the implied warranty of
126 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
127 * GNU General Public License for more details.
128 *
129 * You should have received a copy of the GNU General Public License
130 * along with this program; if not, write to the Free Software
131 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
132 *
133 */
134 #include <sound/driver.h>
135 #include <linux/delay.h>
136 #include <linux/init.h>
137 #include <linux/interrupt.h>
138 #include <linux/pci.h>
139 #include <linux/slab.h>
140 #include <linux/moduleparam.h>
141 #include <linux/dma-mapping.h>
142 #include <sound/core.h>
143 #include <sound/initval.h>
144 #include <sound/pcm.h>
145 #include <sound/ac97_codec.h>
146 #include <sound/info.h>
147
148 MODULE_AUTHOR("James Courtier-Dutton <James@superbug.demon.co.uk>");
149 MODULE_DESCRIPTION("CA0106");
150 MODULE_LICENSE("GPL");
151 MODULE_SUPPORTED_DEVICE("{{Creative,SB CA0106 chip}}");
152
153 // module parameters (see "Module Parameters")
154 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
155 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
156 static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
157 static uint subsystem[SNDRV_CARDS]; /* Force card subsystem model */
158
159 module_param_array(index, int, NULL, 0444);
160 MODULE_PARM_DESC(index, "Index value for the CA0106 soundcard.");
161 module_param_array(id, charp, NULL, 0444);
162 MODULE_PARM_DESC(id, "ID string for the CA0106 soundcard.");
163 module_param_array(enable, bool, NULL, 0444);
164 MODULE_PARM_DESC(enable, "Enable the CA0106 soundcard.");
165 module_param_array(subsystem, uint, NULL, 0444);
166 MODULE_PARM_DESC(subsystem, "Force card subsystem model.");
167
168 #include "ca0106.h"
169
170 static struct snd_ca0106_details ca0106_chip_details[] = {
171 /* Sound Blaster X-Fi Extreme Audio. This does not have an AC97. 53SB079000000 */
172 /* It is really just a normal SB Live 24bit. */
173 /*
174 * CTRL:CA0111-WTLF
175 * ADC: WM8775SEDS
176 * DAC: CS4382-KQZ
177 */
178 /* Tested:
179 * Playback on front, rear, center/lfe speakers
180 * Capture from Mic in.
181 * Not-Tested:
182 * Capture from Line in.
183 * Playback to digital out.
184 */
185 { .serial = 0x10121102,
186 .name = "X-Fi Extreme Audio [SB0790]",
187 .gpio_type = 1,
188 .i2c_adc = 1 } ,
189 /* New Dell Sound Blaster Live! 7.1 24bit. This does not have an AC97. */
190 /* AudigyLS[SB0310] */
191 { .serial = 0x10021102,
192 .name = "AudigyLS [SB0310]",
193 .ac97 = 1 } ,
194 /* Unknown AudigyLS that also says SB0310 on it */
195 { .serial = 0x10051102,
196 .name = "AudigyLS [SB0310b]",
197 .ac97 = 1 } ,
198 /* New Sound Blaster Live! 7.1 24bit. This does not have an AC97. 53SB041000001 */
199 { .serial = 0x10061102,
200 .name = "Live! 7.1 24bit [SB0410]",
201 .gpio_type = 1,
202 .i2c_adc = 1 } ,
203 /* New Dell Sound Blaster Live! 7.1 24bit. This does not have an AC97. */
204 { .serial = 0x10071102,
205 .name = "Live! 7.1 24bit [SB0413]",
206 .gpio_type = 1,
207 .i2c_adc = 1 } ,
208 /* New Audigy SE. Has a different DAC. */
209 /* SB0570:
210 * CTRL:CA0106-DAT
211 * ADC: WM8775EDS
212 * DAC: WM8768GEDS
213 */
214 { .serial = 0x100a1102,
215 .name = "Audigy SE [SB0570]",
216 .gpio_type = 1,
217 .i2c_adc = 1,
218 .spi_dac = 1 } ,
219 /* New Audigy LS. Has a different DAC. */
220 /* SB0570:
221 * CTRL:CA0106-DAT
222 * ADC: WM8775EDS
223 * DAC: WM8768GEDS
224 */
225 { .serial = 0x10111102,
226 .name = "Audigy SE OEM [SB0570a]",
227 .gpio_type = 1,
228 .i2c_adc = 1,
229 .spi_dac = 1 } ,
230 /* MSI K8N Diamond Motherboard with onboard SB Live 24bit without AC97 */
231 /* SB0438
232 * CTRL:CA0106-DAT
233 * ADC: WM8775SEDS
234 * DAC: CS4382-KQZ
235 */
236 { .serial = 0x10091462,
237 .name = "MSI K8N Diamond MB [SB0438]",
238 .gpio_type = 2,
239 .i2c_adc = 1 } ,
240 /* Shuttle XPC SD31P which has an onboard Creative Labs
241 * Sound Blaster Live! 24-bit EAX
242 * high-definition 7.1 audio processor".
243 * Added using info from andrewvegan in alsa bug #1298
244 */
245 { .serial = 0x30381297,
246 .name = "Shuttle XPC SD31P [SD31P]",
247 .gpio_type = 1,
248 .i2c_adc = 1 } ,
249 /* Shuttle XPC SD11G5 which has an onboard Creative Labs
250 * Sound Blaster Live! 24-bit EAX
251 * high-definition 7.1 audio processor".
252 * Fixes ALSA bug#1600
253 */
254 { .serial = 0x30411297,
255 .name = "Shuttle XPC SD11G5 [SD11G5]",
256 .gpio_type = 1,
257 .i2c_adc = 1 } ,
258 { .serial = 0,
259 .name = "AudigyLS [Unknown]" }
260 };
261
262 /* hardware definition */
263 static struct snd_pcm_hardware snd_ca0106_playback_hw = {
264 .info = (SNDRV_PCM_INFO_MMAP |
265 SNDRV_PCM_INFO_INTERLEAVED |
266 SNDRV_PCM_INFO_BLOCK_TRANSFER |
267 SNDRV_PCM_INFO_MMAP_VALID),
268 .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S32_LE,
269 .rates = (SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_96000 |
270 SNDRV_PCM_RATE_192000),
271 .rate_min = 48000,
272 .rate_max = 192000,
273 .channels_min = 2, //1,
274 .channels_max = 2, //6,
275 .buffer_bytes_max = ((65536 - 64) * 8),
276 .period_bytes_min = 64,
277 .period_bytes_max = (65536 - 64),
278 .periods_min = 2,
279 .periods_max = 8,
280 .fifo_size = 0,
281 };
282
283 static struct snd_pcm_hardware snd_ca0106_capture_hw = {
284 .info = (SNDRV_PCM_INFO_MMAP |
285 SNDRV_PCM_INFO_INTERLEAVED |
286 SNDRV_PCM_INFO_BLOCK_TRANSFER |
287 SNDRV_PCM_INFO_MMAP_VALID),
288 .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S32_LE,
289 .rates = (SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |
290 SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_192000),
291 .rate_min = 44100,
292 .rate_max = 192000,
293 .channels_min = 2,
294 .channels_max = 2,
295 .buffer_bytes_max = ((65536 - 64) * 8),
296 .period_bytes_min = 64,
297 .period_bytes_max = (65536 - 64),
298 .periods_min = 2,
299 .periods_max = 2,
300 .fifo_size = 0,
301 };
302
303 unsigned int snd_ca0106_ptr_read(struct snd_ca0106 * emu,
304 unsigned int reg,
305 unsigned int chn)
306 {
307 unsigned long flags;
308 unsigned int regptr, val;
309
310 regptr = (reg << 16) | chn;
311
312 spin_lock_irqsave(&emu->emu_lock, flags);
313 outl(regptr, emu->port + PTR);
314 val = inl(emu->port + DATA);
315 spin_unlock_irqrestore(&emu->emu_lock, flags);
316 return val;
317 }
318
319 void snd_ca0106_ptr_write(struct snd_ca0106 *emu,
320 unsigned int reg,
321 unsigned int chn,
322 unsigned int data)
323 {
324 unsigned int regptr;
325 unsigned long flags;
326
327 regptr = (reg << 16) | chn;
328
329 spin_lock_irqsave(&emu->emu_lock, flags);
330 outl(regptr, emu->port + PTR);
331 outl(data, emu->port + DATA);
332 spin_unlock_irqrestore(&emu->emu_lock, flags);
333 }
334
335 int snd_ca0106_spi_write(struct snd_ca0106 * emu,
336 unsigned int data)
337 {
338 unsigned int reset, set;
339 unsigned int reg, tmp;
340 int n, result;
341 reg = SPI;
342 if (data > 0xffff) /* Only 16bit values allowed */
343 return 1;
344 tmp = snd_ca0106_ptr_read(emu, reg, 0);
345 reset = (tmp & ~0x3ffff) | 0x20000; /* Set xxx20000 */
346 set = reset | 0x10000; /* Set xxx1xxxx */
347 snd_ca0106_ptr_write(emu, reg, 0, reset | data);
348 tmp = snd_ca0106_ptr_read(emu, reg, 0); /* write post */
349 snd_ca0106_ptr_write(emu, reg, 0, set | data);
350 result = 1;
351 /* Wait for status bit to return to 0 */
352 for (n = 0; n < 100; n++) {
353 udelay(10);
354 tmp = snd_ca0106_ptr_read(emu, reg, 0);
355 if (!(tmp & 0x10000)) {
356 result = 0;
357 break;
358 }
359 }
360 if (result) /* Timed out */
361 return 1;
362 snd_ca0106_ptr_write(emu, reg, 0, reset | data);
363 tmp = snd_ca0106_ptr_read(emu, reg, 0); /* Write post */
364 return 0;
365 }
366
367 /* The ADC does not support i2c read, so only write is implemented */
368 int snd_ca0106_i2c_write(struct snd_ca0106 *emu,
369 u32 reg,
370 u32 value)
371 {
372 u32 tmp;
373 int timeout = 0;
374 int status;
375 int retry;
376 if ((reg > 0x7f) || (value > 0x1ff)) {
377 snd_printk(KERN_ERR "i2c_write: invalid values.\n");
378 return -EINVAL;
379 }
380
381 tmp = reg << 25 | value << 16;
382 // snd_printk("I2C-write:reg=0x%x, value=0x%x\n", reg, value);
383 /* Not sure what this I2C channel controls. */
384 /* snd_ca0106_ptr_write(emu, I2C_D0, 0, tmp); */
385
386 /* This controls the I2C connected to the WM8775 ADC Codec */
387 snd_ca0106_ptr_write(emu, I2C_D1, 0, tmp);
388
389 for (retry = 0; retry < 10; retry++) {
390 /* Send the data to i2c */
391 //tmp = snd_ca0106_ptr_read(emu, I2C_A, 0);
392 //tmp = tmp & ~(I2C_A_ADC_READ|I2C_A_ADC_LAST|I2C_A_ADC_START|I2C_A_ADC_ADD_MASK);
393 tmp = 0;
394 tmp = tmp | (I2C_A_ADC_LAST|I2C_A_ADC_START|I2C_A_ADC_ADD);
395 snd_ca0106_ptr_write(emu, I2C_A, 0, tmp);
396
397 /* Wait till the transaction ends */
398 while (1) {
399 status = snd_ca0106_ptr_read(emu, I2C_A, 0);
400 //snd_printk("I2C:status=0x%x\n", status);
401 timeout++;
402 if ((status & I2C_A_ADC_START) == 0)
403 break;
404
405 if (timeout > 1000)
406 break;
407 }
408 //Read back and see if the transaction is successful
409 if ((status & I2C_A_ADC_ABORT) == 0)
410 break;
411 }
412
413 if (retry == 10) {
414 snd_printk(KERN_ERR "Writing to ADC failed!\n");
415 return -EINVAL;
416 }
417
418 return 0;
419 }
420
421
422 static void snd_ca0106_intr_enable(struct snd_ca0106 *emu, unsigned int intrenb)
423 {
424 unsigned long flags;
425 unsigned int enable;
426
427 spin_lock_irqsave(&emu->emu_lock, flags);
428 enable = inl(emu->port + INTE) | intrenb;
429 outl(enable, emu->port + INTE);
430 spin_unlock_irqrestore(&emu->emu_lock, flags);
431 }
432
433 static void snd_ca0106_intr_disable(struct snd_ca0106 *emu, unsigned int intrenb)
434 {
435 unsigned long flags;
436 unsigned int enable;
437
438 spin_lock_irqsave(&emu->emu_lock, flags);
439 enable = inl(emu->port + INTE) & ~intrenb;
440 outl(enable, emu->port + INTE);
441 spin_unlock_irqrestore(&emu->emu_lock, flags);
442 }
443
444
445 static void snd_ca0106_pcm_free_substream(struct snd_pcm_runtime *runtime)
446 {
447 kfree(runtime->private_data);
448 }
449
450 /* open_playback callback */
451 static int snd_ca0106_pcm_open_playback_channel(struct snd_pcm_substream *substream,
452 int channel_id)
453 {
454 struct snd_ca0106 *chip = snd_pcm_substream_chip(substream);
455 struct snd_ca0106_channel *channel = &(chip->playback_channels[channel_id]);
456 struct snd_ca0106_pcm *epcm;
457 struct snd_pcm_runtime *runtime = substream->runtime;
458 int err;
459
460 epcm = kzalloc(sizeof(*epcm), GFP_KERNEL);
461
462 if (epcm == NULL)
463 return -ENOMEM;
464 epcm->emu = chip;
465 epcm->substream = substream;
466 epcm->channel_id=channel_id;
467
468 runtime->private_data = epcm;
469 runtime->private_free = snd_ca0106_pcm_free_substream;
470
471 runtime->hw = snd_ca0106_playback_hw;
472
473 channel->emu = chip;
474 channel->number = channel_id;
475
476 channel->use = 1;
477 //printk("open:channel_id=%d, chip=%p, channel=%p\n",channel_id, chip, channel);
478 //channel->interrupt = snd_ca0106_pcm_channel_interrupt;
479 channel->epcm = epcm;
480 if ((err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
481 return err;
482 if ((err = snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 64)) < 0)
483 return err;
484 return 0;
485 }
486
487 /* close callback */
488 static int snd_ca0106_pcm_close_playback(struct snd_pcm_substream *substream)
489 {
490 struct snd_ca0106 *chip = snd_pcm_substream_chip(substream);
491 struct snd_pcm_runtime *runtime = substream->runtime;
492 struct snd_ca0106_pcm *epcm = runtime->private_data;
493 chip->playback_channels[epcm->channel_id].use = 0;
494 /* FIXME: maybe zero others */
495 return 0;
496 }
497
498 static int snd_ca0106_pcm_open_playback_front(struct snd_pcm_substream *substream)
499 {
500 return snd_ca0106_pcm_open_playback_channel(substream, PCM_FRONT_CHANNEL);
501 }
502
503 static int snd_ca0106_pcm_open_playback_center_lfe(struct snd_pcm_substream *substream)
504 {
505 return snd_ca0106_pcm_open_playback_channel(substream, PCM_CENTER_LFE_CHANNEL);
506 }
507
508 static int snd_ca0106_pcm_open_playback_unknown(struct snd_pcm_substream *substream)
509 {
510 return snd_ca0106_pcm_open_playback_channel(substream, PCM_UNKNOWN_CHANNEL);
511 }
512
513 static int snd_ca0106_pcm_open_playback_rear(struct snd_pcm_substream *substream)
514 {
515 return snd_ca0106_pcm_open_playback_channel(substream, PCM_REAR_CHANNEL);
516 }
517
518 /* open_capture callback */
519 static int snd_ca0106_pcm_open_capture_channel(struct snd_pcm_substream *substream,
520 int channel_id)
521 {
522 struct snd_ca0106 *chip = snd_pcm_substream_chip(substream);
523 struct snd_ca0106_channel *channel = &(chip->capture_channels[channel_id]);
524 struct snd_ca0106_pcm *epcm;
525 struct snd_pcm_runtime *runtime = substream->runtime;
526 int err;
527
528 epcm = kzalloc(sizeof(*epcm), GFP_KERNEL);
529 if (epcm == NULL) {
530 snd_printk(KERN_ERR "open_capture_channel: failed epcm alloc\n");
531 return -ENOMEM;
532 }
533 epcm->emu = chip;
534 epcm->substream = substream;
535 epcm->channel_id=channel_id;
536
537 runtime->private_data = epcm;
538 runtime->private_free = snd_ca0106_pcm_free_substream;
539
540 runtime->hw = snd_ca0106_capture_hw;
541
542 channel->emu = chip;
543 channel->number = channel_id;
544
545 channel->use = 1;
546 //printk("open:channel_id=%d, chip=%p, channel=%p\n",channel_id, chip, channel);
547 //channel->interrupt = snd_ca0106_pcm_channel_interrupt;
548 channel->epcm = epcm;
549 if ((err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
550 return err;
551 //snd_pcm_hw_constraint_list(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, &hw_constraints_capture_period_sizes);
552 if ((err = snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 64)) < 0)
553 return err;
554 return 0;
555 }
556
557 /* close callback */
558 static int snd_ca0106_pcm_close_capture(struct snd_pcm_substream *substream)
559 {
560 struct snd_ca0106 *chip = snd_pcm_substream_chip(substream);
561 struct snd_pcm_runtime *runtime = substream->runtime;
562 struct snd_ca0106_pcm *epcm = runtime->private_data;
563 chip->capture_channels[epcm->channel_id].use = 0;
564 /* FIXME: maybe zero others */
565 return 0;
566 }
567
568 static int snd_ca0106_pcm_open_0_capture(struct snd_pcm_substream *substream)
569 {
570 return snd_ca0106_pcm_open_capture_channel(substream, 0);
571 }
572
573 static int snd_ca0106_pcm_open_1_capture(struct snd_pcm_substream *substream)
574 {
575 return snd_ca0106_pcm_open_capture_channel(substream, 1);
576 }
577
578 static int snd_ca0106_pcm_open_2_capture(struct snd_pcm_substream *substream)
579 {
580 return snd_ca0106_pcm_open_capture_channel(substream, 2);
581 }
582
583 static int snd_ca0106_pcm_open_3_capture(struct snd_pcm_substream *substream)
584 {
585 return snd_ca0106_pcm_open_capture_channel(substream, 3);
586 }
587
588 /* hw_params callback */
589 static int snd_ca0106_pcm_hw_params_playback(struct snd_pcm_substream *substream,
590 struct snd_pcm_hw_params *hw_params)
591 {
592 return snd_pcm_lib_malloc_pages(substream,
593 params_buffer_bytes(hw_params));
594 }
595
596 /* hw_free callback */
597 static int snd_ca0106_pcm_hw_free_playback(struct snd_pcm_substream *substream)
598 {
599 return snd_pcm_lib_free_pages(substream);
600 }
601
602 /* hw_params callback */
603 static int snd_ca0106_pcm_hw_params_capture(struct snd_pcm_substream *substream,
604 struct snd_pcm_hw_params *hw_params)
605 {
606 return snd_pcm_lib_malloc_pages(substream,
607 params_buffer_bytes(hw_params));
608 }
609
610 /* hw_free callback */
611 static int snd_ca0106_pcm_hw_free_capture(struct snd_pcm_substream *substream)
612 {
613 return snd_pcm_lib_free_pages(substream);
614 }
615
616 /* prepare playback callback */
617 static int snd_ca0106_pcm_prepare_playback(struct snd_pcm_substream *substream)
618 {
619 struct snd_ca0106 *emu = snd_pcm_substream_chip(substream);
620 struct snd_pcm_runtime *runtime = substream->runtime;
621 struct snd_ca0106_pcm *epcm = runtime->private_data;
622 int channel = epcm->channel_id;
623 u32 *table_base = (u32 *)(emu->buffer.area+(8*16*channel));
624 u32 period_size_bytes = frames_to_bytes(runtime, runtime->period_size);
625 u32 hcfg_mask = HCFG_PLAYBACK_S32_LE;
626 u32 hcfg_set = 0x00000000;
627 u32 hcfg;
628 u32 reg40_mask = 0x30000 << (channel<<1);
629 u32 reg40_set = 0;
630 u32 reg40;
631 /* FIXME: Depending on mixer selection of SPDIF out or not, select the spdif rate or the DAC rate. */
632 u32 reg71_mask = 0x03030000 ; /* Global. Set SPDIF rate. We only support 44100 to spdif, not to DAC. */
633 u32 reg71_set = 0;
634 u32 reg71;
635 int i;
636
637 //snd_printk("prepare:channel_number=%d, rate=%d, format=0x%x, channels=%d, buffer_size=%ld, period_size=%ld, periods=%u, frames_to_bytes=%d\n",channel, runtime->rate, runtime->format, runtime->channels, runtime->buffer_size, runtime->period_size, runtime->periods, frames_to_bytes(runtime, 1));
638 //snd_printk("dma_addr=%x, dma_area=%p, table_base=%p\n",runtime->dma_addr, runtime->dma_area, table_base);
639 //snd_printk("dma_addr=%x, dma_area=%p, dma_bytes(size)=%x\n",emu->buffer.addr, emu->buffer.area, emu->buffer.bytes);
640 /* Rate can be set per channel. */
641 /* reg40 control host to fifo */
642 /* reg71 controls DAC rate. */
643 switch (runtime->rate) {
644 case 44100:
645 reg40_set = 0x10000 << (channel<<1);
646 reg71_set = 0x01010000;
647 break;
648 case 48000:
649 reg40_set = 0;
650 reg71_set = 0;
651 break;
652 case 96000:
653 reg40_set = 0x20000 << (channel<<1);
654 reg71_set = 0x02020000;
655 break;
656 case 192000:
657 reg40_set = 0x30000 << (channel<<1);
658 reg71_set = 0x03030000;
659 break;
660 default:
661 reg40_set = 0;
662 reg71_set = 0;
663 break;
664 }
665 /* Format is a global setting */
666 /* FIXME: Only let the first channel accessed set this. */
667 switch (runtime->format) {
668 case SNDRV_PCM_FORMAT_S16_LE:
669 hcfg_set = 0;
670 break;
671 case SNDRV_PCM_FORMAT_S32_LE:
672 hcfg_set = HCFG_PLAYBACK_S32_LE;
673 break;
674 default:
675 hcfg_set = 0;
676 break;
677 }
678 hcfg = inl(emu->port + HCFG) ;
679 hcfg = (hcfg & ~hcfg_mask) | hcfg_set;
680 outl(hcfg, emu->port + HCFG);
681 reg40 = snd_ca0106_ptr_read(emu, 0x40, 0);
682 reg40 = (reg40 & ~reg40_mask) | reg40_set;
683 snd_ca0106_ptr_write(emu, 0x40, 0, reg40);
684 reg71 = snd_ca0106_ptr_read(emu, 0x71, 0);
685 reg71 = (reg71 & ~reg71_mask) | reg71_set;
686 snd_ca0106_ptr_write(emu, 0x71, 0, reg71);
687
688 /* FIXME: Check emu->buffer.size before actually writing to it. */
689 for(i=0; i < runtime->periods; i++) {
690 table_base[i*2] = runtime->dma_addr + (i * period_size_bytes);
691 table_base[i*2+1] = period_size_bytes << 16;
692 }
693
694 snd_ca0106_ptr_write(emu, PLAYBACK_LIST_ADDR, channel, emu->buffer.addr+(8*16*channel));
695 snd_ca0106_ptr_write(emu, PLAYBACK_LIST_SIZE, channel, (runtime->periods - 1) << 19);
696 snd_ca0106_ptr_write(emu, PLAYBACK_LIST_PTR, channel, 0);
697 snd_ca0106_ptr_write(emu, PLAYBACK_DMA_ADDR, channel, runtime->dma_addr);
698 snd_ca0106_ptr_write(emu, PLAYBACK_PERIOD_SIZE, channel, frames_to_bytes(runtime, runtime->period_size)<<16); // buffer size in bytes
699 /* FIXME test what 0 bytes does. */
700 snd_ca0106_ptr_write(emu, PLAYBACK_PERIOD_SIZE, channel, 0); // buffer size in bytes
701 snd_ca0106_ptr_write(emu, PLAYBACK_POINTER, channel, 0);
702 snd_ca0106_ptr_write(emu, 0x07, channel, 0x0);
703 snd_ca0106_ptr_write(emu, 0x08, channel, 0);
704 snd_ca0106_ptr_write(emu, PLAYBACK_MUTE, 0x0, 0x0); /* Unmute output */
705 #if 0
706 snd_ca0106_ptr_write(emu, SPCS0, 0,
707 SPCS_CLKACCY_1000PPM | SPCS_SAMPLERATE_48 |
708 SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC |
709 SPCS_GENERATIONSTATUS | 0x00001200 |
710 0x00000000 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT );
711 }
712 #endif
713
714 return 0;
715 }
716
717 /* prepare capture callback */
718 static int snd_ca0106_pcm_prepare_capture(struct snd_pcm_substream *substream)
719 {
720 struct snd_ca0106 *emu = snd_pcm_substream_chip(substream);
721 struct snd_pcm_runtime *runtime = substream->runtime;
722 struct snd_ca0106_pcm *epcm = runtime->private_data;
723 int channel = epcm->channel_id;
724 u32 hcfg_mask = HCFG_CAPTURE_S32_LE;
725 u32 hcfg_set = 0x00000000;
726 u32 hcfg;
727 u32 over_sampling=0x2;
728 u32 reg71_mask = 0x0000c000 ; /* Global. Set ADC rate. */
729 u32 reg71_set = 0;
730 u32 reg71;
731
732 //snd_printk("prepare:channel_number=%d, rate=%d, format=0x%x, channels=%d, buffer_size=%ld, period_size=%ld, periods=%u, frames_to_bytes=%d\n",channel, runtime->rate, runtime->format, runtime->channels, runtime->buffer_size, runtime->period_size, runtime->periods, frames_to_bytes(runtime, 1));
733 //snd_printk("dma_addr=%x, dma_area=%p, table_base=%p\n",runtime->dma_addr, runtime->dma_area, table_base);
734 //snd_printk("dma_addr=%x, dma_area=%p, dma_bytes(size)=%x\n",emu->buffer.addr, emu->buffer.area, emu->buffer.bytes);
735 /* reg71 controls ADC rate. */
736 switch (runtime->rate) {
737 case 44100:
738 reg71_set = 0x00004000;
739 break;
740 case 48000:
741 reg71_set = 0;
742 break;
743 case 96000:
744 reg71_set = 0x00008000;
745 over_sampling=0xa;
746 break;
747 case 192000:
748 reg71_set = 0x0000c000;
749 over_sampling=0xa;
750 break;
751 default:
752 reg71_set = 0;
753 break;
754 }
755 /* Format is a global setting */
756 /* FIXME: Only let the first channel accessed set this. */
757 switch (runtime->format) {
758 case SNDRV_PCM_FORMAT_S16_LE:
759 hcfg_set = 0;
760 break;
761 case SNDRV_PCM_FORMAT_S32_LE:
762 hcfg_set = HCFG_CAPTURE_S32_LE;
763 break;
764 default:
765 hcfg_set = 0;
766 break;
767 }
768 hcfg = inl(emu->port + HCFG) ;
769 hcfg = (hcfg & ~hcfg_mask) | hcfg_set;
770 outl(hcfg, emu->port + HCFG);
771 reg71 = snd_ca0106_ptr_read(emu, 0x71, 0);
772 reg71 = (reg71 & ~reg71_mask) | reg71_set;
773 snd_ca0106_ptr_write(emu, 0x71, 0, reg71);
774 if (emu->details->i2c_adc == 1) { /* The SB0410 and SB0413 use I2C to control ADC. */
775 snd_ca0106_i2c_write(emu, ADC_MASTER, over_sampling); /* Adjust the over sampler to better suit the capture rate. */
776 }
777
778
779 //printk("prepare:channel_number=%d, rate=%d, format=0x%x, channels=%d, buffer_size=%ld, period_size=%ld, frames_to_bytes=%d\n",channel, runtime->rate, runtime->format, runtime->channels, runtime->buffer_size, runtime->period_size, frames_to_bytes(runtime, 1));
780 snd_ca0106_ptr_write(emu, 0x13, channel, 0);
781 snd_ca0106_ptr_write(emu, CAPTURE_DMA_ADDR, channel, runtime->dma_addr);
782 snd_ca0106_ptr_write(emu, CAPTURE_BUFFER_SIZE, channel, frames_to_bytes(runtime, runtime->buffer_size)<<16); // buffer size in bytes
783 snd_ca0106_ptr_write(emu, CAPTURE_POINTER, channel, 0);
784
785 return 0;
786 }
787
788 /* trigger_playback callback */
789 static int snd_ca0106_pcm_trigger_playback(struct snd_pcm_substream *substream,
790 int cmd)
791 {
792 struct snd_ca0106 *emu = snd_pcm_substream_chip(substream);
793 struct snd_pcm_runtime *runtime;
794 struct snd_ca0106_pcm *epcm;
795 int channel;
796 int result = 0;
797 struct snd_pcm_substream *s;
798 u32 basic = 0;
799 u32 extended = 0;
800 int running=0;
801
802 switch (cmd) {
803 case SNDRV_PCM_TRIGGER_START:
804 running=1;
805 break;
806 case SNDRV_PCM_TRIGGER_STOP:
807 default:
808 running=0;
809 break;
810 }
811 snd_pcm_group_for_each_entry(s, substream) {
812 runtime = s->runtime;
813 epcm = runtime->private_data;
814 channel = epcm->channel_id;
815 //snd_printk("channel=%d\n",channel);
816 epcm->running = running;
817 basic |= (0x1<<channel);
818 extended |= (0x10<<channel);
819 snd_pcm_trigger_done(s, substream);
820 }
821 //snd_printk("basic=0x%x, extended=0x%x\n",basic, extended);
822
823 switch (cmd) {
824 case SNDRV_PCM_TRIGGER_START:
825 snd_ca0106_ptr_write(emu, EXTENDED_INT_MASK, 0, snd_ca0106_ptr_read(emu, EXTENDED_INT_MASK, 0) | (extended));
826 snd_ca0106_ptr_write(emu, BASIC_INTERRUPT, 0, snd_ca0106_ptr_read(emu, BASIC_INTERRUPT, 0)|(basic));
827 break;
828 case SNDRV_PCM_TRIGGER_STOP:
829 snd_ca0106_ptr_write(emu, BASIC_INTERRUPT, 0, snd_ca0106_ptr_read(emu, BASIC_INTERRUPT, 0) & ~(basic));
830 snd_ca0106_ptr_write(emu, EXTENDED_INT_MASK, 0, snd_ca0106_ptr_read(emu, EXTENDED_INT_MASK, 0) & ~(extended));
831 break;
832 default:
833 result = -EINVAL;
834 break;
835 }
836 return result;
837 }
838
839 /* trigger_capture callback */
840 static int snd_ca0106_pcm_trigger_capture(struct snd_pcm_substream *substream,
841 int cmd)
842 {
843 struct snd_ca0106 *emu = snd_pcm_substream_chip(substream);
844 struct snd_pcm_runtime *runtime = substream->runtime;
845 struct snd_ca0106_pcm *epcm = runtime->private_data;
846 int channel = epcm->channel_id;
847 int result = 0;
848
849 switch (cmd) {
850 case SNDRV_PCM_TRIGGER_START:
851 snd_ca0106_ptr_write(emu, EXTENDED_INT_MASK, 0, snd_ca0106_ptr_read(emu, EXTENDED_INT_MASK, 0) | (0x110000<<channel));
852 snd_ca0106_ptr_write(emu, BASIC_INTERRUPT, 0, snd_ca0106_ptr_read(emu, BASIC_INTERRUPT, 0)|(0x100<<channel));
853 epcm->running = 1;
854 break;
855 case SNDRV_PCM_TRIGGER_STOP:
856 snd_ca0106_ptr_write(emu, BASIC_INTERRUPT, 0, snd_ca0106_ptr_read(emu, BASIC_INTERRUPT, 0) & ~(0x100<<channel));
857 snd_ca0106_ptr_write(emu, EXTENDED_INT_MASK, 0, snd_ca0106_ptr_read(emu, EXTENDED_INT_MASK, 0) & ~(0x110000<<channel));
858 epcm->running = 0;
859 break;
860 default:
861 result = -EINVAL;
862 break;
863 }
864 return result;
865 }
866
867 /* pointer_playback callback */
868 static snd_pcm_uframes_t
869 snd_ca0106_pcm_pointer_playback(struct snd_pcm_substream *substream)
870 {
871 struct snd_ca0106 *emu = snd_pcm_substream_chip(substream);
872 struct snd_pcm_runtime *runtime = substream->runtime;
873 struct snd_ca0106_pcm *epcm = runtime->private_data;
874 snd_pcm_uframes_t ptr, ptr1, ptr2,ptr3,ptr4 = 0;
875 int channel = epcm->channel_id;
876
877 if (!epcm->running)
878 return 0;
879
880 ptr3 = snd_ca0106_ptr_read(emu, PLAYBACK_LIST_PTR, channel);
881 ptr1 = snd_ca0106_ptr_read(emu, PLAYBACK_POINTER, channel);
882 ptr4 = snd_ca0106_ptr_read(emu, PLAYBACK_LIST_PTR, channel);
883 if (ptr3 != ptr4) ptr1 = snd_ca0106_ptr_read(emu, PLAYBACK_POINTER, channel);
884 ptr2 = bytes_to_frames(runtime, ptr1);
885 ptr2+= (ptr4 >> 3) * runtime->period_size;
886 ptr=ptr2;
887 if (ptr >= runtime->buffer_size)
888 ptr -= runtime->buffer_size;
889 //printk("ptr1 = 0x%lx, ptr2=0x%lx, ptr=0x%lx, buffer_size = 0x%x, period_size = 0x%x, bits=%d, rate=%d\n", ptr1, ptr2, ptr, (int)runtime->buffer_size, (int)runtime->period_size, (int)runtime->frame_bits, (int)runtime->rate);
890
891 return ptr;
892 }
893
894 /* pointer_capture callback */
895 static snd_pcm_uframes_t
896 snd_ca0106_pcm_pointer_capture(struct snd_pcm_substream *substream)
897 {
898 struct snd_ca0106 *emu = snd_pcm_substream_chip(substream);
899 struct snd_pcm_runtime *runtime = substream->runtime;
900 struct snd_ca0106_pcm *epcm = runtime->private_data;
901 snd_pcm_uframes_t ptr, ptr1, ptr2 = 0;
902 int channel = channel=epcm->channel_id;
903
904 if (!epcm->running)
905 return 0;
906
907 ptr1 = snd_ca0106_ptr_read(emu, CAPTURE_POINTER, channel);
908 ptr2 = bytes_to_frames(runtime, ptr1);
909 ptr=ptr2;
910 if (ptr >= runtime->buffer_size)
911 ptr -= runtime->buffer_size;
912 //printk("ptr1 = 0x%lx, ptr2=0x%lx, ptr=0x%lx, buffer_size = 0x%x, period_size = 0x%x, bits=%d, rate=%d\n", ptr1, ptr2, ptr, (int)runtime->buffer_size, (int)runtime->period_size, (int)runtime->frame_bits, (int)runtime->rate);
913
914 return ptr;
915 }
916
917 /* operators */
918 static struct snd_pcm_ops snd_ca0106_playback_front_ops = {
919 .open = snd_ca0106_pcm_open_playback_front,
920 .close = snd_ca0106_pcm_close_playback,
921 .ioctl = snd_pcm_lib_ioctl,
922 .hw_params = snd_ca0106_pcm_hw_params_playback,
923 .hw_free = snd_ca0106_pcm_hw_free_playback,
924 .prepare = snd_ca0106_pcm_prepare_playback,
925 .trigger = snd_ca0106_pcm_trigger_playback,
926 .pointer = snd_ca0106_pcm_pointer_playback,
927 };
928
929 static struct snd_pcm_ops snd_ca0106_capture_0_ops = {
930 .open = snd_ca0106_pcm_open_0_capture,
931 .close = snd_ca0106_pcm_close_capture,
932 .ioctl = snd_pcm_lib_ioctl,
933 .hw_params = snd_ca0106_pcm_hw_params_capture,
934 .hw_free = snd_ca0106_pcm_hw_free_capture,
935 .prepare = snd_ca0106_pcm_prepare_capture,
936 .trigger = snd_ca0106_pcm_trigger_capture,
937 .pointer = snd_ca0106_pcm_pointer_capture,
938 };
939
940 static struct snd_pcm_ops snd_ca0106_capture_1_ops = {
941 .open = snd_ca0106_pcm_open_1_capture,
942 .close = snd_ca0106_pcm_close_capture,
943 .ioctl = snd_pcm_lib_ioctl,
944 .hw_params = snd_ca0106_pcm_hw_params_capture,
945 .hw_free = snd_ca0106_pcm_hw_free_capture,
946 .prepare = snd_ca0106_pcm_prepare_capture,
947 .trigger = snd_ca0106_pcm_trigger_capture,
948 .pointer = snd_ca0106_pcm_pointer_capture,
949 };
950
951 static struct snd_pcm_ops snd_ca0106_capture_2_ops = {
952 .open = snd_ca0106_pcm_open_2_capture,
953 .close = snd_ca0106_pcm_close_capture,
954 .ioctl = snd_pcm_lib_ioctl,
955 .hw_params = snd_ca0106_pcm_hw_params_capture,
956 .hw_free = snd_ca0106_pcm_hw_free_capture,
957 .prepare = snd_ca0106_pcm_prepare_capture,
958 .trigger = snd_ca0106_pcm_trigger_capture,
959 .pointer = snd_ca0106_pcm_pointer_capture,
960 };
961
962 static struct snd_pcm_ops snd_ca0106_capture_3_ops = {
963 .open = snd_ca0106_pcm_open_3_capture,
964 .close = snd_ca0106_pcm_close_capture,
965 .ioctl = snd_pcm_lib_ioctl,
966 .hw_params = snd_ca0106_pcm_hw_params_capture,
967 .hw_free = snd_ca0106_pcm_hw_free_capture,
968 .prepare = snd_ca0106_pcm_prepare_capture,
969 .trigger = snd_ca0106_pcm_trigger_capture,
970 .pointer = snd_ca0106_pcm_pointer_capture,
971 };
972
973 static struct snd_pcm_ops snd_ca0106_playback_center_lfe_ops = {
974 .open = snd_ca0106_pcm_open_playback_center_lfe,
975 .close = snd_ca0106_pcm_close_playback,
976 .ioctl = snd_pcm_lib_ioctl,
977 .hw_params = snd_ca0106_pcm_hw_params_playback,
978 .hw_free = snd_ca0106_pcm_hw_free_playback,
979 .prepare = snd_ca0106_pcm_prepare_playback,
980 .trigger = snd_ca0106_pcm_trigger_playback,
981 .pointer = snd_ca0106_pcm_pointer_playback,
982 };
983
984 static struct snd_pcm_ops snd_ca0106_playback_unknown_ops = {
985 .open = snd_ca0106_pcm_open_playback_unknown,
986 .close = snd_ca0106_pcm_close_playback,
987 .ioctl = snd_pcm_lib_ioctl,
988 .hw_params = snd_ca0106_pcm_hw_params_playback,
989 .hw_free = snd_ca0106_pcm_hw_free_playback,
990 .prepare = snd_ca0106_pcm_prepare_playback,
991 .trigger = snd_ca0106_pcm_trigger_playback,
992 .pointer = snd_ca0106_pcm_pointer_playback,
993 };
994
995 static struct snd_pcm_ops snd_ca0106_playback_rear_ops = {
996 .open = snd_ca0106_pcm_open_playback_rear,
997 .close = snd_ca0106_pcm_close_playback,
998 .ioctl = snd_pcm_lib_ioctl,
999 .hw_params = snd_ca0106_pcm_hw_params_playback,
1000 .hw_free = snd_ca0106_pcm_hw_free_playback,
1001 .prepare = snd_ca0106_pcm_prepare_playback,
1002 .trigger = snd_ca0106_pcm_trigger_playback,
1003 .pointer = snd_ca0106_pcm_pointer_playback,
1004 };
1005
1006
1007 static unsigned short snd_ca0106_ac97_read(struct snd_ac97 *ac97,
1008 unsigned short reg)
1009 {
1010 struct snd_ca0106 *emu = ac97->private_data;
1011 unsigned long flags;
1012 unsigned short val;
1013
1014 spin_lock_irqsave(&emu->emu_lock, flags);
1015 outb(reg, emu->port + AC97ADDRESS);
1016 val = inw(emu->port + AC97DATA);
1017 spin_unlock_irqrestore(&emu->emu_lock, flags);
1018 return val;
1019 }
1020
1021 static void snd_ca0106_ac97_write(struct snd_ac97 *ac97,
1022 unsigned short reg, unsigned short val)
1023 {
1024 struct snd_ca0106 *emu = ac97->private_data;
1025 unsigned long flags;
1026
1027 spin_lock_irqsave(&emu->emu_lock, flags);
1028 outb(reg, emu->port + AC97ADDRESS);
1029 outw(val, emu->port + AC97DATA);
1030 spin_unlock_irqrestore(&emu->emu_lock, flags);
1031 }
1032
1033 static int snd_ca0106_ac97(struct snd_ca0106 *chip)
1034 {
1035 struct snd_ac97_bus *pbus;
1036 struct snd_ac97_template ac97;
1037 int err;
1038 static struct snd_ac97_bus_ops ops = {
1039 .write = snd_ca0106_ac97_write,
1040 .read = snd_ca0106_ac97_read,
1041 };
1042
1043 if ((err = snd_ac97_bus(chip->card, 0, &ops, NULL, &pbus)) < 0)
1044 return err;
1045 pbus->no_vra = 1; /* we don't need VRA */
1046
1047 memset(&ac97, 0, sizeof(ac97));
1048 ac97.private_data = chip;
1049 ac97.scaps = AC97_SCAP_NO_SPDIF;
1050 return snd_ac97_mixer(pbus, &ac97, &chip->ac97);
1051 }
1052
1053 static int snd_ca0106_free(struct snd_ca0106 *chip)
1054 {
1055 if (chip->res_port != NULL) { /* avoid access to already used hardware */
1056 // disable interrupts
1057 snd_ca0106_ptr_write(chip, BASIC_INTERRUPT, 0, 0);
1058 outl(0, chip->port + INTE);
1059 snd_ca0106_ptr_write(chip, EXTENDED_INT_MASK, 0, 0);
1060 udelay(1000);
1061 // disable audio
1062 //outl(HCFG_LOCKSOUNDCACHE, chip->port + HCFG);
1063 outl(0, chip->port + HCFG);
1064 /* FIXME: We need to stop and DMA transfers here.
1065 * But as I am not sure how yet, we cannot from the dma pages.
1066 * So we can fix: snd-malloc: Memory leak? pages not freed = 8
1067 */
1068 }
1069 // release the data
1070 #if 1
1071 if (chip->buffer.area)
1072 snd_dma_free_pages(&chip->buffer);
1073 #endif
1074
1075 // release the i/o port
1076 release_and_free_resource(chip->res_port);
1077
1078 // release the irq
1079 if (chip->irq >= 0)
1080 free_irq(chip->irq, chip);
1081 pci_disable_device(chip->pci);
1082 kfree(chip);
1083 return 0;
1084 }
1085
1086 static int snd_ca0106_dev_free(struct snd_device *device)
1087 {
1088 struct snd_ca0106 *chip = device->device_data;
1089 return snd_ca0106_free(chip);
1090 }
1091
1092 static irqreturn_t snd_ca0106_interrupt(int irq, void *dev_id)
1093 {
1094 unsigned int status;
1095
1096 struct snd_ca0106 *chip = dev_id;
1097 int i;
1098 int mask;
1099 unsigned int stat76;
1100 struct snd_ca0106_channel *pchannel;
1101
1102 status = inl(chip->port + IPR);
1103 if (! status)
1104 return IRQ_NONE;
1105
1106 stat76 = snd_ca0106_ptr_read(chip, EXTENDED_INT, 0);
1107 //snd_printk("interrupt status = 0x%08x, stat76=0x%08x\n", status, stat76);
1108 //snd_printk("ptr=0x%08x\n",snd_ca0106_ptr_read(chip, PLAYBACK_POINTER, 0));
1109 mask = 0x11; /* 0x1 for one half, 0x10 for the other half period. */
1110 for(i = 0; i < 4; i++) {
1111 pchannel = &(chip->playback_channels[i]);
1112 if (stat76 & mask) {
1113 /* FIXME: Select the correct substream for period elapsed */
1114 if(pchannel->use) {
1115 snd_pcm_period_elapsed(pchannel->epcm->substream);
1116 //printk(KERN_INFO "interrupt [%d] used\n", i);
1117 }
1118 }
1119 //printk(KERN_INFO "channel=%p\n",pchannel);
1120 //printk(KERN_INFO "interrupt stat76[%d] = %08x, use=%d, channel=%d\n", i, stat76, pchannel->use, pchannel->number);
1121 mask <<= 1;
1122 }
1123 mask = 0x110000; /* 0x1 for one half, 0x10 for the other half period. */
1124 for(i = 0; i < 4; i++) {
1125 pchannel = &(chip->capture_channels[i]);
1126 if (stat76 & mask) {
1127 /* FIXME: Select the correct substream for period elapsed */
1128 if(pchannel->use) {
1129 snd_pcm_period_elapsed(pchannel->epcm->substream);
1130 //printk(KERN_INFO "interrupt [%d] used\n", i);
1131 }
1132 }
1133 //printk(KERN_INFO "channel=%p\n",pchannel);
1134 //printk(KERN_INFO "interrupt stat76[%d] = %08x, use=%d, channel=%d\n", i, stat76, pchannel->use, pchannel->number);
1135 mask <<= 1;
1136 }
1137
1138 snd_ca0106_ptr_write(chip, EXTENDED_INT, 0, stat76);
1139
1140 if (chip->midi.dev_id &&
1141 (status & (chip->midi.ipr_tx|chip->midi.ipr_rx))) {
1142 if (chip->midi.interrupt)
1143 chip->midi.interrupt(&chip->midi, status);
1144 else
1145 chip->midi.interrupt_disable(&chip->midi, chip->midi.tx_enable | chip->midi.rx_enable);
1146 }
1147
1148 // acknowledge the interrupt if necessary
1149 outl(status, chip->port+IPR);
1150
1151 return IRQ_HANDLED;
1152 }
1153
1154 static int __devinit snd_ca0106_pcm(struct snd_ca0106 *emu, int device, struct snd_pcm **rpcm)
1155 {
1156 struct snd_pcm *pcm;
1157 struct snd_pcm_substream *substream;
1158 int err;
1159
1160 if (rpcm)
1161 *rpcm = NULL;
1162 if ((err = snd_pcm_new(emu->card, "ca0106", device, 1, 1, &pcm)) < 0)
1163 return err;
1164
1165 pcm->private_data = emu;
1166
1167 switch (device) {
1168 case 0:
1169 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_ca0106_playback_front_ops);
1170 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_ca0106_capture_0_ops);
1171 break;
1172 case 1:
1173 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_ca0106_playback_rear_ops);
1174 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_ca0106_capture_1_ops);
1175 break;
1176 case 2:
1177 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_ca0106_playback_center_lfe_ops);
1178 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_ca0106_capture_2_ops);
1179 break;
1180 case 3:
1181 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_ca0106_playback_unknown_ops);
1182 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_ca0106_capture_3_ops);
1183 break;
1184 }
1185
1186 pcm->info_flags = 0;
1187 pcm->dev_subclass = SNDRV_PCM_SUBCLASS_GENERIC_MIX;
1188 strcpy(pcm->name, "CA0106");
1189 emu->pcm = pcm;
1190
1191 for(substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream;
1192 substream;
1193 substream = substream->next) {
1194 if ((err = snd_pcm_lib_preallocate_pages(substream,
1195 SNDRV_DMA_TYPE_DEV,
1196 snd_dma_pci_data(emu->pci),
1197 64*1024, 64*1024)) < 0) /* FIXME: 32*1024 for sound buffer, between 32and64 for Periods table. */
1198 return err;
1199 }
1200
1201 for (substream = pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream;
1202 substream;
1203 substream = substream->next) {
1204 if ((err = snd_pcm_lib_preallocate_pages(substream,
1205 SNDRV_DMA_TYPE_DEV,
1206 snd_dma_pci_data(emu->pci),
1207 64*1024, 64*1024)) < 0)
1208 return err;
1209 }
1210
1211 if (rpcm)
1212 *rpcm = pcm;
1213
1214 return 0;
1215 }
1216
1217 static unsigned int spi_dac_init[] = {
1218 0x00ff,
1219 0x02ff,
1220 0x0400,
1221 0x0520,
1222 0x0620, /* Set 24 bit. Was 0x0600 */
1223 0x08ff,
1224 0x0aff,
1225 0x0cff,
1226 0x0eff,
1227 0x10ff,
1228 0x1200,
1229 0x1400,
1230 0x1480,
1231 0x1800,
1232 0x1aff,
1233 0x1cff,
1234 0x1e00,
1235 0x0530,
1236 0x0602,
1237 0x0622,
1238 0x1400,
1239 };
1240
1241 static unsigned int i2c_adc_init[][2] = {
1242 { 0x17, 0x00 }, /* Reset */
1243 { 0x07, 0x00 }, /* Timeout */
1244 { 0x0b, 0x22 }, /* Interface control */
1245 { 0x0c, 0x22 }, /* Master mode control */
1246 { 0x0d, 0x08 }, /* Powerdown control */
1247 { 0x0e, 0xcf }, /* Attenuation Left 0x01 = -103dB, 0xff = 24dB */
1248 { 0x0f, 0xcf }, /* Attenuation Right 0.5dB steps */
1249 { 0x10, 0x7b }, /* ALC Control 1 */
1250 { 0x11, 0x00 }, /* ALC Control 2 */
1251 { 0x12, 0x32 }, /* ALC Control 3 */
1252 { 0x13, 0x00 }, /* Noise gate control */
1253 { 0x14, 0xa6 }, /* Limiter control */
1254 { 0x15, ADC_MUX_LINEIN }, /* ADC Mixer control */
1255 };
1256
1257 static int __devinit snd_ca0106_create(int dev, struct snd_card *card,
1258 struct pci_dev *pci,
1259 struct snd_ca0106 **rchip)
1260 {
1261 struct snd_ca0106 *chip;
1262 struct snd_ca0106_details *c;
1263 int err;
1264 int ch;
1265 static struct snd_device_ops ops = {
1266 .dev_free = snd_ca0106_dev_free,
1267 };
1268
1269 *rchip = NULL;
1270
1271 if ((err = pci_enable_device(pci)) < 0)
1272 return err;
1273 if (pci_set_dma_mask(pci, DMA_32BIT_MASK) < 0 ||
1274 pci_set_consistent_dma_mask(pci, DMA_32BIT_MASK) < 0) {
1275 printk(KERN_ERR "error to set 32bit mask DMA\n");
1276 pci_disable_device(pci);
1277 return -ENXIO;
1278 }
1279
1280 chip = kzalloc(sizeof(*chip), GFP_KERNEL);
1281 if (chip == NULL) {
1282 pci_disable_device(pci);
1283 return -ENOMEM;
1284 }
1285
1286 chip->card = card;
1287 chip->pci = pci;
1288 chip->irq = -1;
1289
1290 spin_lock_init(&chip->emu_lock);
1291
1292 chip->port = pci_resource_start(pci, 0);
1293 if ((chip->res_port = request_region(chip->port, 0x20,
1294 "snd_ca0106")) == NULL) {
1295 snd_ca0106_free(chip);
1296 printk(KERN_ERR "cannot allocate the port\n");
1297 return -EBUSY;
1298 }
1299
1300 if (request_irq(pci->irq, snd_ca0106_interrupt,
1301 IRQF_SHARED, "snd_ca0106", chip)) {
1302 snd_ca0106_free(chip);
1303 printk(KERN_ERR "cannot grab irq\n");
1304 return -EBUSY;
1305 }
1306 chip->irq = pci->irq;
1307
1308 /* This stores the periods table. */
1309 if(snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci), 1024, &chip->buffer) < 0) {
1310 snd_ca0106_free(chip);
1311 return -ENOMEM;
1312 }
1313
1314 pci_set_master(pci);
1315 /* read serial */
1316 pci_read_config_dword(pci, PCI_SUBSYSTEM_VENDOR_ID, &chip->serial);
1317 pci_read_config_word(pci, PCI_SUBSYSTEM_ID, &chip->model);
1318 #if 1
1319 printk(KERN_INFO "snd-ca0106: Model %04x Rev %08x Serial %08x\n", chip->model,
1320 pci->revision, chip->serial);
1321 #endif
1322 strcpy(card->driver, "CA0106");
1323 strcpy(card->shortname, "CA0106");
1324
1325 for (c = ca0106_chip_details; c->serial; c++) {
1326 if (subsystem[dev]) {
1327 if (c->serial == subsystem[dev])
1328 break;
1329 } else if (c->serial == chip->serial)
1330 break;
1331 }
1332 chip->details = c;
1333 if (subsystem[dev]) {
1334 printk(KERN_INFO "snd-ca0106: Sound card name=%s, subsystem=0x%x. Forced to subsystem=0x%x\n",
1335 c->name, chip->serial, subsystem[dev]);
1336 }
1337
1338 sprintf(card->longname, "%s at 0x%lx irq %i",
1339 c->name, chip->port, chip->irq);
1340
1341 outl(0, chip->port + INTE);
1342
1343 /*
1344 * Init to 0x02109204 :
1345 * Clock accuracy = 0 (1000ppm)
1346 * Sample Rate = 2 (48kHz)
1347 * Audio Channel = 1 (Left of 2)
1348 * Source Number = 0 (Unspecified)
1349 * Generation Status = 1 (Original for Cat Code 12)
1350 * Cat Code = 12 (Digital Signal Mixer)
1351 * Mode = 0 (Mode 0)
1352 * Emphasis = 0 (None)
1353 * CP = 1 (Copyright unasserted)
1354 * AN = 0 (Audio data)
1355 * P = 0 (Consumer)
1356 */
1357 snd_ca0106_ptr_write(chip, SPCS0, 0,
1358 chip->spdif_bits[0] =
1359 SPCS_CLKACCY_1000PPM | SPCS_SAMPLERATE_48 |
1360 SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC |
1361 SPCS_GENERATIONSTATUS | 0x00001200 |
1362 0x00000000 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT);
1363 /* Only SPCS1 has been tested */
1364 snd_ca0106_ptr_write(chip, SPCS1, 0,
1365 chip->spdif_bits[1] =
1366 SPCS_CLKACCY_1000PPM | SPCS_SAMPLERATE_48 |
1367 SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC |
1368 SPCS_GENERATIONSTATUS | 0x00001200 |
1369 0x00000000 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT);
1370 snd_ca0106_ptr_write(chip, SPCS2, 0,
1371 chip->spdif_bits[2] =
1372 SPCS_CLKACCY_1000PPM | SPCS_SAMPLERATE_48 |
1373 SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC |
1374 SPCS_GENERATIONSTATUS | 0x00001200 |
1375 0x00000000 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT);
1376 snd_ca0106_ptr_write(chip, SPCS3, 0,
1377 chip->spdif_bits[3] =
1378 SPCS_CLKACCY_1000PPM | SPCS_SAMPLERATE_48 |
1379 SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC |
1380 SPCS_GENERATIONSTATUS | 0x00001200 |
1381 0x00000000 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT);
1382
1383 snd_ca0106_ptr_write(chip, PLAYBACK_MUTE, 0, 0x00fc0000);
1384 snd_ca0106_ptr_write(chip, CAPTURE_MUTE, 0, 0x00fc0000);
1385
1386 /* Write 0x8000 to AC97_REC_GAIN to mute it. */
1387 outb(AC97_REC_GAIN, chip->port + AC97ADDRESS);
1388 outw(0x8000, chip->port + AC97DATA);
1389 #if 0
1390 snd_ca0106_ptr_write(chip, SPCS0, 0, 0x2108006);
1391 snd_ca0106_ptr_write(chip, 0x42, 0, 0x2108006);
1392 snd_ca0106_ptr_write(chip, 0x43, 0, 0x2108006);
1393 snd_ca0106_ptr_write(chip, 0x44, 0, 0x2108006);
1394 #endif
1395
1396 //snd_ca0106_ptr_write(chip, SPDIF_SELECT2, 0, 0xf0f003f); /* OSS drivers set this. */
1397 /* Analog or Digital output */
1398 snd_ca0106_ptr_write(chip, SPDIF_SELECT1, 0, 0xf);
1399 snd_ca0106_ptr_write(chip, SPDIF_SELECT2, 0, 0x000f0000); /* 0x0b000000 for digital, 0x000b0000 for analog, from win2000 drivers. Use 0x000f0000 for surround71 */
1400 chip->spdif_enable = 0; /* Set digital SPDIF output off */
1401 //snd_ca0106_ptr_write(chip, 0x45, 0, 0); /* Analogue out */
1402 //snd_ca0106_ptr_write(chip, 0x45, 0, 0xf00); /* Digital out */
1403
1404 snd_ca0106_ptr_write(chip, CAPTURE_CONTROL, 0, 0x40c81000); /* goes to 0x40c80000 when doing SPDIF IN/OUT */
1405 snd_ca0106_ptr_write(chip, CAPTURE_CONTROL, 1, 0xffffffff); /* (Mute) CAPTURE feedback into PLAYBACK volume. Only lower 16 bits matter. */
1406 snd_ca0106_ptr_write(chip, CAPTURE_CONTROL, 2, 0x30300000); /* SPDIF IN Volume */
1407 snd_ca0106_ptr_write(chip, CAPTURE_CONTROL, 3, 0x00700000); /* SPDIF IN Volume, 0x70 = (vol & 0x3f) | 0x40 */
1408 snd_ca0106_ptr_write(chip, PLAYBACK_ROUTING1, 0, 0x32765410);
1409 snd_ca0106_ptr_write(chip, PLAYBACK_ROUTING2, 0, 0x76767676);
1410 snd_ca0106_ptr_write(chip, CAPTURE_ROUTING1, 0, 0x32765410);
1411 snd_ca0106_ptr_write(chip, CAPTURE_ROUTING2, 0, 0x76767676);
1412 for(ch = 0; ch < 4; ch++) {
1413 snd_ca0106_ptr_write(chip, CAPTURE_VOLUME1, ch, 0x30303030); /* Only high 16 bits matter */
1414 snd_ca0106_ptr_write(chip, CAPTURE_VOLUME2, ch, 0x30303030);
1415 //snd_ca0106_ptr_write(chip, PLAYBACK_VOLUME1, ch, 0x40404040); /* Mute */
1416 //snd_ca0106_ptr_write(chip, PLAYBACK_VOLUME2, ch, 0x40404040); /* Mute */
1417 snd_ca0106_ptr_write(chip, PLAYBACK_VOLUME1, ch, 0xffffffff); /* Mute */
1418 snd_ca0106_ptr_write(chip, PLAYBACK_VOLUME2, ch, 0xffffffff); /* Mute */
1419 }
1420 if (chip->details->i2c_adc == 1) {
1421 /* Select MIC, Line in, TAD in, AUX in */
1422 snd_ca0106_ptr_write(chip, CAPTURE_SOURCE, 0x0, 0x333300e4);
1423 /* Default to CAPTURE_SOURCE to i2s in */
1424 chip->capture_source = 3;
1425 } else if (chip->details->ac97 == 1) {
1426 /* Default to AC97 in */
1427 snd_ca0106_ptr_write(chip, CAPTURE_SOURCE, 0x0, 0x444400e4);
1428 /* Default to CAPTURE_SOURCE to AC97 in */
1429 chip->capture_source = 4;
1430 } else {
1431 /* Select MIC, Line in, TAD in, AUX in */
1432 snd_ca0106_ptr_write(chip, CAPTURE_SOURCE, 0x0, 0x333300e4);
1433 /* Default to Set CAPTURE_SOURCE to i2s in */
1434 chip->capture_source = 3;
1435 }
1436
1437 if (chip->details->gpio_type == 2) { /* The SB0438 use GPIO differently. */
1438 /* FIXME: Still need to find out what the other GPIO bits do. E.g. For digital spdif out. */
1439 outl(0x0, chip->port+GPIO);
1440 //outl(0x00f0e000, chip->port+GPIO); /* Analog */
1441 outl(0x005f5301, chip->port+GPIO); /* Analog */
1442 } else if (chip->details->gpio_type == 1) { /* The SB0410 and SB0413 use GPIO differently. */
1443 /* FIXME: Still need to find out what the other GPIO bits do. E.g. For digital spdif out. */
1444 outl(0x0, chip->port+GPIO);
1445 //outl(0x00f0e000, chip->port+GPIO); /* Analog */
1446 outl(0x005f5301, chip->port+GPIO); /* Analog */
1447 } else {
1448 outl(0x0, chip->port+GPIO);
1449 outl(0x005f03a3, chip->port+GPIO); /* Analog */
1450 //outl(0x005f02a2, chip->port+GPIO); /* SPDIF */
1451 }
1452 snd_ca0106_intr_enable(chip, 0x105); /* Win2000 uses 0x1e0 */
1453
1454 //outl(HCFG_LOCKSOUNDCACHE|HCFG_AUDIOENABLE, chip->port+HCFG);
1455 //outl(0x00001409, chip->port+HCFG); /* 0x1000 causes AC3 to fails. Maybe it effects 24 bit output. */
1456 //outl(0x00000009, chip->port+HCFG);
1457 outl(HCFG_AC97 | HCFG_AUDIOENABLE, chip->port+HCFG); /* AC97 2.0, Enable outputs. */
1458
1459 if (chip->details->i2c_adc == 1) { /* The SB0410 and SB0413 use I2C to control ADC. */
1460 int size, n;
1461
1462 size = ARRAY_SIZE(i2c_adc_init);
1463 //snd_printk("I2C:array size=0x%x\n", size);
1464 for (n=0; n < size; n++) {
1465 snd_ca0106_i2c_write(chip, i2c_adc_init[n][0], i2c_adc_init[n][1]);
1466 }
1467 for (n=0; n < 4; n++) {
1468 chip->i2c_capture_volume[n][0]= 0xcf;
1469 chip->i2c_capture_volume[n][1]= 0xcf;
1470 }
1471 chip->i2c_capture_source=2; /* Line in */
1472 //snd_ca0106_i2c_write(chip, ADC_MUX, ADC_MUX_LINEIN); /* Enable Line-in capture. MIC in currently untested. */
1473 }
1474 if (chip->details->spi_dac == 1) { /* The SB0570 use SPI to control DAC. */
1475 int size, n;
1476
1477 size = ARRAY_SIZE(spi_dac_init);
1478 for (n=0; n < size; n++)
1479 snd_ca0106_spi_write(chip, spi_dac_init[n]);
1480 }
1481
1482 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL,
1483 chip, &ops)) < 0) {
1484 snd_ca0106_free(chip);
1485 return err;
1486 }
1487 *rchip = chip;
1488 return 0;
1489 }
1490
1491
1492 static void ca0106_midi_interrupt_enable(struct snd_ca_midi *midi, int intr)
1493 {
1494 snd_ca0106_intr_enable((struct snd_ca0106 *)(midi->dev_id), intr);
1495 }
1496
1497 static void ca0106_midi_interrupt_disable(struct snd_ca_midi *midi, int intr)
1498 {
1499 snd_ca0106_intr_disable((struct snd_ca0106 *)(midi->dev_id), intr);
1500 }
1501
1502 static unsigned char ca0106_midi_read(struct snd_ca_midi *midi, int idx)
1503 {
1504 return (unsigned char)snd_ca0106_ptr_read((struct snd_ca0106 *)(midi->dev_id),
1505 midi->port + idx, 0);
1506 }
1507
1508 static void ca0106_midi_write(struct snd_ca_midi *midi, int data, int idx)
1509 {
1510 snd_ca0106_ptr_write((struct snd_ca0106 *)(midi->dev_id), midi->port + idx, 0, data);
1511 }
1512
1513 static struct snd_card *ca0106_dev_id_card(void *dev_id)
1514 {
1515 return ((struct snd_ca0106 *)dev_id)->card;
1516 }
1517
1518 static int ca0106_dev_id_port(void *dev_id)
1519 {
1520 return ((struct snd_ca0106 *)dev_id)->port;
1521 }
1522
1523 static int __devinit snd_ca0106_midi(struct snd_ca0106 *chip, unsigned int channel)
1524 {
1525 struct snd_ca_midi *midi;
1526 char *name;
1527 int err;
1528
1529 if (channel == CA0106_MIDI_CHAN_B) {
1530 name = "CA0106 MPU-401 (UART) B";
1531 midi = &chip->midi2;
1532 midi->tx_enable = INTE_MIDI_TX_B;
1533 midi->rx_enable = INTE_MIDI_RX_B;
1534 midi->ipr_tx = IPR_MIDI_TX_B;
1535 midi->ipr_rx = IPR_MIDI_RX_B;
1536 midi->port = MIDI_UART_B_DATA;
1537 } else {
1538 name = "CA0106 MPU-401 (UART)";
1539 midi = &chip->midi;
1540 midi->tx_enable = INTE_MIDI_TX_A;
1541 midi->rx_enable = INTE_MIDI_TX_B;
1542 midi->ipr_tx = IPR_MIDI_TX_A;
1543 midi->ipr_rx = IPR_MIDI_RX_A;
1544 midi->port = MIDI_UART_A_DATA;
1545 }
1546
1547 midi->reset = CA0106_MPU401_RESET;
1548 midi->enter_uart = CA0106_MPU401_ENTER_UART;
1549 midi->ack = CA0106_MPU401_ACK;
1550
1551 midi->input_avail = CA0106_MIDI_INPUT_AVAIL;
1552 midi->output_ready = CA0106_MIDI_OUTPUT_READY;
1553
1554 midi->channel = channel;
1555
1556 midi->interrupt_enable = ca0106_midi_interrupt_enable;
1557 midi->interrupt_disable = ca0106_midi_interrupt_disable;
1558
1559 midi->read = ca0106_midi_read;
1560 midi->write = ca0106_midi_write;
1561
1562 midi->get_dev_id_card = ca0106_dev_id_card;
1563 midi->get_dev_id_port = ca0106_dev_id_port;
1564
1565 midi->dev_id = chip;
1566
1567 if ((err = ca_midi_init(chip, midi, 0, name)) < 0)
1568 return err;
1569
1570 return 0;
1571 }
1572
1573
1574 static int __devinit snd_ca0106_probe(struct pci_dev *pci,
1575 const struct pci_device_id *pci_id)
1576 {
1577 static int dev;
1578 struct snd_card *card;
1579 struct snd_ca0106 *chip;
1580 int err;
1581
1582 if (dev >= SNDRV_CARDS)
1583 return -ENODEV;
1584 if (!enable[dev]) {
1585 dev++;
1586 return -ENOENT;
1587 }
1588
1589 card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
1590 if (card == NULL)
1591 return -ENOMEM;
1592
1593 if ((err = snd_ca0106_create(dev, card, pci, &chip)) < 0) {
1594 snd_card_free(card);
1595 return err;
1596 }
1597
1598 if ((err = snd_ca0106_pcm(chip, 0, NULL)) < 0) {
1599 snd_card_free(card);
1600 return err;
1601 }
1602 if ((err = snd_ca0106_pcm(chip, 1, NULL)) < 0) {
1603 snd_card_free(card);
1604 return err;
1605 }
1606 if ((err = snd_ca0106_pcm(chip, 2, NULL)) < 0) {
1607 snd_card_free(card);
1608 return err;
1609 }
1610 if ((err = snd_ca0106_pcm(chip, 3, NULL)) < 0) {
1611 snd_card_free(card);
1612 return err;
1613 }
1614 if (chip->details->ac97 == 1) { /* The SB0410 and SB0413 do not have an AC97 chip. */
1615 if ((err = snd_ca0106_ac97(chip)) < 0) {
1616 snd_card_free(card);
1617 return err;
1618 }
1619 }
1620 if ((err = snd_ca0106_mixer(chip)) < 0) {
1621 snd_card_free(card);
1622 return err;
1623 }
1624
1625 snd_printdd("ca0106: probe for MIDI channel A ...");
1626 if ((err = snd_ca0106_midi(chip,CA0106_MIDI_CHAN_A)) < 0) {
1627 snd_card_free(card);
1628 snd_printdd(" failed, err=0x%x\n",err);
1629 return err;
1630 }
1631 snd_printdd(" done.\n");
1632
1633 #ifdef CONFIG_PROC_FS
1634 snd_ca0106_proc_init(chip);
1635 #endif
1636
1637 snd_card_set_dev(card, &pci->dev);
1638
1639 if ((err = snd_card_register(card)) < 0) {
1640 snd_card_free(card);
1641 return err;
1642 }
1643
1644 pci_set_drvdata(pci, card);
1645 dev++;
1646 return 0;
1647 }
1648
1649 static void __devexit snd_ca0106_remove(struct pci_dev *pci)
1650 {
1651 snd_card_free(pci_get_drvdata(pci));
1652 pci_set_drvdata(pci, NULL);
1653 }
1654
1655 // PCI IDs
1656 static struct pci_device_id snd_ca0106_ids[] = {
1657 { 0x1102, 0x0007, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, /* Audigy LS or Live 24bit */
1658 { 0, }
1659 };
1660 MODULE_DEVICE_TABLE(pci, snd_ca0106_ids);
1661
1662 // pci_driver definition
1663 static struct pci_driver driver = {
1664 .name = "CA0106",
1665 .id_table = snd_ca0106_ids,
1666 .probe = snd_ca0106_probe,
1667 .remove = __devexit_p(snd_ca0106_remove),
1668 };
1669
1670 // initialization of the module
1671 static int __init alsa_card_ca0106_init(void)
1672 {
1673 return pci_register_driver(&driver);
1674 }
1675
1676 // clean up the module
1677 static void __exit alsa_card_ca0106_exit(void)
1678 {
1679 pci_unregister_driver(&driver);
1680 }
1681
1682 module_init(alsa_card_ca0106_init)
1683 module_exit(alsa_card_ca0106_exit)
Linux kernel - Deliverables
This page took 0.107297 seconds and 5 git commands to generate.