blob: c5dda1bf3d4606a2c123b13296f7cc4fd380cce4 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * ALSA driver for ATI IXP 150/200/250 AC97 modem controllers
3 *
4 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 *
20 */
21
22#include <sound/driver.h>
23#include <asm/io.h>
24#include <linux/delay.h>
25#include <linux/interrupt.h>
26#include <linux/init.h>
27#include <linux/pci.h>
28#include <linux/slab.h>
29#include <linux/moduleparam.h>
Ingo Molnar62932df2006-01-16 16:34:20 +010030#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include <sound/core.h>
32#include <sound/pcm.h>
33#include <sound/pcm_params.h>
34#include <sound/info.h>
35#include <sound/ac97_codec.h>
36#include <sound/initval.h>
37
38MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
39MODULE_DESCRIPTION("ATI IXP MC97 controller");
40MODULE_LICENSE("GPL");
41MODULE_SUPPORTED_DEVICE("{{ATI,IXP150/200/250}}");
42
Clemens Ladischb7fe4622005-10-04 08:46:51 +020043static int index = -2; /* Exclude the first card */
44static char *id = SNDRV_DEFAULT_STR1; /* ID for this card */
45static int ac97_clock = 48000;
Linus Torvalds1da177e2005-04-16 15:20:36 -070046
Clemens Ladischb7fe4622005-10-04 08:46:51 +020047module_param(index, int, 0444);
Linus Torvalds1da177e2005-04-16 15:20:36 -070048MODULE_PARM_DESC(index, "Index value for ATI IXP controller.");
Clemens Ladischb7fe4622005-10-04 08:46:51 +020049module_param(id, charp, 0444);
Linus Torvalds1da177e2005-04-16 15:20:36 -070050MODULE_PARM_DESC(id, "ID string for ATI IXP controller.");
Clemens Ladischb7fe4622005-10-04 08:46:51 +020051module_param(ac97_clock, int, 0444);
Linus Torvalds1da177e2005-04-16 15:20:36 -070052MODULE_PARM_DESC(ac97_clock, "AC'97 codec clock (default 48000Hz).");
53
Takashi Iwai2b3e5842005-10-06 13:47:23 +020054/* just for backward compatibility */
55static int enable;
Takashi Iwai698444f2005-10-20 16:53:49 +020056module_param(enable, bool, 0444);
Takashi Iwai2b3e5842005-10-06 13:47:23 +020057
Linus Torvalds1da177e2005-04-16 15:20:36 -070058
59/*
60 */
61
62#define ATI_REG_ISR 0x00 /* interrupt source */
63#define ATI_REG_ISR_MODEM_IN_XRUN (1U<<0)
64#define ATI_REG_ISR_MODEM_IN_STATUS (1U<<1)
65#define ATI_REG_ISR_MODEM_OUT1_XRUN (1U<<2)
66#define ATI_REG_ISR_MODEM_OUT1_STATUS (1U<<3)
67#define ATI_REG_ISR_MODEM_OUT2_XRUN (1U<<4)
68#define ATI_REG_ISR_MODEM_OUT2_STATUS (1U<<5)
69#define ATI_REG_ISR_MODEM_OUT3_XRUN (1U<<6)
70#define ATI_REG_ISR_MODEM_OUT3_STATUS (1U<<7)
71#define ATI_REG_ISR_PHYS_INTR (1U<<8)
72#define ATI_REG_ISR_PHYS_MISMATCH (1U<<9)
73#define ATI_REG_ISR_CODEC0_NOT_READY (1U<<10)
74#define ATI_REG_ISR_CODEC1_NOT_READY (1U<<11)
75#define ATI_REG_ISR_CODEC2_NOT_READY (1U<<12)
76#define ATI_REG_ISR_NEW_FRAME (1U<<13)
77#define ATI_REG_ISR_MODEM_GPIO_DATA (1U<<14)
78
79#define ATI_REG_IER 0x04 /* interrupt enable */
80#define ATI_REG_IER_MODEM_IN_XRUN_EN (1U<<0)
81#define ATI_REG_IER_MODEM_STATUS_EN (1U<<1)
82#define ATI_REG_IER_MODEM_OUT1_XRUN_EN (1U<<2)
83#define ATI_REG_IER_MODEM_OUT2_XRUN_EN (1U<<4)
84#define ATI_REG_IER_MODEM_OUT3_XRUN_EN (1U<<6)
85#define ATI_REG_IER_PHYS_INTR_EN (1U<<8)
86#define ATI_REG_IER_PHYS_MISMATCH_EN (1U<<9)
87#define ATI_REG_IER_CODEC0_INTR_EN (1U<<10)
88#define ATI_REG_IER_CODEC1_INTR_EN (1U<<11)
89#define ATI_REG_IER_CODEC2_INTR_EN (1U<<12)
90#define ATI_REG_IER_NEW_FRAME_EN (1U<<13) /* (RO */
91#define ATI_REG_IER_MODEM_GPIO_DATA_EN (1U<<14) /* (WO) modem is running */
92#define ATI_REG_IER_MODEM_SET_BUS_BUSY (1U<<15)
93
94#define ATI_REG_CMD 0x08 /* command */
95#define ATI_REG_CMD_POWERDOWN (1U<<0)
96#define ATI_REG_CMD_MODEM_RECEIVE_EN (1U<<1) /* modem only */
97#define ATI_REG_CMD_MODEM_SEND1_EN (1U<<2) /* modem only */
98#define ATI_REG_CMD_MODEM_SEND2_EN (1U<<3) /* modem only */
99#define ATI_REG_CMD_MODEM_SEND3_EN (1U<<4) /* modem only */
100#define ATI_REG_CMD_MODEM_STATUS_MEM (1U<<5) /* modem only */
101#define ATI_REG_CMD_MODEM_IN_DMA_EN (1U<<8) /* modem only */
102#define ATI_REG_CMD_MODEM_OUT_DMA1_EN (1U<<9) /* modem only */
103#define ATI_REG_CMD_MODEM_OUT_DMA2_EN (1U<<10) /* modem only */
104#define ATI_REG_CMD_MODEM_OUT_DMA3_EN (1U<<11) /* modem only */
105#define ATI_REG_CMD_AUDIO_PRESENT (1U<<20)
106#define ATI_REG_CMD_MODEM_GPIO_THRU_DMA (1U<<22) /* modem only */
107#define ATI_REG_CMD_LOOPBACK_EN (1U<<23)
108#define ATI_REG_CMD_PACKED_DIS (1U<<24)
109#define ATI_REG_CMD_BURST_EN (1U<<25)
110#define ATI_REG_CMD_PANIC_EN (1U<<26)
111#define ATI_REG_CMD_MODEM_PRESENT (1U<<27)
112#define ATI_REG_CMD_ACLINK_ACTIVE (1U<<28)
113#define ATI_REG_CMD_AC_SOFT_RESET (1U<<29)
114#define ATI_REG_CMD_AC_SYNC (1U<<30)
115#define ATI_REG_CMD_AC_RESET (1U<<31)
116
117#define ATI_REG_PHYS_OUT_ADDR 0x0c
118#define ATI_REG_PHYS_OUT_CODEC_MASK (3U<<0)
119#define ATI_REG_PHYS_OUT_RW (1U<<2)
120#define ATI_REG_PHYS_OUT_ADDR_EN (1U<<8)
121#define ATI_REG_PHYS_OUT_ADDR_SHIFT 9
122#define ATI_REG_PHYS_OUT_DATA_SHIFT 16
123
124#define ATI_REG_PHYS_IN_ADDR 0x10
125#define ATI_REG_PHYS_IN_READ_FLAG (1U<<8)
126#define ATI_REG_PHYS_IN_ADDR_SHIFT 9
127#define ATI_REG_PHYS_IN_DATA_SHIFT 16
128
129#define ATI_REG_SLOTREQ 0x14
130
131#define ATI_REG_COUNTER 0x18
132#define ATI_REG_COUNTER_SLOT (3U<<0) /* slot # */
133#define ATI_REG_COUNTER_BITCLOCK (31U<<8)
134
135#define ATI_REG_IN_FIFO_THRESHOLD 0x1c
136
137#define ATI_REG_MODEM_IN_DMA_LINKPTR 0x20
138#define ATI_REG_MODEM_IN_DMA_DT_START 0x24 /* RO */
139#define ATI_REG_MODEM_IN_DMA_DT_NEXT 0x28 /* RO */
140#define ATI_REG_MODEM_IN_DMA_DT_CUR 0x2c /* RO */
141#define ATI_REG_MODEM_IN_DMA_DT_SIZE 0x30
142#define ATI_REG_MODEM_OUT_FIFO 0x34 /* output threshold */
143#define ATI_REG_MODEM_OUT1_DMA_THRESHOLD_MASK (0xf<<16)
144#define ATI_REG_MODEM_OUT1_DMA_THRESHOLD_SHIFT 16
145#define ATI_REG_MODEM_OUT_DMA1_LINKPTR 0x38
146#define ATI_REG_MODEM_OUT_DMA2_LINKPTR 0x3c
147#define ATI_REG_MODEM_OUT_DMA3_LINKPTR 0x40
148#define ATI_REG_MODEM_OUT_DMA1_DT_START 0x44
149#define ATI_REG_MODEM_OUT_DMA1_DT_NEXT 0x48
150#define ATI_REG_MODEM_OUT_DMA1_DT_CUR 0x4c
151#define ATI_REG_MODEM_OUT_DMA2_DT_START 0x50
152#define ATI_REG_MODEM_OUT_DMA2_DT_NEXT 0x54
153#define ATI_REG_MODEM_OUT_DMA2_DT_CUR 0x58
154#define ATI_REG_MODEM_OUT_DMA3_DT_START 0x5c
155#define ATI_REG_MODEM_OUT_DMA3_DT_NEXT 0x60
156#define ATI_REG_MODEM_OUT_DMA3_DT_CUR 0x64
157#define ATI_REG_MODEM_OUT_DMA12_DT_SIZE 0x68
158#define ATI_REG_MODEM_OUT_DMA3_DT_SIZE 0x6c
159#define ATI_REG_MODEM_OUT_FIFO_USED 0x70
160#define ATI_REG_MODEM_OUT_GPIO 0x74
161#define ATI_REG_MODEM_OUT_GPIO_EN 1
162#define ATI_REG_MODEM_OUT_GPIO_DATA_SHIFT 5
163#define ATI_REG_MODEM_IN_GPIO 0x78
164
165#define ATI_REG_MODEM_MIRROR 0x7c
166#define ATI_REG_AUDIO_MIRROR 0x80
167
168#define ATI_REG_MODEM_FIFO_FLUSH 0x88
169#define ATI_REG_MODEM_FIFO_OUT1_FLUSH (1U<<0)
170#define ATI_REG_MODEM_FIFO_OUT2_FLUSH (1U<<1)
171#define ATI_REG_MODEM_FIFO_OUT3_FLUSH (1U<<2)
172#define ATI_REG_MODEM_FIFO_IN_FLUSH (1U<<3)
173
174/* LINKPTR */
175#define ATI_REG_LINKPTR_EN (1U<<0)
176
177#define ATI_MAX_DESCRIPTORS 256 /* max number of descriptor packets */
178
179
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100180struct atiixp_modem;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181
182/*
183 * DMA packate descriptor
184 */
185
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100186struct atiixp_dma_desc {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187 u32 addr; /* DMA buffer address */
188 u16 status; /* status bits */
189 u16 size; /* size of the packet in dwords */
190 u32 next; /* address of the next packet descriptor */
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100191};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192
193/*
194 * stream enum
195 */
196enum { ATI_DMA_PLAYBACK, ATI_DMA_CAPTURE, NUM_ATI_DMAS }; /* DMAs */
197enum { ATI_PCM_OUT, ATI_PCM_IN, NUM_ATI_PCMS }; /* AC97 pcm slots */
198enum { ATI_PCMDEV_ANALOG, NUM_ATI_PCMDEVS }; /* pcm devices */
199
200#define NUM_ATI_CODECS 3
201
202
203/*
204 * constants and callbacks for each DMA type
205 */
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100206struct atiixp_dma_ops {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 int type; /* ATI_DMA_XXX */
208 unsigned int llp_offset; /* LINKPTR offset */
209 unsigned int dt_cur; /* DT_CUR offset */
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100210 /* called from open callback */
211 void (*enable_dma)(struct atiixp_modem *chip, int on);
212 /* called from trigger (START/STOP) */
213 void (*enable_transfer)(struct atiixp_modem *chip, int on);
214 /* called from trigger (STOP only) */
215 void (*flush_dma)(struct atiixp_modem *chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216};
217
218/*
219 * DMA stream
220 */
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100221struct atiixp_dma {
222 const struct atiixp_dma_ops *ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 struct snd_dma_buffer desc_buf;
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100224 struct snd_pcm_substream *substream; /* assigned PCM substream */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225 unsigned int buf_addr, buf_bytes; /* DMA buffer address, bytes */
226 unsigned int period_bytes, periods;
227 int opened;
228 int running;
229 int pcm_open_flag;
230 int ac97_pcm_type; /* index # of ac97_pcm to access, -1 = not used */
231};
232
233/*
234 * ATI IXP chip
235 */
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100236struct atiixp_modem {
237 struct snd_card *card;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 struct pci_dev *pci;
239
240 struct resource *res; /* memory i/o */
241 unsigned long addr;
242 void __iomem *remap_addr;
243 int irq;
244
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100245 struct snd_ac97_bus *ac97_bus;
246 struct snd_ac97 *ac97[NUM_ATI_CODECS];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247
248 spinlock_t reg_lock;
249
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100250 struct atiixp_dma dmas[NUM_ATI_DMAS];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 struct ac97_pcm *pcms[NUM_ATI_PCMS];
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100252 struct snd_pcm *pcmdevs[NUM_ATI_PCMDEVS];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700253
254 int max_channels; /* max. channels for PCM out */
255
256 unsigned int codec_not_ready_bits; /* for codec detection */
257
258 int spdif_over_aclink; /* passed from the module option */
Ingo Molnar62932df2006-01-16 16:34:20 +0100259 struct mutex open_mutex; /* playback open mutex */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260};
261
262
263/*
264 */
Takashi Iwaif40b6892006-07-05 16:51:05 +0200265static struct pci_device_id snd_atiixp_ids[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 { 0x1002, 0x434d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, /* SB200 */
Harald Welte548e7822005-06-27 15:10:56 +0200267 { 0x1002, 0x4378, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, /* SB400 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 { 0, }
269};
270
271MODULE_DEVICE_TABLE(pci, snd_atiixp_ids);
272
273
274/*
275 * lowlevel functions
276 */
277
278/*
279 * update the bits of the given register.
280 * return 1 if the bits changed.
281 */
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100282static int snd_atiixp_update_bits(struct atiixp_modem *chip, unsigned int reg,
283 unsigned int mask, unsigned int value)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284{
285 void __iomem *addr = chip->remap_addr + reg;
286 unsigned int data, old_data;
287 old_data = data = readl(addr);
288 data &= ~mask;
289 data |= value;
290 if (old_data == data)
291 return 0;
292 writel(data, addr);
293 return 1;
294}
295
296/*
297 * macros for easy use
298 */
299#define atiixp_write(chip,reg,value) \
300 writel(value, chip->remap_addr + ATI_REG_##reg)
301#define atiixp_read(chip,reg) \
302 readl(chip->remap_addr + ATI_REG_##reg)
303#define atiixp_update(chip,reg,mask,val) \
304 snd_atiixp_update_bits(chip, ATI_REG_##reg, mask, val)
305
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306/*
307 * handling DMA packets
308 *
309 * we allocate a linear buffer for the DMA, and split it to each packet.
310 * in a future version, a scatter-gather buffer should be implemented.
311 */
312
313#define ATI_DESC_LIST_SIZE \
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100314 PAGE_ALIGN(ATI_MAX_DESCRIPTORS * sizeof(struct atiixp_dma_desc))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315
316/*
317 * build packets ring for the given buffer size.
318 *
319 * IXP handles the buffer descriptors, which are connected as a linked
320 * list. although we can change the list dynamically, in this version,
321 * a static RING of buffer descriptors is used.
322 *
323 * the ring is built in this function, and is set up to the hardware.
324 */
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100325static int atiixp_build_dma_packets(struct atiixp_modem *chip,
326 struct atiixp_dma *dma,
327 struct snd_pcm_substream *substream,
328 unsigned int periods,
329 unsigned int period_bytes)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330{
331 unsigned int i;
332 u32 addr, desc_addr;
333 unsigned long flags;
334
335 if (periods > ATI_MAX_DESCRIPTORS)
336 return -ENOMEM;
337
338 if (dma->desc_buf.area == NULL) {
339 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(chip->pci),
340 ATI_DESC_LIST_SIZE, &dma->desc_buf) < 0)
341 return -ENOMEM;
342 dma->period_bytes = dma->periods = 0; /* clear */
343 }
344
345 if (dma->periods == periods && dma->period_bytes == period_bytes)
346 return 0;
347
348 /* reset DMA before changing the descriptor table */
349 spin_lock_irqsave(&chip->reg_lock, flags);
350 writel(0, chip->remap_addr + dma->ops->llp_offset);
351 dma->ops->enable_dma(chip, 0);
352 dma->ops->enable_dma(chip, 1);
353 spin_unlock_irqrestore(&chip->reg_lock, flags);
354
355 /* fill the entries */
356 addr = (u32)substream->runtime->dma_addr;
357 desc_addr = (u32)dma->desc_buf.addr;
358 for (i = 0; i < periods; i++) {
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100359 struct atiixp_dma_desc *desc;
360 desc = &((struct atiixp_dma_desc *)dma->desc_buf.area)[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 desc->addr = cpu_to_le32(addr);
362 desc->status = 0;
363 desc->size = period_bytes >> 2; /* in dwords */
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100364 desc_addr += sizeof(struct atiixp_dma_desc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 if (i == periods - 1)
366 desc->next = cpu_to_le32((u32)dma->desc_buf.addr);
367 else
368 desc->next = cpu_to_le32(desc_addr);
369 addr += period_bytes;
370 }
371
372 writel((u32)dma->desc_buf.addr | ATI_REG_LINKPTR_EN,
373 chip->remap_addr + dma->ops->llp_offset);
374
375 dma->period_bytes = period_bytes;
376 dma->periods = periods;
377
378 return 0;
379}
380
381/*
382 * remove the ring buffer and release it if assigned
383 */
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100384static void atiixp_clear_dma_packets(struct atiixp_modem *chip,
385 struct atiixp_dma *dma,
386 struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387{
388 if (dma->desc_buf.area) {
389 writel(0, chip->remap_addr + dma->ops->llp_offset);
390 snd_dma_free_pages(&dma->desc_buf);
391 dma->desc_buf.area = NULL;
392 }
393}
394
395/*
396 * AC97 interface
397 */
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100398static int snd_atiixp_acquire_codec(struct atiixp_modem *chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399{
400 int timeout = 1000;
401
402 while (atiixp_read(chip, PHYS_OUT_ADDR) & ATI_REG_PHYS_OUT_ADDR_EN) {
403 if (! timeout--) {
Chuck Ebbert98b4f592005-09-22 21:44:08 -0700404 snd_printk(KERN_WARNING "atiixp-modem: codec acquire timeout\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 return -EBUSY;
406 }
407 udelay(1);
408 }
409 return 0;
410}
411
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100412static unsigned short snd_atiixp_codec_read(struct atiixp_modem *chip,
413 unsigned short codec,
414 unsigned short reg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415{
416 unsigned int data;
417 int timeout;
418
419 if (snd_atiixp_acquire_codec(chip) < 0)
420 return 0xffff;
421 data = (reg << ATI_REG_PHYS_OUT_ADDR_SHIFT) |
422 ATI_REG_PHYS_OUT_ADDR_EN |
423 ATI_REG_PHYS_OUT_RW |
424 codec;
425 atiixp_write(chip, PHYS_OUT_ADDR, data);
426 if (snd_atiixp_acquire_codec(chip) < 0)
427 return 0xffff;
428 timeout = 1000;
429 do {
430 data = atiixp_read(chip, PHYS_IN_ADDR);
431 if (data & ATI_REG_PHYS_IN_READ_FLAG)
432 return data >> ATI_REG_PHYS_IN_DATA_SHIFT;
433 udelay(1);
434 } while (--timeout);
435 /* time out may happen during reset */
436 if (reg < 0x7c)
Chuck Ebbert98b4f592005-09-22 21:44:08 -0700437 snd_printk(KERN_WARNING "atiixp-modem: codec read timeout (reg %x)\n", reg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 return 0xffff;
439}
440
441
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100442static void snd_atiixp_codec_write(struct atiixp_modem *chip,
443 unsigned short codec,
444 unsigned short reg, unsigned short val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445{
446 unsigned int data;
447
448 if (snd_atiixp_acquire_codec(chip) < 0)
449 return;
450 data = ((unsigned int)val << ATI_REG_PHYS_OUT_DATA_SHIFT) |
451 ((unsigned int)reg << ATI_REG_PHYS_OUT_ADDR_SHIFT) |
452 ATI_REG_PHYS_OUT_ADDR_EN | codec;
453 atiixp_write(chip, PHYS_OUT_ADDR, data);
454}
455
456
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100457static unsigned short snd_atiixp_ac97_read(struct snd_ac97 *ac97,
458 unsigned short reg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459{
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100460 struct atiixp_modem *chip = ac97->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 return snd_atiixp_codec_read(chip, ac97->num, reg);
462
463}
464
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100465static void snd_atiixp_ac97_write(struct snd_ac97 *ac97, unsigned short reg,
466 unsigned short val)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467{
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100468 struct atiixp_modem *chip = ac97->private_data;
Sasha Khapyorsky83a5b722005-05-29 15:10:07 +0200469 if (reg == AC97_GPIO_STATUS) {
470 atiixp_write(chip, MODEM_OUT_GPIO,
471 (val << ATI_REG_MODEM_OUT_GPIO_DATA_SHIFT) | ATI_REG_MODEM_OUT_GPIO_EN);
472 return;
473 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 snd_atiixp_codec_write(chip, ac97->num, reg, val);
475}
476
477/*
478 * reset AC link
479 */
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100480static int snd_atiixp_aclink_reset(struct atiixp_modem *chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481{
482 int timeout;
483
484 /* reset powerdoewn */
485 if (atiixp_update(chip, CMD, ATI_REG_CMD_POWERDOWN, 0))
486 udelay(10);
487
488 /* perform a software reset */
489 atiixp_update(chip, CMD, ATI_REG_CMD_AC_SOFT_RESET, ATI_REG_CMD_AC_SOFT_RESET);
490 atiixp_read(chip, CMD);
491 udelay(10);
492 atiixp_update(chip, CMD, ATI_REG_CMD_AC_SOFT_RESET, 0);
493
494 timeout = 10;
495 while (! (atiixp_read(chip, CMD) & ATI_REG_CMD_ACLINK_ACTIVE)) {
496 /* do a hard reset */
497 atiixp_update(chip, CMD, ATI_REG_CMD_AC_SYNC|ATI_REG_CMD_AC_RESET,
498 ATI_REG_CMD_AC_SYNC);
499 atiixp_read(chip, CMD);
Takashi Iwaibfdcbac2005-11-17 10:35:53 +0100500 msleep(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501 atiixp_update(chip, CMD, ATI_REG_CMD_AC_RESET, ATI_REG_CMD_AC_RESET);
502 if (--timeout) {
Chuck Ebbert98b4f592005-09-22 21:44:08 -0700503 snd_printk(KERN_ERR "atiixp-modem: codec reset timeout\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 break;
505 }
506 }
507
508 /* deassert RESET and assert SYNC to make sure */
509 atiixp_update(chip, CMD, ATI_REG_CMD_AC_SYNC|ATI_REG_CMD_AC_RESET,
510 ATI_REG_CMD_AC_SYNC|ATI_REG_CMD_AC_RESET);
511
512 return 0;
513}
514
515#ifdef CONFIG_PM
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100516static int snd_atiixp_aclink_down(struct atiixp_modem *chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517{
518 // if (atiixp_read(chip, MODEM_MIRROR) & 0x1) /* modem running, too? */
519 // return -EBUSY;
520 atiixp_update(chip, CMD,
521 ATI_REG_CMD_POWERDOWN | ATI_REG_CMD_AC_RESET,
522 ATI_REG_CMD_POWERDOWN);
523 return 0;
524}
525#endif
526
527/*
528 * auto-detection of codecs
529 *
530 * the IXP chip can generate interrupts for the non-existing codecs.
531 * NEW_FRAME interrupt is used to make sure that the interrupt is generated
532 * even if all three codecs are connected.
533 */
534
535#define ALL_CODEC_NOT_READY \
536 (ATI_REG_ISR_CODEC0_NOT_READY |\
537 ATI_REG_ISR_CODEC1_NOT_READY |\
538 ATI_REG_ISR_CODEC2_NOT_READY)
539#define CODEC_CHECK_BITS (ALL_CODEC_NOT_READY|ATI_REG_ISR_NEW_FRAME)
540
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100541static int snd_atiixp_codec_detect(struct atiixp_modem *chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542{
543 int timeout;
544
545 chip->codec_not_ready_bits = 0;
546 atiixp_write(chip, IER, CODEC_CHECK_BITS);
547 /* wait for the interrupts */
Takashi Iwaibfdcbac2005-11-17 10:35:53 +0100548 timeout = 50;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 while (timeout-- > 0) {
Takashi Iwaibfdcbac2005-11-17 10:35:53 +0100550 msleep(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551 if (chip->codec_not_ready_bits)
552 break;
553 }
554 atiixp_write(chip, IER, 0); /* disable irqs */
555
556 if ((chip->codec_not_ready_bits & ALL_CODEC_NOT_READY) == ALL_CODEC_NOT_READY) {
Chuck Ebbert98b4f592005-09-22 21:44:08 -0700557 snd_printk(KERN_ERR "atiixp-modem: no codec detected!\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 return -ENXIO;
559 }
560 return 0;
561}
562
563
564/*
565 * enable DMA and irqs
566 */
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100567static int snd_atiixp_chip_start(struct atiixp_modem *chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568{
569 unsigned int reg;
570
571 /* set up spdif, enable burst mode */
572 reg = atiixp_read(chip, CMD);
573 reg |= ATI_REG_CMD_BURST_EN;
574 if(!(reg & ATI_REG_CMD_MODEM_PRESENT))
575 reg |= ATI_REG_CMD_MODEM_PRESENT;
576 atiixp_write(chip, CMD, reg);
577
578 /* clear all interrupt source */
579 atiixp_write(chip, ISR, 0xffffffff);
580 /* enable irqs */
581 atiixp_write(chip, IER,
582 ATI_REG_IER_MODEM_STATUS_EN |
583 ATI_REG_IER_MODEM_IN_XRUN_EN |
584 ATI_REG_IER_MODEM_OUT1_XRUN_EN);
585 return 0;
586}
587
588
589/*
590 * disable DMA and IRQs
591 */
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100592static int snd_atiixp_chip_stop(struct atiixp_modem *chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593{
594 /* clear interrupt source */
595 atiixp_write(chip, ISR, atiixp_read(chip, ISR));
596 /* disable irqs */
597 atiixp_write(chip, IER, 0);
598 return 0;
599}
600
601
602/*
603 * PCM section
604 */
605
606/*
607 * pointer callback simplly reads XXX_DMA_DT_CUR register as the current
608 * position. when SG-buffer is implemented, the offset must be calculated
609 * correctly...
610 */
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100611static snd_pcm_uframes_t snd_atiixp_pcm_pointer(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612{
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100613 struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
614 struct snd_pcm_runtime *runtime = substream->runtime;
615 struct atiixp_dma *dma = runtime->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616 unsigned int curptr;
617 int timeout = 1000;
618
619 while (timeout--) {
620 curptr = readl(chip->remap_addr + dma->ops->dt_cur);
621 if (curptr < dma->buf_addr)
622 continue;
623 curptr -= dma->buf_addr;
624 if (curptr >= dma->buf_bytes)
625 continue;
626 return bytes_to_frames(runtime, curptr);
627 }
628 snd_printd("atiixp-modem: invalid DMA pointer read 0x%x (buf=%x)\n",
629 readl(chip->remap_addr + dma->ops->dt_cur), dma->buf_addr);
630 return 0;
631}
632
633/*
634 * XRUN detected, and stop the PCM substream
635 */
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100636static void snd_atiixp_xrun_dma(struct atiixp_modem *chip,
637 struct atiixp_dma *dma)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638{
639 if (! dma->substream || ! dma->running)
640 return;
Chuck Ebbert98b4f592005-09-22 21:44:08 -0700641 snd_printdd("atiixp-modem: XRUN detected (DMA %d)\n", dma->ops->type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 snd_pcm_stop(dma->substream, SNDRV_PCM_STATE_XRUN);
643}
644
645/*
646 * the period ack. update the substream.
647 */
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100648static void snd_atiixp_update_dma(struct atiixp_modem *chip,
649 struct atiixp_dma *dma)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650{
651 if (! dma->substream || ! dma->running)
652 return;
653 snd_pcm_period_elapsed(dma->substream);
654}
655
656/* set BUS_BUSY interrupt bit if any DMA is running */
657/* call with spinlock held */
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100658static void snd_atiixp_check_bus_busy(struct atiixp_modem *chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659{
660 unsigned int bus_busy;
661 if (atiixp_read(chip, CMD) & (ATI_REG_CMD_MODEM_SEND1_EN |
662 ATI_REG_CMD_MODEM_RECEIVE_EN))
663 bus_busy = ATI_REG_IER_MODEM_SET_BUS_BUSY;
664 else
665 bus_busy = 0;
666 atiixp_update(chip, IER, ATI_REG_IER_MODEM_SET_BUS_BUSY, bus_busy);
667}
668
669/* common trigger callback
670 * calling the lowlevel callbacks in it
671 */
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100672static int snd_atiixp_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673{
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100674 struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
675 struct atiixp_dma *dma = substream->runtime->private_data;
Sasha Khapyorsky83a5b722005-05-29 15:10:07 +0200676 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677
678 snd_assert(dma->ops->enable_transfer && dma->ops->flush_dma, return -EINVAL);
679
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 spin_lock(&chip->reg_lock);
Sasha Khapyorsky83a5b722005-05-29 15:10:07 +0200681 switch(cmd) {
682 case SNDRV_PCM_TRIGGER_START:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 dma->ops->enable_transfer(chip, 1);
684 dma->running = 1;
Sasha Khapyorsky83a5b722005-05-29 15:10:07 +0200685 break;
686 case SNDRV_PCM_TRIGGER_STOP:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 dma->ops->enable_transfer(chip, 0);
688 dma->running = 0;
Sasha Khapyorsky83a5b722005-05-29 15:10:07 +0200689 break;
690 default:
691 err = -EINVAL;
692 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 }
Sasha Khapyorsky83a5b722005-05-29 15:10:07 +0200694 if (! err) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 snd_atiixp_check_bus_busy(chip);
696 if (cmd == SNDRV_PCM_TRIGGER_STOP) {
697 dma->ops->flush_dma(chip);
698 snd_atiixp_check_bus_busy(chip);
699 }
Sasha Khapyorsky83a5b722005-05-29 15:10:07 +0200700 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701 spin_unlock(&chip->reg_lock);
Sasha Khapyorsky83a5b722005-05-29 15:10:07 +0200702 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703}
704
705
706/*
707 * lowlevel callbacks for each DMA type
708 *
709 * every callback is supposed to be called in chip->reg_lock spinlock
710 */
711
712/* flush FIFO of analog OUT DMA */
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100713static void atiixp_out_flush_dma(struct atiixp_modem *chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714{
715 atiixp_write(chip, MODEM_FIFO_FLUSH, ATI_REG_MODEM_FIFO_OUT1_FLUSH);
716}
717
718/* enable/disable analog OUT DMA */
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100719static void atiixp_out_enable_dma(struct atiixp_modem *chip, int on)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720{
721 unsigned int data;
722 data = atiixp_read(chip, CMD);
723 if (on) {
724 if (data & ATI_REG_CMD_MODEM_OUT_DMA1_EN)
725 return;
726 atiixp_out_flush_dma(chip);
727 data |= ATI_REG_CMD_MODEM_OUT_DMA1_EN;
728 } else
729 data &= ~ATI_REG_CMD_MODEM_OUT_DMA1_EN;
730 atiixp_write(chip, CMD, data);
731}
732
733/* start/stop transfer over OUT DMA */
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100734static void atiixp_out_enable_transfer(struct atiixp_modem *chip, int on)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735{
736 atiixp_update(chip, CMD, ATI_REG_CMD_MODEM_SEND1_EN,
737 on ? ATI_REG_CMD_MODEM_SEND1_EN : 0);
738}
739
740/* enable/disable analog IN DMA */
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100741static void atiixp_in_enable_dma(struct atiixp_modem *chip, int on)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742{
743 atiixp_update(chip, CMD, ATI_REG_CMD_MODEM_IN_DMA_EN,
744 on ? ATI_REG_CMD_MODEM_IN_DMA_EN : 0);
745}
746
747/* start/stop analog IN DMA */
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100748static void atiixp_in_enable_transfer(struct atiixp_modem *chip, int on)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749{
750 if (on) {
751 unsigned int data = atiixp_read(chip, CMD);
752 if (! (data & ATI_REG_CMD_MODEM_RECEIVE_EN)) {
753 data |= ATI_REG_CMD_MODEM_RECEIVE_EN;
754 atiixp_write(chip, CMD, data);
755 }
756 } else
757 atiixp_update(chip, CMD, ATI_REG_CMD_MODEM_RECEIVE_EN, 0);
758}
759
760/* flush FIFO of analog IN DMA */
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100761static void atiixp_in_flush_dma(struct atiixp_modem *chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762{
763 atiixp_write(chip, MODEM_FIFO_FLUSH, ATI_REG_MODEM_FIFO_IN_FLUSH);
764}
765
766/* set up slots and formats for analog OUT */
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100767static int snd_atiixp_playback_prepare(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768{
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100769 struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 unsigned int data;
771
772 spin_lock_irq(&chip->reg_lock);
773 /* set output threshold */
774 data = atiixp_read(chip, MODEM_OUT_FIFO);
775 data &= ~ATI_REG_MODEM_OUT1_DMA_THRESHOLD_MASK;
776 data |= 0x04 << ATI_REG_MODEM_OUT1_DMA_THRESHOLD_SHIFT;
777 atiixp_write(chip, MODEM_OUT_FIFO, data);
778 spin_unlock_irq(&chip->reg_lock);
779 return 0;
780}
781
782/* set up slots and formats for analog IN */
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100783static int snd_atiixp_capture_prepare(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784{
785 return 0;
786}
787
788/*
789 * hw_params - allocate the buffer and set up buffer descriptors
790 */
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100791static int snd_atiixp_pcm_hw_params(struct snd_pcm_substream *substream,
792 struct snd_pcm_hw_params *hw_params)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793{
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100794 struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
795 struct atiixp_dma *dma = substream->runtime->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796 int err;
797 int i;
798
799 err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
800 if (err < 0)
801 return err;
802 dma->buf_addr = substream->runtime->dma_addr;
803 dma->buf_bytes = params_buffer_bytes(hw_params);
804
805 err = atiixp_build_dma_packets(chip, dma, substream,
806 params_periods(hw_params),
807 params_period_bytes(hw_params));
808 if (err < 0)
809 return err;
810
811 /* set up modem rate */
812 for (i = 0; i < NUM_ATI_CODECS; i++) {
813 if (! chip->ac97[i])
814 continue;
815 snd_ac97_write(chip->ac97[i], AC97_LINE1_RATE, params_rate(hw_params));
816 snd_ac97_write(chip->ac97[i], AC97_LINE1_LEVEL, 0);
817 }
818
819 return err;
820}
821
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100822static int snd_atiixp_pcm_hw_free(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823{
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100824 struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
825 struct atiixp_dma *dma = substream->runtime->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826
827 atiixp_clear_dma_packets(chip, dma, substream);
828 snd_pcm_lib_free_pages(substream);
829 return 0;
830}
831
832
833/*
834 * pcm hardware definition, identical for all DMA types
835 */
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100836static struct snd_pcm_hardware snd_atiixp_pcm_hw =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837{
838 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
839 SNDRV_PCM_INFO_BLOCK_TRANSFER |
840 SNDRV_PCM_INFO_MMAP_VALID),
841 .formats = SNDRV_PCM_FMTBIT_S16_LE,
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100842 .rates = (SNDRV_PCM_RATE_8000 |
843 SNDRV_PCM_RATE_16000 |
844 SNDRV_PCM_RATE_KNOT),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845 .rate_min = 8000,
846 .rate_max = 16000,
847 .channels_min = 2,
848 .channels_max = 2,
849 .buffer_bytes_max = 256 * 1024,
850 .period_bytes_min = 32,
851 .period_bytes_max = 128 * 1024,
852 .periods_min = 2,
853 .periods_max = ATI_MAX_DESCRIPTORS,
854};
855
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100856static int snd_atiixp_pcm_open(struct snd_pcm_substream *substream,
857 struct atiixp_dma *dma, int pcm_type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858{
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100859 struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
860 struct snd_pcm_runtime *runtime = substream->runtime;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 int err;
862 static unsigned int rates[] = { 8000, 9600, 12000, 16000 };
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100863 static struct snd_pcm_hw_constraint_list hw_constraints_rates = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 .count = ARRAY_SIZE(rates),
865 .list = rates,
866 .mask = 0,
867 };
868
869 snd_assert(dma->ops && dma->ops->enable_dma, return -EINVAL);
870
871 if (dma->opened)
872 return -EBUSY;
873 dma->substream = substream;
874 runtime->hw = snd_atiixp_pcm_hw;
875 dma->ac97_pcm_type = pcm_type;
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100876 if ((err = snd_pcm_hw_constraint_list(runtime, 0,
877 SNDRV_PCM_HW_PARAM_RATE,
878 &hw_constraints_rates)) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 return err;
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100880 if ((err = snd_pcm_hw_constraint_integer(runtime,
881 SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882 return err;
883 runtime->private_data = dma;
884
885 /* enable DMA bits */
886 spin_lock_irq(&chip->reg_lock);
887 dma->ops->enable_dma(chip, 1);
888 spin_unlock_irq(&chip->reg_lock);
889 dma->opened = 1;
890
891 return 0;
892}
893
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100894static int snd_atiixp_pcm_close(struct snd_pcm_substream *substream,
895 struct atiixp_dma *dma)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896{
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100897 struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898 /* disable DMA bits */
899 snd_assert(dma->ops && dma->ops->enable_dma, return -EINVAL);
900 spin_lock_irq(&chip->reg_lock);
901 dma->ops->enable_dma(chip, 0);
902 spin_unlock_irq(&chip->reg_lock);
903 dma->substream = NULL;
904 dma->opened = 0;
905 return 0;
906}
907
908/*
909 */
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100910static int snd_atiixp_playback_open(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911{
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100912 struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913 int err;
914
Ingo Molnar62932df2006-01-16 16:34:20 +0100915 mutex_lock(&chip->open_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916 err = snd_atiixp_pcm_open(substream, &chip->dmas[ATI_DMA_PLAYBACK], 0);
Ingo Molnar62932df2006-01-16 16:34:20 +0100917 mutex_unlock(&chip->open_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918 if (err < 0)
919 return err;
920 return 0;
921}
922
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100923static int snd_atiixp_playback_close(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924{
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100925 struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926 int err;
Ingo Molnar62932df2006-01-16 16:34:20 +0100927 mutex_lock(&chip->open_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928 err = snd_atiixp_pcm_close(substream, &chip->dmas[ATI_DMA_PLAYBACK]);
Ingo Molnar62932df2006-01-16 16:34:20 +0100929 mutex_unlock(&chip->open_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930 return err;
931}
932
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100933static int snd_atiixp_capture_open(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934{
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100935 struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936 return snd_atiixp_pcm_open(substream, &chip->dmas[ATI_DMA_CAPTURE], 1);
937}
938
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100939static int snd_atiixp_capture_close(struct snd_pcm_substream *substream)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940{
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100941 struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942 return snd_atiixp_pcm_close(substream, &chip->dmas[ATI_DMA_CAPTURE]);
943}
944
945
946/* AC97 playback */
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100947static struct snd_pcm_ops snd_atiixp_playback_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948 .open = snd_atiixp_playback_open,
949 .close = snd_atiixp_playback_close,
950 .ioctl = snd_pcm_lib_ioctl,
951 .hw_params = snd_atiixp_pcm_hw_params,
952 .hw_free = snd_atiixp_pcm_hw_free,
953 .prepare = snd_atiixp_playback_prepare,
954 .trigger = snd_atiixp_pcm_trigger,
955 .pointer = snd_atiixp_pcm_pointer,
956};
957
958/* AC97 capture */
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100959static struct snd_pcm_ops snd_atiixp_capture_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960 .open = snd_atiixp_capture_open,
961 .close = snd_atiixp_capture_close,
962 .ioctl = snd_pcm_lib_ioctl,
963 .hw_params = snd_atiixp_pcm_hw_params,
964 .hw_free = snd_atiixp_pcm_hw_free,
965 .prepare = snd_atiixp_capture_prepare,
966 .trigger = snd_atiixp_pcm_trigger,
967 .pointer = snd_atiixp_pcm_pointer,
968};
969
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100970static struct atiixp_dma_ops snd_atiixp_playback_dma_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971 .type = ATI_DMA_PLAYBACK,
972 .llp_offset = ATI_REG_MODEM_OUT_DMA1_LINKPTR,
973 .dt_cur = ATI_REG_MODEM_OUT_DMA1_DT_CUR,
974 .enable_dma = atiixp_out_enable_dma,
975 .enable_transfer = atiixp_out_enable_transfer,
976 .flush_dma = atiixp_out_flush_dma,
977};
978
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100979static struct atiixp_dma_ops snd_atiixp_capture_dma_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980 .type = ATI_DMA_CAPTURE,
981 .llp_offset = ATI_REG_MODEM_IN_DMA_LINKPTR,
982 .dt_cur = ATI_REG_MODEM_IN_DMA_DT_CUR,
983 .enable_dma = atiixp_in_enable_dma,
984 .enable_transfer = atiixp_in_enable_transfer,
985 .flush_dma = atiixp_in_flush_dma,
986};
987
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100988static int __devinit snd_atiixp_pcm_new(struct atiixp_modem *chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989{
Takashi Iwai74ee4ff2005-11-17 15:02:23 +0100990 struct snd_pcm *pcm;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991 int err;
992
993 /* initialize constants */
994 chip->dmas[ATI_DMA_PLAYBACK].ops = &snd_atiixp_playback_dma_ops;
995 chip->dmas[ATI_DMA_CAPTURE].ops = &snd_atiixp_capture_dma_ops;
996
997 /* PCM #0: analog I/O */
998 err = snd_pcm_new(chip->card, "ATI IXP MC97", ATI_PCMDEV_ANALOG, 1, 1, &pcm);
999 if (err < 0)
1000 return err;
1001 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_atiixp_playback_ops);
1002 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_atiixp_capture_ops);
Sasha Khapyorsky6632d192005-09-29 11:48:17 +02001003 pcm->dev_class = SNDRV_PCM_CLASS_MODEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004 pcm->private_data = chip;
1005 strcpy(pcm->name, "ATI IXP MC97");
1006 chip->pcmdevs[ATI_PCMDEV_ANALOG] = pcm;
1007
1008 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
Takashi Iwai74ee4ff2005-11-17 15:02:23 +01001009 snd_dma_pci_data(chip->pci),
1010 64*1024, 128*1024);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011
1012 return 0;
1013}
1014
1015
1016
1017/*
1018 * interrupt handler
1019 */
David Howells7d12e782006-10-05 14:55:46 +01001020static irqreturn_t snd_atiixp_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021{
Takashi Iwai74ee4ff2005-11-17 15:02:23 +01001022 struct atiixp_modem *chip = dev_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023 unsigned int status;
1024
1025 status = atiixp_read(chip, ISR);
1026
1027 if (! status)
1028 return IRQ_NONE;
1029
1030 /* process audio DMA */
1031 if (status & ATI_REG_ISR_MODEM_OUT1_XRUN)
1032 snd_atiixp_xrun_dma(chip, &chip->dmas[ATI_DMA_PLAYBACK]);
1033 else if (status & ATI_REG_ISR_MODEM_OUT1_STATUS)
1034 snd_atiixp_update_dma(chip, &chip->dmas[ATI_DMA_PLAYBACK]);
1035 if (status & ATI_REG_ISR_MODEM_IN_XRUN)
1036 snd_atiixp_xrun_dma(chip, &chip->dmas[ATI_DMA_CAPTURE]);
1037 else if (status & ATI_REG_ISR_MODEM_IN_STATUS)
1038 snd_atiixp_update_dma(chip, &chip->dmas[ATI_DMA_CAPTURE]);
1039
1040 /* for codec detection */
1041 if (status & CODEC_CHECK_BITS) {
1042 unsigned int detected;
1043 detected = status & CODEC_CHECK_BITS;
1044 spin_lock(&chip->reg_lock);
1045 chip->codec_not_ready_bits |= detected;
1046 atiixp_update(chip, IER, detected, 0); /* disable the detected irqs */
1047 spin_unlock(&chip->reg_lock);
1048 }
1049
1050 /* ack */
1051 atiixp_write(chip, ISR, status);
1052
1053 return IRQ_HANDLED;
1054}
1055
1056
1057/*
1058 * ac97 mixer section
1059 */
1060
Takashi Iwai74ee4ff2005-11-17 15:02:23 +01001061static int __devinit snd_atiixp_mixer_new(struct atiixp_modem *chip, int clock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062{
Takashi Iwai74ee4ff2005-11-17 15:02:23 +01001063 struct snd_ac97_bus *pbus;
1064 struct snd_ac97_template ac97;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065 int i, err;
1066 int codec_count;
Takashi Iwai74ee4ff2005-11-17 15:02:23 +01001067 static struct snd_ac97_bus_ops ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068 .write = snd_atiixp_ac97_write,
1069 .read = snd_atiixp_ac97_read,
1070 };
1071 static unsigned int codec_skip[NUM_ATI_CODECS] = {
1072 ATI_REG_ISR_CODEC0_NOT_READY,
1073 ATI_REG_ISR_CODEC1_NOT_READY,
1074 ATI_REG_ISR_CODEC2_NOT_READY,
1075 };
1076
1077 if (snd_atiixp_codec_detect(chip) < 0)
1078 return -ENXIO;
1079
1080 if ((err = snd_ac97_bus(chip->card, 0, &ops, chip, &pbus)) < 0)
1081 return err;
1082 pbus->clock = clock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083 chip->ac97_bus = pbus;
1084
1085 codec_count = 0;
1086 for (i = 0; i < NUM_ATI_CODECS; i++) {
1087 if (chip->codec_not_ready_bits & codec_skip[i])
1088 continue;
1089 memset(&ac97, 0, sizeof(ac97));
1090 ac97.private_data = chip;
1091 ac97.pci = chip->pci;
1092 ac97.num = i;
1093 ac97.scaps = AC97_SCAP_SKIP_AUDIO;
1094 if ((err = snd_ac97_mixer(pbus, &ac97, &chip->ac97[i])) < 0) {
1095 chip->ac97[i] = NULL; /* to be sure */
Chuck Ebbert98b4f592005-09-22 21:44:08 -07001096 snd_printdd("atiixp-modem: codec %d not available for modem\n", i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097 continue;
1098 }
1099 codec_count++;
1100 }
1101
1102 if (! codec_count) {
Chuck Ebbert98b4f592005-09-22 21:44:08 -07001103 snd_printk(KERN_ERR "atiixp-modem: no codec available\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104 return -ENODEV;
1105 }
1106
1107 /* snd_ac97_tune_hardware(chip->ac97, ac97_quirks); */
1108
1109 return 0;
1110}
1111
1112
1113#ifdef CONFIG_PM
1114/*
1115 * power management
1116 */
Takashi Iwai92304cc2005-11-17 16:07:46 +01001117static int snd_atiixp_suspend(struct pci_dev *pci, pm_message_t state)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118{
Takashi Iwai92304cc2005-11-17 16:07:46 +01001119 struct snd_card *card = pci_get_drvdata(pci);
1120 struct atiixp_modem *chip = card->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121 int i;
1122
Takashi Iwai92304cc2005-11-17 16:07:46 +01001123 snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124 for (i = 0; i < NUM_ATI_PCMDEVS; i++)
Takashi Iwai92304cc2005-11-17 16:07:46 +01001125 snd_pcm_suspend_all(chip->pcmdevs[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126 for (i = 0; i < NUM_ATI_CODECS; i++)
Takashi Iwai92304cc2005-11-17 16:07:46 +01001127 snd_ac97_suspend(chip->ac97[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128 snd_atiixp_aclink_down(chip);
1129 snd_atiixp_chip_stop(chip);
1130
Takashi Iwai92304cc2005-11-17 16:07:46 +01001131 pci_set_power_state(pci, PCI_D3hot);
1132 pci_disable_device(pci);
1133 pci_save_state(pci);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134 return 0;
1135}
1136
Takashi Iwai92304cc2005-11-17 16:07:46 +01001137static int snd_atiixp_resume(struct pci_dev *pci)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138{
Takashi Iwai92304cc2005-11-17 16:07:46 +01001139 struct snd_card *card = pci_get_drvdata(pci);
1140 struct atiixp_modem *chip = card->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141 int i;
1142
Takashi Iwai92304cc2005-11-17 16:07:46 +01001143 pci_restore_state(pci);
1144 pci_enable_device(pci);
1145 pci_set_power_state(pci, PCI_D0);
1146 pci_set_master(pci);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147
1148 snd_atiixp_aclink_reset(chip);
1149 snd_atiixp_chip_start(chip);
1150
1151 for (i = 0; i < NUM_ATI_CODECS; i++)
Takashi Iwai92304cc2005-11-17 16:07:46 +01001152 snd_ac97_resume(chip->ac97[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153
Takashi Iwai92304cc2005-11-17 16:07:46 +01001154 snd_power_change_state(card, SNDRV_CTL_POWER_D0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155 return 0;
1156}
1157#endif /* CONFIG_PM */
1158
1159
Takashi Iwaiadf1b3d2005-12-01 10:49:58 +01001160#ifdef CONFIG_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161/*
1162 * proc interface for register dump
1163 */
1164
Takashi Iwai74ee4ff2005-11-17 15:02:23 +01001165static void snd_atiixp_proc_read(struct snd_info_entry *entry,
1166 struct snd_info_buffer *buffer)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167{
Takashi Iwai74ee4ff2005-11-17 15:02:23 +01001168 struct atiixp_modem *chip = entry->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169 int i;
1170
1171 for (i = 0; i < 256; i += 4)
1172 snd_iprintf(buffer, "%02x: %08x\n", i, readl(chip->remap_addr + i));
1173}
1174
Takashi Iwai74ee4ff2005-11-17 15:02:23 +01001175static void __devinit snd_atiixp_proc_init(struct atiixp_modem *chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176{
Takashi Iwai74ee4ff2005-11-17 15:02:23 +01001177 struct snd_info_entry *entry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178
Chuck Ebbert98b4f592005-09-22 21:44:08 -07001179 if (! snd_card_proc_new(chip->card, "atiixp-modem", &entry))
Takashi Iwaibf850202006-04-28 15:13:41 +02001180 snd_info_set_text_ops(entry, chip, snd_atiixp_proc_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181}
Takashi Iwaiadf1b3d2005-12-01 10:49:58 +01001182#else
1183#define snd_atiixp_proc_init(chip)
1184#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185
1186
1187/*
1188 * destructor
1189 */
1190
Takashi Iwai74ee4ff2005-11-17 15:02:23 +01001191static int snd_atiixp_free(struct atiixp_modem *chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192{
1193 if (chip->irq < 0)
1194 goto __hw_end;
1195 snd_atiixp_chip_stop(chip);
1196 synchronize_irq(chip->irq);
1197 __hw_end:
1198 if (chip->irq >= 0)
Takashi Iwai74ee4ff2005-11-17 15:02:23 +01001199 free_irq(chip->irq, chip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200 if (chip->remap_addr)
1201 iounmap(chip->remap_addr);
1202 pci_release_regions(chip->pci);
1203 pci_disable_device(chip->pci);
1204 kfree(chip);
1205 return 0;
1206}
1207
Takashi Iwai74ee4ff2005-11-17 15:02:23 +01001208static int snd_atiixp_dev_free(struct snd_device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001209{
Takashi Iwai74ee4ff2005-11-17 15:02:23 +01001210 struct atiixp_modem *chip = device->device_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001211 return snd_atiixp_free(chip);
1212}
1213
1214/*
1215 * constructor for chip instance
1216 */
Takashi Iwai74ee4ff2005-11-17 15:02:23 +01001217static int __devinit snd_atiixp_create(struct snd_card *card,
1218 struct pci_dev *pci,
1219 struct atiixp_modem **r_chip)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220{
Takashi Iwai74ee4ff2005-11-17 15:02:23 +01001221 static struct snd_device_ops ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222 .dev_free = snd_atiixp_dev_free,
1223 };
Takashi Iwai74ee4ff2005-11-17 15:02:23 +01001224 struct atiixp_modem *chip;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225 int err;
1226
1227 if ((err = pci_enable_device(pci)) < 0)
1228 return err;
1229
Takashi Iwaie560d8d2005-09-09 14:21:46 +02001230 chip = kzalloc(sizeof(*chip), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231 if (chip == NULL) {
1232 pci_disable_device(pci);
1233 return -ENOMEM;
1234 }
1235
1236 spin_lock_init(&chip->reg_lock);
Ingo Molnar62932df2006-01-16 16:34:20 +01001237 mutex_init(&chip->open_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238 chip->card = card;
1239 chip->pci = pci;
1240 chip->irq = -1;
1241 if ((err = pci_request_regions(pci, "ATI IXP MC97")) < 0) {
1242 kfree(chip);
1243 pci_disable_device(pci);
1244 return err;
1245 }
1246 chip->addr = pci_resource_start(pci, 0);
1247 chip->remap_addr = ioremap_nocache(chip->addr, pci_resource_len(pci, 0));
1248 if (chip->remap_addr == NULL) {
1249 snd_printk(KERN_ERR "AC'97 space ioremap problem\n");
1250 snd_atiixp_free(chip);
1251 return -EIO;
1252 }
1253
Thomas Gleixner65ca68b2006-07-01 19:29:46 -07001254 if (request_irq(pci->irq, snd_atiixp_interrupt, IRQF_DISABLED|IRQF_SHARED,
Takashi Iwai74ee4ff2005-11-17 15:02:23 +01001255 card->shortname, chip)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256 snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
1257 snd_atiixp_free(chip);
1258 return -EBUSY;
1259 }
1260 chip->irq = pci->irq;
1261 pci_set_master(pci);
1262 synchronize_irq(chip->irq);
1263
1264 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
1265 snd_atiixp_free(chip);
1266 return err;
1267 }
1268
1269 snd_card_set_dev(card, &pci->dev);
1270
1271 *r_chip = chip;
1272 return 0;
1273}
1274
1275
1276static int __devinit snd_atiixp_probe(struct pci_dev *pci,
1277 const struct pci_device_id *pci_id)
1278{
Takashi Iwai74ee4ff2005-11-17 15:02:23 +01001279 struct snd_card *card;
1280 struct atiixp_modem *chip;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281 unsigned char revision;
1282 int err;
1283
Clemens Ladischb7fe4622005-10-04 08:46:51 +02001284 card = snd_card_new(index, id, THIS_MODULE, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285 if (card == NULL)
1286 return -ENOMEM;
1287
1288 pci_read_config_byte(pci, PCI_REVISION_ID, &revision);
1289
1290 strcpy(card->driver, "ATIIXP-MODEM");
1291 strcpy(card->shortname, "ATI IXP Modem");
1292 if ((err = snd_atiixp_create(card, pci, &chip)) < 0)
1293 goto __error;
Takashi Iwai92304cc2005-11-17 16:07:46 +01001294 card->private_data = chip;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295
1296 if ((err = snd_atiixp_aclink_reset(chip)) < 0)
1297 goto __error;
1298
Clemens Ladischb7fe4622005-10-04 08:46:51 +02001299 if ((err = snd_atiixp_mixer_new(chip, ac97_clock)) < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300 goto __error;
1301
1302 if ((err = snd_atiixp_pcm_new(chip)) < 0)
1303 goto __error;
1304
1305 snd_atiixp_proc_init(chip);
1306
1307 snd_atiixp_chip_start(chip);
1308
1309 sprintf(card->longname, "%s rev %x at 0x%lx, irq %i",
1310 card->shortname, revision, chip->addr, chip->irq);
1311
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312 if ((err = snd_card_register(card)) < 0)
1313 goto __error;
1314
1315 pci_set_drvdata(pci, card);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316 return 0;
1317
1318 __error:
1319 snd_card_free(card);
1320 return err;
1321}
1322
1323static void __devexit snd_atiixp_remove(struct pci_dev *pci)
1324{
1325 snd_card_free(pci_get_drvdata(pci));
1326 pci_set_drvdata(pci, NULL);
1327}
1328
1329static struct pci_driver driver = {
1330 .name = "ATI IXP MC97 controller",
1331 .id_table = snd_atiixp_ids,
1332 .probe = snd_atiixp_probe,
1333 .remove = __devexit_p(snd_atiixp_remove),
Takashi Iwai92304cc2005-11-17 16:07:46 +01001334#ifdef CONFIG_PM
1335 .suspend = snd_atiixp_suspend,
1336 .resume = snd_atiixp_resume,
1337#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338};
1339
1340
1341static int __init alsa_card_atiixp_init(void)
1342{
Takashi Iwai01d25d42005-04-11 16:58:24 +02001343 return pci_register_driver(&driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344}
1345
1346static void __exit alsa_card_atiixp_exit(void)
1347{
1348 pci_unregister_driver(&driver);
1349}
1350
1351module_init(alsa_card_atiixp_init)
1352module_exit(alsa_card_atiixp_exit)