1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Matt Wu <Matt_Wu@acersoftech.com.cn>
5 * Routines for control of ALi pci audio M5451
15 #include <linux/delay.h>
16 #include <linux/interrupt.h>
17 #include <linux/init.h>
18 #include <linux/pci.h>
19 #include <linux/slab.h>
20 #include <linux/module.h>
21 #include <linux/dma-mapping.h>
22 #include <sound/core.h>
23 #include <sound/pcm.h>
24 #include <sound/info.h>
25 #include <sound/ac97_codec.h>
26 #include <sound/mpu401.h>
27 #include <sound/initval.h>
29 MODULE_AUTHOR("Matt Wu <Matt_Wu@acersoftech.com.cn>");
30 MODULE_DESCRIPTION("ALI M5451");
31 MODULE_LICENSE("GPL");
33 static int index
= SNDRV_DEFAULT_IDX1
; /* Index */
34 static char *id
= SNDRV_DEFAULT_STR1
; /* ID for this card */
35 static int pcm_channels
= 32;
38 module_param(index
, int, 0444);
39 MODULE_PARM_DESC(index
, "Index value for ALI M5451 PCI Audio.");
40 module_param(id
, charp
, 0444);
41 MODULE_PARM_DESC(id
, "ID string for ALI M5451 PCI Audio.");
42 module_param(pcm_channels
, int, 0444);
43 MODULE_PARM_DESC(pcm_channels
, "PCM Channels");
44 module_param(spdif
, bool, 0444);
45 MODULE_PARM_DESC(spdif
, "Support SPDIF I/O");
47 /* just for backward compatibility */
49 module_param(enable
, bool, 0444);
53 * Constants definition
56 #define DEVICE_ID_ALI5451 ((PCI_VENDOR_ID_AL<<16)|PCI_DEVICE_ID_AL_M5451)
59 #define ALI_CHANNELS 32
61 #define ALI_PCM_IN_CHANNEL 31
62 #define ALI_SPDIF_IN_CHANNEL 19
63 #define ALI_SPDIF_OUT_CHANNEL 15
64 #define ALI_CENTER_CHANNEL 24
65 #define ALI_LEF_CHANNEL 23
66 #define ALI_SURR_LEFT_CHANNEL 26
67 #define ALI_SURR_RIGHT_CHANNEL 25
68 #define ALI_MODEM_IN_CHANNEL 21
69 #define ALI_MODEM_OUT_CHANNEL 20
71 #define SNDRV_ALI_VOICE_TYPE_PCM 01
72 #define SNDRV_ALI_VOICE_TYPE_OTH 02
74 #define ALI_5451_V02 0x02
80 #define ALI_LEGACY_DMAR0 0x00 /* ADR0 */
81 #define ALI_LEGACY_DMAR4 0x04 /* CNT0 */
82 #define ALI_LEGACY_DMAR11 0x0b /* MOD */
83 #define ALI_LEGACY_DMAR15 0x0f /* MMR */
84 #define ALI_MPUR0 0x20
85 #define ALI_MPUR1 0x21
86 #define ALI_MPUR2 0x22
87 #define ALI_MPUR3 0x23
89 #define ALI_AC97_WRITE 0x40
90 #define ALI_AC97_READ 0x44
92 #define ALI_SCTRL 0x48
93 #define ALI_SPDIF_OUT_ENABLE 0x20
94 #define ALI_SCTRL_LINE_IN2 (1 << 9)
95 #define ALI_SCTRL_GPIO_IN2 (1 << 13)
96 #define ALI_SCTRL_LINE_OUT_EN (1 << 20)
97 #define ALI_SCTRL_GPIO_OUT_EN (1 << 23)
98 #define ALI_SCTRL_CODEC1_READY (1 << 24)
99 #define ALI_SCTRL_CODEC2_READY (1 << 25)
100 #define ALI_AC97_GPIO 0x4c
101 #define ALI_AC97_GPIO_ENABLE 0x8000
102 #define ALI_AC97_GPIO_DATA_SHIFT 16
103 #define ALI_SPDIF_CS 0x70
104 #define ALI_SPDIF_CTRL 0x74
105 #define ALI_SPDIF_IN_FUNC_ENABLE 0x02
106 #define ALI_SPDIF_IN_CH_STATUS 0x40
107 #define ALI_SPDIF_OUT_CH_STATUS 0xbf
108 #define ALI_START 0x80
109 #define ALI_STOP 0x84
110 #define ALI_CSPF 0x90
111 #define ALI_AINT 0x98
112 #define ALI_GC_CIR 0xa0
113 #define ENDLP_IE 0x00001000
114 #define MIDLP_IE 0x00002000
115 #define ALI_AINTEN 0xa4
116 #define ALI_VOLUME 0xa8
117 #define ALI_SBDELTA_DELTA_R 0xac
118 #define ALI_MISCINT 0xb0
119 #define ADDRESS_IRQ 0x00000020
120 #define TARGET_REACHED 0x00008000
121 #define MIXER_OVERFLOW 0x00000800
122 #define MIXER_UNDERFLOW 0x00000400
123 #define GPIO_IRQ 0x01000000
124 #define ALI_SBBL_SBCL 0xc0
125 #define ALI_SBCTRL_SBE2R_SBDD 0xc4
126 #define ALI_STIMER 0xc8
127 #define ALI_GLOBAL_CONTROL 0xd4
128 #define ALI_SPDIF_OUT_SEL_PCM 0x00000400 /* bit 10 */
129 #define ALI_SPDIF_IN_SUPPORT 0x00000800 /* bit 11 */
130 #define ALI_SPDIF_OUT_CH_ENABLE 0x00008000 /* bit 15 */
131 #define ALI_SPDIF_IN_CH_ENABLE 0x00080000 /* bit 19 */
132 #define ALI_PCM_IN_ENABLE 0x80000000 /* bit 31 */
134 #define ALI_CSO_ALPHA_FMS 0xe0
136 #define ALI_ESO_DELTA 0xe8
137 #define ALI_GVSEL_PAN_VOC_CTRL_EC 0xf0
138 #define ALI_EBUF1 0xf4
139 #define ALI_EBUF2 0xf8
141 #define ALI_REG(codec, x) ((codec)->port + x)
147 struct snd_ali_voice
;
149 struct snd_ali_channel_control
{
158 /* register addresses */
164 unsigned int ac97read
;
165 unsigned int ac97write
;
170 struct snd_ali_voice
{
180 struct snd_ali
*codec
;
181 struct snd_pcm_substream
*substream
;
182 struct snd_ali_voice
*extra
;
184 int eso
; /* final ESO value for channel */
185 int count
; /* runtime->period_size */
190 void (*private_free
)(void *private_data
);
196 struct snd_ali_voice voices
[ALI_CHANNELS
];
198 unsigned int chcnt
; /* num of opened channels */
199 unsigned int chmap
; /* bitmap for opened channels */
200 unsigned int synthcount
;
205 #define ALI_GLOBAL_REGS 56
206 #define ALI_CHANNEL_REGS 8
207 struct snd_ali_image
{
208 u32 regs
[ALI_GLOBAL_REGS
];
209 u32 channel_regs
[ALI_CHANNELS
][ALI_CHANNEL_REGS
];
216 unsigned char revision
;
218 unsigned int hw_initialized
:1;
219 unsigned int spdif_support
:1;
222 struct pci_dev
*pci_m1533
;
223 struct pci_dev
*pci_m7101
;
225 struct snd_card
*card
;
226 struct snd_pcm
*pcm
[MAX_CODECS
];
227 struct snd_alidev synth
;
228 struct snd_ali_channel_control chregs
;
231 unsigned int spdif_mask
;
233 unsigned int spurious_irq_count
;
234 unsigned int spurious_irq_max_delta
;
236 unsigned int num_of_codecs
;
238 struct snd_ac97_bus
*ac97_bus
;
239 struct snd_ac97
*ac97
[MAX_CODECS
];
240 unsigned short ac97_ext_id
;
241 unsigned short ac97_ext_status
;
244 spinlock_t voice_alloc
;
246 #ifdef CONFIG_PM_SLEEP
247 struct snd_ali_image
*image
;
251 static const struct pci_device_id snd_ali_ids
[] = {
252 {PCI_DEVICE(PCI_VENDOR_ID_AL
, PCI_DEVICE_ID_AL_M5451
), 0, 0, 0},
255 MODULE_DEVICE_TABLE(pci
, snd_ali_ids
);
257 static void snd_ali_clear_voices(struct snd_ali
*, unsigned int, unsigned int);
258 static unsigned short snd_ali_codec_peek(struct snd_ali
*, int, unsigned short);
259 static void snd_ali_codec_poke(struct snd_ali
*, int, unsigned short,
266 static inline unsigned int snd_ali_5451_peek(struct snd_ali
*codec
,
269 return (unsigned int)inl(ALI_REG(codec
, port
));
272 static inline void snd_ali_5451_poke(struct snd_ali
*codec
,
276 outl((unsigned int)val
, ALI_REG(codec
, port
));
279 static int snd_ali_codec_ready(struct snd_ali
*codec
,
282 unsigned long end_time
;
285 end_time
= jiffies
+ msecs_to_jiffies(250);
288 res
= snd_ali_5451_peek(codec
,port
);
291 if (!time_after_eq(end_time
, jiffies
))
293 schedule_timeout_uninterruptible(1);
296 snd_ali_5451_poke(codec
, port
, res
& ~0x8000);
297 dev_dbg(codec
->card
->dev
, "ali_codec_ready: codec is not ready.\n ");
301 static int snd_ali_stimer_ready(struct snd_ali
*codec
)
303 unsigned long end_time
;
304 unsigned long dwChk1
,dwChk2
;
306 dwChk1
= snd_ali_5451_peek(codec
, ALI_STIMER
);
307 end_time
= jiffies
+ msecs_to_jiffies(250);
310 dwChk2
= snd_ali_5451_peek(codec
, ALI_STIMER
);
311 if (dwChk2
!= dwChk1
)
313 if (!time_after_eq(end_time
, jiffies
))
315 schedule_timeout_uninterruptible(1);
318 dev_err(codec
->card
->dev
, "ali_stimer_read: stimer is not ready.\n");
322 static void snd_ali_codec_poke(struct snd_ali
*codec
,int secondary
,
330 dev_err(codec
->card
->dev
,
331 "ali_codec_poke: reg(%xh) invalid.\n", reg
);
335 port
= codec
->chregs
.regs
.ac97write
;
337 if (snd_ali_codec_ready(codec
, port
) < 0)
339 if (snd_ali_stimer_ready(codec
) < 0)
342 dwVal
= (unsigned int) (reg
& 0xff);
343 dwVal
|= 0x8000 | (val
<< 16);
346 if (codec
->revision
== ALI_5451_V02
)
349 snd_ali_5451_poke(codec
, port
, dwVal
);
354 static unsigned short snd_ali_codec_peek(struct snd_ali
*codec
,
362 dev_err(codec
->card
->dev
,
363 "ali_codec_peek: reg(%xh) invalid.\n", reg
);
367 port
= codec
->chregs
.regs
.ac97read
;
369 if (snd_ali_codec_ready(codec
, port
) < 0)
371 if (snd_ali_stimer_ready(codec
) < 0)
374 dwVal
= (unsigned int) (reg
& 0xff);
375 dwVal
|= 0x8000; /* bit 15*/
379 snd_ali_5451_poke(codec
, port
, dwVal
);
381 if (snd_ali_stimer_ready(codec
) < 0)
383 if (snd_ali_codec_ready(codec
, port
) < 0)
386 return (snd_ali_5451_peek(codec
, port
) & 0xffff0000) >> 16;
389 static void snd_ali_codec_write(struct snd_ac97
*ac97
,
393 struct snd_ali
*codec
= ac97
->private_data
;
395 dev_dbg(codec
->card
->dev
, "codec_write: reg=%xh data=%xh.\n", reg
, val
);
396 if (reg
== AC97_GPIO_STATUS
) {
397 outl((val
<< ALI_AC97_GPIO_DATA_SHIFT
) | ALI_AC97_GPIO_ENABLE
,
398 ALI_REG(codec
, ALI_AC97_GPIO
));
401 snd_ali_codec_poke(codec
, ac97
->num
, reg
, val
);
406 static unsigned short snd_ali_codec_read(struct snd_ac97
*ac97
,
409 struct snd_ali
*codec
= ac97
->private_data
;
411 dev_dbg(codec
->card
->dev
, "codec_read reg=%xh.\n", reg
);
412 return snd_ali_codec_peek(codec
, ac97
->num
, reg
);
419 static int snd_ali_reset_5451(struct snd_ali
*codec
)
421 struct pci_dev
*pci_dev
;
422 unsigned short wCount
, wReg
;
425 pci_dev
= codec
->pci_m1533
;
427 pci_read_config_dword(pci_dev
, 0x7c, &dwVal
);
428 pci_write_config_dword(pci_dev
, 0x7c, dwVal
| 0x08000000);
430 pci_read_config_dword(pci_dev
, 0x7c, &dwVal
);
431 pci_write_config_dword(pci_dev
, 0x7c, dwVal
& 0xf7ffffff);
435 pci_dev
= codec
->pci
;
436 pci_read_config_dword(pci_dev
, 0x44, &dwVal
);
437 pci_write_config_dword(pci_dev
, 0x44, dwVal
| 0x000c0000);
439 pci_read_config_dword(pci_dev
, 0x44, &dwVal
);
440 pci_write_config_dword(pci_dev
, 0x44, dwVal
& 0xfffbffff);
445 wReg
= snd_ali_codec_peek(codec
, 0, AC97_POWERDOWN
);
446 if ((wReg
& 0x000f) == 0x000f)
451 /* non-fatal if you have a non PM capable codec */
452 /* dev_warn(codec->card->dev, "ali5451: reset time out\n"); */
457 * ALI 5451 Controller
460 static void snd_ali_enable_special_channel(struct snd_ali
*codec
,
461 unsigned int channel
)
465 dwVal
= inl(ALI_REG(codec
, ALI_GLOBAL_CONTROL
));
466 dwVal
|= 1 << (channel
& 0x0000001f);
467 outl(dwVal
, ALI_REG(codec
, ALI_GLOBAL_CONTROL
));
470 static void snd_ali_disable_special_channel(struct snd_ali
*codec
,
471 unsigned int channel
)
475 dwVal
= inl(ALI_REG(codec
, ALI_GLOBAL_CONTROL
));
476 dwVal
&= ~(1 << (channel
& 0x0000001f));
477 outl(dwVal
, ALI_REG(codec
, ALI_GLOBAL_CONTROL
));
480 static void snd_ali_enable_address_interrupt(struct snd_ali
*codec
)
484 gc
= inl(ALI_REG(codec
, ALI_GC_CIR
));
487 outl( gc
, ALI_REG(codec
, ALI_GC_CIR
));
490 static void snd_ali_disable_address_interrupt(struct snd_ali
*codec
)
494 gc
= inl(ALI_REG(codec
, ALI_GC_CIR
));
497 outl(gc
, ALI_REG(codec
, ALI_GC_CIR
));
500 static void snd_ali_disable_voice_irq(struct snd_ali
*codec
,
501 unsigned int channel
)
504 struct snd_ali_channel_control
*pchregs
= &(codec
->chregs
);
506 dev_dbg(codec
->card
->dev
, "disable_voice_irq channel=%d\n", channel
);
508 mask
= 1 << (channel
& 0x1f);
509 pchregs
->data
.ainten
= inl(ALI_REG(codec
, pchregs
->regs
.ainten
));
510 pchregs
->data
.ainten
&= ~mask
;
511 outl(pchregs
->data
.ainten
, ALI_REG(codec
, pchregs
->regs
.ainten
));
514 static int snd_ali_alloc_pcm_channel(struct snd_ali
*codec
, int channel
)
516 unsigned int idx
= channel
& 0x1f;
518 if (codec
->synth
.chcnt
>= ALI_CHANNELS
){
519 dev_err(codec
->card
->dev
,
520 "ali_alloc_pcm_channel: no free channels.\n");
524 if (!(codec
->synth
.chmap
& (1 << idx
))) {
525 codec
->synth
.chmap
|= 1 << idx
;
526 codec
->synth
.chcnt
++;
527 dev_dbg(codec
->card
->dev
, "alloc_pcm_channel no. %d.\n", idx
);
533 static int snd_ali_find_free_channel(struct snd_ali
* codec
, int rec
)
538 dev_dbg(codec
->card
->dev
,
539 "find_free_channel: for %s\n", rec
? "rec" : "pcm");
543 if (codec
->spdif_support
&&
544 (inl(ALI_REG(codec
, ALI_GLOBAL_CONTROL
)) &
545 ALI_SPDIF_IN_SUPPORT
))
546 idx
= ALI_SPDIF_IN_CHANNEL
;
548 idx
= ALI_PCM_IN_CHANNEL
;
550 result
= snd_ali_alloc_pcm_channel(codec
, idx
);
554 dev_err(codec
->card
->dev
,
555 "ali_find_free_channel: record channel is busy now.\n");
561 if (codec
->spdif_support
&&
562 (inl(ALI_REG(codec
, ALI_GLOBAL_CONTROL
)) &
563 ALI_SPDIF_OUT_CH_ENABLE
)) {
564 idx
= ALI_SPDIF_OUT_CHANNEL
;
565 result
= snd_ali_alloc_pcm_channel(codec
, idx
);
569 dev_err(codec
->card
->dev
,
570 "ali_find_free_channel: S/PDIF out channel is in busy now.\n");
573 for (idx
= 0; idx
< ALI_CHANNELS
; idx
++) {
574 result
= snd_ali_alloc_pcm_channel(codec
, idx
);
578 dev_err(codec
->card
->dev
, "ali_find_free_channel: no free channels.\n");
582 static void snd_ali_free_channel_pcm(struct snd_ali
*codec
, int channel
)
584 unsigned int idx
= channel
& 0x0000001f;
586 dev_dbg(codec
->card
->dev
, "free_channel_pcm channel=%d\n", channel
);
588 if (channel
< 0 || channel
>= ALI_CHANNELS
)
591 if (!(codec
->synth
.chmap
& (1 << idx
))) {
592 dev_err(codec
->card
->dev
,
593 "ali_free_channel_pcm: channel %d is not in use.\n",
597 codec
->synth
.chmap
&= ~(1 << idx
);
598 codec
->synth
.chcnt
--;
602 static void snd_ali_stop_voice(struct snd_ali
*codec
, unsigned int channel
)
604 unsigned int mask
= 1 << (channel
& 0x1f);
606 dev_dbg(codec
->card
->dev
, "stop_voice: channel=%d\n", channel
);
607 outl(mask
, ALI_REG(codec
, codec
->chregs
.regs
.stop
));
614 static void snd_ali_delay(struct snd_ali
*codec
,int interval
)
616 unsigned long begintimer
,currenttimer
;
618 begintimer
= inl(ALI_REG(codec
, ALI_STIMER
));
619 currenttimer
= inl(ALI_REG(codec
, ALI_STIMER
));
621 while (currenttimer
< begintimer
+ interval
) {
622 if (snd_ali_stimer_ready(codec
) < 0)
624 currenttimer
= inl(ALI_REG(codec
, ALI_STIMER
));
629 static void snd_ali_detect_spdif_rate(struct snd_ali
*codec
)
635 bval
= inb(ALI_REG(codec
, ALI_SPDIF_CTRL
+ 1));
637 outb(bval
, ALI_REG(codec
, ALI_SPDIF_CTRL
+ 1));
639 while ((R1
< 0x0b || R1
> 0x0e) && R1
!= 0x12 && count
<= 50000) {
641 snd_ali_delay(codec
, 6);
642 bval
= inb(ALI_REG(codec
, ALI_SPDIF_CTRL
+ 1));
647 dev_err(codec
->card
->dev
, "ali_detect_spdif_rate: timeout!\n");
651 for (count
= 0; count
<= 50000; count
++) {
652 snd_ali_delay(codec
, 6);
653 bval
= inb(ALI_REG(codec
,ALI_SPDIF_CTRL
+ 1));
662 dev_err(codec
->card
->dev
, "ali_detect_spdif_rate: timeout!\n");
666 if (R2
>= 0x0b && R2
<= 0x0e) {
667 wval
= inw(ALI_REG(codec
, ALI_SPDIF_CTRL
+ 2));
669 wval
|= (0x09 << 8) | 0x05;
670 outw(wval
, ALI_REG(codec
, ALI_SPDIF_CTRL
+ 2));
672 bval
= inb(ALI_REG(codec
, ALI_SPDIF_CS
+ 3)) & 0xf0;
673 outb(bval
| 0x02, ALI_REG(codec
, ALI_SPDIF_CS
+ 3));
674 } else if (R2
== 0x12) {
675 wval
= inw(ALI_REG(codec
, ALI_SPDIF_CTRL
+ 2));
677 wval
|= (0x0e << 8) | 0x08;
678 outw(wval
, ALI_REG(codec
, ALI_SPDIF_CTRL
+ 2));
680 bval
= inb(ALI_REG(codec
,ALI_SPDIF_CS
+ 3)) & 0xf0;
681 outb(bval
| 0x03, ALI_REG(codec
, ALI_SPDIF_CS
+ 3));
685 static unsigned int snd_ali_get_spdif_in_rate(struct snd_ali
*codec
)
690 bval
= inb(ALI_REG(codec
, ALI_SPDIF_CTRL
));
693 outb(bval
, ALI_REG(codec
, ALI_SPDIF_CTRL
));
695 snd_ali_detect_spdif_rate(codec
);
697 bval
= inb(ALI_REG(codec
, ALI_SPDIF_CS
+ 3));
701 case 0: dwRate
= 44100; break;
702 case 1: dwRate
= 48000; break;
703 case 2: dwRate
= 32000; break;
704 default: dwRate
= 0; break;
710 static void snd_ali_enable_spdif_in(struct snd_ali
*codec
)
714 dwVal
= inl(ALI_REG(codec
, ALI_GLOBAL_CONTROL
));
715 dwVal
|= ALI_SPDIF_IN_SUPPORT
;
716 outl(dwVal
, ALI_REG(codec
, ALI_GLOBAL_CONTROL
));
718 dwVal
= inb(ALI_REG(codec
, ALI_SPDIF_CTRL
));
720 outb(dwVal
, ALI_REG(codec
, ALI_SPDIF_CTRL
));
722 snd_ali_enable_special_channel(codec
, ALI_SPDIF_IN_CHANNEL
);
725 static void snd_ali_disable_spdif_in(struct snd_ali
*codec
)
729 dwVal
= inl(ALI_REG(codec
, ALI_GLOBAL_CONTROL
));
730 dwVal
&= ~ALI_SPDIF_IN_SUPPORT
;
731 outl(dwVal
, ALI_REG(codec
, ALI_GLOBAL_CONTROL
));
733 snd_ali_disable_special_channel(codec
, ALI_SPDIF_IN_CHANNEL
);
737 static void snd_ali_set_spdif_out_rate(struct snd_ali
*codec
, unsigned int rate
)
743 case 32000: dwRate
= 0x300; break;
744 case 48000: dwRate
= 0x200; break;
745 default: dwRate
= 0; break;
748 bVal
= inb(ALI_REG(codec
, ALI_SPDIF_CTRL
));
749 bVal
&= (unsigned char)(~(1<<6));
751 bVal
|= 0x80; /* select right */
752 outb(bVal
, ALI_REG(codec
, ALI_SPDIF_CTRL
));
753 outb(dwRate
| 0x20, ALI_REG(codec
, ALI_SPDIF_CS
+ 2));
755 bVal
&= ~0x80; /* select left */
756 outb(bVal
, ALI_REG(codec
, ALI_SPDIF_CTRL
));
757 outw(rate
| 0x10, ALI_REG(codec
, ALI_SPDIF_CS
+ 2));
760 static void snd_ali_enable_spdif_out(struct snd_ali
*codec
)
764 struct pci_dev
*pci_dev
;
766 pci_dev
= codec
->pci_m1533
;
769 pci_read_config_byte(pci_dev
, 0x61, &bVal
);
771 pci_write_config_byte(pci_dev
, 0x61, bVal
);
772 pci_read_config_byte(pci_dev
, 0x7d, &bVal
);
774 pci_write_config_byte(pci_dev
, 0x7d, bVal
);
776 pci_read_config_byte(pci_dev
, 0x7e, &bVal
);
779 pci_write_config_byte(pci_dev
, 0x7e, bVal
);
781 bVal
= inb(ALI_REG(codec
, ALI_SCTRL
));
782 outb(bVal
| ALI_SPDIF_OUT_ENABLE
, ALI_REG(codec
, ALI_SCTRL
));
784 bVal
= inb(ALI_REG(codec
, ALI_SPDIF_CTRL
));
785 outb(bVal
& ALI_SPDIF_OUT_CH_STATUS
, ALI_REG(codec
, ALI_SPDIF_CTRL
));
787 wVal
= inw(ALI_REG(codec
, ALI_GLOBAL_CONTROL
));
788 wVal
|= ALI_SPDIF_OUT_SEL_PCM
;
789 outw(wVal
, ALI_REG(codec
, ALI_GLOBAL_CONTROL
));
790 snd_ali_disable_special_channel(codec
, ALI_SPDIF_OUT_CHANNEL
);
793 static void snd_ali_enable_spdif_chnout(struct snd_ali
*codec
)
797 wVal
= inw(ALI_REG(codec
, ALI_GLOBAL_CONTROL
));
798 wVal
&= ~ALI_SPDIF_OUT_SEL_PCM
;
799 outw(wVal
, ALI_REG(codec
, ALI_GLOBAL_CONTROL
));
801 wVal = inw(ALI_REG(codec, ALI_SPDIF_CS));
802 if (flag & ALI_SPDIF_OUT_NON_PCM)
806 outw(wVal, ALI_REG(codec, ALI_SPDIF_CS));
808 snd_ali_enable_special_channel(codec
, ALI_SPDIF_OUT_CHANNEL
);
811 static void snd_ali_disable_spdif_chnout(struct snd_ali
*codec
)
815 wVal
= inw(ALI_REG(codec
, ALI_GLOBAL_CONTROL
));
816 wVal
|= ALI_SPDIF_OUT_SEL_PCM
;
817 outw(wVal
, ALI_REG(codec
, ALI_GLOBAL_CONTROL
));
819 snd_ali_enable_special_channel(codec
, ALI_SPDIF_OUT_CHANNEL
);
822 static void snd_ali_disable_spdif_out(struct snd_ali
*codec
)
826 bVal
= inb(ALI_REG(codec
, ALI_SCTRL
));
827 outb(bVal
& ~ALI_SPDIF_OUT_ENABLE
, ALI_REG(codec
, ALI_SCTRL
));
829 snd_ali_disable_spdif_chnout(codec
);
832 static void snd_ali_update_ptr(struct snd_ali
*codec
, int channel
)
834 struct snd_ali_voice
*pvoice
;
835 struct snd_ali_channel_control
*pchregs
;
836 unsigned int old
, mask
;
838 pchregs
= &(codec
->chregs
);
840 /* check if interrupt occurred for channel */
841 old
= pchregs
->data
.aint
;
842 mask
= 1U << (channel
& 0x1f);
847 pvoice
= &codec
->synth
.voices
[channel
];
850 spin_lock(&codec
->reg_lock
);
852 if (pvoice
->pcm
&& pvoice
->substream
) {
854 if (pvoice
->running
) {
855 dev_dbg(codec
->card
->dev
,
856 "update_ptr: cso=%4.4x cspf=%d.\n",
857 inw(ALI_REG(codec
, ALI_CSO_ALPHA_FMS
+ 2)),
858 (inl(ALI_REG(codec
, ALI_CSPF
)) & mask
) == mask
);
859 spin_unlock(&codec
->reg_lock
);
860 snd_pcm_period_elapsed(pvoice
->substream
);
861 spin_lock(&codec
->reg_lock
);
863 snd_ali_stop_voice(codec
, channel
);
864 snd_ali_disable_voice_irq(codec
, channel
);
866 } else if (codec
->synth
.voices
[channel
].synth
) {
867 /* synth interrupt */
868 } else if (codec
->synth
.voices
[channel
].midi
) {
871 /* unknown interrupt */
872 snd_ali_stop_voice(codec
, channel
);
873 snd_ali_disable_voice_irq(codec
, channel
);
875 spin_unlock(&codec
->reg_lock
);
876 outl(mask
,ALI_REG(codec
,pchregs
->regs
.aint
));
877 pchregs
->data
.aint
= old
& (~mask
);
880 static irqreturn_t
snd_ali_card_interrupt(int irq
, void *dev_id
)
882 struct snd_ali
*codec
= dev_id
;
884 unsigned int audio_int
;
885 struct snd_ali_channel_control
*pchregs
;
887 if (codec
== NULL
|| !codec
->hw_initialized
)
890 audio_int
= inl(ALI_REG(codec
, ALI_MISCINT
));
894 pchregs
= &(codec
->chregs
);
895 if (audio_int
& ADDRESS_IRQ
) {
896 /* get interrupt status for all channels */
897 pchregs
->data
.aint
= inl(ALI_REG(codec
, pchregs
->regs
.aint
));
898 for (channel
= 0; channel
< ALI_CHANNELS
; channel
++)
899 snd_ali_update_ptr(codec
, channel
);
901 outl((TARGET_REACHED
| MIXER_OVERFLOW
| MIXER_UNDERFLOW
),
902 ALI_REG(codec
, ALI_MISCINT
));
908 static struct snd_ali_voice
*snd_ali_alloc_voice(struct snd_ali
* codec
,
909 int type
, int rec
, int channel
)
911 struct snd_ali_voice
*pvoice
;
914 dev_dbg(codec
->card
->dev
, "alloc_voice: type=%d rec=%d\n", type
, rec
);
916 spin_lock_irq(&codec
->voice_alloc
);
917 if (type
== SNDRV_ALI_VOICE_TYPE_PCM
) {
918 idx
= channel
> 0 ? snd_ali_alloc_pcm_channel(codec
, channel
) :
919 snd_ali_find_free_channel(codec
,rec
);
921 dev_err(codec
->card
->dev
, "ali_alloc_voice: err.\n");
922 spin_unlock_irq(&codec
->voice_alloc
);
925 pvoice
= &(codec
->synth
.voices
[idx
]);
926 pvoice
->codec
= codec
;
930 spin_unlock_irq(&codec
->voice_alloc
);
933 spin_unlock_irq(&codec
->voice_alloc
);
938 static void snd_ali_free_voice(struct snd_ali
* codec
,
939 struct snd_ali_voice
*pvoice
)
941 void (*private_free
)(void *);
944 dev_dbg(codec
->card
->dev
, "free_voice: channel=%d\n", pvoice
->number
);
947 snd_ali_clear_voices(codec
, pvoice
->number
, pvoice
->number
);
948 spin_lock_irq(&codec
->voice_alloc
);
949 private_free
= pvoice
->private_free
;
950 private_data
= pvoice
->private_data
;
951 pvoice
->private_free
= NULL
;
952 pvoice
->private_data
= NULL
;
954 snd_ali_free_channel_pcm(codec
, pvoice
->number
);
955 pvoice
->use
= pvoice
->pcm
= pvoice
->synth
= 0;
956 pvoice
->substream
= NULL
;
957 spin_unlock_irq(&codec
->voice_alloc
);
959 private_free(private_data
);
963 static void snd_ali_clear_voices(struct snd_ali
*codec
,
969 for (i
= v_min
; i
<= v_max
; i
++) {
970 snd_ali_stop_voice(codec
, i
);
971 snd_ali_disable_voice_irq(codec
, i
);
975 static void snd_ali_write_voice_regs(struct snd_ali
*codec
,
976 unsigned int Channel
,
981 unsigned int ALPHA_FMS
,
988 unsigned int ctlcmds
[4];
990 outb((unsigned char)(Channel
& 0x001f), ALI_REG(codec
, ALI_GC_CIR
));
992 ctlcmds
[0] = (CSO
<< 16) | (ALPHA_FMS
& 0x0000ffff);
994 ctlcmds
[2] = (ESO
<< 16) | (DELTA
& 0x0ffff);
995 ctlcmds
[3] = (GVSEL
<< 31) |
996 ((PAN
& 0x0000007f) << 24) |
997 ((VOL
& 0x000000ff) << 16) |
998 ((CTRL
& 0x0000000f) << 12) |
1001 outb(Channel
, ALI_REG(codec
, ALI_GC_CIR
));
1003 outl(ctlcmds
[0], ALI_REG(codec
, ALI_CSO_ALPHA_FMS
));
1004 outl(ctlcmds
[1], ALI_REG(codec
, ALI_LBA
));
1005 outl(ctlcmds
[2], ALI_REG(codec
, ALI_ESO_DELTA
));
1006 outl(ctlcmds
[3], ALI_REG(codec
, ALI_GVSEL_PAN_VOC_CTRL_EC
));
1008 outl(0x30000000, ALI_REG(codec
, ALI_EBUF1
)); /* Still Mode */
1009 outl(0x30000000, ALI_REG(codec
, ALI_EBUF2
)); /* Still Mode */
1012 static unsigned int snd_ali_convert_rate(unsigned int rate
, int rec
)
1024 else if (rate
== 8000)
1026 else if (rate
== 48000)
1029 delta
= ((48000 << 12) / rate
) & 0x0000ffff;
1033 else if (rate
== 8000)
1035 else if (rate
== 48000)
1038 delta
= (((rate
<< 12) + rate
) / 48000) & 0x0000ffff;
1044 static unsigned int snd_ali_control_mode(struct snd_pcm_substream
*substream
)
1047 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1050 CTRL default: 8-bit (unsigned) mono, loop mode enabled
1053 if (snd_pcm_format_width(runtime
->format
) == 16)
1054 CTRL
|= 0x00000008; /* 16-bit data */
1055 if (!snd_pcm_format_unsigned(runtime
->format
))
1056 CTRL
|= 0x00000002; /* signed data */
1057 if (runtime
->channels
> 1)
1058 CTRL
|= 0x00000004; /* stereo data */
1066 static int snd_ali_trigger(struct snd_pcm_substream
*substream
,
1070 struct snd_ali
*codec
= snd_pcm_substream_chip(substream
);
1071 struct snd_pcm_substream
*s
;
1072 unsigned int what
, whati
;
1073 struct snd_ali_voice
*pvoice
, *evoice
;
1078 case SNDRV_PCM_TRIGGER_START
:
1079 case SNDRV_PCM_TRIGGER_RESUME
:
1082 case SNDRV_PCM_TRIGGER_STOP
:
1083 case SNDRV_PCM_TRIGGER_SUSPEND
:
1091 snd_pcm_group_for_each_entry(s
, substream
) {
1092 if ((struct snd_ali
*) snd_pcm_substream_chip(s
) == codec
) {
1093 pvoice
= s
->runtime
->private_data
;
1094 evoice
= pvoice
->extra
;
1095 what
|= 1 << (pvoice
->number
& 0x1f);
1097 whati
|= 1 << (pvoice
->number
& 0x1f);
1099 whati
|= 1 << (evoice
->number
& 0x1f);
1100 what
|= 1 << (evoice
->number
& 0x1f);
1103 pvoice
->running
= 1;
1105 evoice
->running
= 1;
1107 pvoice
->running
= 0;
1109 evoice
->running
= 0;
1111 snd_pcm_trigger_done(s
, substream
);
1114 spin_lock(&codec
->reg_lock
);
1116 outl(what
, ALI_REG(codec
, ALI_STOP
));
1117 val
= inl(ALI_REG(codec
, ALI_AINTEN
));
1122 outl(val
, ALI_REG(codec
, ALI_AINTEN
));
1124 outl(what
, ALI_REG(codec
, ALI_START
));
1125 dev_dbg(codec
->card
->dev
, "trigger: what=%xh whati=%xh\n", what
, whati
);
1126 spin_unlock(&codec
->reg_lock
);
1131 static int snd_ali_playback_hw_params(struct snd_pcm_substream
*substream
,
1132 struct snd_pcm_hw_params
*hw_params
)
1134 struct snd_ali
*codec
= snd_pcm_substream_chip(substream
);
1135 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1136 struct snd_ali_voice
*pvoice
= runtime
->private_data
;
1137 struct snd_ali_voice
*evoice
= pvoice
->extra
;
1139 /* voice management */
1141 if (params_buffer_size(hw_params
) / 2 !=
1142 params_period_size(hw_params
)) {
1144 evoice
= snd_ali_alloc_voice(codec
,
1145 SNDRV_ALI_VOICE_TYPE_PCM
,
1149 pvoice
->extra
= evoice
;
1150 evoice
->substream
= substream
;
1154 snd_ali_free_voice(codec
, evoice
);
1155 pvoice
->extra
= evoice
= NULL
;
1162 static int snd_ali_playback_hw_free(struct snd_pcm_substream
*substream
)
1164 struct snd_ali
*codec
= snd_pcm_substream_chip(substream
);
1165 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1166 struct snd_ali_voice
*pvoice
= runtime
->private_data
;
1167 struct snd_ali_voice
*evoice
= pvoice
? pvoice
->extra
: NULL
;
1170 snd_ali_free_voice(codec
, evoice
);
1171 pvoice
->extra
= NULL
;
1176 static int snd_ali_playback_prepare(struct snd_pcm_substream
*substream
)
1178 struct snd_ali
*codec
= snd_pcm_substream_chip(substream
);
1179 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1180 struct snd_ali_voice
*pvoice
= runtime
->private_data
;
1181 struct snd_ali_voice
*evoice
= pvoice
->extra
;
1192 dev_dbg(codec
->card
->dev
, "playback_prepare ...\n");
1194 spin_lock_irq(&codec
->reg_lock
);
1196 /* set Delta (rate) value */
1197 Delta
= snd_ali_convert_rate(runtime
->rate
, 0);
1199 if (pvoice
->number
== ALI_SPDIF_IN_CHANNEL
||
1200 pvoice
->number
== ALI_PCM_IN_CHANNEL
)
1201 snd_ali_disable_special_channel(codec
, pvoice
->number
);
1202 else if (codec
->spdif_support
&&
1203 (inl(ALI_REG(codec
, ALI_GLOBAL_CONTROL
)) &
1204 ALI_SPDIF_OUT_CH_ENABLE
)
1205 && pvoice
->number
== ALI_SPDIF_OUT_CHANNEL
) {
1206 snd_ali_set_spdif_out_rate(codec
, runtime
->rate
);
1210 /* set Loop Back Address */
1211 LBA
= runtime
->dma_addr
;
1213 /* set interrupt count size */
1214 pvoice
->count
= runtime
->period_size
;
1216 /* set target ESO for channel */
1217 pvoice
->eso
= runtime
->buffer_size
;
1219 dev_dbg(codec
->card
->dev
, "playback_prepare: eso=%xh count=%xh\n",
1220 pvoice
->eso
, pvoice
->count
);
1222 /* set ESO to capture first MIDLP interrupt */
1223 ESO
= pvoice
->eso
-1;
1225 CTRL
= snd_ali_control_mode(substream
);
1231 dev_dbg(codec
->card
->dev
, "playback_prepare:\n");
1232 dev_dbg(codec
->card
->dev
,
1233 "ch=%d, Rate=%d Delta=%xh,GVSEL=%xh,PAN=%xh,CTRL=%xh\n",
1234 pvoice
->number
,runtime
->rate
,Delta
,GVSEL
,PAN
,CTRL
);
1235 snd_ali_write_voice_regs(codec
,
1248 evoice
->count
= pvoice
->count
;
1249 evoice
->eso
= pvoice
->count
<< 1;
1250 ESO
= evoice
->eso
- 1;
1251 snd_ali_write_voice_regs(codec
,
1264 spin_unlock_irq(&codec
->reg_lock
);
1269 static int snd_ali_prepare(struct snd_pcm_substream
*substream
)
1271 struct snd_ali
*codec
= snd_pcm_substream_chip(substream
);
1272 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1273 struct snd_ali_voice
*pvoice
= runtime
->private_data
;
1284 spin_lock_irq(&codec
->reg_lock
);
1286 dev_dbg(codec
->card
->dev
, "ali_prepare...\n");
1288 snd_ali_enable_special_channel(codec
,pvoice
->number
);
1290 Delta
= (pvoice
->number
== ALI_MODEM_IN_CHANNEL
||
1291 pvoice
->number
== ALI_MODEM_OUT_CHANNEL
) ?
1292 0x1000 : snd_ali_convert_rate(runtime
->rate
, pvoice
->mode
);
1294 /* Prepare capture intr channel */
1295 if (pvoice
->number
== ALI_SPDIF_IN_CHANNEL
) {
1299 spin_unlock_irq(&codec
->reg_lock
);
1300 if (codec
->revision
!= ALI_5451_V02
)
1303 rate
= snd_ali_get_spdif_in_rate(codec
);
1305 dev_warn(codec
->card
->dev
,
1306 "ali_capture_prepare: spdif rate detect err!\n");
1309 spin_lock_irq(&codec
->reg_lock
);
1310 bValue
= inb(ALI_REG(codec
,ALI_SPDIF_CTRL
));
1311 if (bValue
& 0x10) {
1312 outb(bValue
,ALI_REG(codec
,ALI_SPDIF_CTRL
));
1313 dev_warn(codec
->card
->dev
,
1314 "clear SPDIF parity error flag.\n");
1318 Delta
= ((rate
<< 12) / runtime
->rate
) & 0x00ffff;
1321 /* set target ESO for channel */
1322 pvoice
->eso
= runtime
->buffer_size
;
1324 /* set interrupt count size */
1325 pvoice
->count
= runtime
->period_size
;
1327 /* set Loop Back Address */
1328 LBA
= runtime
->dma_addr
;
1330 /* set ESO to capture first MIDLP interrupt */
1331 ESO
= pvoice
->eso
- 1;
1332 CTRL
= snd_ali_control_mode(substream
);
1338 snd_ali_write_voice_regs( codec
,
1351 spin_unlock_irq(&codec
->reg_lock
);
1357 static snd_pcm_uframes_t
1358 snd_ali_playback_pointer(struct snd_pcm_substream
*substream
)
1360 struct snd_ali
*codec
= snd_pcm_substream_chip(substream
);
1361 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1362 struct snd_ali_voice
*pvoice
= runtime
->private_data
;
1365 spin_lock(&codec
->reg_lock
);
1366 if (!pvoice
->running
) {
1367 spin_unlock(&codec
->reg_lock
);
1370 outb(pvoice
->number
, ALI_REG(codec
, ALI_GC_CIR
));
1371 cso
= inw(ALI_REG(codec
, ALI_CSO_ALPHA_FMS
+ 2));
1372 spin_unlock(&codec
->reg_lock
);
1373 dev_dbg(codec
->card
->dev
, "playback pointer returned cso=%xh.\n", cso
);
1375 cso
%= runtime
->buffer_size
;
1380 static snd_pcm_uframes_t
snd_ali_pointer(struct snd_pcm_substream
*substream
)
1382 struct snd_ali
*codec
= snd_pcm_substream_chip(substream
);
1383 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1384 struct snd_ali_voice
*pvoice
= runtime
->private_data
;
1387 spin_lock(&codec
->reg_lock
);
1388 if (!pvoice
->running
) {
1389 spin_unlock(&codec
->reg_lock
);
1392 outb(pvoice
->number
, ALI_REG(codec
, ALI_GC_CIR
));
1393 cso
= inw(ALI_REG(codec
, ALI_CSO_ALPHA_FMS
+ 2));
1394 spin_unlock(&codec
->reg_lock
);
1396 cso
%= runtime
->buffer_size
;
1400 static const struct snd_pcm_hardware snd_ali_playback
=
1402 .info
= (SNDRV_PCM_INFO_MMAP
| SNDRV_PCM_INFO_INTERLEAVED
|
1403 SNDRV_PCM_INFO_BLOCK_TRANSFER
|
1404 SNDRV_PCM_INFO_MMAP_VALID
|
1405 SNDRV_PCM_INFO_RESUME
|
1406 SNDRV_PCM_INFO_SYNC_START
),
1407 .formats
= (SNDRV_PCM_FMTBIT_U8
| SNDRV_PCM_FMTBIT_S16_LE
|
1408 SNDRV_PCM_FMTBIT_S8
| SNDRV_PCM_FMTBIT_U16_LE
),
1409 .rates
= SNDRV_PCM_RATE_CONTINUOUS
| SNDRV_PCM_RATE_8000_48000
,
1414 .buffer_bytes_max
= (256*1024),
1415 .period_bytes_min
= 64,
1416 .period_bytes_max
= (256*1024),
1418 .periods_max
= 1024,
1423 * Capture support device description
1426 static const struct snd_pcm_hardware snd_ali_capture
=
1428 .info
= (SNDRV_PCM_INFO_MMAP
| SNDRV_PCM_INFO_INTERLEAVED
|
1429 SNDRV_PCM_INFO_BLOCK_TRANSFER
|
1430 SNDRV_PCM_INFO_MMAP_VALID
|
1431 SNDRV_PCM_INFO_RESUME
|
1432 SNDRV_PCM_INFO_SYNC_START
),
1433 .formats
= (SNDRV_PCM_FMTBIT_U8
| SNDRV_PCM_FMTBIT_S16_LE
|
1434 SNDRV_PCM_FMTBIT_S8
| SNDRV_PCM_FMTBIT_U16_LE
),
1435 .rates
= SNDRV_PCM_RATE_CONTINUOUS
| SNDRV_PCM_RATE_8000_48000
,
1440 .buffer_bytes_max
= (128*1024),
1441 .period_bytes_min
= 64,
1442 .period_bytes_max
= (128*1024),
1444 .periods_max
= 1024,
1448 static void snd_ali_pcm_free_substream(struct snd_pcm_runtime
*runtime
)
1450 struct snd_ali_voice
*pvoice
= runtime
->private_data
;
1453 snd_ali_free_voice(pvoice
->codec
, pvoice
);
1456 static int snd_ali_open(struct snd_pcm_substream
*substream
, int rec
,
1457 int channel
, const struct snd_pcm_hardware
*phw
)
1459 struct snd_ali
*codec
= snd_pcm_substream_chip(substream
);
1460 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1461 struct snd_ali_voice
*pvoice
;
1463 pvoice
= snd_ali_alloc_voice(codec
, SNDRV_ALI_VOICE_TYPE_PCM
, rec
,
1468 pvoice
->substream
= substream
;
1469 runtime
->private_data
= pvoice
;
1470 runtime
->private_free
= snd_ali_pcm_free_substream
;
1473 snd_pcm_set_sync(substream
);
1474 snd_pcm_hw_constraint_minmax(runtime
, SNDRV_PCM_HW_PARAM_BUFFER_SIZE
,
1479 static int snd_ali_playback_open(struct snd_pcm_substream
*substream
)
1481 return snd_ali_open(substream
, 0, -1, &snd_ali_playback
);
1484 static int snd_ali_capture_open(struct snd_pcm_substream
*substream
)
1486 return snd_ali_open(substream
, 1, -1, &snd_ali_capture
);
1489 static int snd_ali_playback_close(struct snd_pcm_substream
*substream
)
1494 static int snd_ali_close(struct snd_pcm_substream
*substream
)
1496 struct snd_ali
*codec
= snd_pcm_substream_chip(substream
);
1497 struct snd_ali_voice
*pvoice
= substream
->runtime
->private_data
;
1499 snd_ali_disable_special_channel(codec
,pvoice
->number
);
1504 static const struct snd_pcm_ops snd_ali_playback_ops
= {
1505 .open
= snd_ali_playback_open
,
1506 .close
= snd_ali_playback_close
,
1507 .hw_params
= snd_ali_playback_hw_params
,
1508 .hw_free
= snd_ali_playback_hw_free
,
1509 .prepare
= snd_ali_playback_prepare
,
1510 .trigger
= snd_ali_trigger
,
1511 .pointer
= snd_ali_playback_pointer
,
1514 static const struct snd_pcm_ops snd_ali_capture_ops
= {
1515 .open
= snd_ali_capture_open
,
1516 .close
= snd_ali_close
,
1517 .prepare
= snd_ali_prepare
,
1518 .trigger
= snd_ali_trigger
,
1519 .pointer
= snd_ali_pointer
,
1526 static int snd_ali_modem_hw_params(struct snd_pcm_substream
*substream
,
1527 struct snd_pcm_hw_params
*hw_params
)
1529 struct snd_ali
*chip
= snd_pcm_substream_chip(substream
);
1530 unsigned int modem_num
= chip
->num_of_codecs
- 1;
1531 snd_ac97_write(chip
->ac97
[modem_num
], AC97_LINE1_RATE
,
1532 params_rate(hw_params
));
1533 snd_ac97_write(chip
->ac97
[modem_num
], AC97_LINE1_LEVEL
, 0);
1537 static const struct snd_pcm_hardware snd_ali_modem
=
1539 .info
= (SNDRV_PCM_INFO_MMAP
| SNDRV_PCM_INFO_INTERLEAVED
|
1540 SNDRV_PCM_INFO_BLOCK_TRANSFER
|
1541 SNDRV_PCM_INFO_MMAP_VALID
|
1542 SNDRV_PCM_INFO_RESUME
|
1543 SNDRV_PCM_INFO_SYNC_START
),
1544 .formats
= SNDRV_PCM_FMTBIT_S16_LE
,
1545 .rates
= (SNDRV_PCM_RATE_KNOT
| SNDRV_PCM_RATE_8000
|
1546 SNDRV_PCM_RATE_16000
),
1551 .buffer_bytes_max
= (256*1024),
1552 .period_bytes_min
= 64,
1553 .period_bytes_max
= (256*1024),
1555 .periods_max
= 1024,
1559 static int snd_ali_modem_open(struct snd_pcm_substream
*substream
, int rec
,
1562 static const unsigned int rates
[] = {8000, 9600, 12000, 16000};
1563 static const struct snd_pcm_hw_constraint_list hw_constraint_rates
= {
1564 .count
= ARRAY_SIZE(rates
),
1568 int err
= snd_ali_open(substream
, rec
, channel
, &snd_ali_modem
);
1572 return snd_pcm_hw_constraint_list(substream
->runtime
, 0,
1573 SNDRV_PCM_HW_PARAM_RATE
, &hw_constraint_rates
);
1576 static int snd_ali_modem_playback_open(struct snd_pcm_substream
*substream
)
1578 return snd_ali_modem_open(substream
, 0, ALI_MODEM_OUT_CHANNEL
);
1581 static int snd_ali_modem_capture_open(struct snd_pcm_substream
*substream
)
1583 return snd_ali_modem_open(substream
, 1, ALI_MODEM_IN_CHANNEL
);
1586 static const struct snd_pcm_ops snd_ali_modem_playback_ops
= {
1587 .open
= snd_ali_modem_playback_open
,
1588 .close
= snd_ali_close
,
1589 .hw_params
= snd_ali_modem_hw_params
,
1590 .prepare
= snd_ali_prepare
,
1591 .trigger
= snd_ali_trigger
,
1592 .pointer
= snd_ali_pointer
,
1595 static const struct snd_pcm_ops snd_ali_modem_capture_ops
= {
1596 .open
= snd_ali_modem_capture_open
,
1597 .close
= snd_ali_close
,
1598 .hw_params
= snd_ali_modem_hw_params
,
1599 .prepare
= snd_ali_prepare
,
1600 .trigger
= snd_ali_trigger
,
1601 .pointer
= snd_ali_pointer
,
1605 struct ali_pcm_description
{
1607 unsigned int playback_num
;
1608 unsigned int capture_num
;
1609 const struct snd_pcm_ops
*playback_ops
;
1610 const struct snd_pcm_ops
*capture_ops
;
1611 unsigned short class;
1615 static void snd_ali_pcm_free(struct snd_pcm
*pcm
)
1617 struct snd_ali
*codec
= pcm
->private_data
;
1618 codec
->pcm
[pcm
->device
] = NULL
;
1622 static int snd_ali_pcm(struct snd_ali
*codec
, int device
,
1623 struct ali_pcm_description
*desc
)
1625 struct snd_pcm
*pcm
;
1628 err
= snd_pcm_new(codec
->card
, desc
->name
, device
,
1629 desc
->playback_num
, desc
->capture_num
, &pcm
);
1631 dev_err(codec
->card
->dev
,
1632 "snd_ali_pcm: err called snd_pcm_new.\n");
1635 pcm
->private_data
= codec
;
1636 pcm
->private_free
= snd_ali_pcm_free
;
1637 if (desc
->playback_ops
)
1638 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_PLAYBACK
,
1639 desc
->playback_ops
);
1640 if (desc
->capture_ops
)
1641 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_CAPTURE
,
1644 snd_pcm_set_managed_buffer_all(pcm
, SNDRV_DMA_TYPE_DEV
,
1645 &codec
->pci
->dev
, 64*1024, 128*1024);
1647 pcm
->info_flags
= 0;
1648 pcm
->dev_class
= desc
->class;
1649 pcm
->dev_subclass
= SNDRV_PCM_SUBCLASS_GENERIC_MIX
;
1650 strcpy(pcm
->name
, desc
->name
);
1651 codec
->pcm
[0] = pcm
;
1655 static struct ali_pcm_description ali_pcms
[] = {
1656 { .name
= "ALI 5451",
1657 .playback_num
= ALI_CHANNELS
,
1659 .playback_ops
= &snd_ali_playback_ops
,
1660 .capture_ops
= &snd_ali_capture_ops
1662 { .name
= "ALI 5451 modem",
1665 .playback_ops
= &snd_ali_modem_playback_ops
,
1666 .capture_ops
= &snd_ali_modem_capture_ops
,
1667 .class = SNDRV_PCM_CLASS_MODEM
1671 static int snd_ali_build_pcms(struct snd_ali
*codec
)
1674 for (i
= 0; i
< codec
->num_of_codecs
&& i
< ARRAY_SIZE(ali_pcms
); i
++) {
1675 err
= snd_ali_pcm(codec
, i
, &ali_pcms
[i
]);
1683 #define ALI5451_SPDIF(xname, xindex, value) \
1684 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex,\
1685 .info = snd_ali5451_spdif_info, .get = snd_ali5451_spdif_get, \
1686 .put = snd_ali5451_spdif_put, .private_value = value}
1688 #define snd_ali5451_spdif_info snd_ctl_boolean_mono_info
1690 static int snd_ali5451_spdif_get(struct snd_kcontrol
*kcontrol
,
1691 struct snd_ctl_elem_value
*ucontrol
)
1693 struct snd_ali
*codec
= kcontrol
->private_data
;
1694 unsigned int spdif_enable
;
1696 spdif_enable
= ucontrol
->value
.integer
.value
[0] ? 1 : 0;
1698 spin_lock_irq(&codec
->reg_lock
);
1699 switch (kcontrol
->private_value
) {
1701 spdif_enable
= (codec
->spdif_mask
& 0x02) ? 1 : 0;
1704 spdif_enable
= ((codec
->spdif_mask
& 0x02) &&
1705 (codec
->spdif_mask
& 0x04)) ? 1 : 0;
1708 spdif_enable
= (codec
->spdif_mask
& 0x01) ? 1 : 0;
1713 ucontrol
->value
.integer
.value
[0] = spdif_enable
;
1714 spin_unlock_irq(&codec
->reg_lock
);
1718 static int snd_ali5451_spdif_put(struct snd_kcontrol
*kcontrol
,
1719 struct snd_ctl_elem_value
*ucontrol
)
1721 struct snd_ali
*codec
= kcontrol
->private_data
;
1722 unsigned int change
= 0, spdif_enable
= 0;
1724 spdif_enable
= ucontrol
->value
.integer
.value
[0] ? 1 : 0;
1726 spin_lock_irq(&codec
->reg_lock
);
1727 switch (kcontrol
->private_value
) {
1729 change
= (codec
->spdif_mask
& 0x02) ? 1 : 0;
1730 change
= change
^ spdif_enable
;
1733 codec
->spdif_mask
|= 0x02;
1734 snd_ali_enable_spdif_out(codec
);
1736 codec
->spdif_mask
&= ~(0x02);
1737 codec
->spdif_mask
&= ~(0x04);
1738 snd_ali_disable_spdif_out(codec
);
1743 change
= (codec
->spdif_mask
& 0x04) ? 1 : 0;
1744 change
= change
^ spdif_enable
;
1745 if (change
&& (codec
->spdif_mask
& 0x02)) {
1747 codec
->spdif_mask
|= 0x04;
1748 snd_ali_enable_spdif_chnout(codec
);
1750 codec
->spdif_mask
&= ~(0x04);
1751 snd_ali_disable_spdif_chnout(codec
);
1756 change
= (codec
->spdif_mask
& 0x01) ? 1 : 0;
1757 change
= change
^ spdif_enable
;
1760 codec
->spdif_mask
|= 0x01;
1761 snd_ali_enable_spdif_in(codec
);
1763 codec
->spdif_mask
&= ~(0x01);
1764 snd_ali_disable_spdif_in(codec
);
1771 spin_unlock_irq(&codec
->reg_lock
);
1776 static const struct snd_kcontrol_new snd_ali5451_mixer_spdif
[] = {
1777 /* spdif aplayback switch */
1778 /* FIXME: "IEC958 Playback Switch" may conflict with one on ac97_codec */
1779 ALI5451_SPDIF(SNDRV_CTL_NAME_IEC958("Output ",NONE
,SWITCH
), 0, 0),
1780 /* spdif out to spdif channel */
1781 ALI5451_SPDIF(SNDRV_CTL_NAME_IEC958("Channel Output ",NONE
,SWITCH
), 0, 1),
1782 /* spdif in from spdif channel */
1783 ALI5451_SPDIF(SNDRV_CTL_NAME_IEC958("",CAPTURE
,SWITCH
), 0, 2)
1786 static int snd_ali_mixer(struct snd_ali
*codec
)
1788 struct snd_ac97_template ac97
;
1791 static const struct snd_ac97_bus_ops ops
= {
1792 .write
= snd_ali_codec_write
,
1793 .read
= snd_ali_codec_read
,
1796 err
= snd_ac97_bus(codec
->card
, 0, &ops
, codec
, &codec
->ac97_bus
);
1800 memset(&ac97
, 0, sizeof(ac97
));
1801 ac97
.private_data
= codec
;
1803 for (i
= 0; i
< codec
->num_of_codecs
; i
++) {
1805 err
= snd_ac97_mixer(codec
->ac97_bus
, &ac97
, &codec
->ac97
[i
]);
1807 dev_err(codec
->card
->dev
,
1808 "ali mixer %d creating error.\n", i
);
1811 codec
->num_of_codecs
= 1;
1816 if (codec
->spdif_support
) {
1817 for (idx
= 0; idx
< ARRAY_SIZE(snd_ali5451_mixer_spdif
); idx
++) {
1818 err
= snd_ctl_add(codec
->card
,
1819 snd_ctl_new1(&snd_ali5451_mixer_spdif
[idx
], codec
));
1827 #ifdef CONFIG_PM_SLEEP
1828 static int ali_suspend(struct device
*dev
)
1830 struct snd_card
*card
= dev_get_drvdata(dev
);
1831 struct snd_ali
*chip
= card
->private_data
;
1832 struct snd_ali_image
*im
;
1839 snd_power_change_state(card
, SNDRV_CTL_POWER_D3hot
);
1840 for (i
= 0; i
< chip
->num_of_codecs
; i
++)
1841 snd_ac97_suspend(chip
->ac97
[i
]);
1843 spin_lock_irq(&chip
->reg_lock
);
1845 im
->regs
[ALI_MISCINT
>> 2] = inl(ALI_REG(chip
, ALI_MISCINT
));
1846 /* im->regs[ALI_START >> 2] = inl(ALI_REG(chip, ALI_START)); */
1847 im
->regs
[ALI_STOP
>> 2] = inl(ALI_REG(chip
, ALI_STOP
));
1849 /* disable all IRQ bits */
1850 outl(0, ALI_REG(chip
, ALI_MISCINT
));
1852 for (i
= 0; i
< ALI_GLOBAL_REGS
; i
++) {
1853 if ((i
*4 == ALI_MISCINT
) || (i
*4 == ALI_STOP
))
1855 im
->regs
[i
] = inl(ALI_REG(chip
, i
*4));
1858 for (i
= 0; i
< ALI_CHANNELS
; i
++) {
1859 outb(i
, ALI_REG(chip
, ALI_GC_CIR
));
1860 for (j
= 0; j
< ALI_CHANNEL_REGS
; j
++)
1861 im
->channel_regs
[i
][j
] = inl(ALI_REG(chip
, j
*4 + 0xe0));
1864 /* stop all HW channel */
1865 outl(0xffffffff, ALI_REG(chip
, ALI_STOP
));
1867 spin_unlock_irq(&chip
->reg_lock
);
1871 static int ali_resume(struct device
*dev
)
1873 struct snd_card
*card
= dev_get_drvdata(dev
);
1874 struct snd_ali
*chip
= card
->private_data
;
1875 struct snd_ali_image
*im
;
1882 spin_lock_irq(&chip
->reg_lock
);
1884 for (i
= 0; i
< ALI_CHANNELS
; i
++) {
1885 outb(i
, ALI_REG(chip
, ALI_GC_CIR
));
1886 for (j
= 0; j
< ALI_CHANNEL_REGS
; j
++)
1887 outl(im
->channel_regs
[i
][j
], ALI_REG(chip
, j
*4 + 0xe0));
1890 for (i
= 0; i
< ALI_GLOBAL_REGS
; i
++) {
1891 if ((i
*4 == ALI_MISCINT
) || (i
*4 == ALI_STOP
) ||
1894 outl(im
->regs
[i
], ALI_REG(chip
, i
*4));
1897 /* start HW channel */
1898 outl(im
->regs
[ALI_START
>> 2], ALI_REG(chip
, ALI_START
));
1899 /* restore IRQ enable bits */
1900 outl(im
->regs
[ALI_MISCINT
>> 2], ALI_REG(chip
, ALI_MISCINT
));
1902 spin_unlock_irq(&chip
->reg_lock
);
1904 for (i
= 0 ; i
< chip
->num_of_codecs
; i
++)
1905 snd_ac97_resume(chip
->ac97
[i
]);
1907 snd_power_change_state(card
, SNDRV_CTL_POWER_D0
);
1911 static SIMPLE_DEV_PM_OPS(ali_pm
, ali_suspend
, ali_resume
);
1912 #define ALI_PM_OPS &ali_pm
1914 #define ALI_PM_OPS NULL
1915 #endif /* CONFIG_PM_SLEEP */
1917 static void snd_ali_free(struct snd_card
*card
)
1919 struct snd_ali
*codec
= card
->private_data
;
1921 if (codec
->hw_initialized
)
1922 snd_ali_disable_address_interrupt(codec
);
1923 pci_dev_put(codec
->pci_m1533
);
1924 pci_dev_put(codec
->pci_m7101
);
1927 static int snd_ali_chip_init(struct snd_ali
*codec
)
1929 unsigned int legacy
;
1931 struct pci_dev
*pci_dev
;
1933 dev_dbg(codec
->card
->dev
, "chip initializing ...\n");
1935 if (snd_ali_reset_5451(codec
)) {
1936 dev_err(codec
->card
->dev
, "ali_chip_init: reset 5451 error.\n");
1940 if (codec
->revision
== ALI_5451_V02
) {
1941 pci_dev
= codec
->pci_m1533
;
1942 pci_read_config_byte(pci_dev
, 0x59, &temp
);
1944 pci_write_config_byte(pci_dev
, 0x59, temp
);
1946 pci_dev
= codec
->pci_m7101
;
1947 pci_read_config_byte(pci_dev
, 0xb8, &temp
);
1949 pci_write_config_byte(pci_dev
, 0xB8, temp
);
1952 pci_read_config_dword(codec
->pci
, 0x44, &legacy
);
1953 legacy
&= 0xff00ff00;
1954 legacy
|= 0x000800aa;
1955 pci_write_config_dword(codec
->pci
, 0x44, legacy
);
1957 outl(0x80000001, ALI_REG(codec
, ALI_GLOBAL_CONTROL
));
1958 outl(0x00000000, ALI_REG(codec
, ALI_AINTEN
));
1959 outl(0xffffffff, ALI_REG(codec
, ALI_AINT
));
1960 outl(0x00000000, ALI_REG(codec
, ALI_VOLUME
));
1961 outb(0x10, ALI_REG(codec
, ALI_MPUR2
));
1963 codec
->ac97_ext_id
= snd_ali_codec_peek(codec
, 0, AC97_EXTENDED_ID
);
1964 codec
->ac97_ext_status
= snd_ali_codec_peek(codec
, 0,
1965 AC97_EXTENDED_STATUS
);
1966 if (codec
->spdif_support
) {
1967 snd_ali_enable_spdif_out(codec
);
1968 codec
->spdif_mask
= 0x00000002;
1971 codec
->num_of_codecs
= 1;
1973 /* secondary codec - modem */
1974 if (inl(ALI_REG(codec
, ALI_SCTRL
)) & ALI_SCTRL_CODEC2_READY
) {
1975 codec
->num_of_codecs
++;
1976 outl(inl(ALI_REG(codec
, ALI_SCTRL
)) |
1977 (ALI_SCTRL_LINE_IN2
| ALI_SCTRL_GPIO_IN2
|
1978 ALI_SCTRL_LINE_OUT_EN
),
1979 ALI_REG(codec
, ALI_SCTRL
));
1982 dev_dbg(codec
->card
->dev
, "chip initialize succeed.\n");
1987 /* proc for register dump */
1988 static void snd_ali_proc_read(struct snd_info_entry
*entry
,
1989 struct snd_info_buffer
*buf
)
1991 struct snd_ali
*codec
= entry
->private_data
;
1993 for (i
= 0; i
< 256 ; i
+= 4)
1994 snd_iprintf(buf
, "%02x: %08x\n", i
, inl(ALI_REG(codec
, i
)));
1997 static void snd_ali_proc_init(struct snd_ali
*codec
)
1999 snd_card_ro_proc_new(codec
->card
, "ali5451", codec
, snd_ali_proc_read
);
2002 static int snd_ali_resources(struct snd_ali
*codec
)
2006 dev_dbg(codec
->card
->dev
, "resources allocation ...\n");
2007 err
= pci_request_regions(codec
->pci
, "ALI 5451");
2010 codec
->port
= pci_resource_start(codec
->pci
, 0);
2012 if (devm_request_irq(&codec
->pci
->dev
, codec
->pci
->irq
,
2013 snd_ali_card_interrupt
,
2014 IRQF_SHARED
, KBUILD_MODNAME
, codec
)) {
2015 dev_err(codec
->card
->dev
, "Unable to request irq.\n");
2018 codec
->irq
= codec
->pci
->irq
;
2019 codec
->card
->sync_irq
= codec
->irq
;
2020 dev_dbg(codec
->card
->dev
, "resources allocated.\n");
2024 static int snd_ali_create(struct snd_card
*card
,
2025 struct pci_dev
*pci
,
2029 struct snd_ali
*codec
= card
->private_data
;
2031 unsigned short cmdw
;
2033 dev_dbg(card
->dev
, "creating ...\n");
2035 /* enable PCI device */
2036 err
= pcim_enable_device(pci
);
2039 /* check, if we can restrict PCI DMA transfers to 31 bits */
2040 if (dma_set_mask_and_coherent(&pci
->dev
, DMA_BIT_MASK(31))) {
2042 "architecture does not support 31bit PCI busmaster DMA\n");
2046 spin_lock_init(&codec
->reg_lock
);
2047 spin_lock_init(&codec
->voice_alloc
);
2052 codec
->revision
= pci
->revision
;
2053 codec
->spdif_support
= spdif_support
;
2055 if (pcm_streams
< 1)
2057 if (pcm_streams
> 32)
2060 pci_set_master(pci
);
2061 pci_read_config_word(pci
, PCI_COMMAND
, &cmdw
);
2062 if ((cmdw
& PCI_COMMAND_IO
) != PCI_COMMAND_IO
) {
2063 cmdw
|= PCI_COMMAND_IO
;
2064 pci_write_config_word(pci
, PCI_COMMAND
, cmdw
);
2067 if (snd_ali_resources(codec
))
2069 card
->private_free
= snd_ali_free
;
2071 codec
->synth
.chmap
= 0;
2072 codec
->synth
.chcnt
= 0;
2073 codec
->spdif_mask
= 0;
2074 codec
->synth
.synthcount
= 0;
2076 if (codec
->revision
== ALI_5451_V02
)
2077 codec
->chregs
.regs
.ac97read
= ALI_AC97_WRITE
;
2079 codec
->chregs
.regs
.ac97read
= ALI_AC97_READ
;
2080 codec
->chregs
.regs
.ac97write
= ALI_AC97_WRITE
;
2082 codec
->chregs
.regs
.start
= ALI_START
;
2083 codec
->chregs
.regs
.stop
= ALI_STOP
;
2084 codec
->chregs
.regs
.aint
= ALI_AINT
;
2085 codec
->chregs
.regs
.ainten
= ALI_AINTEN
;
2087 codec
->chregs
.data
.start
= 0x00;
2088 codec
->chregs
.data
.stop
= 0x00;
2089 codec
->chregs
.data
.aint
= 0x00;
2090 codec
->chregs
.data
.ainten
= 0x00;
2092 /* M1533: southbridge */
2093 codec
->pci_m1533
= pci_get_device(0x10b9, 0x1533, NULL
);
2094 if (!codec
->pci_m1533
) {
2095 dev_err(card
->dev
, "cannot find ALi 1533 chip.\n");
2098 /* M7101: power management */
2099 codec
->pci_m7101
= pci_get_device(0x10b9, 0x7101, NULL
);
2100 if (!codec
->pci_m7101
&& codec
->revision
== ALI_5451_V02
) {
2101 dev_err(card
->dev
, "cannot find ALi 7101 chip.\n");
2105 /* initialise synth voices*/
2106 for (i
= 0; i
< ALI_CHANNELS
; i
++)
2107 codec
->synth
.voices
[i
].number
= i
;
2109 err
= snd_ali_chip_init(codec
);
2111 dev_err(card
->dev
, "ali create: chip init error.\n");
2115 #ifdef CONFIG_PM_SLEEP
2116 codec
->image
= devm_kmalloc(&pci
->dev
, sizeof(*codec
->image
),
2119 dev_warn(card
->dev
, "can't allocate apm buffer\n");
2122 snd_ali_enable_address_interrupt(codec
);
2123 codec
->hw_initialized
= 1;
2127 static int __snd_ali_probe(struct pci_dev
*pci
,
2128 const struct pci_device_id
*pci_id
)
2130 struct snd_card
*card
;
2131 struct snd_ali
*codec
;
2134 dev_dbg(&pci
->dev
, "probe ...\n");
2136 err
= snd_devm_card_new(&pci
->dev
, index
, id
, THIS_MODULE
,
2137 sizeof(*codec
), &card
);
2140 codec
= card
->private_data
;
2142 err
= snd_ali_create(card
, pci
, pcm_channels
, spdif
);
2146 dev_dbg(&pci
->dev
, "mixer building ...\n");
2147 err
= snd_ali_mixer(codec
);
2151 dev_dbg(&pci
->dev
, "pcm building ...\n");
2152 err
= snd_ali_build_pcms(codec
);
2156 snd_ali_proc_init(codec
);
2158 strcpy(card
->driver
, "ALI5451");
2159 strcpy(card
->shortname
, "ALI 5451");
2161 sprintf(card
->longname
, "%s at 0x%lx, irq %i",
2162 card
->shortname
, codec
->port
, codec
->irq
);
2164 dev_dbg(&pci
->dev
, "register card.\n");
2165 err
= snd_card_register(card
);
2169 pci_set_drvdata(pci
, card
);
2173 static int snd_ali_probe(struct pci_dev
*pci
,
2174 const struct pci_device_id
*pci_id
)
2176 return snd_card_free_on_error(&pci
->dev
, __snd_ali_probe(pci
, pci_id
));
2179 static struct pci_driver ali5451_driver
= {
2180 .name
= KBUILD_MODNAME
,
2181 .id_table
= snd_ali_ids
,
2182 .probe
= snd_ali_probe
,
2188 module_pci_driver(ali5451_driver
);