1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138#include <linux/delay.h>
139#include <linux/init.h>
140#include <linux/interrupt.h>
141#include <linux/pci.h>
142#include <linux/slab.h>
143#include <linux/moduleparam.h>
144#include <linux/dma-mapping.h>
145#include <sound/core.h>
146#include <sound/initval.h>
147#include <sound/pcm.h>
148#include <sound/ac97_codec.h>
149#include <sound/info.h>
150
151MODULE_AUTHOR("James Courtier-Dutton <James@superbug.demon.co.uk>");
152MODULE_DESCRIPTION("CA0106");
153MODULE_LICENSE("GPL");
154MODULE_SUPPORTED_DEVICE("{{Creative,SB CA0106 chip}}");
155
156
157static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
158static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
159static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
160static uint subsystem[SNDRV_CARDS];
161
162module_param_array(index, int, NULL, 0444);
163MODULE_PARM_DESC(index, "Index value for the CA0106 soundcard.");
164module_param_array(id, charp, NULL, 0444);
165MODULE_PARM_DESC(id, "ID string for the CA0106 soundcard.");
166module_param_array(enable, bool, NULL, 0444);
167MODULE_PARM_DESC(enable, "Enable the CA0106 soundcard.");
168module_param_array(subsystem, uint, NULL, 0444);
169MODULE_PARM_DESC(subsystem, "Force card subsystem model.");
170
171#include "ca0106.h"
172
173static struct snd_ca0106_details ca0106_chip_details[] = {
174
175
176
177
178
179 { .serial = 0x10131102,
180 .name = "X-Fi Extreme Audio [SBxxxx]",
181 .gpio_type = 1,
182 .i2c_adc = 1 } ,
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197 { .serial = 0x10121102,
198 .name = "X-Fi Extreme Audio [SB0790]",
199 .gpio_type = 1,
200 .i2c_adc = 1 } ,
201
202
203 { .serial = 0x10021102,
204 .name = "AudigyLS [SB0310]",
205 .ac97 = 1 } ,
206
207 { .serial = 0x10051102,
208 .name = "AudigyLS [SB0310b]",
209 .ac97 = 1 } ,
210
211 { .serial = 0x10061102,
212 .name = "Live! 7.1 24bit [SB0410]",
213 .gpio_type = 1,
214 .i2c_adc = 1 } ,
215
216 { .serial = 0x10071102,
217 .name = "Live! 7.1 24bit [SB0413]",
218 .gpio_type = 1,
219 .i2c_adc = 1 } ,
220
221
222
223
224
225
226 { .serial = 0x100a1102,
227 .name = "Audigy SE [SB0570]",
228 .gpio_type = 1,
229 .i2c_adc = 1,
230 .spi_dac = 1 } ,
231
232
233
234
235
236
237 { .serial = 0x10111102,
238 .name = "Audigy SE OEM [SB0570a]",
239 .gpio_type = 1,
240 .i2c_adc = 1,
241 .spi_dac = 1 } ,
242
243
244
245
246
247
248 { .serial = 0x10091462,
249 .name = "MSI K8N Diamond MB [SB0438]",
250 .gpio_type = 2,
251 .i2c_adc = 1 } ,
252
253 { .serial = 0x10091102,
254 .name = "MSI K8N Diamond MB",
255 .gpio_type = 2,
256 .i2c_adc = 1,
257 .spi_dac = 1 } ,
258
259
260
261
262 { .serial = 0x1458a006,
263 .name = "Giga-byte GA-G1975X",
264 .gpio_type = 1,
265 .i2c_adc = 1 },
266
267
268
269
270
271 { .serial = 0x30381297,
272 .name = "Shuttle XPC SD31P [SD31P]",
273 .gpio_type = 1,
274 .i2c_adc = 1 } ,
275
276
277
278
279
280 { .serial = 0x30411297,
281 .name = "Shuttle XPC SD11G5 [SD11G5]",
282 .gpio_type = 1,
283 .i2c_adc = 1 } ,
284 { .serial = 0,
285 .name = "AudigyLS [Unknown]" }
286};
287
288
289static struct snd_pcm_hardware snd_ca0106_playback_hw = {
290 .info = SNDRV_PCM_INFO_MMAP |
291 SNDRV_PCM_INFO_INTERLEAVED |
292 SNDRV_PCM_INFO_BLOCK_TRANSFER |
293 SNDRV_PCM_INFO_MMAP_VALID |
294 SNDRV_PCM_INFO_SYNC_START,
295 .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S32_LE,
296 .rates = (SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_96000 |
297 SNDRV_PCM_RATE_192000),
298 .rate_min = 48000,
299 .rate_max = 192000,
300 .channels_min = 2,
301 .channels_max = 2,
302 .buffer_bytes_max = ((65536 - 64) * 8),
303 .period_bytes_min = 64,
304 .period_bytes_max = (65536 - 64),
305 .periods_min = 2,
306 .periods_max = 8,
307 .fifo_size = 0,
308};
309
310static struct snd_pcm_hardware snd_ca0106_capture_hw = {
311 .info = (SNDRV_PCM_INFO_MMAP |
312 SNDRV_PCM_INFO_INTERLEAVED |
313 SNDRV_PCM_INFO_BLOCK_TRANSFER |
314 SNDRV_PCM_INFO_MMAP_VALID),
315 .formats = SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S32_LE,
316#if 0
317 .rates = (SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |
318 SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_192000),
319 .rate_min = 44100,
320#else
321 .rates = (SNDRV_PCM_RATE_48000 |
322 SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_192000),
323 .rate_min = 48000,
324#endif
325 .rate_max = 192000,
326 .channels_min = 2,
327 .channels_max = 2,
328 .buffer_bytes_max = 65536 - 128,
329 .period_bytes_min = 64,
330 .period_bytes_max = 32768 - 64,
331 .periods_min = 2,
332 .periods_max = 2,
333 .fifo_size = 0,
334};
335
336unsigned int snd_ca0106_ptr_read(struct snd_ca0106 * emu,
337 unsigned int reg,
338 unsigned int chn)
339{
340 unsigned long flags;
341 unsigned int regptr, val;
342
343 regptr = (reg << 16) | chn;
344
345 spin_lock_irqsave(&emu->emu_lock, flags);
346 outl(regptr, emu->port + PTR);
347 val = inl(emu->port + DATA);
348 spin_unlock_irqrestore(&emu->emu_lock, flags);
349 return val;
350}
351
352void snd_ca0106_ptr_write(struct snd_ca0106 *emu,
353 unsigned int reg,
354 unsigned int chn,
355 unsigned int data)
356{
357 unsigned int regptr;
358 unsigned long flags;
359
360 regptr = (reg << 16) | chn;
361
362 spin_lock_irqsave(&emu->emu_lock, flags);
363 outl(regptr, emu->port + PTR);
364 outl(data, emu->port + DATA);
365 spin_unlock_irqrestore(&emu->emu_lock, flags);
366}
367
368int snd_ca0106_spi_write(struct snd_ca0106 * emu,
369 unsigned int data)
370{
371 unsigned int reset, set;
372 unsigned int reg, tmp;
373 int n, result;
374 reg = SPI;
375 if (data > 0xffff)
376 return 1;
377 tmp = snd_ca0106_ptr_read(emu, reg, 0);
378 reset = (tmp & ~0x3ffff) | 0x20000;
379 set = reset | 0x10000;
380 snd_ca0106_ptr_write(emu, reg, 0, reset | data);
381 tmp = snd_ca0106_ptr_read(emu, reg, 0);
382 snd_ca0106_ptr_write(emu, reg, 0, set | data);
383 result = 1;
384
385 for (n = 0; n < 100; n++) {
386 udelay(10);
387 tmp = snd_ca0106_ptr_read(emu, reg, 0);
388 if (!(tmp & 0x10000)) {
389 result = 0;
390 break;
391 }
392 }
393 if (result)
394 return 1;
395 snd_ca0106_ptr_write(emu, reg, 0, reset | data);
396 tmp = snd_ca0106_ptr_read(emu, reg, 0);
397 return 0;
398}
399
400
401int snd_ca0106_i2c_write(struct snd_ca0106 *emu,
402 u32 reg,
403 u32 value)
404{
405 u32 tmp;
406 int timeout = 0;
407 int status;
408 int retry;
409 if ((reg > 0x7f) || (value > 0x1ff)) {
410 snd_printk(KERN_ERR "i2c_write: invalid values.\n");
411 return -EINVAL;
412 }
413
414 tmp = reg << 25 | value << 16;
415
416
417
418
419
420
421
422 snd_ca0106_ptr_write(emu, I2C_D1, 0, tmp);
423
424 for (retry = 0; retry < 10; retry++) {
425
426
427
428 tmp = 0;
429 tmp = tmp | (I2C_A_ADC_LAST|I2C_A_ADC_START|I2C_A_ADC_ADD);
430 snd_ca0106_ptr_write(emu, I2C_A, 0, tmp);
431
432
433 while (1) {
434 status = snd_ca0106_ptr_read(emu, I2C_A, 0);
435
436 timeout++;
437 if ((status & I2C_A_ADC_START) == 0)
438 break;
439
440 if (timeout > 1000)
441 break;
442 }
443
444 if ((status & I2C_A_ADC_ABORT) == 0)
445 break;
446 }
447
448 if (retry == 10) {
449 snd_printk(KERN_ERR "Writing to ADC failed!\n");
450 return -EINVAL;
451 }
452
453 return 0;
454}
455
456
457static void snd_ca0106_intr_enable(struct snd_ca0106 *emu, unsigned int intrenb)
458{
459 unsigned long flags;
460 unsigned int intr_enable;
461
462 spin_lock_irqsave(&emu->emu_lock, flags);
463 intr_enable = inl(emu->port + INTE) | intrenb;
464 outl(intr_enable, emu->port + INTE);
465 spin_unlock_irqrestore(&emu->emu_lock, flags);
466}
467
468static void snd_ca0106_intr_disable(struct snd_ca0106 *emu, unsigned int intrenb)
469{
470 unsigned long flags;
471 unsigned int intr_enable;
472
473 spin_lock_irqsave(&emu->emu_lock, flags);
474 intr_enable = inl(emu->port + INTE) & ~intrenb;
475 outl(intr_enable, emu->port + INTE);
476 spin_unlock_irqrestore(&emu->emu_lock, flags);
477}
478
479
480static void snd_ca0106_pcm_free_substream(struct snd_pcm_runtime *runtime)
481{
482 kfree(runtime->private_data);
483}
484
485static const int spi_dacd_reg[] = {
486 [PCM_FRONT_CHANNEL] = SPI_DACD4_REG,
487 [PCM_REAR_CHANNEL] = SPI_DACD0_REG,
488 [PCM_CENTER_LFE_CHANNEL]= SPI_DACD2_REG,
489 [PCM_UNKNOWN_CHANNEL] = SPI_DACD1_REG,
490};
491static const int spi_dacd_bit[] = {
492 [PCM_FRONT_CHANNEL] = SPI_DACD4_BIT,
493 [PCM_REAR_CHANNEL] = SPI_DACD0_BIT,
494 [PCM_CENTER_LFE_CHANNEL]= SPI_DACD2_BIT,
495 [PCM_UNKNOWN_CHANNEL] = SPI_DACD1_BIT,
496};
497
498static void restore_spdif_bits(struct snd_ca0106 *chip, int idx)
499{
500 if (chip->spdif_str_bits[idx] != chip->spdif_bits[idx]) {
501 chip->spdif_str_bits[idx] = chip->spdif_bits[idx];
502 snd_ca0106_ptr_write(chip, SPCS0 + idx, 0,
503 chip->spdif_str_bits[idx]);
504 }
505}
506
507
508static int snd_ca0106_pcm_open_playback_channel(struct snd_pcm_substream *substream,
509 int channel_id)
510{
511 struct snd_ca0106 *chip = snd_pcm_substream_chip(substream);
512 struct snd_ca0106_channel *channel = &(chip->playback_channels[channel_id]);
513 struct snd_ca0106_pcm *epcm;
514 struct snd_pcm_runtime *runtime = substream->runtime;
515 int err;
516
517 epcm = kzalloc(sizeof(*epcm), GFP_KERNEL);
518
519 if (epcm == NULL)
520 return -ENOMEM;
521 epcm->emu = chip;
522 epcm->substream = substream;
523 epcm->channel_id=channel_id;
524
525 runtime->private_data = epcm;
526 runtime->private_free = snd_ca0106_pcm_free_substream;
527
528 runtime->hw = snd_ca0106_playback_hw;
529
530 channel->emu = chip;
531 channel->number = channel_id;
532
533 channel->use = 1;
534
535
536
537
538
539 channel->epcm = epcm;
540 if ((err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
541 return err;
542 if ((err = snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 64)) < 0)
543 return err;
544 snd_pcm_set_sync(substream);
545
546 if (chip->details->spi_dac && channel_id != PCM_FRONT_CHANNEL) {
547 const int reg = spi_dacd_reg[channel_id];
548
549
550 chip->spi_dac_reg[reg] &= ~spi_dacd_bit[channel_id];
551 err = snd_ca0106_spi_write(chip, chip->spi_dac_reg[reg]);
552 if (err < 0)
553 return err;
554 }
555
556 restore_spdif_bits(chip, channel_id);
557
558 return 0;
559}
560
561
562static int snd_ca0106_pcm_close_playback(struct snd_pcm_substream *substream)
563{
564 struct snd_ca0106 *chip = snd_pcm_substream_chip(substream);
565 struct snd_pcm_runtime *runtime = substream->runtime;
566 struct snd_ca0106_pcm *epcm = runtime->private_data;
567 chip->playback_channels[epcm->channel_id].use = 0;
568
569 restore_spdif_bits(chip, epcm->channel_id);
570
571 if (chip->details->spi_dac && epcm->channel_id != PCM_FRONT_CHANNEL) {
572 const int reg = spi_dacd_reg[epcm->channel_id];
573
574
575 chip->spi_dac_reg[reg] |= spi_dacd_bit[epcm->channel_id];
576 snd_ca0106_spi_write(chip, chip->spi_dac_reg[reg]);
577 }
578
579 return 0;
580}
581
582static int snd_ca0106_pcm_open_playback_front(struct snd_pcm_substream *substream)
583{
584 return snd_ca0106_pcm_open_playback_channel(substream, PCM_FRONT_CHANNEL);
585}
586
587static int snd_ca0106_pcm_open_playback_center_lfe(struct snd_pcm_substream *substream)
588{
589 return snd_ca0106_pcm_open_playback_channel(substream, PCM_CENTER_LFE_CHANNEL);
590}
591
592static int snd_ca0106_pcm_open_playback_unknown(struct snd_pcm_substream *substream)
593{
594 return snd_ca0106_pcm_open_playback_channel(substream, PCM_UNKNOWN_CHANNEL);
595}
596
597static int snd_ca0106_pcm_open_playback_rear(struct snd_pcm_substream *substream)
598{
599 return snd_ca0106_pcm_open_playback_channel(substream, PCM_REAR_CHANNEL);
600}
601
602
603static int snd_ca0106_pcm_open_capture_channel(struct snd_pcm_substream *substream,
604 int channel_id)
605{
606 struct snd_ca0106 *chip = snd_pcm_substream_chip(substream);
607 struct snd_ca0106_channel *channel = &(chip->capture_channels[channel_id]);
608 struct snd_ca0106_pcm *epcm;
609 struct snd_pcm_runtime *runtime = substream->runtime;
610 int err;
611
612 epcm = kzalloc(sizeof(*epcm), GFP_KERNEL);
613 if (epcm == NULL) {
614 snd_printk(KERN_ERR "open_capture_channel: failed epcm alloc\n");
615 return -ENOMEM;
616 }
617 epcm->emu = chip;
618 epcm->substream = substream;
619 epcm->channel_id=channel_id;
620
621 runtime->private_data = epcm;
622 runtime->private_free = snd_ca0106_pcm_free_substream;
623
624 runtime->hw = snd_ca0106_capture_hw;
625
626 channel->emu = chip;
627 channel->number = channel_id;
628
629 channel->use = 1;
630
631
632
633
634
635 channel->epcm = epcm;
636 if ((err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
637 return err;
638
639 if ((err = snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 64)) < 0)
640 return err;
641 return 0;
642}
643
644
645static int snd_ca0106_pcm_close_capture(struct snd_pcm_substream *substream)
646{
647 struct snd_ca0106 *chip = snd_pcm_substream_chip(substream);
648 struct snd_pcm_runtime *runtime = substream->runtime;
649 struct snd_ca0106_pcm *epcm = runtime->private_data;
650 chip->capture_channels[epcm->channel_id].use = 0;
651
652 return 0;
653}
654
655static int snd_ca0106_pcm_open_0_capture(struct snd_pcm_substream *substream)
656{
657 return snd_ca0106_pcm_open_capture_channel(substream, 0);
658}
659
660static int snd_ca0106_pcm_open_1_capture(struct snd_pcm_substream *substream)
661{
662 return snd_ca0106_pcm_open_capture_channel(substream, 1);
663}
664
665static int snd_ca0106_pcm_open_2_capture(struct snd_pcm_substream *substream)
666{
667 return snd_ca0106_pcm_open_capture_channel(substream, 2);
668}
669
670static int snd_ca0106_pcm_open_3_capture(struct snd_pcm_substream *substream)
671{
672 return snd_ca0106_pcm_open_capture_channel(substream, 3);
673}
674
675
676static int snd_ca0106_pcm_hw_params_playback(struct snd_pcm_substream *substream,
677 struct snd_pcm_hw_params *hw_params)
678{
679 return snd_pcm_lib_malloc_pages(substream,
680 params_buffer_bytes(hw_params));
681}
682
683
684static int snd_ca0106_pcm_hw_free_playback(struct snd_pcm_substream *substream)
685{
686 return snd_pcm_lib_free_pages(substream);
687}
688
689
690static int snd_ca0106_pcm_hw_params_capture(struct snd_pcm_substream *substream,
691 struct snd_pcm_hw_params *hw_params)
692{
693 return snd_pcm_lib_malloc_pages(substream,
694 params_buffer_bytes(hw_params));
695}
696
697
698static int snd_ca0106_pcm_hw_free_capture(struct snd_pcm_substream *substream)
699{
700 return snd_pcm_lib_free_pages(substream);
701}
702
703
704static int snd_ca0106_pcm_prepare_playback(struct snd_pcm_substream *substream)
705{
706 struct snd_ca0106 *emu = snd_pcm_substream_chip(substream);
707 struct snd_pcm_runtime *runtime = substream->runtime;
708 struct snd_ca0106_pcm *epcm = runtime->private_data;
709 int channel = epcm->channel_id;
710 u32 *table_base = (u32 *)(emu->buffer.area+(8*16*channel));
711 u32 period_size_bytes = frames_to_bytes(runtime, runtime->period_size);
712 u32 hcfg_mask = HCFG_PLAYBACK_S32_LE;
713 u32 hcfg_set = 0x00000000;
714 u32 hcfg;
715 u32 reg40_mask = 0x30000 << (channel<<1);
716 u32 reg40_set = 0;
717 u32 reg40;
718
719 u32 reg71_mask = 0x03030000 ;
720 u32 reg71_set = 0;
721 u32 reg71;
722 int i;
723
724#if 0
725 snd_printk(KERN_DEBUG
726 "prepare:channel_number=%d, rate=%d, format=0x%x, "
727 "channels=%d, buffer_size=%ld, period_size=%ld, "
728 "periods=%u, frames_to_bytes=%d\n",
729 channel, runtime->rate, runtime->format,
730 runtime->channels, runtime->buffer_size,
731 runtime->period_size, runtime->periods,
732 frames_to_bytes(runtime, 1));
733 snd_printk(KERN_DEBUG "dma_addr=%x, dma_area=%p, table_base=%p\n",
734 runtime->dma_addr, runtime->dma_area, table_base);
735 snd_printk(KERN_DEBUG "dma_addr=%x, dma_area=%p, dma_bytes(size)=%x\n",
736 emu->buffer.addr, emu->buffer.area, emu->buffer.bytes);
737#endif
738
739
740
741 switch (runtime->rate) {
742 case 44100:
743 reg40_set = 0x10000 << (channel<<1);
744 reg71_set = 0x01010000;
745 break;
746 case 48000:
747 reg40_set = 0;
748 reg71_set = 0;
749 break;
750 case 96000:
751 reg40_set = 0x20000 << (channel<<1);
752 reg71_set = 0x02020000;
753 break;
754 case 192000:
755 reg40_set = 0x30000 << (channel<<1);
756 reg71_set = 0x03030000;
757 break;
758 default:
759 reg40_set = 0;
760 reg71_set = 0;
761 break;
762 }
763
764
765 switch (runtime->format) {
766 case SNDRV_PCM_FORMAT_S16_LE:
767 hcfg_set = 0;
768 break;
769 case SNDRV_PCM_FORMAT_S32_LE:
770 hcfg_set = HCFG_PLAYBACK_S32_LE;
771 break;
772 default:
773 hcfg_set = 0;
774 break;
775 }
776 hcfg = inl(emu->port + HCFG) ;
777 hcfg = (hcfg & ~hcfg_mask) | hcfg_set;
778 outl(hcfg, emu->port + HCFG);
779 reg40 = snd_ca0106_ptr_read(emu, 0x40, 0);
780 reg40 = (reg40 & ~reg40_mask) | reg40_set;
781 snd_ca0106_ptr_write(emu, 0x40, 0, reg40);
782 reg71 = snd_ca0106_ptr_read(emu, 0x71, 0);
783 reg71 = (reg71 & ~reg71_mask) | reg71_set;
784 snd_ca0106_ptr_write(emu, 0x71, 0, reg71);
785
786
787 for(i=0; i < runtime->periods; i++) {
788 table_base[i*2] = runtime->dma_addr + (i * period_size_bytes);
789 table_base[i*2+1] = period_size_bytes << 16;
790 }
791
792 snd_ca0106_ptr_write(emu, PLAYBACK_LIST_ADDR, channel, emu->buffer.addr+(8*16*channel));
793 snd_ca0106_ptr_write(emu, PLAYBACK_LIST_SIZE, channel, (runtime->periods - 1) << 19);
794 snd_ca0106_ptr_write(emu, PLAYBACK_LIST_PTR, channel, 0);
795 snd_ca0106_ptr_write(emu, PLAYBACK_DMA_ADDR, channel, runtime->dma_addr);
796 snd_ca0106_ptr_write(emu, PLAYBACK_PERIOD_SIZE, channel, frames_to_bytes(runtime, runtime->period_size)<<16);
797
798 snd_ca0106_ptr_write(emu, PLAYBACK_PERIOD_SIZE, channel, 0);
799 snd_ca0106_ptr_write(emu, PLAYBACK_POINTER, channel, 0);
800 snd_ca0106_ptr_write(emu, 0x07, channel, 0x0);
801 snd_ca0106_ptr_write(emu, 0x08, channel, 0);
802 snd_ca0106_ptr_write(emu, PLAYBACK_MUTE, 0x0, 0x0);
803#if 0
804 snd_ca0106_ptr_write(emu, SPCS0, 0,
805 SPCS_CLKACCY_1000PPM | SPCS_SAMPLERATE_48 |
806 SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC |
807 SPCS_GENERATIONSTATUS | 0x00001200 |
808 0x00000000 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT );
809#endif
810
811 return 0;
812}
813
814
815static int snd_ca0106_pcm_prepare_capture(struct snd_pcm_substream *substream)
816{
817 struct snd_ca0106 *emu = snd_pcm_substream_chip(substream);
818 struct snd_pcm_runtime *runtime = substream->runtime;
819 struct snd_ca0106_pcm *epcm = runtime->private_data;
820 int channel = epcm->channel_id;
821 u32 hcfg_mask = HCFG_CAPTURE_S32_LE;
822 u32 hcfg_set = 0x00000000;
823 u32 hcfg;
824 u32 over_sampling=0x2;
825 u32 reg71_mask = 0x0000c000 ;
826 u32 reg71_set = 0;
827 u32 reg71;
828
829#if 0
830 snd_printk(KERN_DEBUG
831 "prepare:channel_number=%d, rate=%d, format=0x%x, "
832 "channels=%d, buffer_size=%ld, period_size=%ld, "
833 "periods=%u, frames_to_bytes=%d\n",
834 channel, runtime->rate, runtime->format,
835 runtime->channels, runtime->buffer_size,
836 runtime->period_size, runtime->periods,
837 frames_to_bytes(runtime, 1));
838 snd_printk(KERN_DEBUG "dma_addr=%x, dma_area=%p, table_base=%p\n",
839 runtime->dma_addr, runtime->dma_area, table_base);
840 snd_printk(KERN_DEBUG "dma_addr=%x, dma_area=%p, dma_bytes(size)=%x\n",
841 emu->buffer.addr, emu->buffer.area, emu->buffer.bytes);
842#endif
843
844 switch (runtime->rate) {
845 case 44100:
846 reg71_set = 0x00004000;
847 break;
848 case 48000:
849 reg71_set = 0;
850 break;
851 case 96000:
852 reg71_set = 0x00008000;
853 over_sampling=0xa;
854 break;
855 case 192000:
856 reg71_set = 0x0000c000;
857 over_sampling=0xa;
858 break;
859 default:
860 reg71_set = 0;
861 break;
862 }
863
864
865 switch (runtime->format) {
866 case SNDRV_PCM_FORMAT_S16_LE:
867 hcfg_set = 0;
868 break;
869 case SNDRV_PCM_FORMAT_S32_LE:
870 hcfg_set = HCFG_CAPTURE_S32_LE;
871 break;
872 default:
873 hcfg_set = 0;
874 break;
875 }
876 hcfg = inl(emu->port + HCFG) ;
877 hcfg = (hcfg & ~hcfg_mask) | hcfg_set;
878 outl(hcfg, emu->port + HCFG);
879 reg71 = snd_ca0106_ptr_read(emu, 0x71, 0);
880 reg71 = (reg71 & ~reg71_mask) | reg71_set;
881 snd_ca0106_ptr_write(emu, 0x71, 0, reg71);
882 if (emu->details->i2c_adc == 1) {
883 snd_ca0106_i2c_write(emu, ADC_MASTER, over_sampling);
884 }
885
886
887
888
889
890
891
892
893
894
895 snd_ca0106_ptr_write(emu, 0x13, channel, 0);
896 snd_ca0106_ptr_write(emu, CAPTURE_DMA_ADDR, channel, runtime->dma_addr);
897 snd_ca0106_ptr_write(emu, CAPTURE_BUFFER_SIZE, channel, frames_to_bytes(runtime, runtime->buffer_size)<<16);
898 snd_ca0106_ptr_write(emu, CAPTURE_POINTER, channel, 0);
899
900 return 0;
901}
902
903
904static int snd_ca0106_pcm_trigger_playback(struct snd_pcm_substream *substream,
905 int cmd)
906{
907 struct snd_ca0106 *emu = snd_pcm_substream_chip(substream);
908 struct snd_pcm_runtime *runtime;
909 struct snd_ca0106_pcm *epcm;
910 int channel;
911 int result = 0;
912 struct snd_pcm_substream *s;
913 u32 basic = 0;
914 u32 extended = 0;
915 u32 bits;
916 int running = 0;
917
918 switch (cmd) {
919 case SNDRV_PCM_TRIGGER_START:
920 case SNDRV_PCM_TRIGGER_RESUME:
921 running = 1;
922 break;
923 case SNDRV_PCM_TRIGGER_STOP:
924 case SNDRV_PCM_TRIGGER_SUSPEND:
925 default:
926 running = 0;
927 break;
928 }
929 snd_pcm_group_for_each_entry(s, substream) {
930 if (snd_pcm_substream_chip(s) != emu ||
931 s->stream != SNDRV_PCM_STREAM_PLAYBACK)
932 continue;
933 runtime = s->runtime;
934 epcm = runtime->private_data;
935 channel = epcm->channel_id;
936
937 epcm->running = running;
938 basic |= (0x1 << channel);
939 extended |= (0x10 << channel);
940 snd_pcm_trigger_done(s, substream);
941 }
942
943
944 switch (cmd) {
945 case SNDRV_PCM_TRIGGER_START:
946 case SNDRV_PCM_TRIGGER_RESUME:
947 bits = snd_ca0106_ptr_read(emu, EXTENDED_INT_MASK, 0);
948 bits |= extended;
949 snd_ca0106_ptr_write(emu, EXTENDED_INT_MASK, 0, bits);
950 bits = snd_ca0106_ptr_read(emu, BASIC_INTERRUPT, 0);
951 bits |= basic;
952 snd_ca0106_ptr_write(emu, BASIC_INTERRUPT, 0, bits);
953 break;
954 case SNDRV_PCM_TRIGGER_STOP:
955 case SNDRV_PCM_TRIGGER_SUSPEND:
956 bits = snd_ca0106_ptr_read(emu, BASIC_INTERRUPT, 0);
957 bits &= ~basic;
958 snd_ca0106_ptr_write(emu, BASIC_INTERRUPT, 0, bits);
959 bits = snd_ca0106_ptr_read(emu, EXTENDED_INT_MASK, 0);
960 bits &= ~extended;
961 snd_ca0106_ptr_write(emu, EXTENDED_INT_MASK, 0, bits);
962 break;
963 default:
964 result = -EINVAL;
965 break;
966 }
967 return result;
968}
969
970
971static int snd_ca0106_pcm_trigger_capture(struct snd_pcm_substream *substream,
972 int cmd)
973{
974 struct snd_ca0106 *emu = snd_pcm_substream_chip(substream);
975 struct snd_pcm_runtime *runtime = substream->runtime;
976 struct snd_ca0106_pcm *epcm = runtime->private_data;
977 int channel = epcm->channel_id;
978 int result = 0;
979
980 switch (cmd) {
981 case SNDRV_PCM_TRIGGER_START:
982 snd_ca0106_ptr_write(emu, EXTENDED_INT_MASK, 0, snd_ca0106_ptr_read(emu, EXTENDED_INT_MASK, 0) | (0x110000<<channel));
983 snd_ca0106_ptr_write(emu, BASIC_INTERRUPT, 0, snd_ca0106_ptr_read(emu, BASIC_INTERRUPT, 0)|(0x100<<channel));
984 epcm->running = 1;
985 break;
986 case SNDRV_PCM_TRIGGER_STOP:
987 snd_ca0106_ptr_write(emu, BASIC_INTERRUPT, 0, snd_ca0106_ptr_read(emu, BASIC_INTERRUPT, 0) & ~(0x100<<channel));
988 snd_ca0106_ptr_write(emu, EXTENDED_INT_MASK, 0, snd_ca0106_ptr_read(emu, EXTENDED_INT_MASK, 0) & ~(0x110000<<channel));
989 epcm->running = 0;
990 break;
991 default:
992 result = -EINVAL;
993 break;
994 }
995 return result;
996}
997
998
999static snd_pcm_uframes_t
1000snd_ca0106_pcm_pointer_playback(struct snd_pcm_substream *substream)
1001{
1002 struct snd_ca0106 *emu = snd_pcm_substream_chip(substream);
1003 struct snd_pcm_runtime *runtime = substream->runtime;
1004 struct snd_ca0106_pcm *epcm = runtime->private_data;
1005 snd_pcm_uframes_t ptr, ptr1, ptr2,ptr3,ptr4 = 0;
1006 int channel = epcm->channel_id;
1007
1008 if (!epcm->running)
1009 return 0;
1010
1011 ptr3 = snd_ca0106_ptr_read(emu, PLAYBACK_LIST_PTR, channel);
1012 ptr1 = snd_ca0106_ptr_read(emu, PLAYBACK_POINTER, channel);
1013 ptr4 = snd_ca0106_ptr_read(emu, PLAYBACK_LIST_PTR, channel);
1014 if (ptr3 != ptr4) ptr1 = snd_ca0106_ptr_read(emu, PLAYBACK_POINTER, channel);
1015 ptr2 = bytes_to_frames(runtime, ptr1);
1016 ptr2+= (ptr4 >> 3) * runtime->period_size;
1017 ptr=ptr2;
1018 if (ptr >= runtime->buffer_size)
1019 ptr -= runtime->buffer_size;
1020
1021
1022
1023
1024
1025
1026
1027 return ptr;
1028}
1029
1030
1031static snd_pcm_uframes_t
1032snd_ca0106_pcm_pointer_capture(struct snd_pcm_substream *substream)
1033{
1034 struct snd_ca0106 *emu = snd_pcm_substream_chip(substream);
1035 struct snd_pcm_runtime *runtime = substream->runtime;
1036 struct snd_ca0106_pcm *epcm = runtime->private_data;
1037 snd_pcm_uframes_t ptr, ptr1, ptr2 = 0;
1038 int channel = channel=epcm->channel_id;
1039
1040 if (!epcm->running)
1041 return 0;
1042
1043 ptr1 = snd_ca0106_ptr_read(emu, CAPTURE_POINTER, channel);
1044 ptr2 = bytes_to_frames(runtime, ptr1);
1045 ptr=ptr2;
1046 if (ptr >= runtime->buffer_size)
1047 ptr -= runtime->buffer_size;
1048
1049
1050
1051
1052
1053
1054
1055 return ptr;
1056}
1057
1058
1059static struct snd_pcm_ops snd_ca0106_playback_front_ops = {
1060 .open = snd_ca0106_pcm_open_playback_front,
1061 .close = snd_ca0106_pcm_close_playback,
1062 .ioctl = snd_pcm_lib_ioctl,
1063 .hw_params = snd_ca0106_pcm_hw_params_playback,
1064 .hw_free = snd_ca0106_pcm_hw_free_playback,
1065 .prepare = snd_ca0106_pcm_prepare_playback,
1066 .trigger = snd_ca0106_pcm_trigger_playback,
1067 .pointer = snd_ca0106_pcm_pointer_playback,
1068};
1069
1070static struct snd_pcm_ops snd_ca0106_capture_0_ops = {
1071 .open = snd_ca0106_pcm_open_0_capture,
1072 .close = snd_ca0106_pcm_close_capture,
1073 .ioctl = snd_pcm_lib_ioctl,
1074 .hw_params = snd_ca0106_pcm_hw_params_capture,
1075 .hw_free = snd_ca0106_pcm_hw_free_capture,
1076 .prepare = snd_ca0106_pcm_prepare_capture,
1077 .trigger = snd_ca0106_pcm_trigger_capture,
1078 .pointer = snd_ca0106_pcm_pointer_capture,
1079};
1080
1081static struct snd_pcm_ops snd_ca0106_capture_1_ops = {
1082 .open = snd_ca0106_pcm_open_1_capture,
1083 .close = snd_ca0106_pcm_close_capture,
1084 .ioctl = snd_pcm_lib_ioctl,
1085 .hw_params = snd_ca0106_pcm_hw_params_capture,
1086 .hw_free = snd_ca0106_pcm_hw_free_capture,
1087 .prepare = snd_ca0106_pcm_prepare_capture,
1088 .trigger = snd_ca0106_pcm_trigger_capture,
1089 .pointer = snd_ca0106_pcm_pointer_capture,
1090};
1091
1092static struct snd_pcm_ops snd_ca0106_capture_2_ops = {
1093 .open = snd_ca0106_pcm_open_2_capture,
1094 .close = snd_ca0106_pcm_close_capture,
1095 .ioctl = snd_pcm_lib_ioctl,
1096 .hw_params = snd_ca0106_pcm_hw_params_capture,
1097 .hw_free = snd_ca0106_pcm_hw_free_capture,
1098 .prepare = snd_ca0106_pcm_prepare_capture,
1099 .trigger = snd_ca0106_pcm_trigger_capture,
1100 .pointer = snd_ca0106_pcm_pointer_capture,
1101};
1102
1103static struct snd_pcm_ops snd_ca0106_capture_3_ops = {
1104 .open = snd_ca0106_pcm_open_3_capture,
1105 .close = snd_ca0106_pcm_close_capture,
1106 .ioctl = snd_pcm_lib_ioctl,
1107 .hw_params = snd_ca0106_pcm_hw_params_capture,
1108 .hw_free = snd_ca0106_pcm_hw_free_capture,
1109 .prepare = snd_ca0106_pcm_prepare_capture,
1110 .trigger = snd_ca0106_pcm_trigger_capture,
1111 .pointer = snd_ca0106_pcm_pointer_capture,
1112};
1113
1114static struct snd_pcm_ops snd_ca0106_playback_center_lfe_ops = {
1115 .open = snd_ca0106_pcm_open_playback_center_lfe,
1116 .close = snd_ca0106_pcm_close_playback,
1117 .ioctl = snd_pcm_lib_ioctl,
1118 .hw_params = snd_ca0106_pcm_hw_params_playback,
1119 .hw_free = snd_ca0106_pcm_hw_free_playback,
1120 .prepare = snd_ca0106_pcm_prepare_playback,
1121 .trigger = snd_ca0106_pcm_trigger_playback,
1122 .pointer = snd_ca0106_pcm_pointer_playback,
1123};
1124
1125static struct snd_pcm_ops snd_ca0106_playback_unknown_ops = {
1126 .open = snd_ca0106_pcm_open_playback_unknown,
1127 .close = snd_ca0106_pcm_close_playback,
1128 .ioctl = snd_pcm_lib_ioctl,
1129 .hw_params = snd_ca0106_pcm_hw_params_playback,
1130 .hw_free = snd_ca0106_pcm_hw_free_playback,
1131 .prepare = snd_ca0106_pcm_prepare_playback,
1132 .trigger = snd_ca0106_pcm_trigger_playback,
1133 .pointer = snd_ca0106_pcm_pointer_playback,
1134};
1135
1136static struct snd_pcm_ops snd_ca0106_playback_rear_ops = {
1137 .open = snd_ca0106_pcm_open_playback_rear,
1138 .close = snd_ca0106_pcm_close_playback,
1139 .ioctl = snd_pcm_lib_ioctl,
1140 .hw_params = snd_ca0106_pcm_hw_params_playback,
1141 .hw_free = snd_ca0106_pcm_hw_free_playback,
1142 .prepare = snd_ca0106_pcm_prepare_playback,
1143 .trigger = snd_ca0106_pcm_trigger_playback,
1144 .pointer = snd_ca0106_pcm_pointer_playback,
1145};
1146
1147
1148static unsigned short snd_ca0106_ac97_read(struct snd_ac97 *ac97,
1149 unsigned short reg)
1150{
1151 struct snd_ca0106 *emu = ac97->private_data;
1152 unsigned long flags;
1153 unsigned short val;
1154
1155 spin_lock_irqsave(&emu->emu_lock, flags);
1156 outb(reg, emu->port + AC97ADDRESS);
1157 val = inw(emu->port + AC97DATA);
1158 spin_unlock_irqrestore(&emu->emu_lock, flags);
1159 return val;
1160}
1161
1162static void snd_ca0106_ac97_write(struct snd_ac97 *ac97,
1163 unsigned short reg, unsigned short val)
1164{
1165 struct snd_ca0106 *emu = ac97->private_data;
1166 unsigned long flags;
1167
1168 spin_lock_irqsave(&emu->emu_lock, flags);
1169 outb(reg, emu->port + AC97ADDRESS);
1170 outw(val, emu->port + AC97DATA);
1171 spin_unlock_irqrestore(&emu->emu_lock, flags);
1172}
1173
1174static int snd_ca0106_ac97(struct snd_ca0106 *chip)
1175{
1176 struct snd_ac97_bus *pbus;
1177 struct snd_ac97_template ac97;
1178 int err;
1179 static struct snd_ac97_bus_ops ops = {
1180 .write = snd_ca0106_ac97_write,
1181 .read = snd_ca0106_ac97_read,
1182 };
1183
1184 if ((err = snd_ac97_bus(chip->card, 0, &ops, NULL, &pbus)) < 0)
1185 return err;
1186 pbus->no_vra = 1;
1187
1188 memset(&ac97, 0, sizeof(ac97));
1189 ac97.private_data = chip;
1190 ac97.scaps = AC97_SCAP_NO_SPDIF;
1191 return snd_ac97_mixer(pbus, &ac97, &chip->ac97);
1192}
1193
1194static void ca0106_stop_chip(struct snd_ca0106 *chip);
1195
1196static int snd_ca0106_free(struct snd_ca0106 *chip)
1197{
1198 if (chip->res_port != NULL) {
1199
1200 ca0106_stop_chip(chip);
1201 }
1202 if (chip->irq >= 0)
1203 free_irq(chip->irq, chip);
1204
1205#if 1
1206 if (chip->buffer.area)
1207 snd_dma_free_pages(&chip->buffer);
1208#endif
1209
1210
1211 release_and_free_resource(chip->res_port);
1212
1213 pci_disable_device(chip->pci);
1214 kfree(chip);
1215 return 0;
1216}
1217
1218static int snd_ca0106_dev_free(struct snd_device *device)
1219{
1220 struct snd_ca0106 *chip = device->device_data;
1221 return snd_ca0106_free(chip);
1222}
1223
1224static irqreturn_t snd_ca0106_interrupt(int irq, void *dev_id)
1225{
1226 unsigned int status;
1227
1228 struct snd_ca0106 *chip = dev_id;
1229 int i;
1230 int mask;
1231 unsigned int stat76;
1232 struct snd_ca0106_channel *pchannel;
1233
1234 status = inl(chip->port + IPR);
1235 if (! status)
1236 return IRQ_NONE;
1237
1238 stat76 = snd_ca0106_ptr_read(chip, EXTENDED_INT, 0);
1239
1240
1241
1242
1243
1244
1245 mask = 0x11;
1246 for(i = 0; i < 4; i++) {
1247 pchannel = &(chip->playback_channels[i]);
1248 if (stat76 & mask) {
1249
1250 if(pchannel->use) {
1251 snd_pcm_period_elapsed(pchannel->epcm->substream);
1252
1253 }
1254 }
1255
1256
1257 mask <<= 1;
1258 }
1259 mask = 0x110000;
1260 for(i = 0; i < 4; i++) {
1261 pchannel = &(chip->capture_channels[i]);
1262 if (stat76 & mask) {
1263
1264 if(pchannel->use) {
1265 snd_pcm_period_elapsed(pchannel->epcm->substream);
1266
1267 }
1268 }
1269
1270
1271 mask <<= 1;
1272 }
1273
1274 snd_ca0106_ptr_write(chip, EXTENDED_INT, 0, stat76);
1275
1276 if (chip->midi.dev_id &&
1277 (status & (chip->midi.ipr_tx|chip->midi.ipr_rx))) {
1278 if (chip->midi.interrupt)
1279 chip->midi.interrupt(&chip->midi, status);
1280 else
1281 chip->midi.interrupt_disable(&chip->midi, chip->midi.tx_enable | chip->midi.rx_enable);
1282 }
1283
1284
1285 outl(status, chip->port+IPR);
1286
1287 return IRQ_HANDLED;
1288}
1289
1290static int __devinit snd_ca0106_pcm(struct snd_ca0106 *emu, int device)
1291{
1292 struct snd_pcm *pcm;
1293 struct snd_pcm_substream *substream;
1294 int err;
1295
1296 err = snd_pcm_new(emu->card, "ca0106", device, 1, 1, &pcm);
1297 if (err < 0)
1298 return err;
1299
1300 pcm->private_data = emu;
1301
1302 switch (device) {
1303 case 0:
1304 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_ca0106_playback_front_ops);
1305 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_ca0106_capture_0_ops);
1306 break;
1307 case 1:
1308 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_ca0106_playback_rear_ops);
1309 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_ca0106_capture_1_ops);
1310 break;
1311 case 2:
1312 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_ca0106_playback_center_lfe_ops);
1313 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_ca0106_capture_2_ops);
1314 break;
1315 case 3:
1316 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_ca0106_playback_unknown_ops);
1317 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_ca0106_capture_3_ops);
1318 break;
1319 }
1320
1321 pcm->info_flags = 0;
1322 strcpy(pcm->name, "CA0106");
1323
1324 for(substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream;
1325 substream;
1326 substream = substream->next) {
1327 if ((err = snd_pcm_lib_preallocate_pages(substream,
1328 SNDRV_DMA_TYPE_DEV,
1329 snd_dma_pci_data(emu->pci),
1330 64*1024, 64*1024)) < 0)
1331 return err;
1332 }
1333
1334 for (substream = pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream;
1335 substream;
1336 substream = substream->next) {
1337 if ((err = snd_pcm_lib_preallocate_pages(substream,
1338 SNDRV_DMA_TYPE_DEV,
1339 snd_dma_pci_data(emu->pci),
1340 64*1024, 64*1024)) < 0)
1341 return err;
1342 }
1343
1344 emu->pcm[device] = pcm;
1345
1346 return 0;
1347}
1348
1349#define SPI_REG(reg, value) (((reg) << SPI_REG_SHIFT) | (value))
1350static unsigned int spi_dac_init[] = {
1351 SPI_REG(SPI_LDA1_REG, SPI_DA_BIT_0dB),
1352 SPI_REG(SPI_RDA1_REG, SPI_DA_BIT_0dB),
1353 SPI_REG(SPI_PL_REG, SPI_PL_BIT_L_L | SPI_PL_BIT_R_R | SPI_IZD_BIT),
1354 SPI_REG(SPI_FMT_REG, SPI_FMT_BIT_I2S | SPI_IWL_BIT_24),
1355 SPI_REG(SPI_LDA2_REG, SPI_DA_BIT_0dB),
1356 SPI_REG(SPI_RDA2_REG, SPI_DA_BIT_0dB),
1357 SPI_REG(SPI_LDA3_REG, SPI_DA_BIT_0dB),
1358 SPI_REG(SPI_RDA3_REG, SPI_DA_BIT_0dB),
1359 SPI_REG(SPI_MASTDA_REG, SPI_DA_BIT_0dB),
1360 SPI_REG(9, 0x00),
1361 SPI_REG(SPI_MS_REG, SPI_DACD0_BIT | SPI_DACD1_BIT | SPI_DACD2_BIT),
1362 SPI_REG(12, 0x00),
1363 SPI_REG(SPI_LDA4_REG, SPI_DA_BIT_0dB),
1364 SPI_REG(SPI_RDA4_REG, SPI_DA_BIT_0dB | SPI_DA_BIT_UPDATE),
1365 SPI_REG(SPI_DACD4_REG, 0x00),
1366};
1367
1368static unsigned int i2c_adc_init[][2] = {
1369 { 0x17, 0x00 },
1370 { 0x07, 0x00 },
1371 { 0x0b, 0x22 },
1372 { 0x0c, 0x22 },
1373 { 0x0d, 0x08 },
1374 { 0x0e, 0xcf },
1375 { 0x0f, 0xcf },
1376 { 0x10, 0x7b },
1377 { 0x11, 0x00 },
1378 { 0x12, 0x32 },
1379 { 0x13, 0x00 },
1380 { 0x14, 0xa6 },
1381 { 0x15, ADC_MUX_LINEIN },
1382};
1383
1384static void ca0106_init_chip(struct snd_ca0106 *chip, int resume)
1385{
1386 int ch;
1387 unsigned int def_bits;
1388
1389 outl(0, chip->port + INTE);
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405 def_bits =
1406 SPCS_CLKACCY_1000PPM | SPCS_SAMPLERATE_48 |
1407 SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC |
1408 SPCS_GENERATIONSTATUS | 0x00001200 |
1409 0x00000000 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT;
1410 if (!resume) {
1411 chip->spdif_str_bits[0] = chip->spdif_bits[0] = def_bits;
1412 chip->spdif_str_bits[1] = chip->spdif_bits[1] = def_bits;
1413 chip->spdif_str_bits[2] = chip->spdif_bits[2] = def_bits;
1414 chip->spdif_str_bits[3] = chip->spdif_bits[3] = def_bits;
1415 }
1416
1417 snd_ca0106_ptr_write(chip, SPCS1, 0, chip->spdif_str_bits[1]);
1418 snd_ca0106_ptr_write(chip, SPCS0, 0, chip->spdif_str_bits[0]);
1419 snd_ca0106_ptr_write(chip, SPCS2, 0, chip->spdif_str_bits[2]);
1420 snd_ca0106_ptr_write(chip, SPCS3, 0, chip->spdif_str_bits[3]);
1421
1422 snd_ca0106_ptr_write(chip, PLAYBACK_MUTE, 0, 0x00fc0000);
1423 snd_ca0106_ptr_write(chip, CAPTURE_MUTE, 0, 0x00fc0000);
1424
1425
1426 outb(AC97_REC_GAIN, chip->port + AC97ADDRESS);
1427 outw(0x8000, chip->port + AC97DATA);
1428#if 0
1429 snd_ca0106_ptr_write(chip, SPCS0, 0, 0x2108006);
1430 snd_ca0106_ptr_write(chip, 0x42, 0, 0x2108006);
1431 snd_ca0106_ptr_write(chip, 0x43, 0, 0x2108006);
1432 snd_ca0106_ptr_write(chip, 0x44, 0, 0x2108006);
1433#endif
1434
1435
1436
1437
1438
1439 snd_ca0106_ptr_write(chip, SPDIF_SELECT1, 0, 0xf);
1440
1441
1442
1443 snd_ca0106_ptr_write(chip, SPDIF_SELECT2, 0, 0x000f0000);
1444
1445 chip->spdif_enable = 0;
1446
1447
1448
1449
1450 snd_ca0106_ptr_write(chip, CAPTURE_CONTROL, 0, 0x40c81000);
1451
1452
1453
1454 snd_ca0106_ptr_write(chip, CAPTURE_CONTROL, 1, 0xffffffff);
1455
1456 snd_ca0106_ptr_write(chip, CAPTURE_CONTROL, 2, 0x30300000);
1457
1458 snd_ca0106_ptr_write(chip, CAPTURE_CONTROL, 3, 0x00700000);
1459
1460 snd_ca0106_ptr_write(chip, PLAYBACK_ROUTING1, 0, 0x32765410);
1461 snd_ca0106_ptr_write(chip, PLAYBACK_ROUTING2, 0, 0x76767676);
1462 snd_ca0106_ptr_write(chip, CAPTURE_ROUTING1, 0, 0x32765410);
1463 snd_ca0106_ptr_write(chip, CAPTURE_ROUTING2, 0, 0x76767676);
1464
1465 for (ch = 0; ch < 4; ch++) {
1466
1467 snd_ca0106_ptr_write(chip, CAPTURE_VOLUME1, ch, 0x30303030);
1468 snd_ca0106_ptr_write(chip, CAPTURE_VOLUME2, ch, 0x30303030);
1469#if 0
1470 snd_ca0106_ptr_write(chip, PLAYBACK_VOLUME1, ch, 0x40404040);
1471 snd_ca0106_ptr_write(chip, PLAYBACK_VOLUME2, ch, 0x40404040);
1472 snd_ca0106_ptr_write(chip, PLAYBACK_VOLUME1, ch, 0xffffffff);
1473 snd_ca0106_ptr_write(chip, PLAYBACK_VOLUME2, ch, 0xffffffff);
1474#endif
1475 }
1476 if (chip->details->i2c_adc == 1) {
1477
1478 snd_ca0106_ptr_write(chip, CAPTURE_SOURCE, 0x0, 0x333300e4);
1479
1480 if (!resume)
1481 chip->capture_source = 3;
1482 } else if (chip->details->ac97 == 1) {
1483
1484 snd_ca0106_ptr_write(chip, CAPTURE_SOURCE, 0x0, 0x444400e4);
1485
1486 if (!resume)
1487 chip->capture_source = 4;
1488 } else {
1489
1490 snd_ca0106_ptr_write(chip, CAPTURE_SOURCE, 0x0, 0x333300e4);
1491
1492 if (!resume)
1493 chip->capture_source = 3;
1494 }
1495
1496 if (chip->details->gpio_type == 2) {
1497
1498
1499
1500
1501 outl(0x0, chip->port+GPIO);
1502
1503 outl(0x005f5301, chip->port+GPIO);
1504 } else if (chip->details->gpio_type == 1) {
1505
1506
1507
1508
1509 outl(0x0, chip->port+GPIO);
1510
1511 outl(0x005f5301, chip->port+GPIO);
1512 } else {
1513 outl(0x0, chip->port+GPIO);
1514 outl(0x005f03a3, chip->port+GPIO);
1515
1516 }
1517 snd_ca0106_intr_enable(chip, 0x105);
1518
1519
1520
1521
1522
1523
1524 outl(HCFG_AC97 | HCFG_AUDIOENABLE, chip->port+HCFG);
1525
1526 if (chip->details->i2c_adc == 1) {
1527
1528 int size, n;
1529
1530 size = ARRAY_SIZE(i2c_adc_init);
1531
1532 for (n = 0; n < size; n++)
1533 snd_ca0106_i2c_write(chip, i2c_adc_init[n][0],
1534 i2c_adc_init[n][1]);
1535 for (n = 0; n < 4; n++) {
1536 chip->i2c_capture_volume[n][0] = 0xcf;
1537 chip->i2c_capture_volume[n][1] = 0xcf;
1538 }
1539 chip->i2c_capture_source = 2;
1540
1541
1542 }
1543
1544 if (chip->details->spi_dac == 1) {
1545
1546 int size, n;
1547
1548 size = ARRAY_SIZE(spi_dac_init);
1549 for (n = 0; n < size; n++) {
1550 int reg = spi_dac_init[n] >> SPI_REG_SHIFT;
1551
1552 snd_ca0106_spi_write(chip, spi_dac_init[n]);
1553 if (reg < ARRAY_SIZE(chip->spi_dac_reg))
1554 chip->spi_dac_reg[reg] = spi_dac_init[n];
1555 }
1556 }
1557}
1558
1559static void ca0106_stop_chip(struct snd_ca0106 *chip)
1560{
1561
1562 snd_ca0106_ptr_write(chip, BASIC_INTERRUPT, 0, 0);
1563 outl(0, chip->port + INTE);
1564 snd_ca0106_ptr_write(chip, EXTENDED_INT_MASK, 0, 0);
1565 udelay(1000);
1566
1567
1568 outl(0, chip->port + HCFG);
1569
1570
1571
1572
1573}
1574
1575static int __devinit snd_ca0106_create(int dev, struct snd_card *card,
1576 struct pci_dev *pci,
1577 struct snd_ca0106 **rchip)
1578{
1579 struct snd_ca0106 *chip;
1580 struct snd_ca0106_details *c;
1581 int err;
1582 static struct snd_device_ops ops = {
1583 .dev_free = snd_ca0106_dev_free,
1584 };
1585
1586 *rchip = NULL;
1587
1588 err = pci_enable_device(pci);
1589 if (err < 0)
1590 return err;
1591 if (pci_set_dma_mask(pci, DMA_BIT_MASK(32)) < 0 ||
1592 pci_set_consistent_dma_mask(pci, DMA_BIT_MASK(32)) < 0) {
1593 printk(KERN_ERR "error to set 32bit mask DMA\n");
1594 pci_disable_device(pci);
1595 return -ENXIO;
1596 }
1597
1598 chip = kzalloc(sizeof(*chip), GFP_KERNEL);
1599 if (chip == NULL) {
1600 pci_disable_device(pci);
1601 return -ENOMEM;
1602 }
1603
1604 chip->card = card;
1605 chip->pci = pci;
1606 chip->irq = -1;
1607
1608 spin_lock_init(&chip->emu_lock);
1609
1610 chip->port = pci_resource_start(pci, 0);
1611 chip->res_port = request_region(chip->port, 0x20, "snd_ca0106");
1612 if (!chip->res_port) {
1613 snd_ca0106_free(chip);
1614 printk(KERN_ERR "cannot allocate the port\n");
1615 return -EBUSY;
1616 }
1617
1618 if (request_irq(pci->irq, snd_ca0106_interrupt,
1619 IRQF_SHARED, "snd_ca0106", chip)) {
1620 snd_ca0106_free(chip);
1621 printk(KERN_ERR "cannot grab irq\n");
1622 return -EBUSY;
1623 }
1624 chip->irq = pci->irq;
1625
1626
1627 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci),
1628 1024, &chip->buffer) < 0) {
1629 snd_ca0106_free(chip);
1630 return -ENOMEM;
1631 }
1632
1633 pci_set_master(pci);
1634
1635 pci_read_config_dword(pci, PCI_SUBSYSTEM_VENDOR_ID, &chip->serial);
1636 pci_read_config_word(pci, PCI_SUBSYSTEM_ID, &chip->model);
1637 printk(KERN_INFO "snd-ca0106: Model %04x Rev %08x Serial %08x\n",
1638 chip->model, pci->revision, chip->serial);
1639 strcpy(card->driver, "CA0106");
1640 strcpy(card->shortname, "CA0106");
1641
1642 for (c = ca0106_chip_details; c->serial; c++) {
1643 if (subsystem[dev]) {
1644 if (c->serial == subsystem[dev])
1645 break;
1646 } else if (c->serial == chip->serial)
1647 break;
1648 }
1649 chip->details = c;
1650 if (subsystem[dev]) {
1651 printk(KERN_INFO "snd-ca0106: Sound card name=%s, "
1652 "subsystem=0x%x. Forced to subsystem=0x%x\n",
1653 c->name, chip->serial, subsystem[dev]);
1654 }
1655
1656 sprintf(card->longname, "%s at 0x%lx irq %i",
1657 c->name, chip->port, chip->irq);
1658
1659 ca0106_init_chip(chip, 0);
1660
1661 err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
1662 if (err < 0) {
1663 snd_ca0106_free(chip);
1664 return err;
1665 }
1666 *rchip = chip;
1667 return 0;
1668}
1669
1670
1671static void ca0106_midi_interrupt_enable(struct snd_ca_midi *midi, int intr)
1672{
1673 snd_ca0106_intr_enable((struct snd_ca0106 *)(midi->dev_id), intr);
1674}
1675
1676static void ca0106_midi_interrupt_disable(struct snd_ca_midi *midi, int intr)
1677{
1678 snd_ca0106_intr_disable((struct snd_ca0106 *)(midi->dev_id), intr);
1679}
1680
1681static unsigned char ca0106_midi_read(struct snd_ca_midi *midi, int idx)
1682{
1683 return (unsigned char)snd_ca0106_ptr_read((struct snd_ca0106 *)(midi->dev_id),
1684 midi->port + idx, 0);
1685}
1686
1687static void ca0106_midi_write(struct snd_ca_midi *midi, int data, int idx)
1688{
1689 snd_ca0106_ptr_write((struct snd_ca0106 *)(midi->dev_id), midi->port + idx, 0, data);
1690}
1691
1692static struct snd_card *ca0106_dev_id_card(void *dev_id)
1693{
1694 return ((struct snd_ca0106 *)dev_id)->card;
1695}
1696
1697static int ca0106_dev_id_port(void *dev_id)
1698{
1699 return ((struct snd_ca0106 *)dev_id)->port;
1700}
1701
1702static int __devinit snd_ca0106_midi(struct snd_ca0106 *chip, unsigned int channel)
1703{
1704 struct snd_ca_midi *midi;
1705 char *name;
1706 int err;
1707
1708 if (channel == CA0106_MIDI_CHAN_B) {
1709 name = "CA0106 MPU-401 (UART) B";
1710 midi = &chip->midi2;
1711 midi->tx_enable = INTE_MIDI_TX_B;
1712 midi->rx_enable = INTE_MIDI_RX_B;
1713 midi->ipr_tx = IPR_MIDI_TX_B;
1714 midi->ipr_rx = IPR_MIDI_RX_B;
1715 midi->port = MIDI_UART_B_DATA;
1716 } else {
1717 name = "CA0106 MPU-401 (UART)";
1718 midi = &chip->midi;
1719 midi->tx_enable = INTE_MIDI_TX_A;
1720 midi->rx_enable = INTE_MIDI_TX_B;
1721 midi->ipr_tx = IPR_MIDI_TX_A;
1722 midi->ipr_rx = IPR_MIDI_RX_A;
1723 midi->port = MIDI_UART_A_DATA;
1724 }
1725
1726 midi->reset = CA0106_MPU401_RESET;
1727 midi->enter_uart = CA0106_MPU401_ENTER_UART;
1728 midi->ack = CA0106_MPU401_ACK;
1729
1730 midi->input_avail = CA0106_MIDI_INPUT_AVAIL;
1731 midi->output_ready = CA0106_MIDI_OUTPUT_READY;
1732
1733 midi->channel = channel;
1734
1735 midi->interrupt_enable = ca0106_midi_interrupt_enable;
1736 midi->interrupt_disable = ca0106_midi_interrupt_disable;
1737
1738 midi->read = ca0106_midi_read;
1739 midi->write = ca0106_midi_write;
1740
1741 midi->get_dev_id_card = ca0106_dev_id_card;
1742 midi->get_dev_id_port = ca0106_dev_id_port;
1743
1744 midi->dev_id = chip;
1745
1746 if ((err = ca_midi_init(chip, midi, 0, name)) < 0)
1747 return err;
1748
1749 return 0;
1750}
1751
1752
1753static int __devinit snd_ca0106_probe(struct pci_dev *pci,
1754 const struct pci_device_id *pci_id)
1755{
1756 static int dev;
1757 struct snd_card *card;
1758 struct snd_ca0106 *chip;
1759 int i, err;
1760
1761 if (dev >= SNDRV_CARDS)
1762 return -ENODEV;
1763 if (!enable[dev]) {
1764 dev++;
1765 return -ENOENT;
1766 }
1767
1768 err = snd_card_create(index[dev], id[dev], THIS_MODULE, 0, &card);
1769 if (err < 0)
1770 return err;
1771
1772 err = snd_ca0106_create(dev, card, pci, &chip);
1773 if (err < 0)
1774 goto error;
1775 card->private_data = chip;
1776
1777 for (i = 0; i < 4; i++) {
1778 err = snd_ca0106_pcm(chip, i);
1779 if (err < 0)
1780 goto error;
1781 }
1782
1783 if (chip->details->ac97 == 1) {
1784
1785 err = snd_ca0106_ac97(chip);
1786 if (err < 0)
1787 goto error;
1788 }
1789 err = snd_ca0106_mixer(chip);
1790 if (err < 0)
1791 goto error;
1792
1793 snd_printdd("ca0106: probe for MIDI channel A ...");
1794 err = snd_ca0106_midi(chip, CA0106_MIDI_CHAN_A);
1795 if (err < 0)
1796 goto error;
1797 snd_printdd(" done.\n");
1798
1799#ifdef CONFIG_PROC_FS
1800 snd_ca0106_proc_init(chip);
1801#endif
1802
1803 snd_card_set_dev(card, &pci->dev);
1804
1805 err = snd_card_register(card);
1806 if (err < 0)
1807 goto error;
1808
1809 pci_set_drvdata(pci, card);
1810 dev++;
1811 return 0;
1812
1813 error:
1814 snd_card_free(card);
1815 return err;
1816}
1817
1818static void __devexit snd_ca0106_remove(struct pci_dev *pci)
1819{
1820 snd_card_free(pci_get_drvdata(pci));
1821 pci_set_drvdata(pci, NULL);
1822}
1823
1824#ifdef CONFIG_PM
1825static int snd_ca0106_suspend(struct pci_dev *pci, pm_message_t state)
1826{
1827 struct snd_card *card = pci_get_drvdata(pci);
1828 struct snd_ca0106 *chip = card->private_data;
1829 int i;
1830
1831 snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
1832 for (i = 0; i < 4; i++)
1833 snd_pcm_suspend_all(chip->pcm[i]);
1834 if (chip->details->ac97)
1835 snd_ac97_suspend(chip->ac97);
1836 snd_ca0106_mixer_suspend(chip);
1837
1838 ca0106_stop_chip(chip);
1839
1840 pci_disable_device(pci);
1841 pci_save_state(pci);
1842 pci_set_power_state(pci, pci_choose_state(pci, state));
1843 return 0;
1844}
1845
1846static int snd_ca0106_resume(struct pci_dev *pci)
1847{
1848 struct snd_card *card = pci_get_drvdata(pci);
1849 struct snd_ca0106 *chip = card->private_data;
1850 int i;
1851
1852 pci_set_power_state(pci, PCI_D0);
1853 pci_restore_state(pci);
1854
1855 if (pci_enable_device(pci) < 0) {
1856 snd_card_disconnect(card);
1857 return -EIO;
1858 }
1859
1860 pci_set_master(pci);
1861
1862 ca0106_init_chip(chip, 1);
1863
1864 if (chip->details->ac97)
1865 snd_ac97_resume(chip->ac97);
1866 snd_ca0106_mixer_resume(chip);
1867 if (chip->details->spi_dac) {
1868 for (i = 0; i < ARRAY_SIZE(chip->spi_dac_reg); i++)
1869 snd_ca0106_spi_write(chip, chip->spi_dac_reg[i]);
1870 }
1871
1872 snd_power_change_state(card, SNDRV_CTL_POWER_D0);
1873 return 0;
1874}
1875#endif
1876
1877
1878static struct pci_device_id snd_ca0106_ids[] = {
1879 { PCI_VDEVICE(CREATIVE, 0x0007), 0 },
1880 { 0, }
1881};
1882MODULE_DEVICE_TABLE(pci, snd_ca0106_ids);
1883
1884
1885static struct pci_driver driver = {
1886 .name = "CA0106",
1887 .id_table = snd_ca0106_ids,
1888 .probe = snd_ca0106_probe,
1889 .remove = __devexit_p(snd_ca0106_remove),
1890#ifdef CONFIG_PM
1891 .suspend = snd_ca0106_suspend,
1892 .resume = snd_ca0106_resume,
1893#endif
1894};
1895
1896
1897static int __init alsa_card_ca0106_init(void)
1898{
1899 return pci_register_driver(&driver);
1900}
1901
1902
1903static void __exit alsa_card_ca0106_exit(void)
1904{
1905 pci_unregister_driver(&driver);
1906}
1907
1908module_init(alsa_card_ca0106_init)
1909module_exit(alsa_card_ca0106_exit)
1910
