2 * Matt Wu <Matt_Wu@acersoftech.com.cn>
4 * Routines for control of ALi pci audio M5451
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public Lcodecnse as published by
14 * the Free Software Foundation; either version 2 of the Lcodecnse, or
15 * (at your option) any later version.
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public Lcodecnse for more details.
22 * You should have received a copy of the GNU General Public Lcodecnse
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
28 #include <sound/driver.h>
30 #include <linux/delay.h>
31 #include <linux/interrupt.h>
32 #include <linux/init.h>
33 #include <linux/pci.h>
34 #include <linux/slab.h>
35 #include <linux/moduleparam.h>
36 #include <linux/dma-mapping.h>
37 #include <sound/core.h>
38 #include <sound/pcm.h>
39 #include <sound/info.h>
40 #include <sound/ac97_codec.h>
41 #include <sound/mpu401.h>
42 #include <sound/initval.h>
44 MODULE_AUTHOR("Matt Wu <Matt_Wu@acersoftech.com.cn>");
45 MODULE_DESCRIPTION("ALI M5451");
46 MODULE_LICENSE("GPL");
47 MODULE_SUPPORTED_DEVICE("{{ALI,M5451,pci},{ALI,M5451}}");
49 static int index
= SNDRV_DEFAULT_IDX1
; /* Index */
50 static char *id
= SNDRV_DEFAULT_STR1
; /* ID for this card */
51 static int pcm_channels
= 32;
54 module_param(index
, int, 0444);
55 MODULE_PARM_DESC(index
, "Index value for ALI M5451 PCI Audio.");
56 module_param(id
, charp
, 0444);
57 MODULE_PARM_DESC(id
, "ID string for ALI M5451 PCI Audio.");
58 module_param(pcm_channels
, int, 0444);
59 MODULE_PARM_DESC(pcm_channels
, "PCM Channels");
60 module_param(spdif
, bool, 0444);
61 MODULE_PARM_DESC(spdif
, "Support SPDIF I/O");
63 /* just for backward compatibility */
65 module_param(enable
, bool, 0444);
69 * Debug part definitions
72 /* #define ALI_DEBUG */
75 #define snd_ali_printk(format, args...) printk(KERN_DEBUG format, ##args);
77 #define snd_ali_printk(format, args...)
81 * Constants definition
84 #define DEVICE_ID_ALI5451 ((PCI_VENDOR_ID_AL<<16)|PCI_DEVICE_ID_AL_M5451)
87 #define ALI_CHANNELS 32
89 #define ALI_PCM_IN_CHANNEL 31
90 #define ALI_SPDIF_IN_CHANNEL 19
91 #define ALI_SPDIF_OUT_CHANNEL 15
92 #define ALI_CENTER_CHANNEL 24
93 #define ALI_LEF_CHANNEL 23
94 #define ALI_SURR_LEFT_CHANNEL 26
95 #define ALI_SURR_RIGHT_CHANNEL 25
96 #define ALI_MODEM_IN_CHANNEL 21
97 #define ALI_MODEM_OUT_CHANNEL 20
99 #define SNDRV_ALI_VOICE_TYPE_PCM 01
100 #define SNDRV_ALI_VOICE_TYPE_OTH 02
102 #define ALI_5451_V02 0x02
108 #define ALI_LEGACY_DMAR0 0x00 /* ADR0 */
109 #define ALI_LEGACY_DMAR4 0x04 /* CNT0 */
110 #define ALI_LEGACY_DMAR11 0x0b /* MOD */
111 #define ALI_LEGACY_DMAR15 0x0f /* MMR */
112 #define ALI_MPUR0 0x20
113 #define ALI_MPUR1 0x21
114 #define ALI_MPUR2 0x22
115 #define ALI_MPUR3 0x23
117 #define ALI_AC97_WRITE 0x40
118 #define ALI_AC97_READ 0x44
120 #define ALI_SCTRL 0x48
121 #define ALI_SPDIF_OUT_ENABLE 0x20
122 #define ALI_SCTRL_LINE_IN2 (1 << 9)
123 #define ALI_SCTRL_GPIO_IN2 (1 << 13)
124 #define ALI_SCTRL_LINE_OUT_EN (1 << 20)
125 #define ALI_SCTRL_GPIO_OUT_EN (1 << 23)
126 #define ALI_SCTRL_CODEC1_READY (1 << 24)
127 #define ALI_SCTRL_CODEC2_READY (1 << 25)
128 #define ALI_AC97_GPIO 0x4c
129 #define ALI_AC97_GPIO_ENABLE 0x8000
130 #define ALI_AC97_GPIO_DATA_SHIFT 16
131 #define ALI_SPDIF_CS 0x70
132 #define ALI_SPDIF_CTRL 0x74
133 #define ALI_SPDIF_IN_FUNC_ENABLE 0x02
134 #define ALI_SPDIF_IN_CH_STATUS 0x40
135 #define ALI_SPDIF_OUT_CH_STATUS 0xbf
136 #define ALI_START 0x80
137 #define ALI_STOP 0x84
138 #define ALI_CSPF 0x90
139 #define ALI_AINT 0x98
140 #define ALI_GC_CIR 0xa0
141 #define ENDLP_IE 0x00001000
142 #define MIDLP_IE 0x00002000
143 #define ALI_AINTEN 0xa4
144 #define ALI_VOLUME 0xa8
145 #define ALI_SBDELTA_DELTA_R 0xac
146 #define ALI_MISCINT 0xb0
147 #define ADDRESS_IRQ 0x00000020
148 #define TARGET_REACHED 0x00008000
149 #define MIXER_OVERFLOW 0x00000800
150 #define MIXER_UNDERFLOW 0x00000400
151 #define GPIO_IRQ 0x01000000
152 #define ALI_SBBL_SBCL 0xc0
153 #define ALI_SBCTRL_SBE2R_SBDD 0xc4
154 #define ALI_STIMER 0xc8
155 #define ALI_GLOBAL_CONTROL 0xd4
156 #define ALI_SPDIF_OUT_SEL_PCM 0x00000400 /* bit 10 */
157 #define ALI_SPDIF_IN_SUPPORT 0x00000800 /* bit 11 */
158 #define ALI_SPDIF_OUT_CH_ENABLE 0x00008000 /* bit 15 */
159 #define ALI_SPDIF_IN_CH_ENABLE 0x00080000 /* bit 19 */
160 #define ALI_PCM_IN_ENABLE 0x80000000 /* bit 31 */
162 #define ALI_CSO_ALPHA_FMS 0xe0
164 #define ALI_ESO_DELTA 0xe8
165 #define ALI_GVSEL_PAN_VOC_CTRL_EC 0xf0
166 #define ALI_EBUF1 0xf4
167 #define ALI_EBUF2 0xf8
169 #define ALI_REG(codec, x) ((codec)->port + x)
175 struct snd_ali_voice
;
177 struct snd_ali_channel_control
{
186 /* register addresses */
192 unsigned int ac97read
;
193 unsigned int ac97write
;
198 struct snd_ali_voice
{
208 struct snd_ali
*codec
;
209 struct snd_pcm_substream
*substream
;
210 struct snd_ali_voice
*extra
;
212 int eso
; /* final ESO value for channel */
213 int count
; /* runtime->period_size */
218 void (*private_free
)(void *private_data
);
224 struct snd_ali_voice voices
[ALI_CHANNELS
];
226 unsigned int chcnt
; /* num of opened channels */
227 unsigned int chmap
; /* bitmap for opened channels */
228 unsigned int synthcount
;
233 #define ALI_GLOBAL_REGS 56
234 #define ALI_CHANNEL_REGS 8
235 struct snd_ali_image
{
236 u32 regs
[ALI_GLOBAL_REGS
];
237 u32 channel_regs
[ALI_CHANNELS
][ALI_CHANNEL_REGS
];
244 unsigned char revision
;
246 unsigned int hw_initialized
:1;
247 unsigned int spdif_support
:1;
250 struct pci_dev
*pci_m1533
;
251 struct pci_dev
*pci_m7101
;
253 struct snd_card
*card
;
254 struct snd_pcm
*pcm
[MAX_CODECS
];
255 struct snd_alidev synth
;
256 struct snd_ali_channel_control chregs
;
259 unsigned int spdif_mask
;
261 unsigned int spurious_irq_count
;
262 unsigned int spurious_irq_max_delta
;
264 unsigned int num_of_codecs
;
266 struct snd_ac97_bus
*ac97_bus
;
267 struct snd_ac97
*ac97
[MAX_CODECS
];
268 unsigned short ac97_ext_id
;
269 unsigned short ac97_ext_status
;
272 spinlock_t voice_alloc
;
275 struct snd_ali_image
*image
;
279 static struct pci_device_id snd_ali_ids
[] = {
280 {PCI_DEVICE(PCI_VENDOR_ID_AL
, PCI_DEVICE_ID_AL_M5451
), 0, 0, 0},
283 MODULE_DEVICE_TABLE(pci
, snd_ali_ids
);
285 static void snd_ali_clear_voices(struct snd_ali
*, unsigned int, unsigned int);
286 static unsigned short snd_ali_codec_peek(struct snd_ali
*, int, unsigned short);
287 static void snd_ali_codec_poke(struct snd_ali
*, int, unsigned short,
294 static inline unsigned int snd_ali_5451_peek(struct snd_ali
*codec
,
297 return (unsigned int)inl(ALI_REG(codec
, port
));
300 static inline void snd_ali_5451_poke(struct snd_ali
*codec
,
304 outl((unsigned int)val
, ALI_REG(codec
, port
));
307 static int snd_ali_codec_ready(struct snd_ali
*codec
,
310 unsigned long end_time
;
313 end_time
= jiffies
+ msecs_to_jiffies(250);
315 res
= snd_ali_5451_peek(codec
,port
);
318 schedule_timeout_uninterruptible(1);
319 } while (time_after_eq(end_time
, jiffies
));
320 snd_ali_5451_poke(codec
, port
, res
& ~0x8000);
321 snd_printdd("ali_codec_ready: codec is not ready.\n ");
325 static int snd_ali_stimer_ready(struct snd_ali
*codec
)
327 unsigned long end_time
;
328 unsigned long dwChk1
,dwChk2
;
330 dwChk1
= snd_ali_5451_peek(codec
, ALI_STIMER
);
331 dwChk2
= snd_ali_5451_peek(codec
, ALI_STIMER
);
333 end_time
= jiffies
+ msecs_to_jiffies(250);
335 dwChk2
= snd_ali_5451_peek(codec
, ALI_STIMER
);
336 if (dwChk2
!= dwChk1
)
338 schedule_timeout_uninterruptible(1);
339 } while (time_after_eq(end_time
, jiffies
));
340 snd_printk(KERN_ERR
"ali_stimer_read: stimer is not ready.\n");
344 static void snd_ali_codec_poke(struct snd_ali
*codec
,int secondary
,
352 snd_printk(KERN_ERR
"ali_codec_poke: reg(%xh) invalid.\n", reg
);
356 port
= codec
->chregs
.regs
.ac97write
;
358 if (snd_ali_codec_ready(codec
, port
) < 0)
360 if (snd_ali_stimer_ready(codec
) < 0)
363 dwVal
= (unsigned int) (reg
& 0xff);
364 dwVal
|= 0x8000 | (val
<< 16);
367 if (codec
->revision
== ALI_5451_V02
)
370 snd_ali_5451_poke(codec
, port
, dwVal
);
375 static unsigned short snd_ali_codec_peek(struct snd_ali
*codec
,
383 snd_printk(KERN_ERR
"ali_codec_peek: reg(%xh) invalid.\n", reg
);
387 port
= codec
->chregs
.regs
.ac97read
;
389 if (snd_ali_codec_ready(codec
, port
) < 0)
391 if (snd_ali_stimer_ready(codec
) < 0)
394 dwVal
= (unsigned int) (reg
& 0xff);
395 dwVal
|= 0x8000; /* bit 15*/
399 snd_ali_5451_poke(codec
, port
, dwVal
);
401 if (snd_ali_stimer_ready(codec
) < 0)
403 if (snd_ali_codec_ready(codec
, port
) < 0)
406 return (snd_ali_5451_peek(codec
, port
) & 0xffff0000) >> 16;
409 static void snd_ali_codec_write(struct snd_ac97
*ac97
,
413 struct snd_ali
*codec
= ac97
->private_data
;
415 snd_ali_printk("codec_write: reg=%xh data=%xh.\n", reg
, val
);
416 if (reg
== AC97_GPIO_STATUS
) {
417 outl((val
<< ALI_AC97_GPIO_DATA_SHIFT
) | ALI_AC97_GPIO_ENABLE
,
418 ALI_REG(codec
, ALI_AC97_GPIO
));
421 snd_ali_codec_poke(codec
, ac97
->num
, reg
, val
);
426 static unsigned short snd_ali_codec_read(struct snd_ac97
*ac97
,
429 struct snd_ali
*codec
= ac97
->private_data
;
431 snd_ali_printk("codec_read reg=%xh.\n", reg
);
432 return snd_ali_codec_peek(codec
, ac97
->num
, reg
);
439 static int snd_ali_reset_5451(struct snd_ali
*codec
)
441 struct pci_dev
*pci_dev
;
442 unsigned short wCount
, wReg
;
445 pci_dev
= codec
->pci_m1533
;
447 pci_read_config_dword(pci_dev
, 0x7c, &dwVal
);
448 pci_write_config_dword(pci_dev
, 0x7c, dwVal
| 0x08000000);
450 pci_read_config_dword(pci_dev
, 0x7c, &dwVal
);
451 pci_write_config_dword(pci_dev
, 0x7c, dwVal
& 0xf7ffffff);
455 pci_dev
= codec
->pci
;
456 pci_read_config_dword(pci_dev
, 0x44, &dwVal
);
457 pci_write_config_dword(pci_dev
, 0x44, dwVal
| 0x000c0000);
459 pci_read_config_dword(pci_dev
, 0x44, &dwVal
);
460 pci_write_config_dword(pci_dev
, 0x44, dwVal
& 0xfffbffff);
465 wReg
= snd_ali_codec_peek(codec
, 0, AC97_POWERDOWN
);
466 if ((wReg
& 0x000f) == 0x000f)
471 /* non-fatal if you have a non PM capable codec */
472 /* snd_printk(KERN_WARNING "ali5451: reset time out\n"); */
478 static int snd_ali_reset_codec(struct snd_ali
*codec
)
480 struct pci_dev
*pci_dev
;
483 unsigned short wCount
, wReg
;
485 pci_dev
= codec
->pci_m1533
;
487 pci_read_config_dword(pci_dev
, 0x7c, &dwVal
);
488 pci_write_config_dword(pci_dev
, 0x7c, dwVal
| 0x08000000);
490 pci_read_config_dword(pci_dev
, 0x7c, &dwVal
);
491 pci_write_config_dword(pci_dev
, 0x7c, dwVal
& 0xf7ffffff);
494 bVal
= inb(ALI_REG(codec
,ALI_SCTRL
));
496 outb(ALI_REG(codec
,ALI_SCTRL
),bVal
);
498 bVal
= inb(ALI_REG(codec
,ALI_SCTRL
));
500 outb(ALI_REG(codec
,ALI_SCTRL
),bVal
);
505 wReg
= snd_ali_codec_read(codec
->ac97
, AC97_POWERDOWN
);
506 if ((wReg
& 0x000f) == 0x000f)
516 * ALI 5451 Controller
519 static void snd_ali_enable_special_channel(struct snd_ali
*codec
,
520 unsigned int channel
)
524 dwVal
= inl(ALI_REG(codec
, ALI_GLOBAL_CONTROL
));
525 dwVal
|= 1 << (channel
& 0x0000001f);
526 outl(dwVal
, ALI_REG(codec
, ALI_GLOBAL_CONTROL
));
529 static void snd_ali_disable_special_channel(struct snd_ali
*codec
,
530 unsigned int channel
)
534 dwVal
= inl(ALI_REG(codec
, ALI_GLOBAL_CONTROL
));
535 dwVal
&= ~(1 << (channel
& 0x0000001f));
536 outl(dwVal
, ALI_REG(codec
, ALI_GLOBAL_CONTROL
));
539 static void snd_ali_enable_address_interrupt(struct snd_ali
*codec
)
543 gc
= inl(ALI_REG(codec
, ALI_GC_CIR
));
546 outl( gc
, ALI_REG(codec
, ALI_GC_CIR
));
549 static void snd_ali_disable_address_interrupt(struct snd_ali
*codec
)
553 gc
= inl(ALI_REG(codec
, ALI_GC_CIR
));
556 outl(gc
, ALI_REG(codec
, ALI_GC_CIR
));
560 static void snd_ali_enable_voice_irq(struct snd_ali
*codec
,
561 unsigned int channel
)
564 struct snd_ali_channel_control
*pchregs
= &(codec
->chregs
);
566 snd_ali_printk("enable_voice_irq channel=%d\n",channel
);
568 mask
= 1 << (channel
& 0x1f);
569 pchregs
->data
.ainten
= inl(ALI_REG(codec
, pchregs
->regs
.ainten
));
570 pchregs
->data
.ainten
|= mask
;
571 outl(pchregs
->data
.ainten
, ALI_REG(codec
, pchregs
->regs
.ainten
));
575 static void snd_ali_disable_voice_irq(struct snd_ali
*codec
,
576 unsigned int channel
)
579 struct snd_ali_channel_control
*pchregs
= &(codec
->chregs
);
581 snd_ali_printk("disable_voice_irq channel=%d\n",channel
);
583 mask
= 1 << (channel
& 0x1f);
584 pchregs
->data
.ainten
= inl(ALI_REG(codec
, pchregs
->regs
.ainten
));
585 pchregs
->data
.ainten
&= ~mask
;
586 outl(pchregs
->data
.ainten
, ALI_REG(codec
, pchregs
->regs
.ainten
));
589 static int snd_ali_alloc_pcm_channel(struct snd_ali
*codec
, int channel
)
591 unsigned int idx
= channel
& 0x1f;
593 if (codec
->synth
.chcnt
>= ALI_CHANNELS
){
595 "ali_alloc_pcm_channel: no free channels.\n");
599 if (!(codec
->synth
.chmap
& (1 << idx
))) {
600 codec
->synth
.chmap
|= 1 << idx
;
601 codec
->synth
.chcnt
++;
602 snd_ali_printk("alloc_pcm_channel no. %d.\n",idx
);
608 static int snd_ali_find_free_channel(struct snd_ali
* codec
, int rec
)
613 snd_ali_printk("find_free_channel: for %s\n",rec
? "rec" : "pcm");
617 if (codec
->spdif_support
&&
618 (inl(ALI_REG(codec
, ALI_GLOBAL_CONTROL
)) &
619 ALI_SPDIF_IN_SUPPORT
))
620 idx
= ALI_SPDIF_IN_CHANNEL
;
622 idx
= ALI_PCM_IN_CHANNEL
;
624 result
= snd_ali_alloc_pcm_channel(codec
, idx
);
628 snd_printk(KERN_ERR
"ali_find_free_channel: "
629 "record channel is busy now.\n");
635 if (codec
->spdif_support
&&
636 (inl(ALI_REG(codec
, ALI_GLOBAL_CONTROL
)) &
637 ALI_SPDIF_OUT_CH_ENABLE
)) {
638 idx
= ALI_SPDIF_OUT_CHANNEL
;
639 result
= snd_ali_alloc_pcm_channel(codec
, idx
);
643 snd_printk(KERN_ERR
"ali_find_free_channel: "
644 "S/PDIF out channel is in busy now.\n");
647 for (idx
= 0; idx
< ALI_CHANNELS
; idx
++) {
648 result
= snd_ali_alloc_pcm_channel(codec
, idx
);
652 snd_printk(KERN_ERR
"ali_find_free_channel: no free channels.\n");
656 static void snd_ali_free_channel_pcm(struct snd_ali
*codec
, int channel
)
658 unsigned int idx
= channel
& 0x0000001f;
660 snd_ali_printk("free_channel_pcm channel=%d\n",channel
);
662 if (channel
< 0 || channel
>= ALI_CHANNELS
)
665 if (!(codec
->synth
.chmap
& (1 << idx
))) {
666 snd_printk(KERN_ERR
"ali_free_channel_pcm: "
667 "channel %d is not in use.\n", channel
);
670 codec
->synth
.chmap
&= ~(1 << idx
);
671 codec
->synth
.chcnt
--;
676 static void snd_ali_start_voice(struct snd_ali
*codec
, unsigned int channel
)
678 unsigned int mask
= 1 << (channel
& 0x1f);
680 snd_ali_printk("start_voice: channel=%d\n",channel
);
681 outl(mask
, ALI_REG(codec
,codec
->chregs
.regs
.start
));
685 static void snd_ali_stop_voice(struct snd_ali
*codec
, unsigned int channel
)
687 unsigned int mask
= 1 << (channel
& 0x1f);
689 snd_ali_printk("stop_voice: channel=%d\n",channel
);
690 outl(mask
, ALI_REG(codec
, codec
->chregs
.regs
.stop
));
697 static void snd_ali_delay(struct snd_ali
*codec
,int interval
)
699 unsigned long begintimer
,currenttimer
;
701 begintimer
= inl(ALI_REG(codec
, ALI_STIMER
));
702 currenttimer
= inl(ALI_REG(codec
, ALI_STIMER
));
704 while (currenttimer
< begintimer
+ interval
) {
705 if (snd_ali_stimer_ready(codec
) < 0)
707 currenttimer
= inl(ALI_REG(codec
, ALI_STIMER
));
712 static void snd_ali_detect_spdif_rate(struct snd_ali
*codec
)
718 bval
= inb(ALI_REG(codec
, ALI_SPDIF_CTRL
+ 1));
720 outb(bval
, ALI_REG(codec
, ALI_SPDIF_CTRL
+ 1));
722 while ((R1
< 0x0b || R1
> 0x0e) && R1
!= 0x12 && count
<= 50000) {
724 snd_ali_delay(codec
, 6);
725 bval
= inb(ALI_REG(codec
, ALI_SPDIF_CTRL
+ 1));
730 snd_printk(KERN_ERR
"ali_detect_spdif_rate: timeout!\n");
735 while (count
++ <= 50000) {
736 snd_ali_delay(codec
, 6);
737 bval
= inb(ALI_REG(codec
,ALI_SPDIF_CTRL
+ 1));
746 snd_printk(KERN_ERR
"ali_detect_spdif_rate: timeout!\n");
750 if (R2
>= 0x0b && R2
<= 0x0e) {
751 wval
= inw(ALI_REG(codec
, ALI_SPDIF_CTRL
+ 2));
753 wval
|= (0x09 << 8) | 0x05;
754 outw(wval
, ALI_REG(codec
, ALI_SPDIF_CTRL
+ 2));
756 bval
= inb(ALI_REG(codec
, ALI_SPDIF_CS
+ 3)) & 0xf0;
757 outb(bval
| 0x02, ALI_REG(codec
, ALI_SPDIF_CS
+ 3));
758 } else if (R2
== 0x12) {
759 wval
= inw(ALI_REG(codec
, ALI_SPDIF_CTRL
+ 2));
761 wval
|= (0x0e << 8) | 0x08;
762 outw(wval
, ALI_REG(codec
, ALI_SPDIF_CTRL
+ 2));
764 bval
= inb(ALI_REG(codec
,ALI_SPDIF_CS
+ 3)) & 0xf0;
765 outb(bval
| 0x03, ALI_REG(codec
, ALI_SPDIF_CS
+ 3));
769 static unsigned int snd_ali_get_spdif_in_rate(struct snd_ali
*codec
)
774 bval
= inb(ALI_REG(codec
, ALI_SPDIF_CTRL
));
777 outb(bval
, ALI_REG(codec
, ALI_SPDIF_CTRL
));
779 snd_ali_detect_spdif_rate(codec
);
781 bval
= inb(ALI_REG(codec
, ALI_SPDIF_CS
+ 3));
785 case 0: dwRate
= 44100; break;
786 case 1: dwRate
= 48000; break;
787 case 2: dwRate
= 32000; break;
788 default: dwRate
= 0; break;
794 static void snd_ali_enable_spdif_in(struct snd_ali
*codec
)
798 dwVal
= inl(ALI_REG(codec
, ALI_GLOBAL_CONTROL
));
799 dwVal
|= ALI_SPDIF_IN_SUPPORT
;
800 outl(dwVal
, ALI_REG(codec
, ALI_GLOBAL_CONTROL
));
802 dwVal
= inb(ALI_REG(codec
, ALI_SPDIF_CTRL
));
804 outb(dwVal
, ALI_REG(codec
, ALI_SPDIF_CTRL
));
806 snd_ali_enable_special_channel(codec
, ALI_SPDIF_IN_CHANNEL
);
809 static void snd_ali_disable_spdif_in(struct snd_ali
*codec
)
813 dwVal
= inl(ALI_REG(codec
, ALI_GLOBAL_CONTROL
));
814 dwVal
&= ~ALI_SPDIF_IN_SUPPORT
;
815 outl(dwVal
, ALI_REG(codec
, ALI_GLOBAL_CONTROL
));
817 snd_ali_disable_special_channel(codec
, ALI_SPDIF_IN_CHANNEL
);
821 static void snd_ali_set_spdif_out_rate(struct snd_ali
*codec
, unsigned int rate
)
827 case 32000: dwRate
= 0x300; break;
828 case 48000: dwRate
= 0x200; break;
829 default: dwRate
= 0; break;
832 bVal
= inb(ALI_REG(codec
, ALI_SPDIF_CTRL
));
833 bVal
&= (unsigned char)(~(1<<6));
835 bVal
|= 0x80; /* select right */
836 outb(bVal
, ALI_REG(codec
, ALI_SPDIF_CTRL
));
837 outb(dwRate
| 0x20, ALI_REG(codec
, ALI_SPDIF_CS
+ 2));
839 bVal
&= ~0x80; /* select left */
840 outb(bVal
, ALI_REG(codec
, ALI_SPDIF_CTRL
));
841 outw(rate
| 0x10, ALI_REG(codec
, ALI_SPDIF_CS
+ 2));
844 static void snd_ali_enable_spdif_out(struct snd_ali
*codec
)
848 struct pci_dev
*pci_dev
;
850 pci_dev
= codec
->pci_m1533
;
853 pci_read_config_byte(pci_dev
, 0x61, &bVal
);
855 pci_write_config_byte(pci_dev
, 0x61, bVal
);
856 pci_read_config_byte(pci_dev
, 0x7d, &bVal
);
858 pci_write_config_byte(pci_dev
, 0x7d, bVal
);
860 pci_read_config_byte(pci_dev
, 0x7e, &bVal
);
863 pci_write_config_byte(pci_dev
, 0x7e, bVal
);
865 bVal
= inb(ALI_REG(codec
, ALI_SCTRL
));
866 outb(bVal
| ALI_SPDIF_OUT_ENABLE
, ALI_REG(codec
, ALI_SCTRL
));
868 bVal
= inb(ALI_REG(codec
, ALI_SPDIF_CTRL
));
869 outb(bVal
& ALI_SPDIF_OUT_CH_STATUS
, ALI_REG(codec
, ALI_SPDIF_CTRL
));
871 wVal
= inw(ALI_REG(codec
, ALI_GLOBAL_CONTROL
));
872 wVal
|= ALI_SPDIF_OUT_SEL_PCM
;
873 outw(wVal
, ALI_REG(codec
, ALI_GLOBAL_CONTROL
));
874 snd_ali_disable_special_channel(codec
, ALI_SPDIF_OUT_CHANNEL
);
877 static void snd_ali_enable_spdif_chnout(struct snd_ali
*codec
)
881 wVal
= inw(ALI_REG(codec
, ALI_GLOBAL_CONTROL
));
882 wVal
&= ~ALI_SPDIF_OUT_SEL_PCM
;
883 outw(wVal
, ALI_REG(codec
, ALI_GLOBAL_CONTROL
));
885 wVal = inw(ALI_REG(codec, ALI_SPDIF_CS));
886 if (flag & ALI_SPDIF_OUT_NON_PCM)
890 outw(wVal, ALI_REG(codec, ALI_SPDIF_CS));
892 snd_ali_enable_special_channel(codec
, ALI_SPDIF_OUT_CHANNEL
);
895 static void snd_ali_disable_spdif_chnout(struct snd_ali
*codec
)
899 wVal
= inw(ALI_REG(codec
, ALI_GLOBAL_CONTROL
));
900 wVal
|= ALI_SPDIF_OUT_SEL_PCM
;
901 outw(wVal
, ALI_REG(codec
, ALI_GLOBAL_CONTROL
));
903 snd_ali_enable_special_channel(codec
, ALI_SPDIF_OUT_CHANNEL
);
906 static void snd_ali_disable_spdif_out(struct snd_ali
*codec
)
910 bVal
= inb(ALI_REG(codec
, ALI_SCTRL
));
911 outb(bVal
& ~ALI_SPDIF_OUT_ENABLE
, ALI_REG(codec
, ALI_SCTRL
));
913 snd_ali_disable_spdif_chnout(codec
);
916 static void snd_ali_update_ptr(struct snd_ali
*codec
, int channel
)
918 struct snd_ali_voice
*pvoice
;
919 struct snd_pcm_runtime
*runtime
;
920 struct snd_ali_channel_control
*pchregs
;
921 unsigned int old
, mask
;
923 unsigned int temp
, cspf
;
926 pchregs
= &(codec
->chregs
);
928 /* check if interrupt occurred for channel */
929 old
= pchregs
->data
.aint
;
930 mask
= 1U << (channel
& 0x1f);
935 pvoice
= &codec
->synth
.voices
[channel
];
936 runtime
= pvoice
->substream
->runtime
;
939 spin_lock(&codec
->reg_lock
);
941 if (pvoice
->pcm
&& pvoice
->substream
) {
944 outb((u8
)(pvoice
->number
), ALI_REG(codec
, ALI_GC_CIR
));
945 temp
= inw(ALI_REG(codec
, ALI_CSO_ALPHA_FMS
+ 2));
946 cspf
= (inl(ALI_REG(codec
, ALI_CSPF
)) & mask
) == mask
;
948 if (pvoice
->running
) {
949 snd_ali_printk("update_ptr: cso=%4.4x cspf=%d.\n",
951 spin_unlock(&codec
->reg_lock
);
952 snd_pcm_period_elapsed(pvoice
->substream
);
953 spin_lock(&codec
->reg_lock
);
955 snd_ali_stop_voice(codec
, channel
);
956 snd_ali_disable_voice_irq(codec
, channel
);
958 } else if (codec
->synth
.voices
[channel
].synth
) {
959 /* synth interrupt */
960 } else if (codec
->synth
.voices
[channel
].midi
) {
963 /* unknown interrupt */
964 snd_ali_stop_voice(codec
, channel
);
965 snd_ali_disable_voice_irq(codec
, channel
);
967 spin_unlock(&codec
->reg_lock
);
968 outl(mask
,ALI_REG(codec
,pchregs
->regs
.aint
));
969 pchregs
->data
.aint
= old
& (~mask
);
972 static irqreturn_t
snd_ali_card_interrupt(int irq
, void *dev_id
)
974 struct snd_ali
*codec
= dev_id
;
976 unsigned int audio_int
;
977 struct snd_ali_channel_control
*pchregs
;
979 if (codec
== NULL
|| !codec
->hw_initialized
)
982 audio_int
= inl(ALI_REG(codec
, ALI_MISCINT
));
986 pchregs
= &(codec
->chregs
);
987 if (audio_int
& ADDRESS_IRQ
) {
988 /* get interrupt status for all channels */
989 pchregs
->data
.aint
= inl(ALI_REG(codec
, pchregs
->regs
.aint
));
990 for (channel
= 0; channel
< ALI_CHANNELS
; channel
++)
991 snd_ali_update_ptr(codec
, channel
);
993 outl((TARGET_REACHED
| MIXER_OVERFLOW
| MIXER_UNDERFLOW
),
994 ALI_REG(codec
, ALI_MISCINT
));
1000 static struct snd_ali_voice
*snd_ali_alloc_voice(struct snd_ali
* codec
,
1001 int type
, int rec
, int channel
)
1003 struct snd_ali_voice
*pvoice
;
1006 snd_ali_printk("alloc_voice: type=%d rec=%d\n", type
, rec
);
1008 spin_lock_irq(&codec
->voice_alloc
);
1009 if (type
== SNDRV_ALI_VOICE_TYPE_PCM
) {
1010 idx
= channel
> 0 ? snd_ali_alloc_pcm_channel(codec
, channel
) :
1011 snd_ali_find_free_channel(codec
,rec
);
1013 snd_printk(KERN_ERR
"ali_alloc_voice: err.\n");
1014 spin_unlock_irq(&codec
->voice_alloc
);
1017 pvoice
= &(codec
->synth
.voices
[idx
]);
1018 pvoice
->codec
= codec
;
1022 spin_unlock_irq(&codec
->voice_alloc
);
1025 spin_unlock_irq(&codec
->voice_alloc
);
1030 static void snd_ali_free_voice(struct snd_ali
* codec
,
1031 struct snd_ali_voice
*pvoice
)
1033 void (*private_free
)(void *);
1036 snd_ali_printk("free_voice: channel=%d\n",pvoice
->number
);
1037 if (pvoice
== NULL
|| !pvoice
->use
)
1039 snd_ali_clear_voices(codec
, pvoice
->number
, pvoice
->number
);
1040 spin_lock_irq(&codec
->voice_alloc
);
1041 private_free
= pvoice
->private_free
;
1042 private_data
= pvoice
->private_data
;
1043 pvoice
->private_free
= NULL
;
1044 pvoice
->private_data
= NULL
;
1046 snd_ali_free_channel_pcm(codec
, pvoice
->number
);
1047 pvoice
->use
= pvoice
->pcm
= pvoice
->synth
= 0;
1048 pvoice
->substream
= NULL
;
1049 spin_unlock_irq(&codec
->voice_alloc
);
1051 private_free(private_data
);
1055 static void snd_ali_clear_voices(struct snd_ali
*codec
,
1061 for (i
= v_min
; i
<= v_max
; i
++) {
1062 snd_ali_stop_voice(codec
, i
);
1063 snd_ali_disable_voice_irq(codec
, i
);
1067 static void snd_ali_write_voice_regs(struct snd_ali
*codec
,
1068 unsigned int Channel
,
1073 unsigned int ALPHA_FMS
,
1080 unsigned int ctlcmds
[4];
1082 outb((unsigned char)(Channel
& 0x001f), ALI_REG(codec
, ALI_GC_CIR
));
1084 ctlcmds
[0] = (CSO
<< 16) | (ALPHA_FMS
& 0x0000ffff);
1086 ctlcmds
[2] = (ESO
<< 16) | (DELTA
& 0x0ffff);
1087 ctlcmds
[3] = (GVSEL
<< 31) |
1088 ((PAN
& 0x0000007f) << 24) |
1089 ((VOL
& 0x000000ff) << 16) |
1090 ((CTRL
& 0x0000000f) << 12) |
1093 outb(Channel
, ALI_REG(codec
, ALI_GC_CIR
));
1095 outl(ctlcmds
[0], ALI_REG(codec
, ALI_CSO_ALPHA_FMS
));
1096 outl(ctlcmds
[1], ALI_REG(codec
, ALI_LBA
));
1097 outl(ctlcmds
[2], ALI_REG(codec
, ALI_ESO_DELTA
));
1098 outl(ctlcmds
[3], ALI_REG(codec
, ALI_GVSEL_PAN_VOC_CTRL_EC
));
1100 outl(0x30000000, ALI_REG(codec
, ALI_EBUF1
)); /* Still Mode */
1101 outl(0x30000000, ALI_REG(codec
, ALI_EBUF2
)); /* Still Mode */
1104 static unsigned int snd_ali_convert_rate(unsigned int rate
, int rec
)
1116 else if (rate
== 8000)
1118 else if (rate
== 48000)
1121 delta
= ((48000 << 12) / rate
) & 0x0000ffff;
1125 else if (rate
== 8000)
1127 else if (rate
== 48000)
1130 delta
= (((rate
<< 12) + rate
) / 48000) & 0x0000ffff;
1136 static unsigned int snd_ali_control_mode(struct snd_pcm_substream
*substream
)
1139 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1142 CTRL default: 8-bit (unsigned) mono, loop mode enabled
1145 if (snd_pcm_format_width(runtime
->format
) == 16)
1146 CTRL
|= 0x00000008; /* 16-bit data */
1147 if (!snd_pcm_format_unsigned(runtime
->format
))
1148 CTRL
|= 0x00000002; /* signed data */
1149 if (runtime
->channels
> 1)
1150 CTRL
|= 0x00000004; /* stereo data */
1158 static int snd_ali_trigger(struct snd_pcm_substream
*substream
,
1162 struct snd_ali
*codec
= snd_pcm_substream_chip(substream
);
1163 struct snd_pcm_substream
*s
;
1164 unsigned int what
, whati
, capture_flag
;
1165 struct snd_ali_voice
*pvoice
, *evoice
;
1170 case SNDRV_PCM_TRIGGER_START
:
1171 case SNDRV_PCM_TRIGGER_RESUME
:
1174 case SNDRV_PCM_TRIGGER_STOP
:
1175 case SNDRV_PCM_TRIGGER_SUSPEND
:
1182 what
= whati
= capture_flag
= 0;
1183 snd_pcm_group_for_each_entry(s
, substream
) {
1184 if ((struct snd_ali
*) snd_pcm_substream_chip(s
) == codec
) {
1185 pvoice
= s
->runtime
->private_data
;
1186 evoice
= pvoice
->extra
;
1187 what
|= 1 << (pvoice
->number
& 0x1f);
1189 whati
|= 1 << (pvoice
->number
& 0x1f);
1191 whati
|= 1 << (evoice
->number
& 0x1f);
1192 what
|= 1 << (evoice
->number
& 0x1f);
1195 pvoice
->running
= 1;
1197 evoice
->running
= 1;
1199 pvoice
->running
= 0;
1201 evoice
->running
= 0;
1203 snd_pcm_trigger_done(s
, substream
);
1208 spin_lock(&codec
->reg_lock
);
1210 outl(what
, ALI_REG(codec
, ALI_STOP
));
1211 val
= inl(ALI_REG(codec
, ALI_AINTEN
));
1216 outl(val
, ALI_REG(codec
, ALI_AINTEN
));
1218 outl(what
, ALI_REG(codec
, ALI_START
));
1219 snd_ali_printk("trigger: what=%xh whati=%xh\n", what
, whati
);
1220 spin_unlock(&codec
->reg_lock
);
1225 static int snd_ali_playback_hw_params(struct snd_pcm_substream
*substream
,
1226 struct snd_pcm_hw_params
*hw_params
)
1228 struct snd_ali
*codec
= snd_pcm_substream_chip(substream
);
1229 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1230 struct snd_ali_voice
*pvoice
= runtime
->private_data
;
1231 struct snd_ali_voice
*evoice
= pvoice
->extra
;
1234 err
= snd_pcm_lib_malloc_pages(substream
,
1235 params_buffer_bytes(hw_params
));
1239 /* voice management */
1241 if (params_buffer_size(hw_params
) / 2 !=
1242 params_period_size(hw_params
)) {
1244 evoice
= snd_ali_alloc_voice(codec
,
1245 SNDRV_ALI_VOICE_TYPE_PCM
,
1249 pvoice
->extra
= evoice
;
1250 evoice
->substream
= substream
;
1254 snd_ali_free_voice(codec
, evoice
);
1255 pvoice
->extra
= evoice
= NULL
;
1262 static int snd_ali_playback_hw_free(struct snd_pcm_substream
*substream
)
1264 struct snd_ali
*codec
= snd_pcm_substream_chip(substream
);
1265 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1266 struct snd_ali_voice
*pvoice
= runtime
->private_data
;
1267 struct snd_ali_voice
*evoice
= pvoice
? pvoice
->extra
: NULL
;
1269 snd_pcm_lib_free_pages(substream
);
1271 snd_ali_free_voice(codec
, evoice
);
1272 pvoice
->extra
= NULL
;
1277 static int snd_ali_hw_params(struct snd_pcm_substream
*substream
,
1278 struct snd_pcm_hw_params
*hw_params
)
1280 return snd_pcm_lib_malloc_pages(substream
,
1281 params_buffer_bytes(hw_params
));
1284 static int snd_ali_hw_free(struct snd_pcm_substream
*substream
)
1286 return snd_pcm_lib_free_pages(substream
);
1289 static int snd_ali_playback_prepare(struct snd_pcm_substream
*substream
)
1291 struct snd_ali
*codec
= snd_pcm_substream_chip(substream
);
1292 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1293 struct snd_ali_voice
*pvoice
= runtime
->private_data
;
1294 struct snd_ali_voice
*evoice
= pvoice
->extra
;
1305 snd_ali_printk("playback_prepare ...\n");
1307 spin_lock_irq(&codec
->reg_lock
);
1309 /* set Delta (rate) value */
1310 Delta
= snd_ali_convert_rate(runtime
->rate
, 0);
1312 if (pvoice
->number
== ALI_SPDIF_IN_CHANNEL
||
1313 pvoice
->number
== ALI_PCM_IN_CHANNEL
)
1314 snd_ali_disable_special_channel(codec
, pvoice
->number
);
1315 else if (codec
->spdif_support
&&
1316 (inl(ALI_REG(codec
, ALI_GLOBAL_CONTROL
)) &
1317 ALI_SPDIF_OUT_CH_ENABLE
)
1318 && pvoice
->number
== ALI_SPDIF_OUT_CHANNEL
) {
1319 snd_ali_set_spdif_out_rate(codec
, runtime
->rate
);
1323 /* set Loop Back Address */
1324 LBA
= runtime
->dma_addr
;
1326 /* set interrupt count size */
1327 pvoice
->count
= runtime
->period_size
;
1329 /* set target ESO for channel */
1330 pvoice
->eso
= runtime
->buffer_size
;
1332 snd_ali_printk("playback_prepare: eso=%xh count=%xh\n",
1333 pvoice
->eso
, pvoice
->count
);
1335 /* set ESO to capture first MIDLP interrupt */
1336 ESO
= pvoice
->eso
-1;
1338 CTRL
= snd_ali_control_mode(substream
);
1344 snd_ali_printk("playback_prepare:\n");
1345 snd_ali_printk("ch=%d, Rate=%d Delta=%xh,GVSEL=%xh,PAN=%xh,CTRL=%xh\n",
1346 pvoice
->number
,runtime
->rate
,Delta
,GVSEL
,PAN
,CTRL
);
1347 snd_ali_write_voice_regs(codec
,
1360 evoice
->count
= pvoice
->count
;
1361 evoice
->eso
= pvoice
->count
<< 1;
1362 ESO
= evoice
->eso
- 1;
1363 snd_ali_write_voice_regs(codec
,
1376 spin_unlock_irq(&codec
->reg_lock
);
1381 static int snd_ali_prepare(struct snd_pcm_substream
*substream
)
1383 struct snd_ali
*codec
= snd_pcm_substream_chip(substream
);
1384 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1385 struct snd_ali_voice
*pvoice
= runtime
->private_data
;
1396 spin_lock_irq(&codec
->reg_lock
);
1398 snd_ali_printk("ali_prepare...\n");
1400 snd_ali_enable_special_channel(codec
,pvoice
->number
);
1402 Delta
= (pvoice
->number
== ALI_MODEM_IN_CHANNEL
||
1403 pvoice
->number
== ALI_MODEM_OUT_CHANNEL
) ?
1404 0x1000 : snd_ali_convert_rate(runtime
->rate
, pvoice
->mode
);
1406 /* Prepare capture intr channel */
1407 if (pvoice
->number
== ALI_SPDIF_IN_CHANNEL
) {
1411 spin_unlock_irq(&codec
->reg_lock
);
1412 if (codec
->revision
!= ALI_5451_V02
)
1415 rate
= snd_ali_get_spdif_in_rate(codec
);
1417 snd_printk(KERN_WARNING
"ali_capture_preapre: "
1418 "spdif rate detect err!\n");
1421 spin_lock_irq(&codec
->reg_lock
);
1422 bValue
= inb(ALI_REG(codec
,ALI_SPDIF_CTRL
));
1423 if (bValue
& 0x10) {
1424 outb(bValue
,ALI_REG(codec
,ALI_SPDIF_CTRL
));
1425 printk(KERN_WARNING
"clear SPDIF parity error flag.\n");
1429 Delta
= ((rate
<< 12) / runtime
->rate
) & 0x00ffff;
1432 /* set target ESO for channel */
1433 pvoice
->eso
= runtime
->buffer_size
;
1435 /* set interrupt count size */
1436 pvoice
->count
= runtime
->period_size
;
1438 /* set Loop Back Address */
1439 LBA
= runtime
->dma_addr
;
1441 /* set ESO to capture first MIDLP interrupt */
1442 ESO
= pvoice
->eso
- 1;
1443 CTRL
= snd_ali_control_mode(substream
);
1449 snd_ali_write_voice_regs( codec
,
1462 spin_unlock_irq(&codec
->reg_lock
);
1468 static snd_pcm_uframes_t
1469 snd_ali_playback_pointer(struct snd_pcm_substream
*substream
)
1471 struct snd_ali
*codec
= snd_pcm_substream_chip(substream
);
1472 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1473 struct snd_ali_voice
*pvoice
= runtime
->private_data
;
1476 spin_lock(&codec
->reg_lock
);
1477 if (!pvoice
->running
) {
1478 spin_unlock(&codec
->reg_lock
);
1481 outb(pvoice
->number
, ALI_REG(codec
, ALI_GC_CIR
));
1482 cso
= inw(ALI_REG(codec
, ALI_CSO_ALPHA_FMS
+ 2));
1483 spin_unlock(&codec
->reg_lock
);
1484 snd_ali_printk("playback pointer returned cso=%xh.\n", cso
);
1490 static snd_pcm_uframes_t
snd_ali_pointer(struct snd_pcm_substream
*substream
)
1492 struct snd_ali
*codec
= snd_pcm_substream_chip(substream
);
1493 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1494 struct snd_ali_voice
*pvoice
= runtime
->private_data
;
1497 spin_lock(&codec
->reg_lock
);
1498 if (!pvoice
->running
) {
1499 spin_unlock_irq(&codec
->reg_lock
);
1502 outb(pvoice
->number
, ALI_REG(codec
, ALI_GC_CIR
));
1503 cso
= inw(ALI_REG(codec
, ALI_CSO_ALPHA_FMS
+ 2));
1504 spin_unlock(&codec
->reg_lock
);
1509 static struct snd_pcm_hardware snd_ali_playback
=
1511 .info
= (SNDRV_PCM_INFO_MMAP
| SNDRV_PCM_INFO_INTERLEAVED
|
1512 SNDRV_PCM_INFO_BLOCK_TRANSFER
|
1513 SNDRV_PCM_INFO_MMAP_VALID
|
1514 SNDRV_PCM_INFO_RESUME
|
1515 SNDRV_PCM_INFO_SYNC_START
),
1516 .formats
= (SNDRV_PCM_FMTBIT_U8
| SNDRV_PCM_FMTBIT_S16_LE
|
1517 SNDRV_PCM_FMTBIT_S8
| SNDRV_PCM_FMTBIT_U16_LE
),
1518 .rates
= SNDRV_PCM_RATE_CONTINUOUS
| SNDRV_PCM_RATE_8000_48000
,
1523 .buffer_bytes_max
= (256*1024),
1524 .period_bytes_min
= 64,
1525 .period_bytes_max
= (256*1024),
1527 .periods_max
= 1024,
1532 * Capture support device description
1535 static struct snd_pcm_hardware snd_ali_capture
=
1537 .info
= (SNDRV_PCM_INFO_MMAP
| SNDRV_PCM_INFO_INTERLEAVED
|
1538 SNDRV_PCM_INFO_BLOCK_TRANSFER
|
1539 SNDRV_PCM_INFO_MMAP_VALID
|
1540 SNDRV_PCM_INFO_RESUME
|
1541 SNDRV_PCM_INFO_SYNC_START
),
1542 .formats
= (SNDRV_PCM_FMTBIT_U8
| SNDRV_PCM_FMTBIT_S16_LE
|
1543 SNDRV_PCM_FMTBIT_S8
| SNDRV_PCM_FMTBIT_U16_LE
),
1544 .rates
= SNDRV_PCM_RATE_CONTINUOUS
| SNDRV_PCM_RATE_8000_48000
,
1549 .buffer_bytes_max
= (128*1024),
1550 .period_bytes_min
= 64,
1551 .period_bytes_max
= (128*1024),
1553 .periods_max
= 1024,
1557 static void snd_ali_pcm_free_substream(struct snd_pcm_runtime
*runtime
)
1559 struct snd_ali_voice
*pvoice
= runtime
->private_data
;
1560 struct snd_ali
*codec
;
1563 codec
= pvoice
->codec
;
1564 snd_ali_free_voice(pvoice
->codec
, pvoice
);
1568 static int snd_ali_open(struct snd_pcm_substream
*substream
, int rec
,
1569 int channel
, struct snd_pcm_hardware
*phw
)
1571 struct snd_ali
*codec
= snd_pcm_substream_chip(substream
);
1572 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
1573 struct snd_ali_voice
*pvoice
;
1575 pvoice
= snd_ali_alloc_voice(codec
, SNDRV_ALI_VOICE_TYPE_PCM
, rec
,
1580 pvoice
->substream
= substream
;
1581 runtime
->private_data
= pvoice
;
1582 runtime
->private_free
= snd_ali_pcm_free_substream
;
1585 snd_pcm_set_sync(substream
);
1586 snd_pcm_hw_constraint_minmax(runtime
, SNDRV_PCM_HW_PARAM_BUFFER_SIZE
,
1591 static int snd_ali_playback_open(struct snd_pcm_substream
*substream
)
1593 return snd_ali_open(substream
, 0, -1, &snd_ali_playback
);
1596 static int snd_ali_capture_open(struct snd_pcm_substream
*substream
)
1598 return snd_ali_open(substream
, 1, -1, &snd_ali_capture
);
1601 static int snd_ali_playback_close(struct snd_pcm_substream
*substream
)
1606 static int snd_ali_close(struct snd_pcm_substream
*substream
)
1608 struct snd_ali
*codec
= snd_pcm_substream_chip(substream
);
1609 struct snd_ali_voice
*pvoice
= substream
->runtime
->private_data
;
1611 snd_ali_disable_special_channel(codec
,pvoice
->number
);
1616 static struct snd_pcm_ops snd_ali_playback_ops
= {
1617 .open
= snd_ali_playback_open
,
1618 .close
= snd_ali_playback_close
,
1619 .ioctl
= snd_pcm_lib_ioctl
,
1620 .hw_params
= snd_ali_playback_hw_params
,
1621 .hw_free
= snd_ali_playback_hw_free
,
1622 .prepare
= snd_ali_playback_prepare
,
1623 .trigger
= snd_ali_trigger
,
1624 .pointer
= snd_ali_playback_pointer
,
1627 static struct snd_pcm_ops snd_ali_capture_ops
= {
1628 .open
= snd_ali_capture_open
,
1629 .close
= snd_ali_close
,
1630 .ioctl
= snd_pcm_lib_ioctl
,
1631 .hw_params
= snd_ali_hw_params
,
1632 .hw_free
= snd_ali_hw_free
,
1633 .prepare
= snd_ali_prepare
,
1634 .trigger
= snd_ali_trigger
,
1635 .pointer
= snd_ali_pointer
,
1642 static int snd_ali_modem_hw_params(struct snd_pcm_substream
*substream
,
1643 struct snd_pcm_hw_params
*hw_params
)
1645 struct snd_ali
*chip
= snd_pcm_substream_chip(substream
);
1646 unsigned int modem_num
= chip
->num_of_codecs
- 1;
1647 snd_ac97_write(chip
->ac97
[modem_num
], AC97_LINE1_RATE
,
1648 params_rate(hw_params
));
1649 snd_ac97_write(chip
->ac97
[modem_num
], AC97_LINE1_LEVEL
, 0);
1650 return snd_ali_hw_params(substream
, hw_params
);
1653 static struct snd_pcm_hardware snd_ali_modem
=
1655 .info
= (SNDRV_PCM_INFO_MMAP
| SNDRV_PCM_INFO_INTERLEAVED
|
1656 SNDRV_PCM_INFO_BLOCK_TRANSFER
|
1657 SNDRV_PCM_INFO_MMAP_VALID
|
1658 SNDRV_PCM_INFO_RESUME
|
1659 SNDRV_PCM_INFO_SYNC_START
),
1660 .formats
= SNDRV_PCM_FMTBIT_S16_LE
,
1661 .rates
= (SNDRV_PCM_RATE_KNOT
| SNDRV_PCM_RATE_8000
|
1662 SNDRV_PCM_RATE_16000
),
1667 .buffer_bytes_max
= (256*1024),
1668 .period_bytes_min
= 64,
1669 .period_bytes_max
= (256*1024),
1671 .periods_max
= 1024,
1675 static int snd_ali_modem_open(struct snd_pcm_substream
*substream
, int rec
,
1678 static unsigned int rates
[] = {8000, 9600, 12000, 16000};
1679 static struct snd_pcm_hw_constraint_list hw_constraint_rates
= {
1680 .count
= ARRAY_SIZE(rates
),
1684 int err
= snd_ali_open(substream
, rec
, channel
, &snd_ali_modem
);
1688 return snd_pcm_hw_constraint_list(substream
->runtime
, 0,
1689 SNDRV_PCM_HW_PARAM_RATE
, &hw_constraint_rates
);
1692 static int snd_ali_modem_playback_open(struct snd_pcm_substream
*substream
)
1694 return snd_ali_modem_open(substream
, 0, ALI_MODEM_OUT_CHANNEL
);
1697 static int snd_ali_modem_capture_open(struct snd_pcm_substream
*substream
)
1699 return snd_ali_modem_open(substream
, 1, ALI_MODEM_IN_CHANNEL
);
1702 static struct snd_pcm_ops snd_ali_modem_playback_ops
= {
1703 .open
= snd_ali_modem_playback_open
,
1704 .close
= snd_ali_close
,
1705 .ioctl
= snd_pcm_lib_ioctl
,
1706 .hw_params
= snd_ali_modem_hw_params
,
1707 .hw_free
= snd_ali_hw_free
,
1708 .prepare
= snd_ali_prepare
,
1709 .trigger
= snd_ali_trigger
,
1710 .pointer
= snd_ali_pointer
,
1713 static struct snd_pcm_ops snd_ali_modem_capture_ops
= {
1714 .open
= snd_ali_modem_capture_open
,
1715 .close
= snd_ali_close
,
1716 .ioctl
= snd_pcm_lib_ioctl
,
1717 .hw_params
= snd_ali_modem_hw_params
,
1718 .hw_free
= snd_ali_hw_free
,
1719 .prepare
= snd_ali_prepare
,
1720 .trigger
= snd_ali_trigger
,
1721 .pointer
= snd_ali_pointer
,
1725 struct ali_pcm_description
{
1727 unsigned int playback_num
;
1728 unsigned int capture_num
;
1729 struct snd_pcm_ops
*playback_ops
;
1730 struct snd_pcm_ops
*capture_ops
;
1731 unsigned short class;
1735 static void snd_ali_pcm_free(struct snd_pcm
*pcm
)
1737 struct snd_ali
*codec
= pcm
->private_data
;
1738 codec
->pcm
[pcm
->device
] = NULL
;
1742 static int __devinit
snd_ali_pcm(struct snd_ali
* codec
, int device
,
1743 struct ali_pcm_description
*desc
)
1745 struct snd_pcm
*pcm
;
1748 err
= snd_pcm_new(codec
->card
, desc
->name
, device
,
1749 desc
->playback_num
, desc
->capture_num
, &pcm
);
1751 snd_printk(KERN_ERR
"snd_ali_pcm: err called snd_pcm_new.\n");
1754 pcm
->private_data
= codec
;
1755 pcm
->private_free
= snd_ali_pcm_free
;
1756 if (desc
->playback_ops
)
1757 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_PLAYBACK
,
1758 desc
->playback_ops
);
1759 if (desc
->capture_ops
)
1760 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_CAPTURE
,
1763 snd_pcm_lib_preallocate_pages_for_all(pcm
, SNDRV_DMA_TYPE_DEV
,
1764 snd_dma_pci_data(codec
->pci
),
1767 pcm
->info_flags
= 0;
1768 pcm
->dev_class
= desc
->class;
1769 pcm
->dev_subclass
= SNDRV_PCM_SUBCLASS_GENERIC_MIX
;
1770 strcpy(pcm
->name
, desc
->name
);
1771 codec
->pcm
[0] = pcm
;
1775 static struct ali_pcm_description ali_pcms
[] = {
1776 { .name
= "ALI 5451",
1777 .playback_num
= ALI_CHANNELS
,
1779 .playback_ops
= &snd_ali_playback_ops
,
1780 .capture_ops
= &snd_ali_capture_ops
1782 { .name
= "ALI 5451 modem",
1785 .playback_ops
= &snd_ali_modem_playback_ops
,
1786 .capture_ops
= &snd_ali_modem_capture_ops
,
1787 .class = SNDRV_PCM_CLASS_MODEM
1791 static int __devinit
snd_ali_build_pcms(struct snd_ali
*codec
)
1794 for (i
= 0; i
< codec
->num_of_codecs
&& i
< ARRAY_SIZE(ali_pcms
); i
++) {
1795 err
= snd_ali_pcm(codec
, i
, &ali_pcms
[i
]);
1803 #define ALI5451_SPDIF(xname, xindex, value) \
1804 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex,\
1805 .info = snd_ali5451_spdif_info, .get = snd_ali5451_spdif_get, \
1806 .put = snd_ali5451_spdif_put, .private_value = value}
1808 static int snd_ali5451_spdif_info(struct snd_kcontrol
*kcontrol
,
1809 struct snd_ctl_elem_info
*uinfo
)
1811 uinfo
->type
= SNDRV_CTL_ELEM_TYPE_BOOLEAN
;
1813 uinfo
->value
.integer
.min
= 0;
1814 uinfo
->value
.integer
.max
= 1;
1818 static int snd_ali5451_spdif_get(struct snd_kcontrol
*kcontrol
,
1819 struct snd_ctl_elem_value
*ucontrol
)
1821 struct snd_ali
*codec
= kcontrol
->private_data
;
1822 unsigned int enable
;
1824 enable
= ucontrol
->value
.integer
.value
[0] ? 1 : 0;
1826 spin_lock_irq(&codec
->reg_lock
);
1827 switch (kcontrol
->private_value
) {
1829 enable
= (codec
->spdif_mask
& 0x02) ? 1 : 0;
1832 enable
= ((codec
->spdif_mask
& 0x02) &&
1833 (codec
->spdif_mask
& 0x04)) ? 1 : 0;
1836 enable
= (codec
->spdif_mask
& 0x01) ? 1 : 0;
1841 ucontrol
->value
.integer
.value
[0] = enable
;
1842 spin_unlock_irq(&codec
->reg_lock
);
1846 static int snd_ali5451_spdif_put(struct snd_kcontrol
*kcontrol
,
1847 struct snd_ctl_elem_value
*ucontrol
)
1849 struct snd_ali
*codec
= kcontrol
->private_data
;
1850 unsigned int change
= 0, enable
= 0;
1852 enable
= ucontrol
->value
.integer
.value
[0] ? 1 : 0;
1854 spin_lock_irq(&codec
->reg_lock
);
1855 switch (kcontrol
->private_value
) {
1857 change
= (codec
->spdif_mask
& 0x02) ? 1 : 0;
1858 change
= change
^ enable
;
1861 codec
->spdif_mask
|= 0x02;
1862 snd_ali_enable_spdif_out(codec
);
1864 codec
->spdif_mask
&= ~(0x02);
1865 codec
->spdif_mask
&= ~(0x04);
1866 snd_ali_disable_spdif_out(codec
);
1871 change
= (codec
->spdif_mask
& 0x04) ? 1 : 0;
1872 change
= change
^ enable
;
1873 if (change
&& (codec
->spdif_mask
& 0x02)) {
1875 codec
->spdif_mask
|= 0x04;
1876 snd_ali_enable_spdif_chnout(codec
);
1878 codec
->spdif_mask
&= ~(0x04);
1879 snd_ali_disable_spdif_chnout(codec
);
1884 change
= (codec
->spdif_mask
& 0x01) ? 1 : 0;
1885 change
= change
^ enable
;
1888 codec
->spdif_mask
|= 0x01;
1889 snd_ali_enable_spdif_in(codec
);
1891 codec
->spdif_mask
&= ~(0x01);
1892 snd_ali_disable_spdif_in(codec
);
1899 spin_unlock_irq(&codec
->reg_lock
);
1904 static struct snd_kcontrol_new snd_ali5451_mixer_spdif
[] __devinitdata
= {
1905 /* spdif aplayback switch */
1906 /* FIXME: "IEC958 Playback Switch" may conflict with one on ac97_codec */
1907 ALI5451_SPDIF(SNDRV_CTL_NAME_IEC958("Output ",NONE
,SWITCH
), 0, 0),
1908 /* spdif out to spdif channel */
1909 ALI5451_SPDIF(SNDRV_CTL_NAME_IEC958("Channel Output ",NONE
,SWITCH
), 0, 1),
1910 /* spdif in from spdif channel */
1911 ALI5451_SPDIF(SNDRV_CTL_NAME_IEC958("",CAPTURE
,SWITCH
), 0, 2)
1914 static int __devinit
snd_ali_mixer(struct snd_ali
* codec
)
1916 struct snd_ac97_template ac97
;
1919 static struct snd_ac97_bus_ops ops
= {
1920 .write
= snd_ali_codec_write
,
1921 .read
= snd_ali_codec_read
,
1924 err
= snd_ac97_bus(codec
->card
, 0, &ops
, codec
, &codec
->ac97_bus
);
1928 memset(&ac97
, 0, sizeof(ac97
));
1929 ac97
.private_data
= codec
;
1931 for (i
= 0; i
< codec
->num_of_codecs
; i
++) {
1933 err
= snd_ac97_mixer(codec
->ac97_bus
, &ac97
, &codec
->ac97
[i
]);
1936 "ali mixer %d creating error.\n", i
);
1939 codec
->num_of_codecs
= 1;
1944 if (codec
->spdif_support
) {
1945 for (idx
= 0; idx
< ARRAY_SIZE(snd_ali5451_mixer_spdif
); idx
++) {
1946 err
= snd_ctl_add(codec
->card
,
1947 snd_ctl_new1(&snd_ali5451_mixer_spdif
[idx
], codec
));
1956 static int ali_suspend(struct pci_dev
*pci
, pm_message_t state
)
1958 struct snd_card
*card
= pci_get_drvdata(pci
);
1959 struct snd_ali
*chip
= card
->private_data
;
1960 struct snd_ali_image
*im
;
1967 snd_power_change_state(card
, SNDRV_CTL_POWER_D3hot
);
1968 for (i
= 0; i
< chip
->num_of_codecs
; i
++) {
1969 snd_pcm_suspend_all(chip
->pcm
[i
]);
1970 snd_ac97_suspend(chip
->ac97
[i
]);
1973 spin_lock_irq(&chip
->reg_lock
);
1975 im
->regs
[ALI_MISCINT
>> 2] = inl(ALI_REG(chip
, ALI_MISCINT
));
1976 /* im->regs[ALI_START >> 2] = inl(ALI_REG(chip, ALI_START)); */
1977 im
->regs
[ALI_STOP
>> 2] = inl(ALI_REG(chip
, ALI_STOP
));
1979 /* disable all IRQ bits */
1980 outl(0, ALI_REG(chip
, ALI_MISCINT
));
1982 for (i
= 0; i
< ALI_GLOBAL_REGS
; i
++) {
1983 if ((i
*4 == ALI_MISCINT
) || (i
*4 == ALI_STOP
))
1985 im
->regs
[i
] = inl(ALI_REG(chip
, i
*4));
1988 for (i
= 0; i
< ALI_CHANNELS
; i
++) {
1989 outb(i
, ALI_REG(chip
, ALI_GC_CIR
));
1990 for (j
= 0; j
< ALI_CHANNEL_REGS
; j
++)
1991 im
->channel_regs
[i
][j
] = inl(ALI_REG(chip
, j
*4 + 0xe0));
1994 /* stop all HW channel */
1995 outl(0xffffffff, ALI_REG(chip
, ALI_STOP
));
1997 spin_unlock_irq(&chip
->reg_lock
);
1999 pci_disable_device(pci
);
2000 pci_save_state(pci
);
2001 pci_set_power_state(pci
, pci_choose_state(pci
, state
));
2005 static int ali_resume(struct pci_dev
*pci
)
2007 struct snd_card
*card
= pci_get_drvdata(pci
);
2008 struct snd_ali
*chip
= card
->private_data
;
2009 struct snd_ali_image
*im
;
2016 pci_set_power_state(pci
, PCI_D0
);
2017 pci_restore_state(pci
);
2018 if (pci_enable_device(pci
) < 0) {
2019 printk(KERN_ERR
"ali5451: pci_enable_device failed, "
2020 "disabling device\n");
2021 snd_card_disconnect(card
);
2024 pci_set_master(pci
);
2026 spin_lock_irq(&chip
->reg_lock
);
2028 for (i
= 0; i
< ALI_CHANNELS
; i
++) {
2029 outb(i
, ALI_REG(chip
, ALI_GC_CIR
));
2030 for (j
= 0; j
< ALI_CHANNEL_REGS
; j
++)
2031 outl(im
->channel_regs
[i
][j
], ALI_REG(chip
, j
*4 + 0xe0));
2034 for (i
= 0; i
< ALI_GLOBAL_REGS
; i
++) {
2035 if ((i
*4 == ALI_MISCINT
) || (i
*4 == ALI_STOP
) ||
2038 outl(im
->regs
[i
], ALI_REG(chip
, i
*4));
2041 /* start HW channel */
2042 outl(im
->regs
[ALI_START
>> 2], ALI_REG(chip
, ALI_START
));
2043 /* restore IRQ enable bits */
2044 outl(im
->regs
[ALI_MISCINT
>> 2], ALI_REG(chip
, ALI_MISCINT
));
2046 spin_unlock_irq(&chip
->reg_lock
);
2048 for (i
= 0 ; i
< chip
->num_of_codecs
; i
++)
2049 snd_ac97_resume(chip
->ac97
[i
]);
2051 snd_power_change_state(card
, SNDRV_CTL_POWER_D0
);
2054 #endif /* CONFIG_PM */
2056 static int snd_ali_free(struct snd_ali
* codec
)
2058 if (codec
->hw_initialized
)
2059 snd_ali_disable_address_interrupt(codec
);
2060 if (codec
->irq
>= 0) {
2061 synchronize_irq(codec
->irq
);
2062 free_irq(codec
->irq
, codec
);
2065 pci_release_regions(codec
->pci
);
2066 pci_disable_device(codec
->pci
);
2068 kfree(codec
->image
);
2070 pci_dev_put(codec
->pci_m1533
);
2071 pci_dev_put(codec
->pci_m7101
);
2076 static int snd_ali_chip_init(struct snd_ali
*codec
)
2078 unsigned int legacy
;
2080 struct pci_dev
*pci_dev
;
2082 snd_ali_printk("chip initializing ... \n");
2084 if (snd_ali_reset_5451(codec
)) {
2085 snd_printk(KERN_ERR
"ali_chip_init: reset 5451 error.\n");
2089 if (codec
->revision
== ALI_5451_V02
) {
2090 pci_dev
= codec
->pci_m1533
;
2091 pci_read_config_byte(pci_dev
, 0x59, &temp
);
2093 pci_write_config_byte(pci_dev
, 0x59, temp
);
2095 pci_dev
= codec
->pci_m7101
;
2096 pci_read_config_byte(pci_dev
, 0xb8, &temp
);
2098 pci_write_config_byte(pci_dev
, 0xB8, temp
);
2101 pci_read_config_dword(codec
->pci
, 0x44, &legacy
);
2102 legacy
&= 0xff00ff00;
2103 legacy
|= 0x000800aa;
2104 pci_write_config_dword(codec
->pci
, 0x44, legacy
);
2106 outl(0x80000001, ALI_REG(codec
, ALI_GLOBAL_CONTROL
));
2107 outl(0x00000000, ALI_REG(codec
, ALI_AINTEN
));
2108 outl(0xffffffff, ALI_REG(codec
, ALI_AINT
));
2109 outl(0x00000000, ALI_REG(codec
, ALI_VOLUME
));
2110 outb(0x10, ALI_REG(codec
, ALI_MPUR2
));
2112 codec
->ac97_ext_id
= snd_ali_codec_peek(codec
, 0, AC97_EXTENDED_ID
);
2113 codec
->ac97_ext_status
= snd_ali_codec_peek(codec
, 0,
2114 AC97_EXTENDED_STATUS
);
2115 if (codec
->spdif_support
) {
2116 snd_ali_enable_spdif_out(codec
);
2117 codec
->spdif_mask
= 0x00000002;
2120 codec
->num_of_codecs
= 1;
2122 /* secondary codec - modem */
2123 if (inl(ALI_REG(codec
, ALI_SCTRL
)) & ALI_SCTRL_CODEC2_READY
) {
2124 codec
->num_of_codecs
++;
2125 outl(inl(ALI_REG(codec
, ALI_SCTRL
)) |
2126 (ALI_SCTRL_LINE_IN2
| ALI_SCTRL_GPIO_IN2
|
2127 ALI_SCTRL_LINE_OUT_EN
),
2128 ALI_REG(codec
, ALI_SCTRL
));
2131 snd_ali_printk("chip initialize succeed.\n");
2136 /* proc for register dump */
2137 static void snd_ali_proc_read(struct snd_info_entry
*entry
,
2138 struct snd_info_buffer
*buf
)
2140 struct snd_ali
*codec
= entry
->private_data
;
2142 for (i
= 0; i
< 256 ; i
+= 4)
2143 snd_iprintf(buf
, "%02x: %08x\n", i
, inl(ALI_REG(codec
, i
)));
2146 static void __devinit
snd_ali_proc_init(struct snd_ali
*codec
)
2148 struct snd_info_entry
*entry
;
2149 if (!snd_card_proc_new(codec
->card
, "ali5451", &entry
))
2150 snd_info_set_text_ops(entry
, codec
, snd_ali_proc_read
);
2153 static int __devinit
snd_ali_resources(struct snd_ali
*codec
)
2157 snd_ali_printk("resouces allocation ...\n");
2158 err
= pci_request_regions(codec
->pci
, "ALI 5451");
2161 codec
->port
= pci_resource_start(codec
->pci
, 0);
2163 if (request_irq(codec
->pci
->irq
, snd_ali_card_interrupt
,
2164 IRQF_SHARED
, "ALI 5451", codec
)) {
2165 snd_printk(KERN_ERR
"Unable to request irq.\n");
2168 codec
->irq
= codec
->pci
->irq
;
2169 snd_ali_printk("resouces allocated.\n");
2172 static int snd_ali_dev_free(struct snd_device
*device
)
2174 struct snd_ali
*codec
= device
->device_data
;
2175 snd_ali_free(codec
);
2179 static int __devinit
snd_ali_create(struct snd_card
*card
,
2180 struct pci_dev
*pci
,
2183 struct snd_ali
** r_ali
)
2185 struct snd_ali
*codec
;
2187 unsigned short cmdw
;
2188 static struct snd_device_ops ops
= {
2189 .dev_free
= snd_ali_dev_free
,
2194 snd_ali_printk("creating ...\n");
2196 /* enable PCI device */
2197 err
= pci_enable_device(pci
);
2200 /* check, if we can restrict PCI DMA transfers to 31 bits */
2201 if (pci_set_dma_mask(pci
, DMA_31BIT_MASK
) < 0 ||
2202 pci_set_consistent_dma_mask(pci
, DMA_31BIT_MASK
) < 0) {
2203 snd_printk(KERN_ERR
"architecture does not support "
2204 "31bit PCI busmaster DMA\n");
2205 pci_disable_device(pci
);
2209 codec
= kzalloc(sizeof(*codec
), GFP_KERNEL
);
2211 pci_disable_device(pci
);
2215 spin_lock_init(&codec
->reg_lock
);
2216 spin_lock_init(&codec
->voice_alloc
);
2221 codec
->revision
= pci
->revision
;
2222 codec
->spdif_support
= spdif_support
;
2224 if (pcm_streams
< 1)
2226 if (pcm_streams
> 32)
2229 pci_set_master(pci
);
2230 pci_read_config_word(pci
, PCI_COMMAND
, &cmdw
);
2231 if ((cmdw
& PCI_COMMAND_IO
) != PCI_COMMAND_IO
) {
2232 cmdw
|= PCI_COMMAND_IO
;
2233 pci_write_config_word(pci
, PCI_COMMAND
, cmdw
);
2235 pci_set_master(pci
);
2237 if (snd_ali_resources(codec
)) {
2238 snd_ali_free(codec
);
2242 synchronize_irq(pci
->irq
);
2244 codec
->synth
.chmap
= 0;
2245 codec
->synth
.chcnt
= 0;
2246 codec
->spdif_mask
= 0;
2247 codec
->synth
.synthcount
= 0;
2249 if (codec
->revision
== ALI_5451_V02
)
2250 codec
->chregs
.regs
.ac97read
= ALI_AC97_WRITE
;
2252 codec
->chregs
.regs
.ac97read
= ALI_AC97_READ
;
2253 codec
->chregs
.regs
.ac97write
= ALI_AC97_WRITE
;
2255 codec
->chregs
.regs
.start
= ALI_START
;
2256 codec
->chregs
.regs
.stop
= ALI_STOP
;
2257 codec
->chregs
.regs
.aint
= ALI_AINT
;
2258 codec
->chregs
.regs
.ainten
= ALI_AINTEN
;
2260 codec
->chregs
.data
.start
= 0x00;
2261 codec
->chregs
.data
.stop
= 0x00;
2262 codec
->chregs
.data
.aint
= 0x00;
2263 codec
->chregs
.data
.ainten
= 0x00;
2265 /* M1533: southbridge */
2266 codec
->pci_m1533
= pci_get_device(0x10b9, 0x1533, NULL
);
2267 if (!codec
->pci_m1533
) {
2268 snd_printk(KERN_ERR
"ali5451: cannot find ALi 1533 chip.\n");
2269 snd_ali_free(codec
);
2272 /* M7101: power management */
2273 codec
->pci_m7101
= pci_get_device(0x10b9, 0x7101, NULL
);
2274 if (!codec
->pci_m7101
&& codec
->revision
== ALI_5451_V02
) {
2275 snd_printk(KERN_ERR
"ali5451: cannot find ALi 7101 chip.\n");
2276 snd_ali_free(codec
);
2280 snd_ali_printk("snd_device_new is called.\n");
2281 err
= snd_device_new(card
, SNDRV_DEV_LOWLEVEL
, codec
, &ops
);
2283 snd_ali_free(codec
);
2287 snd_card_set_dev(card
, &pci
->dev
);
2289 /* initialise synth voices*/
2290 for (i
= 0; i
< ALI_CHANNELS
; i
++)
2291 codec
->synth
.voices
[i
].number
= i
;
2293 err
= snd_ali_chip_init(codec
);
2295 snd_printk(KERN_ERR
"ali create: chip init error.\n");
2300 codec
->image
= kmalloc(sizeof(*codec
->image
), GFP_KERNEL
);
2302 snd_printk(KERN_WARNING
"can't allocate apm buffer\n");
2305 snd_ali_enable_address_interrupt(codec
);
2306 codec
->hw_initialized
= 1;
2309 snd_ali_printk("created.\n");
2313 static int __devinit
snd_ali_probe(struct pci_dev
*pci
,
2314 const struct pci_device_id
*pci_id
)
2316 struct snd_card
*card
;
2317 struct snd_ali
*codec
;
2320 snd_ali_printk("probe ...\n");
2322 card
= snd_card_new(index
, id
, THIS_MODULE
, 0);
2326 err
= snd_ali_create(card
, pci
, pcm_channels
, spdif
, &codec
);
2329 card
->private_data
= codec
;
2331 snd_ali_printk("mixer building ...\n");
2332 err
= snd_ali_mixer(codec
);
2336 snd_ali_printk("pcm building ...\n");
2337 err
= snd_ali_build_pcms(codec
);
2341 snd_ali_proc_init(codec
);
2343 strcpy(card
->driver
, "ALI5451");
2344 strcpy(card
->shortname
, "ALI 5451");
2346 sprintf(card
->longname
, "%s at 0x%lx, irq %li",
2347 card
->shortname
, codec
->port
, codec
->irq
);
2349 snd_ali_printk("register card.\n");
2350 err
= snd_card_register(card
);
2354 pci_set_drvdata(pci
, card
);
2358 snd_card_free(card
);
2362 static void __devexit
snd_ali_remove(struct pci_dev
*pci
)
2364 snd_card_free(pci_get_drvdata(pci
));
2365 pci_set_drvdata(pci
, NULL
);
2368 static struct pci_driver driver
= {
2370 .id_table
= snd_ali_ids
,
2371 .probe
= snd_ali_probe
,
2372 .remove
= __devexit_p(snd_ali_remove
),
2374 .suspend
= ali_suspend
,
2375 .resume
= ali_resume
,
2379 static int __init
alsa_card_ali_init(void)
2381 return pci_register_driver(&driver
);
2384 static void __exit
alsa_card_ali_exit(void)
2386 pci_unregister_driver(&driver
);
2389 module_init(alsa_card_ali_init
)
2390 module_exit(alsa_card_ali_exit
)