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