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