projects / GitHub / LineageOS / android_kernel_motorola_exynos9610.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
PCI: Change all drivers to use pci_device->revision
[GitHub/LineageOS/android_kernel_motorola_exynos9610.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;
e4a3d145 778 struct snd_pcm_substream *s;
1da177e4
LT		 779 u32 basic = 0;
780 u32 extended = 0;
781 int running=0;
782
783 switch (cmd) {
784 case SNDRV_PCM_TRIGGER_START:
785 running=1;
786 break;
787 case SNDRV_PCM_TRIGGER_STOP:
788 default:
789 running=0;
790 break;
791 }
ef991b95 792 snd_pcm_group_for_each_entry(s, substream) {
1da177e4
LT		 793 runtime = s->runtime;
794 epcm = runtime->private_data;
795 channel = epcm->channel_id;
796 //snd_printk("channel=%d\n",channel);
797 epcm->running = running;
798 basic |= (0x1<<channel);
799 extended |= (0x10<<channel);
800 snd_pcm_trigger_done(s, substream);
801 }
802 //snd_printk("basic=0x%x, extended=0x%x\n",basic, extended);
803
804 switch (cmd) {
805 case SNDRV_PCM_TRIGGER_START:
806 snd_ca0106_ptr_write(emu, EXTENDED_INT_MASK, 0, snd_ca0106_ptr_read(emu, EXTENDED_INT_MASK, 0) | (extended));
807 snd_ca0106_ptr_write(emu, BASIC_INTERRUPT, 0, snd_ca0106_ptr_read(emu, BASIC_INTERRUPT, 0)|(basic));
808 break;
809 case SNDRV_PCM_TRIGGER_STOP:
810 snd_ca0106_ptr_write(emu, BASIC_INTERRUPT, 0, snd_ca0106_ptr_read(emu, BASIC_INTERRUPT, 0) & ~(basic));
811 snd_ca0106_ptr_write(emu, EXTENDED_INT_MASK, 0, snd_ca0106_ptr_read(emu, EXTENDED_INT_MASK, 0) & ~(extended));
812 break;
813 default:
814 result = -EINVAL;
815 break;
816 }
817 return result;
818}
819
820/* trigger_capture callback */
e4a3d145 821static int snd_ca0106_pcm_trigger_capture(struct snd_pcm_substream *substream,
1da177e4
LT		 822 int cmd)
823{
e4a3d145
TI		 824 struct snd_ca0106 *emu = snd_pcm_substream_chip(substream);
825 struct snd_pcm_runtime *runtime = substream->runtime;
826 struct snd_ca0106_pcm *epcm = runtime->private_data;
1da177e4
LT		 827 int channel = epcm->channel_id;
828 int result = 0;
829
830 switch (cmd) {
831 case SNDRV_PCM_TRIGGER_START:
832 snd_ca0106_ptr_write(emu, EXTENDED_INT_MASK, 0, snd_ca0106_ptr_read(emu, EXTENDED_INT_MASK, 0) | (0x110000<<channel));
833 snd_ca0106_ptr_write(emu, BASIC_INTERRUPT, 0, snd_ca0106_ptr_read(emu, BASIC_INTERRUPT, 0)|(0x100<<channel));
834 epcm->running = 1;
835 break;
836 case SNDRV_PCM_TRIGGER_STOP:
837 snd_ca0106_ptr_write(emu, BASIC_INTERRUPT, 0, snd_ca0106_ptr_read(emu, BASIC_INTERRUPT, 0) & ~(0x100<<channel));
838 snd_ca0106_ptr_write(emu, EXTENDED_INT_MASK, 0, snd_ca0106_ptr_read(emu, EXTENDED_INT_MASK, 0) & ~(0x110000<<channel));
839 epcm->running = 0;
840 break;
841 default:
842 result = -EINVAL;
843 break;
844 }
845 return result;
846}
847
848/* pointer_playback callback */
849static snd_pcm_uframes_t
e4a3d145 850snd_ca0106_pcm_pointer_playback(struct snd_pcm_substream *substream)
1da177e4 851{
e4a3d145
TI		 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;
1da177e4
LT		 855 snd_pcm_uframes_t ptr, ptr1, ptr2,ptr3,ptr4 = 0;
856 int channel = epcm->channel_id;
857
858 if (!epcm->running)
859 return 0;
860
861 ptr3 = snd_ca0106_ptr_read(emu, PLAYBACK_LIST_PTR, channel);
862 ptr1 = snd_ca0106_ptr_read(emu, PLAYBACK_POINTER, channel);
863 ptr4 = snd_ca0106_ptr_read(emu, PLAYBACK_LIST_PTR, channel);
864 if (ptr3 != ptr4) ptr1 = snd_ca0106_ptr_read(emu, PLAYBACK_POINTER, channel);
865 ptr2 = bytes_to_frames(runtime, ptr1);
866 ptr2+= (ptr4 >> 3) * runtime->period_size;
867 ptr=ptr2;
868 if (ptr >= runtime->buffer_size)
869 ptr -= runtime->buffer_size;
870 //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);
871
872 return ptr;
873}
874
875/* pointer_capture callback */
876static snd_pcm_uframes_t
e4a3d145 877snd_ca0106_pcm_pointer_capture(struct snd_pcm_substream *substream)
1da177e4 878{
e4a3d145
TI		 879 struct snd_ca0106 *emu = snd_pcm_substream_chip(substream);
880 struct snd_pcm_runtime *runtime = substream->runtime;
881 struct snd_ca0106_pcm *epcm = runtime->private_data;
1da177e4
LT		 882 snd_pcm_uframes_t ptr, ptr1, ptr2 = 0;
883 int channel = channel=epcm->channel_id;
884
885 if (!epcm->running)
886 return 0;
887
888 ptr1 = snd_ca0106_ptr_read(emu, CAPTURE_POINTER, channel);
889 ptr2 = bytes_to_frames(runtime, ptr1);
890 ptr=ptr2;
891 if (ptr >= runtime->buffer_size)
892 ptr -= runtime->buffer_size;
893 //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);
894
895 return ptr;
896}
897
898/* operators */
e4a3d145 899static struct snd_pcm_ops snd_ca0106_playback_front_ops = {
1da177e4
LT		 900 .open = snd_ca0106_pcm_open_playback_front,
901 .close = snd_ca0106_pcm_close_playback,
902 .ioctl = snd_pcm_lib_ioctl,
903 .hw_params = snd_ca0106_pcm_hw_params_playback,
904 .hw_free = snd_ca0106_pcm_hw_free_playback,
905 .prepare = snd_ca0106_pcm_prepare_playback,
906 .trigger = snd_ca0106_pcm_trigger_playback,
907 .pointer = snd_ca0106_pcm_pointer_playback,
908};
909
e4a3d145 910static struct snd_pcm_ops snd_ca0106_capture_0_ops = {
1da177e4
LT		 911 .open = snd_ca0106_pcm_open_0_capture,
912 .close = snd_ca0106_pcm_close_capture,
913 .ioctl = snd_pcm_lib_ioctl,
914 .hw_params = snd_ca0106_pcm_hw_params_capture,
915 .hw_free = snd_ca0106_pcm_hw_free_capture,
916 .prepare = snd_ca0106_pcm_prepare_capture,
917 .trigger = snd_ca0106_pcm_trigger_capture,
918 .pointer = snd_ca0106_pcm_pointer_capture,
919};
920
e4a3d145 921static struct snd_pcm_ops snd_ca0106_capture_1_ops = {
1da177e4
LT		 922 .open = snd_ca0106_pcm_open_1_capture,
923 .close = snd_ca0106_pcm_close_capture,
924 .ioctl = snd_pcm_lib_ioctl,
925 .hw_params = snd_ca0106_pcm_hw_params_capture,
926 .hw_free = snd_ca0106_pcm_hw_free_capture,
927 .prepare = snd_ca0106_pcm_prepare_capture,
928 .trigger = snd_ca0106_pcm_trigger_capture,
929 .pointer = snd_ca0106_pcm_pointer_capture,
930};
931
e4a3d145 932static struct snd_pcm_ops snd_ca0106_capture_2_ops = {
1da177e4
LT		 933 .open = snd_ca0106_pcm_open_2_capture,
934 .close = snd_ca0106_pcm_close_capture,
935 .ioctl = snd_pcm_lib_ioctl,
936 .hw_params = snd_ca0106_pcm_hw_params_capture,
937 .hw_free = snd_ca0106_pcm_hw_free_capture,
938 .prepare = snd_ca0106_pcm_prepare_capture,
939 .trigger = snd_ca0106_pcm_trigger_capture,
940 .pointer = snd_ca0106_pcm_pointer_capture,
941};
942
e4a3d145 943static struct snd_pcm_ops snd_ca0106_capture_3_ops = {
1da177e4
LT		 944 .open = snd_ca0106_pcm_open_3_capture,
945 .close = snd_ca0106_pcm_close_capture,
946 .ioctl = snd_pcm_lib_ioctl,
947 .hw_params = snd_ca0106_pcm_hw_params_capture,
948 .hw_free = snd_ca0106_pcm_hw_free_capture,
949 .prepare = snd_ca0106_pcm_prepare_capture,
950 .trigger = snd_ca0106_pcm_trigger_capture,
951 .pointer = snd_ca0106_pcm_pointer_capture,
952};
953
e4a3d145 954static struct snd_pcm_ops snd_ca0106_playback_center_lfe_ops = {
1da177e4
LT		 955 .open = snd_ca0106_pcm_open_playback_center_lfe,
956 .close = snd_ca0106_pcm_close_playback,
957 .ioctl = snd_pcm_lib_ioctl,
958 .hw_params = snd_ca0106_pcm_hw_params_playback,
959 .hw_free = snd_ca0106_pcm_hw_free_playback,
960 .prepare = snd_ca0106_pcm_prepare_playback,
961 .trigger = snd_ca0106_pcm_trigger_playback,
962 .pointer = snd_ca0106_pcm_pointer_playback,
963};
964
e4a3d145 965static struct snd_pcm_ops snd_ca0106_playback_unknown_ops = {
1da177e4
LT		 966 .open = snd_ca0106_pcm_open_playback_unknown,
967 .close = snd_ca0106_pcm_close_playback,
968 .ioctl = snd_pcm_lib_ioctl,
969 .hw_params = snd_ca0106_pcm_hw_params_playback,
970 .hw_free = snd_ca0106_pcm_hw_free_playback,
971 .prepare = snd_ca0106_pcm_prepare_playback,
972 .trigger = snd_ca0106_pcm_trigger_playback,
973 .pointer = snd_ca0106_pcm_pointer_playback,
974};
975
e4a3d145 976static struct snd_pcm_ops snd_ca0106_playback_rear_ops = {
1da177e4
LT		 977 .open = snd_ca0106_pcm_open_playback_rear,
978 .close = snd_ca0106_pcm_close_playback,
979 .ioctl = snd_pcm_lib_ioctl,
980 .hw_params = snd_ca0106_pcm_hw_params_playback,
981 .hw_free = snd_ca0106_pcm_hw_free_playback,
982 .prepare = snd_ca0106_pcm_prepare_playback,
983 .trigger = snd_ca0106_pcm_trigger_playback,
984 .pointer = snd_ca0106_pcm_pointer_playback,
985};
986
987
e4a3d145 988static unsigned short snd_ca0106_ac97_read(struct snd_ac97 *ac97,
1da177e4
LT		 989 unsigned short reg)
990{
e4a3d145 991 struct snd_ca0106 *emu = ac97->private_data;
1da177e4
LT		 992 unsigned long flags;
993 unsigned short val;
994
995 spin_lock_irqsave(&emu->emu_lock, flags);
996 outb(reg, emu->port + AC97ADDRESS);
997 val = inw(emu->port + AC97DATA);
998 spin_unlock_irqrestore(&emu->emu_lock, flags);
999 return val;
1000}
1001
e4a3d145 1002static void snd_ca0106_ac97_write(struct snd_ac97 *ac97,
1da177e4
LT		 1003 unsigned short reg, unsigned short val)
1004{
e4a3d145 1005 struct snd_ca0106 *emu = ac97->private_data;
1da177e4
LT		 1006 unsigned long flags;
1007
1008 spin_lock_irqsave(&emu->emu_lock, flags);
1009 outb(reg, emu->port + AC97ADDRESS);
1010 outw(val, emu->port + AC97DATA);
1011 spin_unlock_irqrestore(&emu->emu_lock, flags);
1012}
1013
e4a3d145 1014static int snd_ca0106_ac97(struct snd_ca0106 *chip)
1da177e4 1015{
e4a3d145
TI		 1016 struct snd_ac97_bus *pbus;
1017 struct snd_ac97_template ac97;
1da177e4 1018 int err;
e4a3d145 1019 static struct snd_ac97_bus_ops ops = {
1da177e4
LT		 1020 .write = snd_ca0106_ac97_write,
1021 .read = snd_ca0106_ac97_read,
1022 };
1023
1024 if ((err = snd_ac97_bus(chip->card, 0, &ops, NULL, &pbus)) < 0)
1025 return err;
1026 pbus->no_vra = 1; /* we don't need VRA */
1027
1028 memset(&ac97, 0, sizeof(ac97));
1029 ac97.private_data = chip;
36c4dc42 1030 ac97.scaps = AC97_SCAP_NO_SPDIF;
1da177e4
LT		 1031 return snd_ac97_mixer(pbus, &ac97, &chip->ac97);
1032}
1033
e4a3d145 1034static int snd_ca0106_free(struct snd_ca0106 *chip)
1da177e4
LT		 1035{
1036 if (chip->res_port != NULL) { /* avoid access to already used hardware */
1037 // disable interrupts
1038 snd_ca0106_ptr_write(chip, BASIC_INTERRUPT, 0, 0);
1039 outl(0, chip->port + INTE);
1040 snd_ca0106_ptr_write(chip, EXTENDED_INT_MASK, 0, 0);
1041 udelay(1000);
1042 // disable audio
1043 //outl(HCFG_LOCKSOUNDCACHE, chip->port + HCFG);
1044 outl(0, chip->port + HCFG);
1045 /* FIXME: We need to stop and DMA transfers here.
1046 * But as I am not sure how yet, we cannot from the dma pages.
1047 * So we can fix: snd-malloc: Memory leak? pages not freed = 8
1048 */
1049 }
1050 // release the data
1051#if 1
1052 if (chip->buffer.area)
1053 snd_dma_free_pages(&chip->buffer);
1054#endif
1055
1056 // release the i/o port
b1d5776d
TI		 1057 release_and_free_resource(chip->res_port);
1058
1da177e4
LT		 1059 // release the irq
1060 if (chip->irq >= 0)
437a5a46 1061 free_irq(chip->irq, chip);
1da177e4
LT		 1062 pci_disable_device(chip->pci);
1063 kfree(chip);
1064 return 0;
1065}
1066
e4a3d145 1067static int snd_ca0106_dev_free(struct snd_device *device)
1da177e4 1068{
e4a3d145 1069 struct snd_ca0106 *chip = device->device_data;
1da177e4
LT		 1070 return snd_ca0106_free(chip);
1071}
1072
7d12e780 1073static irqreturn_t snd_ca0106_interrupt(int irq, void *dev_id)
1da177e4
LT		 1074{
1075 unsigned int status;
1076
e4a3d145 1077 struct snd_ca0106 *chip = dev_id;
1da177e4
LT		 1078 int i;
1079 int mask;
1080 unsigned int stat76;
e4a3d145 1081 struct snd_ca0106_channel *pchannel;
1da177e4 1082
1da177e4 1083 status = inl(chip->port + IPR);
1da177e4
LT		 1084 if (! status)
1085 return IRQ_NONE;
1086
1087 stat76 = snd_ca0106_ptr_read(chip, EXTENDED_INT, 0);
1088 //snd_printk("interrupt status = 0x%08x, stat76=0x%08x\n", status, stat76);
1089 //snd_printk("ptr=0x%08x\n",snd_ca0106_ptr_read(chip, PLAYBACK_POINTER, 0));
1090 mask = 0x11; /* 0x1 for one half, 0x10 for the other half period. */
1091 for(i = 0; i < 4; i++) {
1092 pchannel = &(chip->playback_channels[i]);
95a98265 1093 if (stat76 & mask) {
1da177e4
LT		 1094/* FIXME: Select the correct substream for period elapsed */
1095 if(pchannel->use) {
95a98265
TI		 1096 snd_pcm_period_elapsed(pchannel->epcm->substream);
1097 //printk(KERN_INFO "interrupt [%d] used\n", i);
1da177e4
LT		 1098 }
1099 }
1100 //printk(KERN_INFO "channel=%p\n",pchannel);
1101 //printk(KERN_INFO "interrupt stat76[%d] = %08x, use=%d, channel=%d\n", i, stat76, pchannel->use, pchannel->number);
1102 mask <<= 1;
1103 }
1104 mask = 0x110000; /* 0x1 for one half, 0x10 for the other half period. */
1105 for(i = 0; i < 4; i++) {
1106 pchannel = &(chip->capture_channels[i]);
95a98265 1107 if (stat76 & mask) {
1da177e4
LT		 1108/* FIXME: Select the correct substream for period elapsed */
1109 if(pchannel->use) {
95a98265
TI		 1110 snd_pcm_period_elapsed(pchannel->epcm->substream);
1111 //printk(KERN_INFO "interrupt [%d] used\n", i);
1da177e4
LT		 1112 }
1113 }
1114 //printk(KERN_INFO "channel=%p\n",pchannel);
1115 //printk(KERN_INFO "interrupt stat76[%d] = %08x, use=%d, channel=%d\n", i, stat76, pchannel->use, pchannel->number);
1116 mask <<= 1;
1117 }
1118
1119 snd_ca0106_ptr_write(chip, EXTENDED_INT, 0, stat76);
8a5afd29
JCD		 1120
1121 if (chip->midi.dev_id &&
95a98265 1122 (status & (chip->midi.ipr_tx|chip->midi.ipr_rx))) {
8a5afd29
JCD		 1123 if (chip->midi.interrupt)
1124 chip->midi.interrupt(&chip->midi, status);
1125 else
1126 chip->midi.interrupt_disable(&chip->midi, chip->midi.tx_enable | chip->midi.rx_enable);
1127 }
1128
1da177e4
LT		 1129 // acknowledge the interrupt if necessary
1130 outl(status, chip->port+IPR);
1131
1da177e4
LT		 1132 return IRQ_HANDLED;
1133}
1134
e4a3d145 1135static int __devinit snd_ca0106_pcm(struct snd_ca0106 *emu, int device, struct snd_pcm **rpcm)
1da177e4 1136{
e4a3d145
TI		 1137 struct snd_pcm *pcm;
1138 struct snd_pcm_substream *substream;
1da177e4
LT		 1139 int err;
1140
1141 if (rpcm)
1142 *rpcm = NULL;
1143 if ((err = snd_pcm_new(emu->card, "ca0106", device, 1, 1, &pcm)) < 0)
1144 return err;
1145
1146 pcm->private_data = emu;
1da177e4
LT		 1147
1148 switch (device) {
1149 case 0:
1150 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_ca0106_playback_front_ops);
1151 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_ca0106_capture_0_ops);
1152 break;
1153 case 1:
1154 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_ca0106_playback_rear_ops);
1155 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_ca0106_capture_1_ops);
1156 break;
1157 case 2:
1158 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_ca0106_playback_center_lfe_ops);
1159 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_ca0106_capture_2_ops);
1160 break;
1161 case 3:
1162 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_ca0106_playback_unknown_ops);
1163 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_ca0106_capture_3_ops);
1164 break;
1165 }
1166
1167 pcm->info_flags = 0;
1168 pcm->dev_subclass = SNDRV_PCM_SUBCLASS_GENERIC_MIX;
1169 strcpy(pcm->name, "CA0106");
1170 emu->pcm = pcm;
1171
1172 for(substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream;
1173 substream;
1174 substream = substream->next) {
1175 if ((err = snd_pcm_lib_preallocate_pages(substream,
1176 SNDRV_DMA_TYPE_DEV,
1177 snd_dma_pci_data(emu->pci),
1178 64*1024, 64*1024)) < 0) /* FIXME: 32*1024 for sound buffer, between 32and64 for Periods table. */
1179 return err;
1180 }
1181
1182 for (substream = pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream;
1183 substream;
1184 substream = substream->next) {
1185 if ((err = snd_pcm_lib_preallocate_pages(substream,
1186 SNDRV_DMA_TYPE_DEV,
1187 snd_dma_pci_data(emu->pci),
1188 64*1024, 64*1024)) < 0)
1189 return err;
1190 }
1191
1192 if (rpcm)
1193 *rpcm = pcm;
1194
1195 return 0;
1196}
1197
aad90953
JCD		 1198static unsigned int spi_dac_init[] = {
1199 0x00ff,
1200 0x02ff,
1201 0x0400,
1202 0x0520,
58398895 1203 0x0620, /* Set 24 bit. Was 0x0600 */
aad90953
JCD		 1204 0x08ff,
1205 0x0aff,
1206 0x0cff,
1207 0x0eff,
1208 0x10ff,
1209 0x1200,
1210 0x1400,
1211 0x1480,
1212 0x1800,
1213 0x1aff,
1214 0x1cff,
1215 0x1e00,
1216 0x0530,
1217 0x0602,
1218 0x0622,
1219 0x1400,
1220};
1221
6129daaa
JCD		 1222static unsigned int i2c_adc_init[][2] = {
1223 { 0x17, 0x00 }, /* Reset */
1224 { 0x07, 0x00 }, /* Timeout */
1225 { 0x0b, 0x22 }, /* Interface control */
1226 { 0x0c, 0x22 }, /* Master mode control */
1227 { 0x0d, 0x08 }, /* Powerdown control */
1228 { 0x0e, 0xcf }, /* Attenuation Left 0x01 = -103dB, 0xff = 24dB */
1229 { 0x0f, 0xcf }, /* Attenuation Right 0.5dB steps */
1230 { 0x10, 0x7b }, /* ALC Control 1 */
1231 { 0x11, 0x00 }, /* ALC Control 2 */
1232 { 0x12, 0x32 }, /* ALC Control 3 */
1233 { 0x13, 0x00 }, /* Noise gate control */
1234 { 0x14, 0xa6 }, /* Limiter control */
1235 { 0x15, ADC_MUX_LINEIN }, /* ADC Mixer control */
1236};
1237
e4f55d80 1238static int __devinit snd_ca0106_create(int dev, struct snd_card *card,
1da177e4 1239 struct pci_dev *pci,
e4a3d145 1240 struct snd_ca0106 **rchip)
1da177e4 1241{
e4a3d145
TI		 1242 struct snd_ca0106 *chip;
1243 struct snd_ca0106_details *c;
1da177e4
LT		 1244 int err;
1245 int ch;
e4a3d145 1246 static struct snd_device_ops ops = {
1da177e4
LT		 1247 .dev_free = snd_ca0106_dev_free,
1248 };
1249
1250 *rchip = NULL;
1251
1252 if ((err = pci_enable_device(pci)) < 0)
1253 return err;
299676b1
TK		 1254 if (pci_set_dma_mask(pci, DMA_32BIT_MASK) < 0 ||
1255 pci_set_consistent_dma_mask(pci, DMA_32BIT_MASK) < 0) {
1da177e4
LT		 1256 printk(KERN_ERR "error to set 32bit mask DMA\n");
1257 pci_disable_device(pci);
1258 return -ENXIO;
1259 }
1260
e560d8d8 1261 chip = kzalloc(sizeof(*chip), GFP_KERNEL);
1da177e4
LT		 1262 if (chip == NULL) {
1263 pci_disable_device(pci);
1264 return -ENOMEM;
1265 }
1266
1267 chip->card = card;
1268 chip->pci = pci;
1269 chip->irq = -1;
1270
1271 spin_lock_init(&chip->emu_lock);
1272
1273 chip->port = pci_resource_start(pci, 0);
1274 if ((chip->res_port = request_region(chip->port, 0x20,
1275 "snd_ca0106")) == NULL) {
1276 snd_ca0106_free(chip);
1277 printk(KERN_ERR "cannot allocate the port\n");
1278 return -EBUSY;
1279 }
1280
1281 if (request_irq(pci->irq, snd_ca0106_interrupt,
437a5a46 1282 IRQF_SHARED, "snd_ca0106", chip)) {
1da177e4
LT		 1283 snd_ca0106_free(chip);
1284 printk(KERN_ERR "cannot grab irq\n");
1285 return -EBUSY;
1286 }
1287 chip->irq = pci->irq;
1288
1289 /* This stores the periods table. */
1290 if(snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci), 1024, &chip->buffer) < 0) {
1291 snd_ca0106_free(chip);
1292 return -ENOMEM;
1293 }
1294
1295 pci_set_master(pci);
44c10138 1296 /* read serial */
1da177e4
LT		 1297 pci_read_config_dword(pci, PCI_SUBSYSTEM_VENDOR_ID, &chip->serial);
1298 pci_read_config_word(pci, PCI_SUBSYSTEM_ID, &chip->model);
1299#if 1
e4f55d80 1300 printk(KERN_INFO "snd-ca0106: Model %04x Rev %08x Serial %08x\n", chip->model,
44c10138 1301 pci->revision, chip->serial);
1da177e4 1302#endif
1baa705b
JCD		 1303 strcpy(card->driver, "CA0106");
1304 strcpy(card->shortname, "CA0106");
1305
95a98265 1306 for (c = ca0106_chip_details; c->serial; c++) {
e4f55d80
JCD		 1307 if (subsystem[dev]) {
1308 if (c->serial == subsystem[dev])
1309 break;
1310 } else if (c->serial == chip->serial)
95a98265 1311 break;
1baa705b
JCD		 1312 }
1313 chip->details = c;
e4f55d80 1314 if (subsystem[dev]) {
d5f6a38d 1315 printk(KERN_INFO "snd-ca0106: Sound card name=%s, subsystem=0x%x. Forced to subsystem=0x%x\n",
e4f55d80
JCD		 1316 c->name, chip->serial, subsystem[dev]);
1317 }
1318
1baa705b
JCD		 1319 sprintf(card->longname, "%s at 0x%lx irq %i",
1320 c->name, chip->port, chip->irq);
1da177e4
LT		 1321
1322 outl(0, chip->port + INTE);
1323
1324 /*
1325 * Init to 0x02109204 :
1326 * Clock accuracy = 0 (1000ppm)
1327 * Sample Rate = 2 (48kHz)
1328 * Audio Channel = 1 (Left of 2)
1329 * Source Number = 0 (Unspecified)
1330 * Generation Status = 1 (Original for Cat Code 12)
1331 * Cat Code = 12 (Digital Signal Mixer)
1332 * Mode = 0 (Mode 0)
1333 * Emphasis = 0 (None)
1334 * CP = 1 (Copyright unasserted)
1335 * AN = 0 (Audio data)
1336 * P = 0 (Consumer)
1337 */
1338 snd_ca0106_ptr_write(chip, SPCS0, 0,
1339 chip->spdif_bits[0] =
1340 SPCS_CLKACCY_1000PPM | SPCS_SAMPLERATE_48 |
1341 SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC |
1342 SPCS_GENERATIONSTATUS | 0x00001200 |
1343 0x00000000 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT);
1344 /* Only SPCS1 has been tested */
1345 snd_ca0106_ptr_write(chip, SPCS1, 0,
1346 chip->spdif_bits[1] =
1347 SPCS_CLKACCY_1000PPM | SPCS_SAMPLERATE_48 |
1348 SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC |
1349 SPCS_GENERATIONSTATUS | 0x00001200 |
1350 0x00000000 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT);
1351 snd_ca0106_ptr_write(chip, SPCS2, 0,
1352 chip->spdif_bits[2] =
1353 SPCS_CLKACCY_1000PPM | SPCS_SAMPLERATE_48 |
1354 SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC |
1355 SPCS_GENERATIONSTATUS | 0x00001200 |
1356 0x00000000 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT);
1357 snd_ca0106_ptr_write(chip, SPCS3, 0,
1358 chip->spdif_bits[3] =
1359 SPCS_CLKACCY_1000PPM | SPCS_SAMPLERATE_48 |
1360 SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC |
1361 SPCS_GENERATIONSTATUS | 0x00001200 |
1362 0x00000000 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT);
1363
1364 snd_ca0106_ptr_write(chip, PLAYBACK_MUTE, 0, 0x00fc0000);
1365 snd_ca0106_ptr_write(chip, CAPTURE_MUTE, 0, 0x00fc0000);
1366
1367 /* Write 0x8000 to AC97_REC_GAIN to mute it. */
1368 outb(AC97_REC_GAIN, chip->port + AC97ADDRESS);
1369 outw(0x8000, chip->port + AC97DATA);
1370#if 0
1371 snd_ca0106_ptr_write(chip, SPCS0, 0, 0x2108006);
1372 snd_ca0106_ptr_write(chip, 0x42, 0, 0x2108006);
1373 snd_ca0106_ptr_write(chip, 0x43, 0, 0x2108006);
1374 snd_ca0106_ptr_write(chip, 0x44, 0, 0x2108006);
1375#endif
1376
1377 //snd_ca0106_ptr_write(chip, SPDIF_SELECT2, 0, 0xf0f003f); /* OSS drivers set this. */
1378 /* Analog or Digital output */
1379 snd_ca0106_ptr_write(chip, SPDIF_SELECT1, 0, 0xf);
8f55fbb0 1380 snd_ca0106_ptr_write(chip, SPDIF_SELECT2, 0, 0x000f0000); /* 0x0b000000 for digital, 0x000b0000 for analog, from win2000 drivers. Use 0x000f0000 for surround71 */
1da177e4 1381 chip->spdif_enable = 0; /* Set digital SPDIF output off */
1da177e4
LT		 1382 //snd_ca0106_ptr_write(chip, 0x45, 0, 0); /* Analogue out */
1383 //snd_ca0106_ptr_write(chip, 0x45, 0, 0xf00); /* Digital out */
1384
1385 snd_ca0106_ptr_write(chip, CAPTURE_CONTROL, 0, 0x40c81000); /* goes to 0x40c80000 when doing SPDIF IN/OUT */
1386 snd_ca0106_ptr_write(chip, CAPTURE_CONTROL, 1, 0xffffffff); /* (Mute) CAPTURE feedback into PLAYBACK volume. Only lower 16 bits matter. */
1387 snd_ca0106_ptr_write(chip, CAPTURE_CONTROL, 2, 0x30300000); /* SPDIF IN Volume */
1388 snd_ca0106_ptr_write(chip, CAPTURE_CONTROL, 3, 0x00700000); /* SPDIF IN Volume, 0x70 = (vol & 0x3f) | 0x40 */
1389 snd_ca0106_ptr_write(chip, PLAYBACK_ROUTING1, 0, 0x32765410);
1390 snd_ca0106_ptr_write(chip, PLAYBACK_ROUTING2, 0, 0x76767676);
1391 snd_ca0106_ptr_write(chip, CAPTURE_ROUTING1, 0, 0x32765410);
1392 snd_ca0106_ptr_write(chip, CAPTURE_ROUTING2, 0, 0x76767676);
1393 for(ch = 0; ch < 4; ch++) {
1394 snd_ca0106_ptr_write(chip, CAPTURE_VOLUME1, ch, 0x30303030); /* Only high 16 bits matter */
1395 snd_ca0106_ptr_write(chip, CAPTURE_VOLUME2, ch, 0x30303030);
1396 //snd_ca0106_ptr_write(chip, PLAYBACK_VOLUME1, ch, 0x40404040); /* Mute */
1397 //snd_ca0106_ptr_write(chip, PLAYBACK_VOLUME2, ch, 0x40404040); /* Mute */
1398 snd_ca0106_ptr_write(chip, PLAYBACK_VOLUME1, ch, 0xffffffff); /* Mute */
1399 snd_ca0106_ptr_write(chip, PLAYBACK_VOLUME2, ch, 0xffffffff); /* Mute */
1400 }
7c157069
JCD		 1401 if (chip->details->i2c_adc == 1) {
1402 /* Select MIC, Line in, TAD in, AUX in */
1403 snd_ca0106_ptr_write(chip, CAPTURE_SOURCE, 0x0, 0x333300e4);
1404 /* Default to CAPTURE_SOURCE to i2s in */
1405 chip->capture_source = 3;
1406 } else if (chip->details->ac97 == 1) {
1407 /* Default to AC97 in */
1408 snd_ca0106_ptr_write(chip, CAPTURE_SOURCE, 0x0, 0x444400e4);
1409 /* Default to CAPTURE_SOURCE to AC97 in */
1410 chip->capture_source = 4;
1411 } else {
1412 /* Select MIC, Line in, TAD in, AUX in */
1413 snd_ca0106_ptr_write(chip, CAPTURE_SOURCE, 0x0, 0x333300e4);
1414 /* Default to Set CAPTURE_SOURCE to i2s in */
1415 chip->capture_source = 3;
1416 }
1da177e4 1417
be0b7b01 1418 if (chip->details->gpio_type == 2) { /* The SB0438 use GPIO differently. */
6129daaa
JCD		 1419 /* FIXME: Still need to find out what the other GPIO bits do. E.g. For digital spdif out. */
1420 outl(0x0, chip->port+GPIO);
1421 //outl(0x00f0e000, chip->port+GPIO); /* Analog */
1422 outl(0x005f5301, chip->port+GPIO); /* Analog */
1423 } else if (chip->details->gpio_type == 1) { /* The SB0410 and SB0413 use GPIO differently. */
1da177e4
LT		 1424 /* FIXME: Still need to find out what the other GPIO bits do. E.g. For digital spdif out. */
1425 outl(0x0, chip->port+GPIO);
1426 //outl(0x00f0e000, chip->port+GPIO); /* Analog */
c82bf829 1427 outl(0x005f5301, chip->port+GPIO); /* Analog */
1da177e4
LT		 1428 } else {
1429 outl(0x0, chip->port+GPIO);
1430 outl(0x005f03a3, chip->port+GPIO); /* Analog */
1431 //outl(0x005f02a2, chip->port+GPIO); /* SPDIF */
1432 }
1433 snd_ca0106_intr_enable(chip, 0x105); /* Win2000 uses 0x1e0 */
1434
1435 //outl(HCFG_LOCKSOUNDCACHE|HCFG_AUDIOENABLE, chip->port+HCFG);
1436 //outl(0x00001409, chip->port+HCFG); /* 0x1000 causes AC3 to fails. Maybe it effects 24 bit output. */
1437 //outl(0x00000009, chip->port+HCFG);
1438 outl(HCFG_AC97 | HCFG_AUDIOENABLE, chip->port+HCFG); /* AC97 2.0, Enable outputs. */
1439
7199acdc 1440 if (chip->details->i2c_adc == 1) { /* The SB0410 and SB0413 use I2C to control ADC. */
6129daaa
JCD		 1441 int size, n;
1442
1443 size = ARRAY_SIZE(i2c_adc_init);
1444 //snd_printk("I2C:array size=0x%x\n", size);
1445 for (n=0; n < size; n++) {
1446 snd_ca0106_i2c_write(chip, i2c_adc_init[n][0], i2c_adc_init[n][1]);
1447 }
1448 for (n=0; n < 4; n++) {
1449 chip->i2c_capture_volume[n][0]= 0xcf;
1450 chip->i2c_capture_volume[n][1]= 0xcf;
1451 }
1452 chip->i2c_capture_source=2; /* Line in */
1453 //snd_ca0106_i2c_write(chip, ADC_MUX, ADC_MUX_LINEIN); /* Enable Line-in capture. MIC in currently untested. */
7199acdc 1454 }
a5875159 1455 if (chip->details->spi_dac == 1) { /* The SB0570 use SPI to control DAC. */
aad90953
JCD		 1456 int size, n;
1457
1458 size = ARRAY_SIZE(spi_dac_init);
1459 for (n=0; n < size; n++)
1460 snd_ca0106_spi_write(chip, spi_dac_init[n]);
a5875159 1461 }
7199acdc 1462
1da177e4
LT		 1463 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL,
1464 chip, &ops)) < 0) {
1465 snd_ca0106_free(chip);
1466 return err;
1467 }
1468 *rchip = chip;
1469 return 0;
1470}
1471
8a5afd29 1472
e4a3d145 1473static void ca0106_midi_interrupt_enable(struct snd_ca_midi *midi, int intr)
7cf4783b 1474{
e4a3d145 1475 snd_ca0106_intr_enable((struct snd_ca0106 *)(midi->dev_id), intr);
8a5afd29
JCD		 1476}
1477
e4a3d145 1478static void ca0106_midi_interrupt_disable(struct snd_ca_midi *midi, int intr)
7cf4783b 1479{
e4a3d145 1480 snd_ca0106_intr_disable((struct snd_ca0106 *)(midi->dev_id), intr);
8a5afd29
JCD		 1481}
1482
e4a3d145 1483static unsigned char ca0106_midi_read(struct snd_ca_midi *midi, int idx)
7cf4783b 1484{
e4a3d145
TI		 1485 return (unsigned char)snd_ca0106_ptr_read((struct snd_ca0106 *)(midi->dev_id),
1486 midi->port + idx, 0);
8a5afd29
JCD		 1487}
1488
e4a3d145 1489static void ca0106_midi_write(struct snd_ca_midi *midi, int data, int idx)
7cf4783b 1490{
e4a3d145 1491 snd_ca0106_ptr_write((struct snd_ca0106 *)(midi->dev_id), midi->port + idx, 0, data);
8a5afd29
JCD		 1492}
1493
e4a3d145 1494static struct snd_card *ca0106_dev_id_card(void *dev_id)
7cf4783b 1495{
e4a3d145 1496 return ((struct snd_ca0106 *)dev_id)->card;
8a5afd29
JCD		 1497}
1498
7cf4783b
JCD		 1499static int ca0106_dev_id_port(void *dev_id)
1500{
e4a3d145 1501 return ((struct snd_ca0106 *)dev_id)->port;
8a5afd29
JCD		 1502}
1503
e4a3d145 1504static int __devinit snd_ca0106_midi(struct snd_ca0106 *chip, unsigned int channel)
8a5afd29 1505{
e4a3d145 1506 struct snd_ca_midi *midi;
8a5afd29
JCD		 1507 char *name;
1508 int err;
1509
95a98265 1510 if (channel == CA0106_MIDI_CHAN_B) {
8a5afd29
JCD		 1511 name = "CA0106 MPU-401 (UART) B";
1512 midi = &chip->midi2;
1513 midi->tx_enable = INTE_MIDI_TX_B;
1514 midi->rx_enable = INTE_MIDI_RX_B;
1515 midi->ipr_tx = IPR_MIDI_TX_B;
1516 midi->ipr_rx = IPR_MIDI_RX_B;
1517 midi->port = MIDI_UART_B_DATA;
1518 } else {
1519 name = "CA0106 MPU-401 (UART)";
1520 midi = &chip->midi;
1521 midi->tx_enable = INTE_MIDI_TX_A;
1522 midi->rx_enable = INTE_MIDI_TX_B;
1523 midi->ipr_tx = IPR_MIDI_TX_A;
1524 midi->ipr_rx = IPR_MIDI_RX_A;
1525 midi->port = MIDI_UART_A_DATA;
1526 }
1527
1528 midi->reset = CA0106_MPU401_RESET;
1529 midi->enter_uart = CA0106_MPU401_ENTER_UART;
1530 midi->ack = CA0106_MPU401_ACK;
1531
1532 midi->input_avail = CA0106_MIDI_INPUT_AVAIL;
1533 midi->output_ready = CA0106_MIDI_OUTPUT_READY;
1534
1535 midi->channel = channel;
1536
1537 midi->interrupt_enable = ca0106_midi_interrupt_enable;
1538 midi->interrupt_disable = ca0106_midi_interrupt_disable;
1539
1540 midi->read = ca0106_midi_read;
1541 midi->write = ca0106_midi_write;
1542
1543 midi->get_dev_id_card = ca0106_dev_id_card;
1544 midi->get_dev_id_port = ca0106_dev_id_port;
1545
1546 midi->dev_id = chip;
1547
1548 if ((err = ca_midi_init(chip, midi, 0, name)) < 0)
1549 return err;
1550
1551 return 0;
1552}
1553
1554
1da177e4
LT		 1555static int __devinit snd_ca0106_probe(struct pci_dev *pci,
1556 const struct pci_device_id *pci_id)
1557{
1558 static int dev;
e4a3d145
TI		 1559 struct snd_card *card;
1560 struct snd_ca0106 *chip;
1da177e4
LT		 1561 int err;
1562
1563 if (dev >= SNDRV_CARDS)
1564 return -ENODEV;
1565 if (!enable[dev]) {
1566 dev++;
1567 return -ENOENT;
1568 }
1569
1570 card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
1571 if (card == NULL)
1572 return -ENOMEM;
1573
e4f55d80 1574 if ((err = snd_ca0106_create(dev, card, pci, &chip)) < 0) {
1da177e4
LT		 1575 snd_card_free(card);
1576 return err;
1577 }
1578
1579 if ((err = snd_ca0106_pcm(chip, 0, NULL)) < 0) {
1580 snd_card_free(card);
1581 return err;
1582 }
1583 if ((err = snd_ca0106_pcm(chip, 1, NULL)) < 0) {
1584 snd_card_free(card);
1585 return err;
1586 }
1587 if ((err = snd_ca0106_pcm(chip, 2, NULL)) < 0) {
1588 snd_card_free(card);
1589 return err;
1590 }
1591 if ((err = snd_ca0106_pcm(chip, 3, NULL)) < 0) {
1592 snd_card_free(card);
1593 return err;
1594 }
1baa705b 1595 if (chip->details->ac97 == 1) { /* The SB0410 and SB0413 do not have an AC97 chip. */
1da177e4
LT		 1596 if ((err = snd_ca0106_ac97(chip)) < 0) {
1597 snd_card_free(card);
1598 return err;
1599 }
1600 }
1601 if ((err = snd_ca0106_mixer(chip)) < 0) {
1602 snd_card_free(card);
1603 return err;
1604 }
1605
7cf4783b 1606 snd_printdd("ca0106: probe for MIDI channel A ...");
8a5afd29
JCD		 1607 if ((err = snd_ca0106_midi(chip,CA0106_MIDI_CHAN_A)) < 0) {
1608 snd_card_free(card);
7cf4783b 1609 snd_printdd(" failed, err=0x%x\n",err);
8a5afd29
JCD		 1610 return err;
1611 }
7cf4783b 1612 snd_printdd(" done.\n");
8a5afd29 1613
adf1b3d2 1614#ifdef CONFIG_PROC_FS
1da177e4 1615 snd_ca0106_proc_init(chip);
adf1b3d2 1616#endif
1da177e4 1617
c6d6eeea
TI		 1618 snd_card_set_dev(card, &pci->dev);
1619
1da177e4
LT		 1620 if ((err = snd_card_register(card)) < 0) {
1621 snd_card_free(card);
1622 return err;
1623 }
1624
1625 pci_set_drvdata(pci, card);
1626 dev++;
1627 return 0;
1628}
1629
1630static void __devexit snd_ca0106_remove(struct pci_dev *pci)
1631{
1632 snd_card_free(pci_get_drvdata(pci));
1633 pci_set_drvdata(pci, NULL);
1634}
1635
1636// PCI IDs
f40b6890 1637static struct pci_device_id snd_ca0106_ids[] = {
1da177e4
LT		 1638 { 0x1102, 0x0007, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, /* Audigy LS or Live 24bit */
1639 { 0, }
1640};
1641MODULE_DEVICE_TABLE(pci, snd_ca0106_ids);
1642
1643// pci_driver definition
1644static struct pci_driver driver = {
1645 .name = "CA0106",
1646 .id_table = snd_ca0106_ids,
1647 .probe = snd_ca0106_probe,
1648 .remove = __devexit_p(snd_ca0106_remove),
1649};
1650
1651// initialization of the module
1652static int __init alsa_card_ca0106_init(void)
1653{
95a98265 1654 return pci_register_driver(&driver);
1da177e4
LT		 1655}
1656
1657// clean up the module
1658static void __exit alsa_card_ca0106_exit(void)
1659{
1660 pci_unregister_driver(&driver);
1661}
1662
1663module_init(alsa_card_ca0106_init)
1664module_exit(alsa_card_ca0106_exit)