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