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