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 const 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 const 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 dev_err(emu->card->dev, "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 dev_err(emu->card->dev, "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 *chip,
520 struct snd_ca0106_details *details,
521 int channel_id)
522{
523 switch (channel_id) {
524 case PCM_FRONT_CHANNEL:
525 return (details->spi_dac & 0xf000) >> (4 * 3);
526 case PCM_REAR_CHANNEL:
527 return (details->spi_dac & 0x0f00) >> (4 * 2);
528 case PCM_CENTER_LFE_CHANNEL:
529 return (details->spi_dac & 0x00f0) >> (4 * 1);
530 case PCM_UNKNOWN_CHANNEL:
531 return (details->spi_dac & 0x000f) >> (4 * 0);
532 default:
533 dev_dbg(chip->card->dev, "ca0106: unknown channel_id %d\n",
534 channel_id);
535 }
536 return 0;
537}
538
539static int snd_ca0106_pcm_power_dac(struct snd_ca0106 *chip, int channel_id,
540 int power)
541{
542 if (chip->details->spi_dac) {
543 const int dac = snd_ca0106_channel_dac(chip, chip->details,
544 channel_id);
545 const int reg = spi_dacd_reg[dac];
546 const int bit = spi_dacd_bit[dac];
547
548 if (power)
549
550 chip->spi_dac_reg[reg] &= ~bit;
551 else
552
553 chip->spi_dac_reg[reg] |= bit;
554 return snd_ca0106_spi_write(chip, chip->spi_dac_reg[reg]);
555 }
556 return 0;
557}
558
559
560static int snd_ca0106_pcm_open_playback_channel(struct snd_pcm_substream *substream,
561 int channel_id)
562{
563 struct snd_ca0106 *chip = snd_pcm_substream_chip(substream);
564 struct snd_ca0106_channel *channel = &(chip->playback_channels[channel_id]);
565 struct snd_ca0106_pcm *epcm;
566 struct snd_pcm_runtime *runtime = substream->runtime;
567 int err;
568
569 epcm = kzalloc(sizeof(*epcm), GFP_KERNEL);
570
571 if (epcm == NULL)
572 return -ENOMEM;
573 epcm->emu = chip;
574 epcm->substream = substream;
575 epcm->channel_id=channel_id;
576
577 runtime->private_data = epcm;
578 runtime->private_free = snd_ca0106_pcm_free_substream;
579
580 runtime->hw = snd_ca0106_playback_hw;
581
582 channel->emu = chip;
583 channel->number = channel_id;
584
585 channel->use = 1;
586
587
588
589
590
591 channel->epcm = epcm;
592 if ((err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
593 return err;
594 if ((err = snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 64)) < 0)
595 return err;
596 snd_pcm_set_sync(substream);
597
598
599 if (channel_id != PCM_FRONT_CHANNEL) {
600 err = snd_ca0106_pcm_power_dac(chip, channel_id, 1);
601 if (err < 0)
602 return err;
603 }
604
605 restore_spdif_bits(chip, channel_id);
606
607 return 0;
608}
609
610
611static int snd_ca0106_pcm_close_playback(struct snd_pcm_substream *substream)
612{
613 struct snd_ca0106 *chip = snd_pcm_substream_chip(substream);
614 struct snd_pcm_runtime *runtime = substream->runtime;
615 struct snd_ca0106_pcm *epcm = runtime->private_data;
616 chip->playback_channels[epcm->channel_id].use = 0;
617
618 restore_spdif_bits(chip, epcm->channel_id);
619
620
621 if (epcm->channel_id != PCM_FRONT_CHANNEL) {
622 int err;
623 err = snd_ca0106_pcm_power_dac(chip, epcm->channel_id, 0);
624 if (err < 0)
625 return err;
626 }
627
628
629 return 0;
630}
631
632static int snd_ca0106_pcm_open_playback_front(struct snd_pcm_substream *substream)
633{
634 return snd_ca0106_pcm_open_playback_channel(substream, PCM_FRONT_CHANNEL);
635}
636
637static int snd_ca0106_pcm_open_playback_center_lfe(struct snd_pcm_substream *substream)
638{
639 return snd_ca0106_pcm_open_playback_channel(substream, PCM_CENTER_LFE_CHANNEL);
640}
641
642static int snd_ca0106_pcm_open_playback_unknown(struct snd_pcm_substream *substream)
643{
644 return snd_ca0106_pcm_open_playback_channel(substream, PCM_UNKNOWN_CHANNEL);
645}
646
647static int snd_ca0106_pcm_open_playback_rear(struct snd_pcm_substream *substream)
648{
649 return snd_ca0106_pcm_open_playback_channel(substream, PCM_REAR_CHANNEL);
650}
651
652
653static int snd_ca0106_pcm_open_capture_channel(struct snd_pcm_substream *substream,
654 int channel_id)
655{
656 struct snd_ca0106 *chip = snd_pcm_substream_chip(substream);
657 struct snd_ca0106_channel *channel = &(chip->capture_channels[channel_id]);
658 struct snd_ca0106_pcm *epcm;
659 struct snd_pcm_runtime *runtime = substream->runtime;
660 int err;
661
662 epcm = kzalloc(sizeof(*epcm), GFP_KERNEL);
663 if (!epcm)
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 dev_dbg(emu->card->dev,
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 dev_dbg(emu->card->dev,
783 "dma_addr=%x, dma_area=%p, table_base=%p\n",
784 runtime->dma_addr, runtime->dma_area, table_base);
785 dev_dbg(emu->card->dev,
786 "dma_addr=%x, dma_area=%p, dma_bytes(size)=%x\n",
787 emu->buffer.addr, emu->buffer.area, emu->buffer.bytes);
788#endif
789
790
791
792 switch (runtime->rate) {
793 case 44100:
794 reg40_set = 0x10000 << (channel<<1);
795 reg71_set = 0x01010000;
796 break;
797 case 48000:
798 reg40_set = 0;
799 reg71_set = 0;
800 break;
801 case 96000:
802 reg40_set = 0x20000 << (channel<<1);
803 reg71_set = 0x02020000;
804 break;
805 case 192000:
806 reg40_set = 0x30000 << (channel<<1);
807 reg71_set = 0x03030000;
808 break;
809 default:
810 reg40_set = 0;
811 reg71_set = 0;
812 break;
813 }
814
815
816 switch (runtime->format) {
817 case SNDRV_PCM_FORMAT_S16_LE:
818 hcfg_set = 0;
819 break;
820 case SNDRV_PCM_FORMAT_S32_LE:
821 hcfg_set = HCFG_PLAYBACK_S32_LE;
822 break;
823 default:
824 hcfg_set = 0;
825 break;
826 }
827 hcfg = inl(emu->port + HCFG) ;
828 hcfg = (hcfg & ~hcfg_mask) | hcfg_set;
829 outl(hcfg, emu->port + HCFG);
830 reg40 = snd_ca0106_ptr_read(emu, 0x40, 0);
831 reg40 = (reg40 & ~reg40_mask) | reg40_set;
832 snd_ca0106_ptr_write(emu, 0x40, 0, reg40);
833 reg71 = snd_ca0106_ptr_read(emu, 0x71, 0);
834 reg71 = (reg71 & ~reg71_mask) | reg71_set;
835 snd_ca0106_ptr_write(emu, 0x71, 0, reg71);
836
837
838 for(i=0; i < runtime->periods; i++) {
839 table_base[i*2] = runtime->dma_addr + (i * period_size_bytes);
840 table_base[i*2+1] = period_size_bytes << 16;
841 }
842
843 snd_ca0106_ptr_write(emu, PLAYBACK_LIST_ADDR, channel, emu->buffer.addr+(8*16*channel));
844 snd_ca0106_ptr_write(emu, PLAYBACK_LIST_SIZE, channel, (runtime->periods - 1) << 19);
845 snd_ca0106_ptr_write(emu, PLAYBACK_LIST_PTR, channel, 0);
846 snd_ca0106_ptr_write(emu, PLAYBACK_DMA_ADDR, channel, runtime->dma_addr);
847 snd_ca0106_ptr_write(emu, PLAYBACK_PERIOD_SIZE, channel, frames_to_bytes(runtime, runtime->period_size)<<16);
848
849 snd_ca0106_ptr_write(emu, PLAYBACK_PERIOD_SIZE, channel, 0);
850 snd_ca0106_ptr_write(emu, PLAYBACK_POINTER, channel, 0);
851 snd_ca0106_ptr_write(emu, 0x07, channel, 0x0);
852 snd_ca0106_ptr_write(emu, 0x08, channel, 0);
853 snd_ca0106_ptr_write(emu, PLAYBACK_MUTE, 0x0, 0x0);
854#if 0
855 snd_ca0106_ptr_write(emu, SPCS0, 0,
856 SPCS_CLKACCY_1000PPM | SPCS_SAMPLERATE_48 |
857 SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC |
858 SPCS_GENERATIONSTATUS | 0x00001200 |
859 0x00000000 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT );
860#endif
861
862 return 0;
863}
864
865
866static int snd_ca0106_pcm_prepare_capture(struct snd_pcm_substream *substream)
867{
868 struct snd_ca0106 *emu = snd_pcm_substream_chip(substream);
869 struct snd_pcm_runtime *runtime = substream->runtime;
870 struct snd_ca0106_pcm *epcm = runtime->private_data;
871 int channel = epcm->channel_id;
872 u32 hcfg_mask = HCFG_CAPTURE_S32_LE;
873 u32 hcfg_set = 0x00000000;
874 u32 hcfg;
875 u32 over_sampling=0x2;
876 u32 reg71_mask = 0x0000c000 ;
877 u32 reg71_set = 0;
878 u32 reg71;
879
880#if 0
881 dev_dbg(emu->card->dev,
882 "prepare:channel_number=%d, rate=%d, format=0x%x, "
883 "channels=%d, buffer_size=%ld, period_size=%ld, "
884 "periods=%u, frames_to_bytes=%d\n",
885 channel, runtime->rate, runtime->format,
886 runtime->channels, runtime->buffer_size,
887 runtime->period_size, runtime->periods,
888 frames_to_bytes(runtime, 1));
889 dev_dbg(emu->card->dev,
890 "dma_addr=%x, dma_area=%p, table_base=%p\n",
891 runtime->dma_addr, runtime->dma_area, table_base);
892 dev_dbg(emu->card->dev,
893 "dma_addr=%x, dma_area=%p, dma_bytes(size)=%x\n",
894 emu->buffer.addr, emu->buffer.area, emu->buffer.bytes);
895#endif
896
897 switch (runtime->rate) {
898 case 44100:
899 reg71_set = 0x00004000;
900 break;
901 case 48000:
902 reg71_set = 0;
903 break;
904 case 96000:
905 reg71_set = 0x00008000;
906 over_sampling=0xa;
907 break;
908 case 192000:
909 reg71_set = 0x0000c000;
910 over_sampling=0xa;
911 break;
912 default:
913 reg71_set = 0;
914 break;
915 }
916
917
918 switch (runtime->format) {
919 case SNDRV_PCM_FORMAT_S16_LE:
920 hcfg_set = 0;
921 break;
922 case SNDRV_PCM_FORMAT_S32_LE:
923 hcfg_set = HCFG_CAPTURE_S32_LE;
924 break;
925 default:
926 hcfg_set = 0;
927 break;
928 }
929 hcfg = inl(emu->port + HCFG) ;
930 hcfg = (hcfg & ~hcfg_mask) | hcfg_set;
931 outl(hcfg, emu->port + HCFG);
932 reg71 = snd_ca0106_ptr_read(emu, 0x71, 0);
933 reg71 = (reg71 & ~reg71_mask) | reg71_set;
934 snd_ca0106_ptr_write(emu, 0x71, 0, reg71);
935 if (emu->details->i2c_adc == 1) {
936 snd_ca0106_i2c_write(emu, ADC_MASTER, over_sampling);
937 }
938
939
940
941
942
943
944
945
946
947
948 snd_ca0106_ptr_write(emu, 0x13, channel, 0);
949 snd_ca0106_ptr_write(emu, CAPTURE_DMA_ADDR, channel, runtime->dma_addr);
950 snd_ca0106_ptr_write(emu, CAPTURE_BUFFER_SIZE, channel, frames_to_bytes(runtime, runtime->buffer_size)<<16);
951 snd_ca0106_ptr_write(emu, CAPTURE_POINTER, channel, 0);
952
953 return 0;
954}
955
956
957static int snd_ca0106_pcm_trigger_playback(struct snd_pcm_substream *substream,
958 int cmd)
959{
960 struct snd_ca0106 *emu = snd_pcm_substream_chip(substream);
961 struct snd_pcm_runtime *runtime;
962 struct snd_ca0106_pcm *epcm;
963 int channel;
964 int result = 0;
965 struct snd_pcm_substream *s;
966 u32 basic = 0;
967 u32 extended = 0;
968 u32 bits;
969 int running = 0;
970
971 switch (cmd) {
972 case SNDRV_PCM_TRIGGER_START:
973 case SNDRV_PCM_TRIGGER_RESUME:
974 running = 1;
975 break;
976 case SNDRV_PCM_TRIGGER_STOP:
977 case SNDRV_PCM_TRIGGER_SUSPEND:
978 default:
979 running = 0;
980 break;
981 }
982 snd_pcm_group_for_each_entry(s, substream) {
983 if (snd_pcm_substream_chip(s) != emu ||
984 s->stream != SNDRV_PCM_STREAM_PLAYBACK)
985 continue;
986 runtime = s->runtime;
987 epcm = runtime->private_data;
988 channel = epcm->channel_id;
989
990 epcm->running = running;
991 basic |= (0x1 << channel);
992 extended |= (0x10 << channel);
993 snd_pcm_trigger_done(s, substream);
994 }
995
996
997 switch (cmd) {
998 case SNDRV_PCM_TRIGGER_START:
999 case SNDRV_PCM_TRIGGER_RESUME:
1000 bits = snd_ca0106_ptr_read(emu, EXTENDED_INT_MASK, 0);
1001 bits |= extended;
1002 snd_ca0106_ptr_write(emu, EXTENDED_INT_MASK, 0, bits);
1003 bits = snd_ca0106_ptr_read(emu, BASIC_INTERRUPT, 0);
1004 bits |= basic;
1005 snd_ca0106_ptr_write(emu, BASIC_INTERRUPT, 0, bits);
1006 break;
1007 case SNDRV_PCM_TRIGGER_STOP:
1008 case SNDRV_PCM_TRIGGER_SUSPEND:
1009 bits = snd_ca0106_ptr_read(emu, BASIC_INTERRUPT, 0);
1010 bits &= ~basic;
1011 snd_ca0106_ptr_write(emu, BASIC_INTERRUPT, 0, bits);
1012 bits = snd_ca0106_ptr_read(emu, EXTENDED_INT_MASK, 0);
1013 bits &= ~extended;
1014 snd_ca0106_ptr_write(emu, EXTENDED_INT_MASK, 0, bits);
1015 break;
1016 default:
1017 result = -EINVAL;
1018 break;
1019 }
1020 return result;
1021}
1022
1023
1024static int snd_ca0106_pcm_trigger_capture(struct snd_pcm_substream *substream,
1025 int cmd)
1026{
1027 struct snd_ca0106 *emu = snd_pcm_substream_chip(substream);
1028 struct snd_pcm_runtime *runtime = substream->runtime;
1029 struct snd_ca0106_pcm *epcm = runtime->private_data;
1030 int channel = epcm->channel_id;
1031 int result = 0;
1032
1033 switch (cmd) {
1034 case SNDRV_PCM_TRIGGER_START:
1035 snd_ca0106_ptr_write(emu, EXTENDED_INT_MASK, 0, snd_ca0106_ptr_read(emu, EXTENDED_INT_MASK, 0) | (0x110000<<channel));
1036 snd_ca0106_ptr_write(emu, BASIC_INTERRUPT, 0, snd_ca0106_ptr_read(emu, BASIC_INTERRUPT, 0)|(0x100<<channel));
1037 epcm->running = 1;
1038 break;
1039 case SNDRV_PCM_TRIGGER_STOP:
1040 snd_ca0106_ptr_write(emu, BASIC_INTERRUPT, 0, snd_ca0106_ptr_read(emu, BASIC_INTERRUPT, 0) & ~(0x100<<channel));
1041 snd_ca0106_ptr_write(emu, EXTENDED_INT_MASK, 0, snd_ca0106_ptr_read(emu, EXTENDED_INT_MASK, 0) & ~(0x110000<<channel));
1042 epcm->running = 0;
1043 break;
1044 default:
1045 result = -EINVAL;
1046 break;
1047 }
1048 return result;
1049}
1050
1051
1052static snd_pcm_uframes_t
1053snd_ca0106_pcm_pointer_playback(struct snd_pcm_substream *substream)
1054{
1055 struct snd_ca0106 *emu = snd_pcm_substream_chip(substream);
1056 struct snd_pcm_runtime *runtime = substream->runtime;
1057 struct snd_ca0106_pcm *epcm = runtime->private_data;
1058 unsigned int ptr, prev_ptr;
1059 int channel = epcm->channel_id;
1060 int timeout = 10;
1061
1062 if (!epcm->running)
1063 return 0;
1064
1065 prev_ptr = -1;
1066 do {
1067 ptr = snd_ca0106_ptr_read(emu, PLAYBACK_LIST_PTR, channel);
1068 ptr = (ptr >> 3) * runtime->period_size;
1069 ptr += bytes_to_frames(runtime,
1070 snd_ca0106_ptr_read(emu, PLAYBACK_POINTER, channel));
1071 if (ptr >= runtime->buffer_size)
1072 ptr -= runtime->buffer_size;
1073 if (prev_ptr == ptr)
1074 return ptr;
1075 prev_ptr = ptr;
1076 } while (--timeout);
1077 dev_warn(emu->card->dev, "ca0106: unstable DMA pointer!\n");
1078 return 0;
1079}
1080
1081
1082static snd_pcm_uframes_t
1083snd_ca0106_pcm_pointer_capture(struct snd_pcm_substream *substream)
1084{
1085 struct snd_ca0106 *emu = snd_pcm_substream_chip(substream);
1086 struct snd_pcm_runtime *runtime = substream->runtime;
1087 struct snd_ca0106_pcm *epcm = runtime->private_data;
1088 snd_pcm_uframes_t ptr, ptr1, ptr2 = 0;
1089 int channel = epcm->channel_id;
1090
1091 if (!epcm->running)
1092 return 0;
1093
1094 ptr1 = snd_ca0106_ptr_read(emu, CAPTURE_POINTER, channel);
1095 ptr2 = bytes_to_frames(runtime, ptr1);
1096 ptr=ptr2;
1097 if (ptr >= runtime->buffer_size)
1098 ptr -= runtime->buffer_size;
1099
1100
1101
1102
1103
1104
1105
1106 return ptr;
1107}
1108
1109
1110static const struct snd_pcm_ops snd_ca0106_playback_front_ops = {
1111 .open = snd_ca0106_pcm_open_playback_front,
1112 .close = snd_ca0106_pcm_close_playback,
1113 .ioctl = snd_pcm_lib_ioctl,
1114 .hw_params = snd_ca0106_pcm_hw_params_playback,
1115 .hw_free = snd_ca0106_pcm_hw_free_playback,
1116 .prepare = snd_ca0106_pcm_prepare_playback,
1117 .trigger = snd_ca0106_pcm_trigger_playback,
1118 .pointer = snd_ca0106_pcm_pointer_playback,
1119};
1120
1121static const struct snd_pcm_ops snd_ca0106_capture_0_ops = {
1122 .open = snd_ca0106_pcm_open_0_capture,
1123 .close = snd_ca0106_pcm_close_capture,
1124 .ioctl = snd_pcm_lib_ioctl,
1125 .hw_params = snd_ca0106_pcm_hw_params_capture,
1126 .hw_free = snd_ca0106_pcm_hw_free_capture,
1127 .prepare = snd_ca0106_pcm_prepare_capture,
1128 .trigger = snd_ca0106_pcm_trigger_capture,
1129 .pointer = snd_ca0106_pcm_pointer_capture,
1130};
1131
1132static const struct snd_pcm_ops snd_ca0106_capture_1_ops = {
1133 .open = snd_ca0106_pcm_open_1_capture,
1134 .close = snd_ca0106_pcm_close_capture,
1135 .ioctl = snd_pcm_lib_ioctl,
1136 .hw_params = snd_ca0106_pcm_hw_params_capture,
1137 .hw_free = snd_ca0106_pcm_hw_free_capture,
1138 .prepare = snd_ca0106_pcm_prepare_capture,
1139 .trigger = snd_ca0106_pcm_trigger_capture,
1140 .pointer = snd_ca0106_pcm_pointer_capture,
1141};
1142
1143static const struct snd_pcm_ops snd_ca0106_capture_2_ops = {
1144 .open = snd_ca0106_pcm_open_2_capture,
1145 .close = snd_ca0106_pcm_close_capture,
1146 .ioctl = snd_pcm_lib_ioctl,
1147 .hw_params = snd_ca0106_pcm_hw_params_capture,
1148 .hw_free = snd_ca0106_pcm_hw_free_capture,
1149 .prepare = snd_ca0106_pcm_prepare_capture,
1150 .trigger = snd_ca0106_pcm_trigger_capture,
1151 .pointer = snd_ca0106_pcm_pointer_capture,
1152};
1153
1154static const struct snd_pcm_ops snd_ca0106_capture_3_ops = {
1155 .open = snd_ca0106_pcm_open_3_capture,
1156 .close = snd_ca0106_pcm_close_capture,
1157 .ioctl = snd_pcm_lib_ioctl,
1158 .hw_params = snd_ca0106_pcm_hw_params_capture,
1159 .hw_free = snd_ca0106_pcm_hw_free_capture,
1160 .prepare = snd_ca0106_pcm_prepare_capture,
1161 .trigger = snd_ca0106_pcm_trigger_capture,
1162 .pointer = snd_ca0106_pcm_pointer_capture,
1163};
1164
1165static const struct snd_pcm_ops snd_ca0106_playback_center_lfe_ops = {
1166 .open = snd_ca0106_pcm_open_playback_center_lfe,
1167 .close = snd_ca0106_pcm_close_playback,
1168 .ioctl = snd_pcm_lib_ioctl,
1169 .hw_params = snd_ca0106_pcm_hw_params_playback,
1170 .hw_free = snd_ca0106_pcm_hw_free_playback,
1171 .prepare = snd_ca0106_pcm_prepare_playback,
1172 .trigger = snd_ca0106_pcm_trigger_playback,
1173 .pointer = snd_ca0106_pcm_pointer_playback,
1174};
1175
1176static const struct snd_pcm_ops snd_ca0106_playback_unknown_ops = {
1177 .open = snd_ca0106_pcm_open_playback_unknown,
1178 .close = snd_ca0106_pcm_close_playback,
1179 .ioctl = snd_pcm_lib_ioctl,
1180 .hw_params = snd_ca0106_pcm_hw_params_playback,
1181 .hw_free = snd_ca0106_pcm_hw_free_playback,
1182 .prepare = snd_ca0106_pcm_prepare_playback,
1183 .trigger = snd_ca0106_pcm_trigger_playback,
1184 .pointer = snd_ca0106_pcm_pointer_playback,
1185};
1186
1187static const struct snd_pcm_ops snd_ca0106_playback_rear_ops = {
1188 .open = snd_ca0106_pcm_open_playback_rear,
1189 .close = snd_ca0106_pcm_close_playback,
1190 .ioctl = snd_pcm_lib_ioctl,
1191 .hw_params = snd_ca0106_pcm_hw_params_playback,
1192 .hw_free = snd_ca0106_pcm_hw_free_playback,
1193 .prepare = snd_ca0106_pcm_prepare_playback,
1194 .trigger = snd_ca0106_pcm_trigger_playback,
1195 .pointer = snd_ca0106_pcm_pointer_playback,
1196};
1197
1198
1199static unsigned short snd_ca0106_ac97_read(struct snd_ac97 *ac97,
1200 unsigned short reg)
1201{
1202 struct snd_ca0106 *emu = ac97->private_data;
1203 unsigned long flags;
1204 unsigned short val;
1205
1206 spin_lock_irqsave(&emu->emu_lock, flags);
1207 outb(reg, emu->port + AC97ADDRESS);
1208 val = inw(emu->port + AC97DATA);
1209 spin_unlock_irqrestore(&emu->emu_lock, flags);
1210 return val;
1211}
1212
1213static void snd_ca0106_ac97_write(struct snd_ac97 *ac97,
1214 unsigned short reg, unsigned short val)
1215{
1216 struct snd_ca0106 *emu = ac97->private_data;
1217 unsigned long flags;
1218
1219 spin_lock_irqsave(&emu->emu_lock, flags);
1220 outb(reg, emu->port + AC97ADDRESS);
1221 outw(val, emu->port + AC97DATA);
1222 spin_unlock_irqrestore(&emu->emu_lock, flags);
1223}
1224
1225static int snd_ca0106_ac97(struct snd_ca0106 *chip)
1226{
1227 struct snd_ac97_bus *pbus;
1228 struct snd_ac97_template ac97;
1229 int err;
1230 static struct snd_ac97_bus_ops ops = {
1231 .write = snd_ca0106_ac97_write,
1232 .read = snd_ca0106_ac97_read,
1233 };
1234
1235 if ((err = snd_ac97_bus(chip->card, 0, &ops, NULL, &pbus)) < 0)
1236 return err;
1237 pbus->no_vra = 1;
1238
1239 memset(&ac97, 0, sizeof(ac97));
1240 ac97.private_data = chip;
1241 ac97.scaps = AC97_SCAP_NO_SPDIF;
1242 return snd_ac97_mixer(pbus, &ac97, &chip->ac97);
1243}
1244
1245static void ca0106_stop_chip(struct snd_ca0106 *chip);
1246
1247static int snd_ca0106_free(struct snd_ca0106 *chip)
1248{
1249 if (chip->res_port != NULL) {
1250
1251 ca0106_stop_chip(chip);
1252 }
1253 if (chip->irq >= 0)
1254 free_irq(chip->irq, chip);
1255
1256#if 1
1257 if (chip->buffer.area)
1258 snd_dma_free_pages(&chip->buffer);
1259#endif
1260
1261
1262 release_and_free_resource(chip->res_port);
1263
1264 pci_disable_device(chip->pci);
1265 kfree(chip);
1266 return 0;
1267}
1268
1269static int snd_ca0106_dev_free(struct snd_device *device)
1270{
1271 struct snd_ca0106 *chip = device->device_data;
1272 return snd_ca0106_free(chip);
1273}
1274
1275static irqreturn_t snd_ca0106_interrupt(int irq, void *dev_id)
1276{
1277 unsigned int status;
1278
1279 struct snd_ca0106 *chip = dev_id;
1280 int i;
1281 int mask;
1282 unsigned int stat76;
1283 struct snd_ca0106_channel *pchannel;
1284
1285 status = inl(chip->port + IPR);
1286 if (! status)
1287 return IRQ_NONE;
1288
1289 stat76 = snd_ca0106_ptr_read(chip, EXTENDED_INT, 0);
1290
1291
1292
1293
1294
1295
1296 mask = 0x11;
1297 for(i = 0; i < 4; i++) {
1298 pchannel = &(chip->playback_channels[i]);
1299 if (stat76 & mask) {
1300
1301 if(pchannel->use) {
1302 snd_pcm_period_elapsed(pchannel->epcm->substream);
1303
1304 }
1305 }
1306
1307
1308
1309
1310 mask <<= 1;
1311 }
1312 mask = 0x110000;
1313 for(i = 0; i < 4; i++) {
1314 pchannel = &(chip->capture_channels[i]);
1315 if (stat76 & mask) {
1316
1317 if(pchannel->use) {
1318 snd_pcm_period_elapsed(pchannel->epcm->substream);
1319
1320 }
1321 }
1322
1323
1324
1325
1326 mask <<= 1;
1327 }
1328
1329 snd_ca0106_ptr_write(chip, EXTENDED_INT, 0, stat76);
1330
1331 if (chip->midi.dev_id &&
1332 (status & (chip->midi.ipr_tx|chip->midi.ipr_rx))) {
1333 if (chip->midi.interrupt)
1334 chip->midi.interrupt(&chip->midi, status);
1335 else
1336 chip->midi.interrupt_disable(&chip->midi, chip->midi.tx_enable | chip->midi.rx_enable);
1337 }
1338
1339
1340 outl(status, chip->port+IPR);
1341
1342 return IRQ_HANDLED;
1343}
1344
1345static const struct snd_pcm_chmap_elem surround_map[] = {
1346 { .channels = 2,
1347 .map = { SNDRV_CHMAP_RL, SNDRV_CHMAP_RR } },
1348 { }
1349};
1350
1351static const struct snd_pcm_chmap_elem clfe_map[] = {
1352 { .channels = 2,
1353 .map = { SNDRV_CHMAP_FC, SNDRV_CHMAP_LFE } },
1354 { }
1355};
1356
1357static const struct snd_pcm_chmap_elem side_map[] = {
1358 { .channels = 2,
1359 .map = { SNDRV_CHMAP_SL, SNDRV_CHMAP_SR } },
1360 { }
1361};
1362
1363static int snd_ca0106_pcm(struct snd_ca0106 *emu, int device)
1364{
1365 struct snd_pcm *pcm;
1366 struct snd_pcm_substream *substream;
1367 const struct snd_pcm_chmap_elem *map = NULL;
1368 int err;
1369
1370 err = snd_pcm_new(emu->card, "ca0106", device, 1, 1, &pcm);
1371 if (err < 0)
1372 return err;
1373
1374 pcm->private_data = emu;
1375
1376 switch (device) {
1377 case 0:
1378 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_ca0106_playback_front_ops);
1379 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_ca0106_capture_0_ops);
1380 map = snd_pcm_std_chmaps;
1381 break;
1382 case 1:
1383 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_ca0106_playback_rear_ops);
1384 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_ca0106_capture_1_ops);
1385 map = surround_map;
1386 break;
1387 case 2:
1388 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_ca0106_playback_center_lfe_ops);
1389 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_ca0106_capture_2_ops);
1390 map = clfe_map;
1391 break;
1392 case 3:
1393 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_ca0106_playback_unknown_ops);
1394 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_ca0106_capture_3_ops);
1395 map = side_map;
1396 break;
1397 }
1398
1399 pcm->info_flags = 0;
1400 strcpy(pcm->name, "CA0106");
1401
1402 for(substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream;
1403 substream;
1404 substream = substream->next) {
1405 if ((err = snd_pcm_lib_preallocate_pages(substream,
1406 SNDRV_DMA_TYPE_DEV,
1407 snd_dma_pci_data(emu->pci),
1408 64*1024, 64*1024)) < 0)
1409 return err;
1410 }
1411
1412 for (substream = pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream;
1413 substream;
1414 substream = substream->next) {
1415 if ((err = snd_pcm_lib_preallocate_pages(substream,
1416 SNDRV_DMA_TYPE_DEV,
1417 snd_dma_pci_data(emu->pci),
1418 64*1024, 64*1024)) < 0)
1419 return err;
1420 }
1421
1422 err = snd_pcm_add_chmap_ctls(pcm, SNDRV_PCM_STREAM_PLAYBACK, map, 2,
1423 1 << 2, NULL);
1424 if (err < 0)
1425 return err;
1426
1427 emu->pcm[device] = pcm;
1428
1429 return 0;
1430}
1431
1432#define SPI_REG(reg, value) (((reg) << SPI_REG_SHIFT) | (value))
1433static unsigned int spi_dac_init[] = {
1434 SPI_REG(SPI_LDA1_REG, SPI_DA_BIT_0dB),
1435 SPI_REG(SPI_RDA1_REG, SPI_DA_BIT_0dB),
1436 SPI_REG(SPI_PL_REG, SPI_PL_BIT_L_L | SPI_PL_BIT_R_R | SPI_IZD_BIT),
1437 SPI_REG(SPI_FMT_REG, SPI_FMT_BIT_I2S | SPI_IWL_BIT_24),
1438 SPI_REG(SPI_LDA2_REG, SPI_DA_BIT_0dB),
1439 SPI_REG(SPI_RDA2_REG, SPI_DA_BIT_0dB),
1440 SPI_REG(SPI_LDA3_REG, SPI_DA_BIT_0dB),
1441 SPI_REG(SPI_RDA3_REG, SPI_DA_BIT_0dB),
1442 SPI_REG(SPI_MASTDA_REG, SPI_DA_BIT_0dB),
1443 SPI_REG(9, 0x00),
1444 SPI_REG(SPI_MS_REG, SPI_DACD0_BIT | SPI_DACD1_BIT | SPI_DACD2_BIT),
1445 SPI_REG(12, 0x00),
1446 SPI_REG(SPI_LDA4_REG, SPI_DA_BIT_0dB),
1447 SPI_REG(SPI_RDA4_REG, SPI_DA_BIT_0dB | SPI_DA_BIT_UPDATE),
1448 SPI_REG(SPI_DACD4_REG, SPI_DACD4_BIT),
1449};
1450
1451static unsigned int i2c_adc_init[][2] = {
1452 { 0x17, 0x00 },
1453 { 0x07, 0x00 },
1454 { 0x0b, 0x22 },
1455 { 0x0c, 0x22 },
1456 { 0x0d, 0x08 },
1457 { 0x0e, 0xcf },
1458 { 0x0f, 0xcf },
1459 { 0x10, 0x7b },
1460 { 0x11, 0x00 },
1461 { 0x12, 0x32 },
1462 { 0x13, 0x00 },
1463 { 0x14, 0xa6 },
1464 { 0x15, ADC_MUX_LINEIN },
1465};
1466
1467static void ca0106_init_chip(struct snd_ca0106 *chip, int resume)
1468{
1469 int ch;
1470 unsigned int def_bits;
1471
1472 outl(0, chip->port + INTE);
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488 def_bits =
1489 SPCS_CLKACCY_1000PPM | SPCS_SAMPLERATE_48 |
1490 SPCS_CHANNELNUM_LEFT | SPCS_SOURCENUM_UNSPEC |
1491 SPCS_GENERATIONSTATUS | 0x00001200 |
1492 0x00000000 | SPCS_EMPHASIS_NONE | SPCS_COPYRIGHT;
1493 if (!resume) {
1494 chip->spdif_str_bits[0] = chip->spdif_bits[0] = def_bits;
1495 chip->spdif_str_bits[1] = chip->spdif_bits[1] = def_bits;
1496 chip->spdif_str_bits[2] = chip->spdif_bits[2] = def_bits;
1497 chip->spdif_str_bits[3] = chip->spdif_bits[3] = def_bits;
1498 }
1499
1500 snd_ca0106_ptr_write(chip, SPCS1, 0, chip->spdif_str_bits[1]);
1501 snd_ca0106_ptr_write(chip, SPCS0, 0, chip->spdif_str_bits[0]);
1502 snd_ca0106_ptr_write(chip, SPCS2, 0, chip->spdif_str_bits[2]);
1503 snd_ca0106_ptr_write(chip, SPCS3, 0, chip->spdif_str_bits[3]);
1504
1505 snd_ca0106_ptr_write(chip, PLAYBACK_MUTE, 0, 0x00fc0000);
1506 snd_ca0106_ptr_write(chip, CAPTURE_MUTE, 0, 0x00fc0000);
1507
1508
1509 outb(AC97_REC_GAIN, chip->port + AC97ADDRESS);
1510 outw(0x8000, chip->port + AC97DATA);
1511#if 0
1512 snd_ca0106_ptr_write(chip, SPCS0, 0, 0x2108006);
1513 snd_ca0106_ptr_write(chip, 0x42, 0, 0x2108006);
1514 snd_ca0106_ptr_write(chip, 0x43, 0, 0x2108006);
1515 snd_ca0106_ptr_write(chip, 0x44, 0, 0x2108006);
1516#endif
1517
1518
1519
1520
1521
1522 snd_ca0106_ptr_write(chip, SPDIF_SELECT1, 0, 0xf);
1523
1524
1525
1526 snd_ca0106_ptr_write(chip, SPDIF_SELECT2, 0, 0x000f0000);
1527
1528 chip->spdif_enable = 0;
1529
1530
1531
1532
1533 snd_ca0106_ptr_write(chip, CAPTURE_CONTROL, 0, 0x40c81000);
1534
1535
1536
1537 snd_ca0106_ptr_write(chip, CAPTURE_CONTROL, 1, 0xffffffff);
1538
1539 snd_ca0106_ptr_write(chip, CAPTURE_CONTROL, 2, 0x30300000);
1540
1541 snd_ca0106_ptr_write(chip, CAPTURE_CONTROL, 3, 0x00700000);
1542
1543 snd_ca0106_ptr_write(chip, PLAYBACK_ROUTING1, 0, 0x32765410);
1544 snd_ca0106_ptr_write(chip, PLAYBACK_ROUTING2, 0, 0x76767676);
1545 snd_ca0106_ptr_write(chip, CAPTURE_ROUTING1, 0, 0x32765410);
1546 snd_ca0106_ptr_write(chip, CAPTURE_ROUTING2, 0, 0x76767676);
1547
1548 for (ch = 0; ch < 4; ch++) {
1549
1550 snd_ca0106_ptr_write(chip, CAPTURE_VOLUME1, ch, 0x30303030);
1551 snd_ca0106_ptr_write(chip, CAPTURE_VOLUME2, ch, 0x30303030);
1552#if 0
1553 snd_ca0106_ptr_write(chip, PLAYBACK_VOLUME1, ch, 0x40404040);
1554 snd_ca0106_ptr_write(chip, PLAYBACK_VOLUME2, ch, 0x40404040);
1555 snd_ca0106_ptr_write(chip, PLAYBACK_VOLUME1, ch, 0xffffffff);
1556 snd_ca0106_ptr_write(chip, PLAYBACK_VOLUME2, ch, 0xffffffff);
1557#endif
1558 }
1559 if (chip->details->i2c_adc == 1) {
1560
1561 snd_ca0106_ptr_write(chip, CAPTURE_SOURCE, 0x0, 0x333300e4);
1562
1563 if (!resume)
1564 chip->capture_source = 3;
1565 } else if (chip->details->ac97 == 1) {
1566
1567 snd_ca0106_ptr_write(chip, CAPTURE_SOURCE, 0x0, 0x444400e4);
1568
1569 if (!resume)
1570 chip->capture_source = 4;
1571 } else {
1572
1573 snd_ca0106_ptr_write(chip, CAPTURE_SOURCE, 0x0, 0x333300e4);
1574
1575 if (!resume)
1576 chip->capture_source = 3;
1577 }
1578
1579 if (chip->details->gpio_type == 2) {
1580
1581
1582
1583
1584 outl(0x0, chip->port+GPIO);
1585
1586 outl(0x005f5301, chip->port+GPIO);
1587 } else if (chip->details->gpio_type == 1) {
1588
1589
1590
1591
1592 outl(0x0, chip->port+GPIO);
1593
1594 outl(0x005f5301, chip->port+GPIO);
1595 } else {
1596 outl(0x0, chip->port+GPIO);
1597 outl(0x005f03a3, chip->port+GPIO);
1598
1599 }
1600 snd_ca0106_intr_enable(chip, 0x105);
1601
1602
1603
1604
1605
1606
1607 outl(HCFG_AC97 | HCFG_AUDIOENABLE, chip->port+HCFG);
1608
1609 if (chip->details->i2c_adc == 1) {
1610
1611 int size, n;
1612
1613 size = ARRAY_SIZE(i2c_adc_init);
1614
1615 for (n = 0; n < size; n++)
1616 snd_ca0106_i2c_write(chip, i2c_adc_init[n][0],
1617 i2c_adc_init[n][1]);
1618 for (n = 0; n < 4; n++) {
1619 chip->i2c_capture_volume[n][0] = 0xcf;
1620 chip->i2c_capture_volume[n][1] = 0xcf;
1621 }
1622 chip->i2c_capture_source = 2;
1623
1624
1625 }
1626
1627 if (chip->details->spi_dac) {
1628
1629 int size, n;
1630
1631 size = ARRAY_SIZE(spi_dac_init);
1632 for (n = 0; n < size; n++) {
1633 int reg = spi_dac_init[n] >> SPI_REG_SHIFT;
1634
1635 snd_ca0106_spi_write(chip, spi_dac_init[n]);
1636 if (reg < ARRAY_SIZE(chip->spi_dac_reg))
1637 chip->spi_dac_reg[reg] = spi_dac_init[n];
1638 }
1639
1640
1641 snd_ca0106_pcm_power_dac(chip, PCM_FRONT_CHANNEL, 1);
1642 }
1643}
1644
1645static void ca0106_stop_chip(struct snd_ca0106 *chip)
1646{
1647
1648 snd_ca0106_ptr_write(chip, BASIC_INTERRUPT, 0, 0);
1649 outl(0, chip->port + INTE);
1650 snd_ca0106_ptr_write(chip, EXTENDED_INT_MASK, 0, 0);
1651 udelay(1000);
1652
1653
1654 outl(0, chip->port + HCFG);
1655
1656
1657
1658
1659}
1660
1661static int snd_ca0106_create(int dev, struct snd_card *card,
1662 struct pci_dev *pci,
1663 struct snd_ca0106 **rchip)
1664{
1665 struct snd_ca0106 *chip;
1666 struct snd_ca0106_details *c;
1667 int err;
1668 static struct snd_device_ops ops = {
1669 .dev_free = snd_ca0106_dev_free,
1670 };
1671
1672 *rchip = NULL;
1673
1674 err = pci_enable_device(pci);
1675 if (err < 0)
1676 return err;
1677 if (dma_set_mask(&pci->dev, DMA_BIT_MASK(32)) < 0 ||
1678 dma_set_coherent_mask(&pci->dev, DMA_BIT_MASK(32)) < 0) {
1679 dev_err(card->dev, "error to set 32bit mask DMA\n");
1680 pci_disable_device(pci);
1681 return -ENXIO;
1682 }
1683
1684 chip = kzalloc(sizeof(*chip), GFP_KERNEL);
1685 if (chip == NULL) {
1686 pci_disable_device(pci);
1687 return -ENOMEM;
1688 }
1689
1690 chip->card = card;
1691 chip->pci = pci;
1692 chip->irq = -1;
1693
1694 spin_lock_init(&chip->emu_lock);
1695
1696 chip->port = pci_resource_start(pci, 0);
1697 chip->res_port = request_region(chip->port, 0x20, "snd_ca0106");
1698 if (!chip->res_port) {
1699 snd_ca0106_free(chip);
1700 dev_err(card->dev, "cannot allocate the port\n");
1701 return -EBUSY;
1702 }
1703
1704 if (request_irq(pci->irq, snd_ca0106_interrupt,
1705 IRQF_SHARED, KBUILD_MODNAME, chip)) {
1706 snd_ca0106_free(chip);
1707 dev_err(card->dev, "cannot grab irq\n");
1708 return -EBUSY;
1709 }
1710 chip->irq = pci->irq;
1711
1712
1713 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(pci),
1714 1024, &chip->buffer) < 0) {
1715 snd_ca0106_free(chip);
1716 return -ENOMEM;
1717 }
1718
1719 pci_set_master(pci);
1720
1721 pci_read_config_dword(pci, PCI_SUBSYSTEM_VENDOR_ID, &chip->serial);
1722 pci_read_config_word(pci, PCI_SUBSYSTEM_ID, &chip->model);
1723 dev_info(card->dev, "Model %04x Rev %08x Serial %08x\n",
1724 chip->model, pci->revision, chip->serial);
1725 strcpy(card->driver, "CA0106");
1726 strcpy(card->shortname, "CA0106");
1727
1728 for (c = ca0106_chip_details; c->serial; c++) {
1729 if (subsystem[dev]) {
1730 if (c->serial == subsystem[dev])
1731 break;
1732 } else if (c->serial == chip->serial)
1733 break;
1734 }
1735 chip->details = c;
1736 if (subsystem[dev]) {
1737 dev_info(card->dev, "Sound card name=%s, "
1738 "subsystem=0x%x. Forced to subsystem=0x%x\n",
1739 c->name, chip->serial, subsystem[dev]);
1740 }
1741
1742 sprintf(card->longname, "%s at 0x%lx irq %i",
1743 c->name, chip->port, chip->irq);
1744
1745 ca0106_init_chip(chip, 0);
1746
1747 err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops);
1748 if (err < 0) {
1749 snd_ca0106_free(chip);
1750 return err;
1751 }
1752 *rchip = chip;
1753 return 0;
1754}
1755
1756
1757static void ca0106_midi_interrupt_enable(struct snd_ca_midi *midi, int intr)
1758{
1759 snd_ca0106_intr_enable((struct snd_ca0106 *)(midi->dev_id), intr);
1760}
1761
1762static void ca0106_midi_interrupt_disable(struct snd_ca_midi *midi, int intr)
1763{
1764 snd_ca0106_intr_disable((struct snd_ca0106 *)(midi->dev_id), intr);
1765}
1766
1767static unsigned char ca0106_midi_read(struct snd_ca_midi *midi, int idx)
1768{
1769 return (unsigned char)snd_ca0106_ptr_read((struct snd_ca0106 *)(midi->dev_id),
1770 midi->port + idx, 0);
1771}
1772
1773static void ca0106_midi_write(struct snd_ca_midi *midi, int data, int idx)
1774{
1775 snd_ca0106_ptr_write((struct snd_ca0106 *)(midi->dev_id), midi->port + idx, 0, data);
1776}
1777
1778static struct snd_card *ca0106_dev_id_card(void *dev_id)
1779{
1780 return ((struct snd_ca0106 *)dev_id)->card;
1781}
1782
1783static int ca0106_dev_id_port(void *dev_id)
1784{
1785 return ((struct snd_ca0106 *)dev_id)->port;
1786}
1787
1788static int snd_ca0106_midi(struct snd_ca0106 *chip, unsigned int channel)
1789{
1790 struct snd_ca_midi *midi;
1791 char *name;
1792 int err;
1793
1794 if (channel == CA0106_MIDI_CHAN_B) {
1795 name = "CA0106 MPU-401 (UART) B";
1796 midi = &chip->midi2;
1797 midi->tx_enable = INTE_MIDI_TX_B;
1798 midi->rx_enable = INTE_MIDI_RX_B;
1799 midi->ipr_tx = IPR_MIDI_TX_B;
1800 midi->ipr_rx = IPR_MIDI_RX_B;
1801 midi->port = MIDI_UART_B_DATA;
1802 } else {
1803 name = "CA0106 MPU-401 (UART)";
1804 midi = &chip->midi;
1805 midi->tx_enable = INTE_MIDI_TX_A;
1806 midi->rx_enable = INTE_MIDI_TX_B;
1807 midi->ipr_tx = IPR_MIDI_TX_A;
1808 midi->ipr_rx = IPR_MIDI_RX_A;
1809 midi->port = MIDI_UART_A_DATA;
1810 }
1811
1812 midi->reset = CA0106_MPU401_RESET;
1813 midi->enter_uart = CA0106_MPU401_ENTER_UART;
1814 midi->ack = CA0106_MPU401_ACK;
1815
1816 midi->input_avail = CA0106_MIDI_INPUT_AVAIL;
1817 midi->output_ready = CA0106_MIDI_OUTPUT_READY;
1818
1819 midi->channel = channel;
1820
1821 midi->interrupt_enable = ca0106_midi_interrupt_enable;
1822 midi->interrupt_disable = ca0106_midi_interrupt_disable;
1823
1824 midi->read = ca0106_midi_read;
1825 midi->write = ca0106_midi_write;
1826
1827 midi->get_dev_id_card = ca0106_dev_id_card;
1828 midi->get_dev_id_port = ca0106_dev_id_port;
1829
1830 midi->dev_id = chip;
1831
1832 if ((err = ca_midi_init(chip, midi, 0, name)) < 0)
1833 return err;
1834
1835 return 0;
1836}
1837
1838
1839static int snd_ca0106_probe(struct pci_dev *pci,
1840 const struct pci_device_id *pci_id)
1841{
1842 static int dev;
1843 struct snd_card *card;
1844 struct snd_ca0106 *chip;
1845 int i, err;
1846
1847 if (dev >= SNDRV_CARDS)
1848 return -ENODEV;
1849 if (!enable[dev]) {
1850 dev++;
1851 return -ENOENT;
1852 }
1853
1854 err = snd_card_new(&pci->dev, index[dev], id[dev], THIS_MODULE,
1855 0, &card);
1856 if (err < 0)
1857 return err;
1858
1859 err = snd_ca0106_create(dev, card, pci, &chip);
1860 if (err < 0)
1861 goto error;
1862 card->private_data = chip;
1863
1864 for (i = 0; i < 4; i++) {
1865 err = snd_ca0106_pcm(chip, i);
1866 if (err < 0)
1867 goto error;
1868 }
1869
1870 if (chip->details->ac97 == 1) {
1871
1872 err = snd_ca0106_ac97(chip);
1873 if (err < 0)
1874 goto error;
1875 }
1876 err = snd_ca0106_mixer(chip);
1877 if (err < 0)
1878 goto error;
1879
1880 dev_dbg(card->dev, "probe for MIDI channel A ...");
1881 err = snd_ca0106_midi(chip, CA0106_MIDI_CHAN_A);
1882 if (err < 0)
1883 goto error;
1884 dev_dbg(card->dev, " done.\n");
1885
1886#ifdef CONFIG_SND_PROC_FS
1887 snd_ca0106_proc_init(chip);
1888#endif
1889
1890 err = snd_card_register(card);
1891 if (err < 0)
1892 goto error;
1893
1894 pci_set_drvdata(pci, card);
1895 dev++;
1896 return 0;
1897
1898 error:
1899 snd_card_free(card);
1900 return err;
1901}
1902
1903static void snd_ca0106_remove(struct pci_dev *pci)
1904{
1905 snd_card_free(pci_get_drvdata(pci));
1906}
1907
1908#ifdef CONFIG_PM_SLEEP
1909static int snd_ca0106_suspend(struct device *dev)
1910{
1911 struct snd_card *card = dev_get_drvdata(dev);
1912 struct snd_ca0106 *chip = card->private_data;
1913 int i;
1914
1915 snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
1916 for (i = 0; i < 4; i++)
1917 snd_pcm_suspend_all(chip->pcm[i]);
1918 if (chip->details->ac97)
1919 snd_ac97_suspend(chip->ac97);
1920 snd_ca0106_mixer_suspend(chip);
1921
1922 ca0106_stop_chip(chip);
1923 return 0;
1924}
1925
1926static int snd_ca0106_resume(struct device *dev)
1927{
1928 struct snd_card *card = dev_get_drvdata(dev);
1929 struct snd_ca0106 *chip = card->private_data;
1930 int i;
1931
1932 ca0106_init_chip(chip, 1);
1933
1934 if (chip->details->ac97)
1935 snd_ac97_resume(chip->ac97);
1936 snd_ca0106_mixer_resume(chip);
1937 if (chip->details->spi_dac) {
1938 for (i = 0; i < ARRAY_SIZE(chip->spi_dac_reg); i++)
1939 snd_ca0106_spi_write(chip, chip->spi_dac_reg[i]);
1940 }
1941
1942 snd_power_change_state(card, SNDRV_CTL_POWER_D0);
1943 return 0;
1944}
1945
1946static SIMPLE_DEV_PM_OPS(snd_ca0106_pm, snd_ca0106_suspend, snd_ca0106_resume);
1947#define SND_CA0106_PM_OPS &snd_ca0106_pm
1948#else
1949#define SND_CA0106_PM_OPS NULL
1950#endif
1951
1952
1953static const struct pci_device_id snd_ca0106_ids[] = {
1954 { PCI_VDEVICE(CREATIVE, 0x0007), 0 },
1955 { 0, }
1956};
1957MODULE_DEVICE_TABLE(pci, snd_ca0106_ids);
1958
1959
1960static struct pci_driver ca0106_driver = {
1961 .name = KBUILD_MODNAME,
1962 .id_table = snd_ca0106_ids,
1963 .probe = snd_ca0106_probe,
1964 .remove = snd_ca0106_remove,
1965 .driver = {
1966 .pm = SND_CA0106_PM_OPS,
1967 },
1968};
1969
1970module_pci_driver(ca0106_driver);
1971
