3 * hda_intel.c - Implementation of primary alsa driver code base for Intel HD Audio.
5 * Copyright(c) 2004 Intel Corporation. All rights reserved.
7 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
8 * PeiSen Hou <pshou@realtek.com.tw>
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by the Free
12 * Software Foundation; either version 2 of the License, or (at your option)
15 * This program is distributed in the hope that it will be useful, but WITHOUT
16 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
20 * You should have received a copy of the GNU General Public License along with
21 * this program; if not, write to the Free Software Foundation, Inc., 59
22 * Temple Place - Suite 330, Boston, MA 02111-1307, USA.
26 * Matt Jared matt.jared@intel.com
27 * Andy Kopp andy.kopp@intel.com
28 * Dan Kogan dan.d.kogan@intel.com
32 * 2004.12.01 Major rewrite by tiwai, merged the work of pshou
36 #include <sound/driver.h>
38 #include <linux/delay.h>
39 #include <linux/interrupt.h>
40 #include <linux/module.h>
41 #include <linux/moduleparam.h>
42 #include <linux/init.h>
43 #include <linux/slab.h>
44 #include <linux/pci.h>
45 #include <sound/core.h>
46 #include <sound/initval.h>
47 #include "hda_codec.h"
50 static int index
[SNDRV_CARDS
] = SNDRV_DEFAULT_IDX
;
51 static int enable
[SNDRV_CARDS
] = SNDRV_DEFAULT_ENABLE_PNP
;
52 static char *id
[SNDRV_CARDS
] = SNDRV_DEFAULT_STR
;
53 static char *model
[SNDRV_CARDS
];
54 static int position_fix
[SNDRV_CARDS
];
56 module_param_array(index
, int, NULL
, 0444);
57 MODULE_PARM_DESC(index
, "Index value for Intel HD audio interface.");
58 module_param_array(id
, charp
, NULL
, 0444);
59 MODULE_PARM_DESC(id
, "ID string for Intel HD audio interface.");
60 module_param_array(enable
, bool, NULL
, 0444);
61 MODULE_PARM_DESC(enable
, "Enable Intel HD audio interface.");
62 module_param_array(model
, charp
, NULL
, 0444);
63 MODULE_PARM_DESC(model
, "Use the given board model.");
64 module_param_array(position_fix
, int, NULL
, 0444);
65 MODULE_PARM_DESC(position_fix
, "Fix DMA pointer (0 = auto, 1 = none, 2 = POSBUF, 3 = FIFO size).");
67 MODULE_LICENSE("GPL");
68 MODULE_SUPPORTED_DEVICE("{{Intel, ICH6},"
77 MODULE_DESCRIPTION("Intel HDA driver");
79 #define SFX "hda-intel: "
84 #define ICH6_REG_GCAP 0x00
85 #define ICH6_REG_VMIN 0x02
86 #define ICH6_REG_VMAJ 0x03
87 #define ICH6_REG_OUTPAY 0x04
88 #define ICH6_REG_INPAY 0x06
89 #define ICH6_REG_GCTL 0x08
90 #define ICH6_REG_WAKEEN 0x0c
91 #define ICH6_REG_STATESTS 0x0e
92 #define ICH6_REG_GSTS 0x10
93 #define ICH6_REG_INTCTL 0x20
94 #define ICH6_REG_INTSTS 0x24
95 #define ICH6_REG_WALCLK 0x30
96 #define ICH6_REG_SYNC 0x34
97 #define ICH6_REG_CORBLBASE 0x40
98 #define ICH6_REG_CORBUBASE 0x44
99 #define ICH6_REG_CORBWP 0x48
100 #define ICH6_REG_CORBRP 0x4A
101 #define ICH6_REG_CORBCTL 0x4c
102 #define ICH6_REG_CORBSTS 0x4d
103 #define ICH6_REG_CORBSIZE 0x4e
105 #define ICH6_REG_RIRBLBASE 0x50
106 #define ICH6_REG_RIRBUBASE 0x54
107 #define ICH6_REG_RIRBWP 0x58
108 #define ICH6_REG_RINTCNT 0x5a
109 #define ICH6_REG_RIRBCTL 0x5c
110 #define ICH6_REG_RIRBSTS 0x5d
111 #define ICH6_REG_RIRBSIZE 0x5e
113 #define ICH6_REG_IC 0x60
114 #define ICH6_REG_IR 0x64
115 #define ICH6_REG_IRS 0x68
116 #define ICH6_IRS_VALID (1<<1)
117 #define ICH6_IRS_BUSY (1<<0)
119 #define ICH6_REG_DPLBASE 0x70
120 #define ICH6_REG_DPUBASE 0x74
121 #define ICH6_DPLBASE_ENABLE 0x1 /* Enable position buffer */
123 /* SD offset: SDI0=0x80, SDI1=0xa0, ... SDO3=0x160 */
124 enum { SDI0
, SDI1
, SDI2
, SDI3
, SDO0
, SDO1
, SDO2
, SDO3
};
126 /* stream register offsets from stream base */
127 #define ICH6_REG_SD_CTL 0x00
128 #define ICH6_REG_SD_STS 0x03
129 #define ICH6_REG_SD_LPIB 0x04
130 #define ICH6_REG_SD_CBL 0x08
131 #define ICH6_REG_SD_LVI 0x0c
132 #define ICH6_REG_SD_FIFOW 0x0e
133 #define ICH6_REG_SD_FIFOSIZE 0x10
134 #define ICH6_REG_SD_FORMAT 0x12
135 #define ICH6_REG_SD_BDLPL 0x18
136 #define ICH6_REG_SD_BDLPU 0x1c
139 #define ICH6_PCIREG_TCSEL 0x44
145 /* max number of SDs */
146 /* ICH, ATI and VIA have 4 playback and 4 capture */
147 #define ICH6_CAPTURE_INDEX 0
148 #define ICH6_NUM_CAPTURE 4
149 #define ICH6_PLAYBACK_INDEX 4
150 #define ICH6_NUM_PLAYBACK 4
152 /* ULI has 6 playback and 5 capture */
153 #define ULI_CAPTURE_INDEX 0
154 #define ULI_NUM_CAPTURE 5
155 #define ULI_PLAYBACK_INDEX 5
156 #define ULI_NUM_PLAYBACK 6
158 /* this number is statically defined for simplicity */
159 #define MAX_AZX_DEV 16
161 /* max number of fragments - we may use more if allocating more pages for BDL */
162 #define BDL_SIZE PAGE_ALIGN(8192)
163 #define AZX_MAX_FRAG (BDL_SIZE / (MAX_AZX_DEV * 16))
164 /* max buffer size - no h/w limit, you can increase as you like */
165 #define AZX_MAX_BUF_SIZE (1024*1024*1024)
166 /* max number of PCM devics per card */
167 #define AZX_MAX_AUDIO_PCMS 6
168 #define AZX_MAX_MODEM_PCMS 2
169 #define AZX_MAX_PCMS (AZX_MAX_AUDIO_PCMS + AZX_MAX_MODEM_PCMS)
171 /* RIRB int mask: overrun[2], response[0] */
172 #define RIRB_INT_RESPONSE 0x01
173 #define RIRB_INT_OVERRUN 0x04
174 #define RIRB_INT_MASK 0x05
176 /* STATESTS int mask: SD2,SD1,SD0 */
177 #define STATESTS_INT_MASK 0x07
178 #define AZX_MAX_CODECS 4
181 #define SD_CTL_STREAM_RESET 0x01 /* stream reset bit */
182 #define SD_CTL_DMA_START 0x02 /* stream DMA start bit */
183 #define SD_CTL_STREAM_TAG_MASK (0xf << 20)
184 #define SD_CTL_STREAM_TAG_SHIFT 20
186 /* SD_CTL and SD_STS */
187 #define SD_INT_DESC_ERR 0x10 /* descriptor error interrupt */
188 #define SD_INT_FIFO_ERR 0x08 /* FIFO error interrupt */
189 #define SD_INT_COMPLETE 0x04 /* completion interrupt */
190 #define SD_INT_MASK (SD_INT_DESC_ERR|SD_INT_FIFO_ERR|SD_INT_COMPLETE)
193 #define SD_STS_FIFO_READY 0x20 /* FIFO ready */
195 /* INTCTL and INTSTS */
196 #define ICH6_INT_ALL_STREAM 0xff /* all stream interrupts */
197 #define ICH6_INT_CTRL_EN 0x40000000 /* controller interrupt enable bit */
198 #define ICH6_INT_GLOBAL_EN 0x80000000 /* global interrupt enable bit */
200 /* GCTL unsolicited response enable bit */
201 #define ICH6_GCTL_UREN (1<<8)
204 #define ICH6_GCTL_RESET (1<<0)
206 /* CORB/RIRB control, read/write pointer */
207 #define ICH6_RBCTL_DMA_EN 0x02 /* enable DMA */
208 #define ICH6_RBCTL_IRQ_EN 0x01 /* enable IRQ */
209 #define ICH6_RBRWP_CLR 0x8000 /* read/write pointer clear */
210 /* below are so far hardcoded - should read registers in future */
211 #define ICH6_MAX_CORB_ENTRIES 256
212 #define ICH6_MAX_RIRB_ENTRIES 256
214 /* position fix mode */
222 /* Defines for ATI HD Audio support in SB450 south bridge */
223 #define ATI_SB450_HDAUDIO_MISC_CNTR2_ADDR 0x42
224 #define ATI_SB450_HDAUDIO_ENABLE_SNOOP 0x02
228 * Use CORB/RIRB for communication from/to codecs.
229 * This is the way recommended by Intel (see below).
231 #define USE_CORB_RIRB
236 typedef struct snd_azx azx_t
;
237 typedef struct snd_azx_rb azx_rb_t
;
238 typedef struct snd_azx_dev azx_dev_t
;
241 u32
*bdl
; /* virtual address of the BDL */
242 dma_addr_t bdl_addr
; /* physical address of the BDL */
243 volatile u32
*posbuf
; /* position buffer pointer */
245 unsigned int bufsize
; /* size of the play buffer in bytes */
246 unsigned int fragsize
; /* size of each period in bytes */
247 unsigned int frags
; /* number for period in the play buffer */
248 unsigned int fifo_size
; /* FIFO size */
249 unsigned int last_pos
; /* last updated period position */
251 void __iomem
*sd_addr
; /* stream descriptor pointer */
253 u32 sd_int_sta_mask
; /* stream int status mask */
256 snd_pcm_substream_t
*substream
; /* assigned substream, set in PCM open */
257 unsigned int format_val
; /* format value to be set in the controller and the codec */
258 unsigned char stream_tag
; /* assigned stream */
259 unsigned char index
; /* stream index */
261 unsigned int opened
: 1;
262 unsigned int running
: 1;
263 unsigned int period_updating
: 1;
268 u32
*buf
; /* CORB/RIRB buffer
269 * Each CORB entry is 4byte, RIRB is 8byte
271 dma_addr_t addr
; /* physical address of CORB/RIRB buffer */
273 unsigned short rp
, wp
; /* read/write pointers */
274 int cmds
; /* number of pending requests */
275 u32 res
; /* last read value */
282 /* chip type specific */
284 int playback_streams
;
285 int playback_index_offset
;
287 int capture_index_offset
;
292 void __iomem
*remap_addr
;
297 struct semaphore open_mutex
;
299 /* streams (x num_streams) */
303 unsigned int pcm_devs
;
304 snd_pcm_t
*pcm
[AZX_MAX_PCMS
];
307 unsigned short codec_mask
;
314 /* BDL, CORB/RIRB and position buffers */
315 struct snd_dma_buffer bdl
;
316 struct snd_dma_buffer rb
;
317 struct snd_dma_buffer posbuf
;
321 unsigned int initialized
: 1;
333 static char *driver_short_names
[] __devinitdata
= {
334 [AZX_DRIVER_ICH
] = "HDA Intel",
335 [AZX_DRIVER_ATI
] = "HDA ATI SB",
336 [AZX_DRIVER_VIA
] = "HDA VIA VT82xx",
337 [AZX_DRIVER_SIS
] = "HDA SIS966",
338 [AZX_DRIVER_ULI
] = "HDA ULI M5461"
342 * macros for easy use
344 #define azx_writel(chip,reg,value) \
345 writel(value, (chip)->remap_addr + ICH6_REG_##reg)
346 #define azx_readl(chip,reg) \
347 readl((chip)->remap_addr + ICH6_REG_##reg)
348 #define azx_writew(chip,reg,value) \
349 writew(value, (chip)->remap_addr + ICH6_REG_##reg)
350 #define azx_readw(chip,reg) \
351 readw((chip)->remap_addr + ICH6_REG_##reg)
352 #define azx_writeb(chip,reg,value) \
353 writeb(value, (chip)->remap_addr + ICH6_REG_##reg)
354 #define azx_readb(chip,reg) \
355 readb((chip)->remap_addr + ICH6_REG_##reg)
357 #define azx_sd_writel(dev,reg,value) \
358 writel(value, (dev)->sd_addr + ICH6_REG_##reg)
359 #define azx_sd_readl(dev,reg) \
360 readl((dev)->sd_addr + ICH6_REG_##reg)
361 #define azx_sd_writew(dev,reg,value) \
362 writew(value, (dev)->sd_addr + ICH6_REG_##reg)
363 #define azx_sd_readw(dev,reg) \
364 readw((dev)->sd_addr + ICH6_REG_##reg)
365 #define azx_sd_writeb(dev,reg,value) \
366 writeb(value, (dev)->sd_addr + ICH6_REG_##reg)
367 #define azx_sd_readb(dev,reg) \
368 readb((dev)->sd_addr + ICH6_REG_##reg)
370 /* for pcm support */
371 #define get_azx_dev(substream) (azx_dev_t*)(substream->runtime->private_data)
373 /* Get the upper 32bit of the given dma_addr_t
374 * Compiler should optimize and eliminate the code if dma_addr_t is 32bit
376 #define upper_32bit(addr) (sizeof(addr) > 4 ? (u32)((addr) >> 32) : (u32)0)
380 * Interface for HD codec
385 * CORB / RIRB interface
387 static int azx_alloc_cmd_io(azx_t
*chip
)
391 /* single page (at least 4096 bytes) must suffice for both ringbuffes */
392 err
= snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV
, snd_dma_pci_data(chip
->pci
),
393 PAGE_SIZE
, &chip
->rb
);
395 snd_printk(KERN_ERR SFX
"cannot allocate CORB/RIRB\n");
401 static void azx_init_cmd_io(azx_t
*chip
)
404 chip
->corb
.addr
= chip
->rb
.addr
;
405 chip
->corb
.buf
= (u32
*)chip
->rb
.area
;
406 azx_writel(chip
, CORBLBASE
, (u32
)chip
->corb
.addr
);
407 azx_writel(chip
, CORBUBASE
, upper_32bit(chip
->corb
.addr
));
409 /* set the corb size to 256 entries (ULI requires explicitly) */
410 azx_writeb(chip
, CORBSIZE
, 0x02);
411 /* set the corb write pointer to 0 */
412 azx_writew(chip
, CORBWP
, 0);
413 /* reset the corb hw read pointer */
414 azx_writew(chip
, CORBRP
, ICH6_RBRWP_CLR
);
415 /* enable corb dma */
416 azx_writeb(chip
, CORBCTL
, ICH6_RBCTL_DMA_EN
);
419 chip
->rirb
.addr
= chip
->rb
.addr
+ 2048;
420 chip
->rirb
.buf
= (u32
*)(chip
->rb
.area
+ 2048);
421 azx_writel(chip
, RIRBLBASE
, (u32
)chip
->rirb
.addr
);
422 azx_writel(chip
, RIRBUBASE
, upper_32bit(chip
->rirb
.addr
));
424 /* set the rirb size to 256 entries (ULI requires explicitly) */
425 azx_writeb(chip
, RIRBSIZE
, 0x02);
426 /* reset the rirb hw write pointer */
427 azx_writew(chip
, RIRBWP
, ICH6_RBRWP_CLR
);
428 /* set N=1, get RIRB response interrupt for new entry */
429 azx_writew(chip
, RINTCNT
, 1);
430 /* enable rirb dma and response irq */
432 azx_writeb(chip
, RIRBCTL
, ICH6_RBCTL_DMA_EN
| ICH6_RBCTL_IRQ_EN
);
434 azx_writeb(chip
, RIRBCTL
, ICH6_RBCTL_DMA_EN
);
436 chip
->rirb
.rp
= chip
->rirb
.cmds
= 0;
439 static void azx_free_cmd_io(azx_t
*chip
)
441 /* disable ringbuffer DMAs */
442 azx_writeb(chip
, RIRBCTL
, 0);
443 azx_writeb(chip
, CORBCTL
, 0);
447 static int azx_send_cmd(struct hda_codec
*codec
, hda_nid_t nid
, int direct
,
448 unsigned int verb
, unsigned int para
)
450 azx_t
*chip
= codec
->bus
->private_data
;
454 val
= (u32
)(codec
->addr
& 0x0f) << 28;
455 val
|= (u32
)direct
<< 27;
456 val
|= (u32
)nid
<< 20;
460 /* add command to corb */
461 wp
= azx_readb(chip
, CORBWP
);
463 wp
%= ICH6_MAX_CORB_ENTRIES
;
465 spin_lock_irq(&chip
->reg_lock
);
467 chip
->corb
.buf
[wp
] = cpu_to_le32(val
);
468 azx_writel(chip
, CORBWP
, wp
);
469 spin_unlock_irq(&chip
->reg_lock
);
474 #define ICH6_RIRB_EX_UNSOL_EV (1<<4)
476 /* retrieve RIRB entry - called from interrupt handler */
477 static void azx_update_rirb(azx_t
*chip
)
482 wp
= azx_readb(chip
, RIRBWP
);
483 if (wp
== chip
->rirb
.wp
)
487 while (chip
->rirb
.rp
!= wp
) {
489 chip
->rirb
.rp
%= ICH6_MAX_RIRB_ENTRIES
;
491 rp
= chip
->rirb
.rp
<< 1; /* an RIRB entry is 8-bytes */
492 res_ex
= le32_to_cpu(chip
->rirb
.buf
[rp
+ 1]);
493 res
= le32_to_cpu(chip
->rirb
.buf
[rp
]);
494 if (res_ex
& ICH6_RIRB_EX_UNSOL_EV
)
495 snd_hda_queue_unsol_event(chip
->bus
, res
, res_ex
);
496 else if (chip
->rirb
.cmds
) {
498 chip
->rirb
.res
= res
;
503 /* receive a response */
504 static unsigned int azx_get_response(struct hda_codec
*codec
)
506 azx_t
*chip
= codec
->bus
->private_data
;
509 while (chip
->rirb
.cmds
) {
511 snd_printk(KERN_ERR
"azx_get_response timeout\n");
512 chip
->rirb
.rp
= azx_readb(chip
, RIRBWP
);
518 return chip
->rirb
.res
; /* the last value */
523 * Use the single immediate command instead of CORB/RIRB for simplicity
525 * Note: according to Intel, this is not preferred use. The command was
526 * intended for the BIOS only, and may get confused with unsolicited
527 * responses. So, we shouldn't use it for normal operation from the
529 * I left the codes, however, for debugging/testing purposes.
532 #define azx_alloc_cmd_io(chip) 0
533 #define azx_init_cmd_io(chip)
534 #define azx_free_cmd_io(chip)
537 static int azx_send_cmd(struct hda_codec
*codec
, hda_nid_t nid
, int direct
,
538 unsigned int verb
, unsigned int para
)
540 azx_t
*chip
= codec
->bus
->private_data
;
544 val
= (u32
)(codec
->addr
& 0x0f) << 28;
545 val
|= (u32
)direct
<< 27;
546 val
|= (u32
)nid
<< 20;
551 /* check ICB busy bit */
552 if (! (azx_readw(chip
, IRS
) & ICH6_IRS_BUSY
)) {
553 /* Clear IRV valid bit */
554 azx_writew(chip
, IRS
, azx_readw(chip
, IRS
) | ICH6_IRS_VALID
);
555 azx_writel(chip
, IC
, val
);
556 azx_writew(chip
, IRS
, azx_readw(chip
, IRS
) | ICH6_IRS_BUSY
);
561 snd_printd(SFX
"send_cmd timeout: IRS=0x%x, val=0x%x\n", azx_readw(chip
, IRS
), val
);
565 /* receive a response */
566 static unsigned int azx_get_response(struct hda_codec
*codec
)
568 azx_t
*chip
= codec
->bus
->private_data
;
572 /* check IRV busy bit */
573 if (azx_readw(chip
, IRS
) & ICH6_IRS_VALID
)
574 return azx_readl(chip
, IR
);
577 snd_printd(SFX
"get_response timeout: IRS=0x%x\n", azx_readw(chip
, IRS
));
578 return (unsigned int)-1;
581 #define azx_update_rirb(chip)
583 #endif /* USE_CORB_RIRB */
585 /* reset codec link */
586 static int azx_reset(azx_t
*chip
)
590 /* reset controller */
591 azx_writel(chip
, GCTL
, azx_readl(chip
, GCTL
) & ~ICH6_GCTL_RESET
);
594 while (azx_readb(chip
, GCTL
) && --count
)
597 /* delay for >= 100us for codec PLL to settle per spec
598 * Rev 0.9 section 5.5.1
602 /* Bring controller out of reset */
603 azx_writeb(chip
, GCTL
, azx_readb(chip
, GCTL
) | ICH6_GCTL_RESET
);
606 while (! azx_readb(chip
, GCTL
) && --count
)
609 /* Brent Chartrand said to wait >= 540us for codecs to intialize */
612 /* check to see if controller is ready */
613 if (! azx_readb(chip
, GCTL
)) {
614 snd_printd("azx_reset: controller not ready!\n");
618 /* Accept unsolicited responses */
619 azx_writel(chip
, GCTL
, azx_readl(chip
, GCTL
) | ICH6_GCTL_UREN
);
622 if (! chip
->codec_mask
) {
623 chip
->codec_mask
= azx_readw(chip
, STATESTS
);
624 snd_printdd("codec_mask = 0x%x\n", chip
->codec_mask
);
635 /* enable interrupts */
636 static void azx_int_enable(azx_t
*chip
)
638 /* enable controller CIE and GIE */
639 azx_writel(chip
, INTCTL
, azx_readl(chip
, INTCTL
) |
640 ICH6_INT_CTRL_EN
| ICH6_INT_GLOBAL_EN
);
643 /* disable interrupts */
644 static void azx_int_disable(azx_t
*chip
)
648 /* disable interrupts in stream descriptor */
649 for (i
= 0; i
< chip
->num_streams
; i
++) {
650 azx_dev_t
*azx_dev
= &chip
->azx_dev
[i
];
651 azx_sd_writeb(azx_dev
, SD_CTL
,
652 azx_sd_readb(azx_dev
, SD_CTL
) & ~SD_INT_MASK
);
655 /* disable SIE for all streams */
656 azx_writeb(chip
, INTCTL
, 0);
658 /* disable controller CIE and GIE */
659 azx_writel(chip
, INTCTL
, azx_readl(chip
, INTCTL
) &
660 ~(ICH6_INT_CTRL_EN
| ICH6_INT_GLOBAL_EN
));
663 /* clear interrupts */
664 static void azx_int_clear(azx_t
*chip
)
668 /* clear stream status */
669 for (i
= 0; i
< chip
->num_streams
; i
++) {
670 azx_dev_t
*azx_dev
= &chip
->azx_dev
[i
];
671 azx_sd_writeb(azx_dev
, SD_STS
, SD_INT_MASK
);
675 azx_writeb(chip
, STATESTS
, STATESTS_INT_MASK
);
677 /* clear rirb status */
678 azx_writeb(chip
, RIRBSTS
, RIRB_INT_MASK
);
680 /* clear int status */
681 azx_writel(chip
, INTSTS
, ICH6_INT_CTRL_EN
| ICH6_INT_ALL_STREAM
);
685 static void azx_stream_start(azx_t
*chip
, azx_dev_t
*azx_dev
)
688 azx_writeb(chip
, INTCTL
,
689 azx_readb(chip
, INTCTL
) | (1 << azx_dev
->index
));
690 /* set DMA start and interrupt mask */
691 azx_sd_writeb(azx_dev
, SD_CTL
, azx_sd_readb(azx_dev
, SD_CTL
) |
692 SD_CTL_DMA_START
| SD_INT_MASK
);
696 static void azx_stream_stop(azx_t
*chip
, azx_dev_t
*azx_dev
)
699 azx_sd_writeb(azx_dev
, SD_CTL
, azx_sd_readb(azx_dev
, SD_CTL
) &
700 ~(SD_CTL_DMA_START
| SD_INT_MASK
));
701 azx_sd_writeb(azx_dev
, SD_STS
, SD_INT_MASK
); /* to be sure */
703 azx_writeb(chip
, INTCTL
,
704 azx_readb(chip
, INTCTL
) & ~(1 << azx_dev
->index
));
709 * initialize the chip
711 static void azx_init_chip(azx_t
*chip
)
713 unsigned char tcsel_reg
, ati_misc_cntl2
;
715 /* Clear bits 0-2 of PCI register TCSEL (at offset 0x44)
716 * TCSEL == Traffic Class Select Register, which sets PCI express QOS
717 * Ensuring these bits are 0 clears playback static on some HD Audio codecs
719 pci_read_config_byte (chip
->pci
, ICH6_PCIREG_TCSEL
, &tcsel_reg
);
720 pci_write_config_byte(chip
->pci
, ICH6_PCIREG_TCSEL
, tcsel_reg
& 0xf8);
722 /* reset controller */
725 /* initialize interrupts */
727 azx_int_enable(chip
);
729 /* initialize the codec command I/O */
730 azx_init_cmd_io(chip
);
732 /* program the position buffer */
733 azx_writel(chip
, DPLBASE
, (u32
)chip
->posbuf
.addr
);
734 azx_writel(chip
, DPUBASE
, upper_32bit(chip
->posbuf
.addr
));
736 /* For ATI SB450 azalia HD audio, we need to enable snoop */
737 if (chip
->driver_type
== AZX_DRIVER_ATI
) {
738 pci_read_config_byte(chip
->pci
, ATI_SB450_HDAUDIO_MISC_CNTR2_ADDR
,
740 pci_write_config_byte(chip
->pci
, ATI_SB450_HDAUDIO_MISC_CNTR2_ADDR
,
741 (ati_misc_cntl2
& 0xf8) | ATI_SB450_HDAUDIO_ENABLE_SNOOP
);
749 static irqreturn_t
azx_interrupt(int irq
, void* dev_id
, struct pt_regs
*regs
)
751 azx_t
*chip
= dev_id
;
756 spin_lock(&chip
->reg_lock
);
758 status
= azx_readl(chip
, INTSTS
);
760 spin_unlock(&chip
->reg_lock
);
764 for (i
= 0; i
< chip
->num_streams
; i
++) {
765 azx_dev
= &chip
->azx_dev
[i
];
766 if (status
& azx_dev
->sd_int_sta_mask
) {
767 azx_sd_writeb(azx_dev
, SD_STS
, SD_INT_MASK
);
768 if (azx_dev
->substream
&& azx_dev
->running
) {
769 azx_dev
->period_updating
= 1;
770 spin_unlock(&chip
->reg_lock
);
771 snd_pcm_period_elapsed(azx_dev
->substream
);
772 spin_lock(&chip
->reg_lock
);
773 azx_dev
->period_updating
= 0;
779 status
= azx_readb(chip
, RIRBSTS
);
780 if (status
& RIRB_INT_MASK
) {
781 if (status
& RIRB_INT_RESPONSE
)
782 azx_update_rirb(chip
);
783 azx_writeb(chip
, RIRBSTS
, RIRB_INT_MASK
);
787 /* clear state status int */
788 if (azx_readb(chip
, STATESTS
) & 0x04)
789 azx_writeb(chip
, STATESTS
, 0x04);
791 spin_unlock(&chip
->reg_lock
);
800 static void azx_setup_periods(azx_dev_t
*azx_dev
)
802 u32
*bdl
= azx_dev
->bdl
;
803 dma_addr_t dma_addr
= azx_dev
->substream
->runtime
->dma_addr
;
806 /* reset BDL address */
807 azx_sd_writel(azx_dev
, SD_BDLPL
, 0);
808 azx_sd_writel(azx_dev
, SD_BDLPU
, 0);
810 /* program the initial BDL entries */
811 for (idx
= 0; idx
< azx_dev
->frags
; idx
++) {
812 unsigned int off
= idx
<< 2; /* 4 dword step */
813 dma_addr_t addr
= dma_addr
+ idx
* azx_dev
->fragsize
;
814 /* program the address field of the BDL entry */
815 bdl
[off
] = cpu_to_le32((u32
)addr
);
816 bdl
[off
+1] = cpu_to_le32(upper_32bit(addr
));
818 /* program the size field of the BDL entry */
819 bdl
[off
+2] = cpu_to_le32(azx_dev
->fragsize
);
821 /* program the IOC to enable interrupt when buffer completes */
822 bdl
[off
+3] = cpu_to_le32(0x01);
827 * set up the SD for streaming
829 static int azx_setup_controller(azx_t
*chip
, azx_dev_t
*azx_dev
)
834 /* make sure the run bit is zero for SD */
835 azx_sd_writeb(azx_dev
, SD_CTL
, azx_sd_readb(azx_dev
, SD_CTL
) & ~SD_CTL_DMA_START
);
837 azx_sd_writeb(azx_dev
, SD_CTL
, azx_sd_readb(azx_dev
, SD_CTL
) | SD_CTL_STREAM_RESET
);
840 while (!((val
= azx_sd_readb(azx_dev
, SD_CTL
)) & SD_CTL_STREAM_RESET
) &&
843 val
&= ~SD_CTL_STREAM_RESET
;
844 azx_sd_writeb(azx_dev
, SD_CTL
, val
);
848 /* waiting for hardware to report that the stream is out of reset */
849 while (((val
= azx_sd_readb(azx_dev
, SD_CTL
)) & SD_CTL_STREAM_RESET
) &&
853 /* program the stream_tag */
854 azx_sd_writel(azx_dev
, SD_CTL
,
855 (azx_sd_readl(azx_dev
, SD_CTL
) & ~SD_CTL_STREAM_TAG_MASK
) |
856 (azx_dev
->stream_tag
<< SD_CTL_STREAM_TAG_SHIFT
));
858 /* program the length of samples in cyclic buffer */
859 azx_sd_writel(azx_dev
, SD_CBL
, azx_dev
->bufsize
);
861 /* program the stream format */
862 /* this value needs to be the same as the one programmed */
863 azx_sd_writew(azx_dev
, SD_FORMAT
, azx_dev
->format_val
);
865 /* program the stream LVI (last valid index) of the BDL */
866 azx_sd_writew(azx_dev
, SD_LVI
, azx_dev
->frags
- 1);
868 /* program the BDL address */
869 /* lower BDL address */
870 azx_sd_writel(azx_dev
, SD_BDLPL
, (u32
)azx_dev
->bdl_addr
);
871 /* upper BDL address */
872 azx_sd_writel(azx_dev
, SD_BDLPU
, upper_32bit(azx_dev
->bdl_addr
));
874 /* enable the position buffer */
875 if (! (azx_readl(chip
, DPLBASE
) & ICH6_DPLBASE_ENABLE
))
876 azx_writel(chip
, DPLBASE
, (u32
)chip
->posbuf
.addr
| ICH6_DPLBASE_ENABLE
);
878 /* set the interrupt enable bits in the descriptor control register */
879 azx_sd_writel(azx_dev
, SD_CTL
, azx_sd_readl(azx_dev
, SD_CTL
) | SD_INT_MASK
);
886 * Codec initialization
889 static int __devinit
azx_codec_create(azx_t
*chip
, const char *model
)
891 struct hda_bus_template bus_temp
;
894 memset(&bus_temp
, 0, sizeof(bus_temp
));
895 bus_temp
.private_data
= chip
;
896 bus_temp
.modelname
= model
;
897 bus_temp
.pci
= chip
->pci
;
898 bus_temp
.ops
.command
= azx_send_cmd
;
899 bus_temp
.ops
.get_response
= azx_get_response
;
901 if ((err
= snd_hda_bus_new(chip
->card
, &bus_temp
, &chip
->bus
)) < 0)
905 for (c
= 0; c
< AZX_MAX_CODECS
; c
++) {
906 if (chip
->codec_mask
& (1 << c
)) {
907 err
= snd_hda_codec_new(chip
->bus
, c
, NULL
);
914 snd_printk(KERN_ERR SFX
"no codecs initialized\n");
926 /* assign a stream for the PCM */
927 static inline azx_dev_t
*azx_assign_device(azx_t
*chip
, int stream
)
930 if (stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
931 dev
= chip
->playback_index_offset
;
932 nums
= chip
->playback_streams
;
934 dev
= chip
->capture_index_offset
;
935 nums
= chip
->capture_streams
;
937 for (i
= 0; i
< nums
; i
++, dev
++)
938 if (! chip
->azx_dev
[dev
].opened
) {
939 chip
->azx_dev
[dev
].opened
= 1;
940 return &chip
->azx_dev
[dev
];
945 /* release the assigned stream */
946 static inline void azx_release_device(azx_dev_t
*azx_dev
)
951 static snd_pcm_hardware_t azx_pcm_hw
= {
952 .info
= (SNDRV_PCM_INFO_MMAP
| SNDRV_PCM_INFO_INTERLEAVED
|
953 SNDRV_PCM_INFO_BLOCK_TRANSFER
|
954 SNDRV_PCM_INFO_MMAP_VALID
|
955 SNDRV_PCM_INFO_PAUSE
/*|*/
956 /*SNDRV_PCM_INFO_RESUME*/),
957 .formats
= SNDRV_PCM_FMTBIT_S16_LE
,
958 .rates
= SNDRV_PCM_RATE_48000
,
963 .buffer_bytes_max
= AZX_MAX_BUF_SIZE
,
964 .period_bytes_min
= 128,
965 .period_bytes_max
= AZX_MAX_BUF_SIZE
/ 2,
967 .periods_max
= AZX_MAX_FRAG
,
973 struct hda_codec
*codec
;
974 struct hda_pcm_stream
*hinfo
[2];
977 static int azx_pcm_open(snd_pcm_substream_t
*substream
)
979 struct azx_pcm
*apcm
= snd_pcm_substream_chip(substream
);
980 struct hda_pcm_stream
*hinfo
= apcm
->hinfo
[substream
->stream
];
981 azx_t
*chip
= apcm
->chip
;
983 snd_pcm_runtime_t
*runtime
= substream
->runtime
;
987 down(&chip
->open_mutex
);
988 azx_dev
= azx_assign_device(chip
, substream
->stream
);
989 if (azx_dev
== NULL
) {
990 up(&chip
->open_mutex
);
993 runtime
->hw
= azx_pcm_hw
;
994 runtime
->hw
.channels_min
= hinfo
->channels_min
;
995 runtime
->hw
.channels_max
= hinfo
->channels_max
;
996 runtime
->hw
.formats
= hinfo
->formats
;
997 runtime
->hw
.rates
= hinfo
->rates
;
998 snd_pcm_limit_hw_rates(runtime
);
999 snd_pcm_hw_constraint_integer(runtime
, SNDRV_PCM_HW_PARAM_PERIODS
);
1000 if ((err
= hinfo
->ops
.open(hinfo
, apcm
->codec
, substream
)) < 0) {
1001 azx_release_device(azx_dev
);
1002 up(&chip
->open_mutex
);
1005 spin_lock_irqsave(&chip
->reg_lock
, flags
);
1006 azx_dev
->substream
= substream
;
1007 azx_dev
->running
= 0;
1008 spin_unlock_irqrestore(&chip
->reg_lock
, flags
);
1010 runtime
->private_data
= azx_dev
;
1011 up(&chip
->open_mutex
);
1015 static int azx_pcm_close(snd_pcm_substream_t
*substream
)
1017 struct azx_pcm
*apcm
= snd_pcm_substream_chip(substream
);
1018 struct hda_pcm_stream
*hinfo
= apcm
->hinfo
[substream
->stream
];
1019 azx_t
*chip
= apcm
->chip
;
1020 azx_dev_t
*azx_dev
= get_azx_dev(substream
);
1021 unsigned long flags
;
1023 down(&chip
->open_mutex
);
1024 spin_lock_irqsave(&chip
->reg_lock
, flags
);
1025 azx_dev
->substream
= NULL
;
1026 azx_dev
->running
= 0;
1027 spin_unlock_irqrestore(&chip
->reg_lock
, flags
);
1028 azx_release_device(azx_dev
);
1029 hinfo
->ops
.close(hinfo
, apcm
->codec
, substream
);
1030 up(&chip
->open_mutex
);
1034 static int azx_pcm_hw_params(snd_pcm_substream_t
*substream
, snd_pcm_hw_params_t
*hw_params
)
1036 return snd_pcm_lib_malloc_pages(substream
, params_buffer_bytes(hw_params
));
1039 static int azx_pcm_hw_free(snd_pcm_substream_t
*substream
)
1041 struct azx_pcm
*apcm
= snd_pcm_substream_chip(substream
);
1042 azx_dev_t
*azx_dev
= get_azx_dev(substream
);
1043 struct hda_pcm_stream
*hinfo
= apcm
->hinfo
[substream
->stream
];
1045 /* reset BDL address */
1046 azx_sd_writel(azx_dev
, SD_BDLPL
, 0);
1047 azx_sd_writel(azx_dev
, SD_BDLPU
, 0);
1048 azx_sd_writel(azx_dev
, SD_CTL
, 0);
1050 hinfo
->ops
.cleanup(hinfo
, apcm
->codec
, substream
);
1052 return snd_pcm_lib_free_pages(substream
);
1055 static int azx_pcm_prepare(snd_pcm_substream_t
*substream
)
1057 struct azx_pcm
*apcm
= snd_pcm_substream_chip(substream
);
1058 azx_t
*chip
= apcm
->chip
;
1059 azx_dev_t
*azx_dev
= get_azx_dev(substream
);
1060 struct hda_pcm_stream
*hinfo
= apcm
->hinfo
[substream
->stream
];
1061 snd_pcm_runtime_t
*runtime
= substream
->runtime
;
1063 azx_dev
->bufsize
= snd_pcm_lib_buffer_bytes(substream
);
1064 azx_dev
->fragsize
= snd_pcm_lib_period_bytes(substream
);
1065 azx_dev
->frags
= azx_dev
->bufsize
/ azx_dev
->fragsize
;
1066 azx_dev
->format_val
= snd_hda_calc_stream_format(runtime
->rate
,
1070 if (! azx_dev
->format_val
) {
1071 snd_printk(KERN_ERR SFX
"invalid format_val, rate=%d, ch=%d, format=%d\n",
1072 runtime
->rate
, runtime
->channels
, runtime
->format
);
1076 snd_printdd("azx_pcm_prepare: bufsize=0x%x, fragsize=0x%x, format=0x%x\n",
1077 azx_dev
->bufsize
, azx_dev
->fragsize
, azx_dev
->format_val
);
1078 azx_setup_periods(azx_dev
);
1079 azx_setup_controller(chip
, azx_dev
);
1080 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
1081 azx_dev
->fifo_size
= azx_sd_readw(azx_dev
, SD_FIFOSIZE
) + 1;
1083 azx_dev
->fifo_size
= 0;
1084 azx_dev
->last_pos
= 0;
1086 return hinfo
->ops
.prepare(hinfo
, apcm
->codec
, azx_dev
->stream_tag
,
1087 azx_dev
->format_val
, substream
);
1090 static int azx_pcm_trigger(snd_pcm_substream_t
*substream
, int cmd
)
1092 struct azx_pcm
*apcm
= snd_pcm_substream_chip(substream
);
1093 azx_dev_t
*azx_dev
= get_azx_dev(substream
);
1094 azx_t
*chip
= apcm
->chip
;
1097 spin_lock(&chip
->reg_lock
);
1099 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE
:
1100 case SNDRV_PCM_TRIGGER_RESUME
:
1101 case SNDRV_PCM_TRIGGER_START
:
1102 azx_stream_start(chip
, azx_dev
);
1103 azx_dev
->running
= 1;
1105 case SNDRV_PCM_TRIGGER_PAUSE_PUSH
:
1106 case SNDRV_PCM_TRIGGER_SUSPEND
:
1107 case SNDRV_PCM_TRIGGER_STOP
:
1108 azx_stream_stop(chip
, azx_dev
);
1109 azx_dev
->running
= 0;
1114 spin_unlock(&chip
->reg_lock
);
1115 if (cmd
== SNDRV_PCM_TRIGGER_PAUSE_PUSH
||
1116 cmd
== SNDRV_PCM_TRIGGER_SUSPEND
||
1117 cmd
== SNDRV_PCM_TRIGGER_STOP
) {
1119 while (azx_sd_readb(azx_dev
, SD_CTL
) & SD_CTL_DMA_START
&& --timeout
)
1125 static snd_pcm_uframes_t
azx_pcm_pointer(snd_pcm_substream_t
*substream
)
1127 struct azx_pcm
*apcm
= snd_pcm_substream_chip(substream
);
1128 azx_t
*chip
= apcm
->chip
;
1129 azx_dev_t
*azx_dev
= get_azx_dev(substream
);
1132 if (chip
->position_fix
== POS_FIX_POSBUF
) {
1133 /* use the position buffer */
1134 pos
= *azx_dev
->posbuf
;
1137 pos
= azx_sd_readl(azx_dev
, SD_LPIB
);
1138 if (chip
->position_fix
== POS_FIX_FIFO
)
1139 pos
+= azx_dev
->fifo_size
;
1140 #if 0 /* disabled temprarily, auto-correction doesn't work well... */
1141 else if (chip
->position_fix
== POS_FIX_AUTO
&& azx_dev
->period_updating
) {
1142 /* check the validity of DMA position */
1143 unsigned int diff
= 0;
1144 azx_dev
->last_pos
+= azx_dev
->fragsize
;
1145 if (azx_dev
->last_pos
> pos
)
1146 diff
= azx_dev
->last_pos
- pos
;
1147 if (azx_dev
->last_pos
>= azx_dev
->bufsize
) {
1148 if (pos
< azx_dev
->fragsize
)
1150 azx_dev
->last_pos
= 0;
1152 if (diff
> 0 && diff
<= azx_dev
->fifo_size
)
1153 pos
+= azx_dev
->fifo_size
;
1155 snd_printdd(KERN_INFO
"hda_intel: DMA position fix %d, switching to posbuf\n", diff
);
1156 chip
->position_fix
= POS_FIX_POSBUF
;
1157 pos
= *azx_dev
->posbuf
;
1159 azx_dev
->period_updating
= 0;
1162 else if (chip
->position_fix
== POS_FIX_AUTO
)
1163 pos
+= azx_dev
->fifo_size
;
1166 if (pos
>= azx_dev
->bufsize
)
1168 return bytes_to_frames(substream
->runtime
, pos
);
1171 static snd_pcm_ops_t azx_pcm_ops
= {
1172 .open
= azx_pcm_open
,
1173 .close
= azx_pcm_close
,
1174 .ioctl
= snd_pcm_lib_ioctl
,
1175 .hw_params
= azx_pcm_hw_params
,
1176 .hw_free
= azx_pcm_hw_free
,
1177 .prepare
= azx_pcm_prepare
,
1178 .trigger
= azx_pcm_trigger
,
1179 .pointer
= azx_pcm_pointer
,
1182 static void azx_pcm_free(snd_pcm_t
*pcm
)
1184 kfree(pcm
->private_data
);
1187 static int __devinit
create_codec_pcm(azx_t
*chip
, struct hda_codec
*codec
,
1188 struct hda_pcm
*cpcm
, int pcm_dev
)
1192 struct azx_pcm
*apcm
;
1194 snd_assert(cpcm
->stream
[0].substreams
|| cpcm
->stream
[1].substreams
, return -EINVAL
);
1195 snd_assert(cpcm
->name
, return -EINVAL
);
1197 err
= snd_pcm_new(chip
->card
, cpcm
->name
, pcm_dev
,
1198 cpcm
->stream
[0].substreams
, cpcm
->stream
[1].substreams
,
1202 strcpy(pcm
->name
, cpcm
->name
);
1203 apcm
= kmalloc(sizeof(*apcm
), GFP_KERNEL
);
1207 apcm
->codec
= codec
;
1208 apcm
->hinfo
[0] = &cpcm
->stream
[0];
1209 apcm
->hinfo
[1] = &cpcm
->stream
[1];
1210 pcm
->private_data
= apcm
;
1211 pcm
->private_free
= azx_pcm_free
;
1212 if (cpcm
->stream
[0].substreams
)
1213 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_PLAYBACK
, &azx_pcm_ops
);
1214 if (cpcm
->stream
[1].substreams
)
1215 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_CAPTURE
, &azx_pcm_ops
);
1216 snd_pcm_lib_preallocate_pages_for_all(pcm
, SNDRV_DMA_TYPE_DEV
,
1217 snd_dma_pci_data(chip
->pci
),
1218 1024 * 64, 1024 * 128);
1219 chip
->pcm
[pcm_dev
] = pcm
;
1220 chip
->pcm_devs
= pcm_dev
+ 1;
1225 static int __devinit
azx_pcm_create(azx_t
*chip
)
1227 struct list_head
*p
;
1228 struct hda_codec
*codec
;
1232 if ((err
= snd_hda_build_pcms(chip
->bus
)) < 0)
1235 /* create audio PCMs */
1237 list_for_each(p
, &chip
->bus
->codec_list
) {
1238 codec
= list_entry(p
, struct hda_codec
, list
);
1239 for (c
= 0; c
< codec
->num_pcms
; c
++) {
1240 if (codec
->pcm_info
[c
].is_modem
)
1241 continue; /* create later */
1242 if (pcm_dev
>= AZX_MAX_AUDIO_PCMS
) {
1243 snd_printk(KERN_ERR SFX
"Too many audio PCMs\n");
1246 err
= create_codec_pcm(chip
, codec
, &codec
->pcm_info
[c
], pcm_dev
);
1253 /* create modem PCMs */
1254 pcm_dev
= AZX_MAX_AUDIO_PCMS
;
1255 list_for_each(p
, &chip
->bus
->codec_list
) {
1256 codec
= list_entry(p
, struct hda_codec
, list
);
1257 for (c
= 0; c
< codec
->num_pcms
; c
++) {
1258 if (! codec
->pcm_info
[c
].is_modem
)
1259 continue; /* already created */
1260 if (pcm_dev
>= AZX_MAX_PCMS
) {
1261 snd_printk(KERN_ERR SFX
"Too many modem PCMs\n");
1264 err
= create_codec_pcm(chip
, codec
, &codec
->pcm_info
[c
], pcm_dev
);
1274 * mixer creation - all stuff is implemented in hda module
1276 static int __devinit
azx_mixer_create(azx_t
*chip
)
1278 return snd_hda_build_controls(chip
->bus
);
1283 * initialize SD streams
1285 static int __devinit
azx_init_stream(azx_t
*chip
)
1289 /* initialize each stream (aka device)
1290 * assign the starting bdl address to each stream (device) and initialize
1292 for (i
= 0; i
< chip
->num_streams
; i
++) {
1293 unsigned int off
= sizeof(u32
) * (i
* AZX_MAX_FRAG
* 4);
1294 azx_dev_t
*azx_dev
= &chip
->azx_dev
[i
];
1295 azx_dev
->bdl
= (u32
*)(chip
->bdl
.area
+ off
);
1296 azx_dev
->bdl_addr
= chip
->bdl
.addr
+ off
;
1297 azx_dev
->posbuf
= (volatile u32
*)(chip
->posbuf
.area
+ i
* 8);
1298 /* offset: SDI0=0x80, SDI1=0xa0, ... SDO3=0x160 */
1299 azx_dev
->sd_addr
= chip
->remap_addr
+ (0x20 * i
+ 0x80);
1300 /* int mask: SDI0=0x01, SDI1=0x02, ... SDO3=0x80 */
1301 azx_dev
->sd_int_sta_mask
= 1 << i
;
1302 /* stream tag: must be non-zero and unique */
1304 azx_dev
->stream_tag
= i
+ 1;
1315 static int azx_suspend(snd_card_t
*card
, pm_message_t state
)
1317 azx_t
*chip
= card
->pm_private_data
;
1320 for (i
= 0; i
< chip
->pcm_devs
; i
++)
1322 snd_pcm_suspend_all(chip
->pcm
[i
]);
1323 snd_hda_suspend(chip
->bus
, state
);
1324 azx_free_cmd_io(chip
);
1325 pci_disable_device(chip
->pci
);
1329 static int azx_resume(snd_card_t
*card
)
1331 azx_t
*chip
= card
->pm_private_data
;
1333 pci_enable_device(chip
->pci
);
1334 pci_set_master(chip
->pci
);
1335 azx_init_chip(chip
);
1336 snd_hda_resume(chip
->bus
);
1339 #endif /* CONFIG_PM */
1345 static int azx_free(azx_t
*chip
)
1347 if (chip
->initialized
) {
1350 for (i
= 0; i
< chip
->num_streams
; i
++)
1351 azx_stream_stop(chip
, &chip
->azx_dev
[i
]);
1353 /* disable interrupts */
1354 azx_int_disable(chip
);
1355 azx_int_clear(chip
);
1357 /* disable CORB/RIRB */
1358 azx_free_cmd_io(chip
);
1360 /* disable position buffer */
1361 azx_writel(chip
, DPLBASE
, 0);
1362 azx_writel(chip
, DPUBASE
, 0);
1364 /* wait a little for interrupts to finish */
1368 if (chip
->remap_addr
)
1369 iounmap(chip
->remap_addr
);
1371 free_irq(chip
->irq
, (void*)chip
);
1374 snd_dma_free_pages(&chip
->bdl
);
1376 snd_dma_free_pages(&chip
->rb
);
1377 if (chip
->posbuf
.area
)
1378 snd_dma_free_pages(&chip
->posbuf
);
1379 pci_release_regions(chip
->pci
);
1380 pci_disable_device(chip
->pci
);
1381 kfree(chip
->azx_dev
);
1387 static int azx_dev_free(snd_device_t
*device
)
1389 return azx_free(device
->device_data
);
1395 static int __devinit
azx_create(snd_card_t
*card
, struct pci_dev
*pci
,
1396 int posfix
, int driver_type
,
1401 static snd_device_ops_t ops
= {
1402 .dev_free
= azx_dev_free
,
1407 if ((err
= pci_enable_device(pci
)) < 0)
1410 chip
= kzalloc(sizeof(*chip
), GFP_KERNEL
);
1413 snd_printk(KERN_ERR SFX
"cannot allocate chip\n");
1414 pci_disable_device(pci
);
1418 spin_lock_init(&chip
->reg_lock
);
1419 init_MUTEX(&chip
->open_mutex
);
1423 chip
->driver_type
= driver_type
;
1425 chip
->position_fix
= posfix
;
1427 #if BITS_PER_LONG != 64
1428 /* Fix up base address on ULI M5461 */
1429 if (chip
->driver_type
== AZX_DRIVER_ULI
) {
1431 pci_read_config_word(pci
, 0x40, &tmp3
);
1432 pci_write_config_word(pci
, 0x40, tmp3
| 0x10);
1433 pci_write_config_dword(pci
, PCI_BASE_ADDRESS_1
, 0);
1437 if ((err
= pci_request_regions(pci
, "ICH HD audio")) < 0) {
1439 pci_disable_device(pci
);
1443 chip
->addr
= pci_resource_start(pci
,0);
1444 chip
->remap_addr
= ioremap_nocache(chip
->addr
, pci_resource_len(pci
,0));
1445 if (chip
->remap_addr
== NULL
) {
1446 snd_printk(KERN_ERR SFX
"ioremap error\n");
1451 if (request_irq(pci
->irq
, azx_interrupt
, SA_INTERRUPT
|SA_SHIRQ
,
1452 "HDA Intel", (void*)chip
)) {
1453 snd_printk(KERN_ERR SFX
"unable to grab IRQ %d\n", pci
->irq
);
1457 chip
->irq
= pci
->irq
;
1459 pci_set_master(pci
);
1460 synchronize_irq(chip
->irq
);
1462 switch (chip
->driver_type
) {
1463 case AZX_DRIVER_ULI
:
1464 chip
->playback_streams
= ULI_NUM_PLAYBACK
;
1465 chip
->capture_streams
= ULI_NUM_CAPTURE
;
1466 chip
->playback_index_offset
= ULI_PLAYBACK_INDEX
;
1467 chip
->capture_index_offset
= ULI_CAPTURE_INDEX
;
1470 chip
->playback_streams
= ICH6_NUM_PLAYBACK
;
1471 chip
->capture_streams
= ICH6_NUM_CAPTURE
;
1472 chip
->playback_index_offset
= ICH6_PLAYBACK_INDEX
;
1473 chip
->capture_index_offset
= ICH6_CAPTURE_INDEX
;
1476 chip
->num_streams
= chip
->playback_streams
+ chip
->capture_streams
;
1477 chip
->azx_dev
= kcalloc(chip
->num_streams
, sizeof(*chip
->azx_dev
), GFP_KERNEL
);
1478 if (! chip
->azx_dev
) {
1479 snd_printk(KERN_ERR
"cannot malloc azx_dev\n");
1483 /* allocate memory for the BDL for each stream */
1484 if ((err
= snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV
, snd_dma_pci_data(chip
->pci
),
1485 BDL_SIZE
, &chip
->bdl
)) < 0) {
1486 snd_printk(KERN_ERR SFX
"cannot allocate BDL\n");
1489 /* allocate memory for the position buffer */
1490 if ((err
= snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV
, snd_dma_pci_data(chip
->pci
),
1491 chip
->num_streams
* 8, &chip
->posbuf
)) < 0) {
1492 snd_printk(KERN_ERR SFX
"cannot allocate posbuf\n");
1495 /* allocate CORB/RIRB */
1496 if ((err
= azx_alloc_cmd_io(chip
)) < 0)
1499 /* initialize streams */
1500 azx_init_stream(chip
);
1502 /* initialize chip */
1503 azx_init_chip(chip
);
1505 chip
->initialized
= 1;
1507 /* codec detection */
1508 if (! chip
->codec_mask
) {
1509 snd_printk(KERN_ERR SFX
"no codecs found!\n");
1514 if ((err
= snd_device_new(card
, SNDRV_DEV_LOWLEVEL
, chip
, &ops
)) <0) {
1515 snd_printk(KERN_ERR SFX
"Error creating device [card]!\n");
1519 strcpy(card
->driver
, "HDA-Intel");
1520 strcpy(card
->shortname
, driver_short_names
[chip
->driver_type
]);
1521 sprintf(card
->longname
, "%s at 0x%lx irq %i", card
->shortname
, chip
->addr
, chip
->irq
);
1531 static int __devinit
azx_probe(struct pci_dev
*pci
, const struct pci_device_id
*pci_id
)
1538 if (dev
>= SNDRV_CARDS
)
1540 if (! enable
[dev
]) {
1545 card
= snd_card_new(index
[dev
], id
[dev
], THIS_MODULE
, 0);
1547 snd_printk(KERN_ERR SFX
"Error creating card!\n");
1551 if ((err
= azx_create(card
, pci
, position_fix
[dev
], pci_id
->driver_data
,
1553 snd_card_free(card
);
1557 /* create codec instances */
1558 if ((err
= azx_codec_create(chip
, model
[dev
])) < 0) {
1559 snd_card_free(card
);
1563 /* create PCM streams */
1564 if ((err
= azx_pcm_create(chip
)) < 0) {
1565 snd_card_free(card
);
1569 /* create mixer controls */
1570 if ((err
= azx_mixer_create(chip
)) < 0) {
1571 snd_card_free(card
);
1575 snd_card_set_pm_callback(card
, azx_suspend
, azx_resume
, chip
);
1576 snd_card_set_dev(card
, &pci
->dev
);
1578 if ((err
= snd_card_register(card
)) < 0) {
1579 snd_card_free(card
);
1583 pci_set_drvdata(pci
, card
);
1589 static void __devexit
azx_remove(struct pci_dev
*pci
)
1591 snd_card_free(pci_get_drvdata(pci
));
1592 pci_set_drvdata(pci
, NULL
);
1596 static struct pci_device_id azx_ids
[] = {
1597 { 0x8086, 0x2668, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, AZX_DRIVER_ICH
}, /* ICH6 */
1598 { 0x8086, 0x27d8, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, AZX_DRIVER_ICH
}, /* ICH7 */
1599 { 0x8086, 0x269a, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, AZX_DRIVER_ICH
}, /* ESB2 */
1600 { 0x1002, 0x437b, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, AZX_DRIVER_ATI
}, /* ATI SB450 */
1601 { 0x1106, 0x3288, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, AZX_DRIVER_VIA
}, /* VIA VT8251/VT8237A */
1602 { 0x1039, 0x7502, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, AZX_DRIVER_SIS
}, /* SIS966 */
1603 { 0x10b9, 0x5461, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, AZX_DRIVER_ULI
}, /* ULI M5461 */
1606 MODULE_DEVICE_TABLE(pci
, azx_ids
);
1608 /* pci_driver definition */
1609 static struct pci_driver driver
= {
1610 .name
= "HDA Intel",
1611 .owner
= THIS_MODULE
,
1612 .id_table
= azx_ids
,
1614 .remove
= __devexit_p(azx_remove
),
1615 SND_PCI_PM_CALLBACKS
1618 static int __init
alsa_card_azx_init(void)
1620 return pci_register_driver(&driver
);
1623 static void __exit
alsa_card_azx_exit(void)
1625 pci_unregister_driver(&driver
);
1628 module_init(alsa_card_azx_init
)
1629 module_exit(alsa_card_azx_exit
)