Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
atiixp_modem.c
Go to the documentation of this file.
1 /*
2  * ALSA driver for ATI IXP 150/200/250 AC97 modem controllers
3  *
4  * Copyright (c) 2004 Takashi Iwai <[email protected]>
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 <asm/io.h>
23 #include <linux/delay.h>
24 #include <linux/interrupt.h>
25 #include <linux/init.h>
26 #include <linux/pci.h>
27 #include <linux/slab.h>
28 #include <linux/module.h>
29 #include <linux/mutex.h>
30 #include <sound/core.h>
31 #include <sound/pcm.h>
32 #include <sound/pcm_params.h>
33 #include <sound/info.h>
34 #include <sound/ac97_codec.h>
35 #include <sound/initval.h>
36 
37 MODULE_AUTHOR("Takashi Iwai <[email protected]>");
38 MODULE_DESCRIPTION("ATI IXP MC97 controller");
39 MODULE_LICENSE("GPL");
40 MODULE_SUPPORTED_DEVICE("{{ATI,IXP150/200/250}}");
41 
42 static int index = -2; /* Exclude the first card */
43 static char *id = SNDRV_DEFAULT_STR1; /* ID for this card */
44 static int ac97_clock = 48000;
45 
46 module_param(index, int, 0444);
47 MODULE_PARM_DESC(index, "Index value for ATI IXP controller.");
48 module_param(id, charp, 0444);
49 MODULE_PARM_DESC(id, "ID string for ATI IXP controller.");
50 module_param(ac97_clock, int, 0444);
51 MODULE_PARM_DESC(ac97_clock, "AC'97 codec clock (default 48000Hz).");
52 
53 /* just for backward compatibility */
54 static bool enable;
55 module_param(enable, bool, 0444);
56 
57 
58 /*
59  */
60 
61 #define ATI_REG_ISR 0x00 /* interrupt source */
62 #define ATI_REG_ISR_MODEM_IN_XRUN (1U<<0)
63 #define ATI_REG_ISR_MODEM_IN_STATUS (1U<<1)
64 #define ATI_REG_ISR_MODEM_OUT1_XRUN (1U<<2)
65 #define ATI_REG_ISR_MODEM_OUT1_STATUS (1U<<3)
66 #define ATI_REG_ISR_MODEM_OUT2_XRUN (1U<<4)
67 #define ATI_REG_ISR_MODEM_OUT2_STATUS (1U<<5)
68 #define ATI_REG_ISR_MODEM_OUT3_XRUN (1U<<6)
69 #define ATI_REG_ISR_MODEM_OUT3_STATUS (1U<<7)
70 #define ATI_REG_ISR_PHYS_INTR (1U<<8)
71 #define ATI_REG_ISR_PHYS_MISMATCH (1U<<9)
72 #define ATI_REG_ISR_CODEC0_NOT_READY (1U<<10)
73 #define ATI_REG_ISR_CODEC1_NOT_READY (1U<<11)
74 #define ATI_REG_ISR_CODEC2_NOT_READY (1U<<12)
75 #define ATI_REG_ISR_NEW_FRAME (1U<<13)
76 #define ATI_REG_ISR_MODEM_GPIO_DATA (1U<<14)
77 
78 #define ATI_REG_IER 0x04 /* interrupt enable */
79 #define ATI_REG_IER_MODEM_IN_XRUN_EN (1U<<0)
80 #define ATI_REG_IER_MODEM_STATUS_EN (1U<<1)
81 #define ATI_REG_IER_MODEM_OUT1_XRUN_EN (1U<<2)
82 #define ATI_REG_IER_MODEM_OUT2_XRUN_EN (1U<<4)
83 #define ATI_REG_IER_MODEM_OUT3_XRUN_EN (1U<<6)
84 #define ATI_REG_IER_PHYS_INTR_EN (1U<<8)
85 #define ATI_REG_IER_PHYS_MISMATCH_EN (1U<<9)
86 #define ATI_REG_IER_CODEC0_INTR_EN (1U<<10)
87 #define ATI_REG_IER_CODEC1_INTR_EN (1U<<11)
88 #define ATI_REG_IER_CODEC2_INTR_EN (1U<<12)
89 #define ATI_REG_IER_NEW_FRAME_EN (1U<<13) /* (RO */
90 #define ATI_REG_IER_MODEM_GPIO_DATA_EN (1U<<14) /* (WO) modem is running */
91 #define ATI_REG_IER_MODEM_SET_BUS_BUSY (1U<<15)
92 
93 #define ATI_REG_CMD 0x08 /* command */
94 #define ATI_REG_CMD_POWERDOWN (1U<<0)
95 #define ATI_REG_CMD_MODEM_RECEIVE_EN (1U<<1) /* modem only */
96 #define ATI_REG_CMD_MODEM_SEND1_EN (1U<<2) /* modem only */
97 #define ATI_REG_CMD_MODEM_SEND2_EN (1U<<3) /* modem only */
98 #define ATI_REG_CMD_MODEM_SEND3_EN (1U<<4) /* modem only */
99 #define ATI_REG_CMD_MODEM_STATUS_MEM (1U<<5) /* modem only */
100 #define ATI_REG_CMD_MODEM_IN_DMA_EN (1U<<8) /* modem only */
101 #define ATI_REG_CMD_MODEM_OUT_DMA1_EN (1U<<9) /* modem only */
102 #define ATI_REG_CMD_MODEM_OUT_DMA2_EN (1U<<10) /* modem only */
103 #define ATI_REG_CMD_MODEM_OUT_DMA3_EN (1U<<11) /* modem only */
104 #define ATI_REG_CMD_AUDIO_PRESENT (1U<<20)
105 #define ATI_REG_CMD_MODEM_GPIO_THRU_DMA (1U<<22) /* modem only */
106 #define ATI_REG_CMD_LOOPBACK_EN (1U<<23)
107 #define ATI_REG_CMD_PACKED_DIS (1U<<24)
108 #define ATI_REG_CMD_BURST_EN (1U<<25)
109 #define ATI_REG_CMD_PANIC_EN (1U<<26)
110 #define ATI_REG_CMD_MODEM_PRESENT (1U<<27)
111 #define ATI_REG_CMD_ACLINK_ACTIVE (1U<<28)
112 #define ATI_REG_CMD_AC_SOFT_RESET (1U<<29)
113 #define ATI_REG_CMD_AC_SYNC (1U<<30)
114 #define ATI_REG_CMD_AC_RESET (1U<<31)
115 
116 #define ATI_REG_PHYS_OUT_ADDR 0x0c
117 #define ATI_REG_PHYS_OUT_CODEC_MASK (3U<<0)
118 #define ATI_REG_PHYS_OUT_RW (1U<<2)
119 #define ATI_REG_PHYS_OUT_ADDR_EN (1U<<8)
120 #define ATI_REG_PHYS_OUT_ADDR_SHIFT 9
121 #define ATI_REG_PHYS_OUT_DATA_SHIFT 16
122 
123 #define ATI_REG_PHYS_IN_ADDR 0x10
124 #define ATI_REG_PHYS_IN_READ_FLAG (1U<<8)
125 #define ATI_REG_PHYS_IN_ADDR_SHIFT 9
126 #define ATI_REG_PHYS_IN_DATA_SHIFT 16
127 
128 #define ATI_REG_SLOTREQ 0x14
129 
130 #define ATI_REG_COUNTER 0x18
131 #define ATI_REG_COUNTER_SLOT (3U<<0) /* slot # */
132 #define ATI_REG_COUNTER_BITCLOCK (31U<<8)
133 
134 #define ATI_REG_IN_FIFO_THRESHOLD 0x1c
135 
136 #define ATI_REG_MODEM_IN_DMA_LINKPTR 0x20
137 #define ATI_REG_MODEM_IN_DMA_DT_START 0x24 /* RO */
138 #define ATI_REG_MODEM_IN_DMA_DT_NEXT 0x28 /* RO */
139 #define ATI_REG_MODEM_IN_DMA_DT_CUR 0x2c /* RO */
140 #define ATI_REG_MODEM_IN_DMA_DT_SIZE 0x30
141 #define ATI_REG_MODEM_OUT_FIFO 0x34 /* output threshold */
142 #define ATI_REG_MODEM_OUT1_DMA_THRESHOLD_MASK (0xf<<16)
143 #define ATI_REG_MODEM_OUT1_DMA_THRESHOLD_SHIFT 16
144 #define ATI_REG_MODEM_OUT_DMA1_LINKPTR 0x38
145 #define ATI_REG_MODEM_OUT_DMA2_LINKPTR 0x3c
146 #define ATI_REG_MODEM_OUT_DMA3_LINKPTR 0x40
147 #define ATI_REG_MODEM_OUT_DMA1_DT_START 0x44
148 #define ATI_REG_MODEM_OUT_DMA1_DT_NEXT 0x48
149 #define ATI_REG_MODEM_OUT_DMA1_DT_CUR 0x4c
150 #define ATI_REG_MODEM_OUT_DMA2_DT_START 0x50
151 #define ATI_REG_MODEM_OUT_DMA2_DT_NEXT 0x54
152 #define ATI_REG_MODEM_OUT_DMA2_DT_CUR 0x58
153 #define ATI_REG_MODEM_OUT_DMA3_DT_START 0x5c
154 #define ATI_REG_MODEM_OUT_DMA3_DT_NEXT 0x60
155 #define ATI_REG_MODEM_OUT_DMA3_DT_CUR 0x64
156 #define ATI_REG_MODEM_OUT_DMA12_DT_SIZE 0x68
157 #define ATI_REG_MODEM_OUT_DMA3_DT_SIZE 0x6c
158 #define ATI_REG_MODEM_OUT_FIFO_USED 0x70
159 #define ATI_REG_MODEM_OUT_GPIO 0x74
160 #define ATI_REG_MODEM_OUT_GPIO_EN 1
161 #define ATI_REG_MODEM_OUT_GPIO_DATA_SHIFT 5
162 #define ATI_REG_MODEM_IN_GPIO 0x78
163 
164 #define ATI_REG_MODEM_MIRROR 0x7c
165 #define ATI_REG_AUDIO_MIRROR 0x80
166 
167 #define ATI_REG_MODEM_FIFO_FLUSH 0x88
168 #define ATI_REG_MODEM_FIFO_OUT1_FLUSH (1U<<0)
169 #define ATI_REG_MODEM_FIFO_OUT2_FLUSH (1U<<1)
170 #define ATI_REG_MODEM_FIFO_OUT3_FLUSH (1U<<2)
171 #define ATI_REG_MODEM_FIFO_IN_FLUSH (1U<<3)
172 
173 /* LINKPTR */
174 #define ATI_REG_LINKPTR_EN (1U<<0)
175 
176 #define ATI_MAX_DESCRIPTORS 256 /* max number of descriptor packets */
177 
178 
179 struct atiixp_modem;
180 
181 /*
182  * DMA packate descriptor
183  */
184 
185 struct atiixp_dma_desc {
186  u32 addr; /* DMA buffer address */
187  u16 status; /* status bits */
188  u16 size; /* size of the packet in dwords */
189  u32 next; /* address of the next packet descriptor */
190 };
191 
192 /*
193  * stream enum
194  */
196 enum { ATI_PCM_OUT, ATI_PCM_IN, NUM_ATI_PCMS }; /* AC97 pcm slots */
197 enum { ATI_PCMDEV_ANALOG, NUM_ATI_PCMDEVS }; /* pcm devices */
198 
199 #define NUM_ATI_CODECS 3
200 
201 
202 /*
203  * constants and callbacks for each DMA type
204  */
205 struct atiixp_dma_ops {
206  int type; /* ATI_DMA_XXX */
207  unsigned int llp_offset; /* LINKPTR offset */
208  unsigned int dt_cur; /* DT_CUR offset */
209  /* called from open callback */
210  void (*enable_dma)(struct atiixp_modem *chip, int on);
211  /* called from trigger (START/STOP) */
212  void (*enable_transfer)(struct atiixp_modem *chip, int on);
213  /* called from trigger (STOP only) */
214  void (*flush_dma)(struct atiixp_modem *chip);
215 };
216 
217 /*
218  * DMA stream
219  */
220 struct atiixp_dma {
221  const struct atiixp_dma_ops *ops;
222  struct snd_dma_buffer desc_buf;
223  struct snd_pcm_substream *substream; /* assigned PCM substream */
224  unsigned int buf_addr, buf_bytes; /* DMA buffer address, bytes */
225  unsigned int period_bytes, periods;
226  int opened;
227  int running;
228  int pcm_open_flag;
229  int ac97_pcm_type; /* index # of ac97_pcm to access, -1 = not used */
230 };
231 
232 /*
233  * ATI IXP chip
234  */
235 struct atiixp_modem {
236  struct snd_card *card;
237  struct pci_dev *pci;
238 
239  struct resource *res; /* memory i/o */
240  unsigned long addr;
242  int irq;
243 
246 
248 
252 
253  int max_channels; /* max. channels for PCM out */
254 
255  unsigned int codec_not_ready_bits; /* for codec detection */
256 
257  int spdif_over_aclink; /* passed from the module option */
258  struct mutex open_mutex; /* playback open mutex */
259 };
260 
261 
262 /*
263  */
264 static DEFINE_PCI_DEVICE_TABLE(snd_atiixp_ids) = {
265  { PCI_VDEVICE(ATI, 0x434d), 0 }, /* SB200 */
266  { PCI_VDEVICE(ATI, 0x4378), 0 }, /* SB400 */
267  { 0, }
268 };
269 
270 MODULE_DEVICE_TABLE(pci, snd_atiixp_ids);
271 
272 
273 /*
274  * lowlevel functions
275  */
276 
277 /*
278  * update the bits of the given register.
279  * return 1 if the bits changed.
280  */
281 static int snd_atiixp_update_bits(struct atiixp_modem *chip, unsigned int reg,
282  unsigned int mask, unsigned int value)
283 {
284  void __iomem *addr = chip->remap_addr + reg;
285  unsigned int data, old_data;
286  old_data = data = readl(addr);
287  data &= ~mask;
288  data |= value;
289  if (old_data == data)
290  return 0;
291  writel(data, addr);
292  return 1;
293 }
294 
295 /*
296  * macros for easy use
297  */
298 #define atiixp_write(chip,reg,value) \
299  writel(value, chip->remap_addr + ATI_REG_##reg)
300 #define atiixp_read(chip,reg) \
301  readl(chip->remap_addr + ATI_REG_##reg)
302 #define atiixp_update(chip,reg,mask,val) \
303  snd_atiixp_update_bits(chip, ATI_REG_##reg, mask, val)
304 
305 /*
306  * handling DMA packets
307  *
308  * we allocate a linear buffer for the DMA, and split it to each packet.
309  * in a future version, a scatter-gather buffer should be implemented.
310  */
311 
312 #define ATI_DESC_LIST_SIZE \
313  PAGE_ALIGN(ATI_MAX_DESCRIPTORS * sizeof(struct atiixp_dma_desc))
314 
315 /*
316  * build packets ring for the given buffer size.
317  *
318  * IXP handles the buffer descriptors, which are connected as a linked
319  * list. although we can change the list dynamically, in this version,
320  * a static RING of buffer descriptors is used.
321  *
322  * the ring is built in this function, and is set up to the hardware.
323  */
324 static int atiixp_build_dma_packets(struct atiixp_modem *chip,
325  struct atiixp_dma *dma,
326  struct snd_pcm_substream *substream,
327  unsigned int periods,
328  unsigned int period_bytes)
329 {
330  unsigned int i;
331  u32 addr, desc_addr;
332  unsigned long flags;
333 
334  if (periods > ATI_MAX_DESCRIPTORS)
335  return -ENOMEM;
336 
337  if (dma->desc_buf.area == NULL) {
339  ATI_DESC_LIST_SIZE, &dma->desc_buf) < 0)
340  return -ENOMEM;
341  dma->period_bytes = dma->periods = 0; /* clear */
342  }
343 
344  if (dma->periods == periods && dma->period_bytes == period_bytes)
345  return 0;
346 
347  /* reset DMA before changing the descriptor table */
348  spin_lock_irqsave(&chip->reg_lock, flags);
349  writel(0, chip->remap_addr + dma->ops->llp_offset);
350  dma->ops->enable_dma(chip, 0);
351  dma->ops->enable_dma(chip, 1);
352  spin_unlock_irqrestore(&chip->reg_lock, flags);
353 
354  /* fill the entries */
355  addr = (u32)substream->runtime->dma_addr;
356  desc_addr = (u32)dma->desc_buf.addr;
357  for (i = 0; i < periods; i++) {
358  struct atiixp_dma_desc *desc;
359  desc = &((struct atiixp_dma_desc *)dma->desc_buf.area)[i];
360  desc->addr = cpu_to_le32(addr);
361  desc->status = 0;
362  desc->size = period_bytes >> 2; /* in dwords */
363  desc_addr += sizeof(struct atiixp_dma_desc);
364  if (i == periods - 1)
365  desc->next = cpu_to_le32((u32)dma->desc_buf.addr);
366  else
367  desc->next = cpu_to_le32(desc_addr);
368  addr += period_bytes;
369  }
370 
371  writel((u32)dma->desc_buf.addr | ATI_REG_LINKPTR_EN,
372  chip->remap_addr + dma->ops->llp_offset);
373 
374  dma->period_bytes = period_bytes;
375  dma->periods = periods;
376 
377  return 0;
378 }
379 
380 /*
381  * remove the ring buffer and release it if assigned
382  */
383 static void atiixp_clear_dma_packets(struct atiixp_modem *chip,
384  struct atiixp_dma *dma,
385  struct snd_pcm_substream *substream)
386 {
387  if (dma->desc_buf.area) {
388  writel(0, chip->remap_addr + dma->ops->llp_offset);
390  dma->desc_buf.area = NULL;
391  }
392 }
393 
394 /*
395  * AC97 interface
396  */
397 static int snd_atiixp_acquire_codec(struct atiixp_modem *chip)
398 {
399  int timeout = 1000;
400 
401  while (atiixp_read(chip, PHYS_OUT_ADDR) & ATI_REG_PHYS_OUT_ADDR_EN) {
402  if (! timeout--) {
403  snd_printk(KERN_WARNING "atiixp-modem: codec acquire timeout\n");
404  return -EBUSY;
405  }
406  udelay(1);
407  }
408  return 0;
409 }
410 
411 static unsigned short snd_atiixp_codec_read(struct atiixp_modem *chip,
412  unsigned short codec,
413  unsigned short reg)
414 {
415  unsigned int data;
416  int timeout;
417 
418  if (snd_atiixp_acquire_codec(chip) < 0)
419  return 0xffff;
420  data = (reg << ATI_REG_PHYS_OUT_ADDR_SHIFT) |
421  ATI_REG_PHYS_OUT_ADDR_EN |
423  codec;
424  atiixp_write(chip, PHYS_OUT_ADDR, data);
425  if (snd_atiixp_acquire_codec(chip) < 0)
426  return 0xffff;
427  timeout = 1000;
428  do {
429  data = atiixp_read(chip, PHYS_IN_ADDR);
430  if (data & ATI_REG_PHYS_IN_READ_FLAG)
431  return data >> ATI_REG_PHYS_IN_DATA_SHIFT;
432  udelay(1);
433  } while (--timeout);
434  /* time out may happen during reset */
435  if (reg < 0x7c)
436  snd_printk(KERN_WARNING "atiixp-modem: codec read timeout (reg %x)\n", reg);
437  return 0xffff;
438 }
439 
440 
441 static void snd_atiixp_codec_write(struct atiixp_modem *chip,
442  unsigned short codec,
443  unsigned short reg, unsigned short val)
444 {
445  unsigned int data;
446 
447  if (snd_atiixp_acquire_codec(chip) < 0)
448  return;
449  data = ((unsigned int)val << ATI_REG_PHYS_OUT_DATA_SHIFT) |
450  ((unsigned int)reg << ATI_REG_PHYS_OUT_ADDR_SHIFT) |
451  ATI_REG_PHYS_OUT_ADDR_EN | codec;
452  atiixp_write(chip, PHYS_OUT_ADDR, data);
453 }
454 
455 
456 static unsigned short snd_atiixp_ac97_read(struct snd_ac97 *ac97,
457  unsigned short reg)
458 {
459  struct atiixp_modem *chip = ac97->private_data;
460  return snd_atiixp_codec_read(chip, ac97->num, reg);
461 
462 }
463 
464 static void snd_atiixp_ac97_write(struct snd_ac97 *ac97, unsigned short reg,
465  unsigned short val)
466 {
467  struct atiixp_modem *chip = ac97->private_data;
468  if (reg == AC97_GPIO_STATUS) {
469  atiixp_write(chip, MODEM_OUT_GPIO,
471  return;
472  }
473  snd_atiixp_codec_write(chip, ac97->num, reg, val);
474 }
475 
476 /*
477  * reset AC link
478  */
479 static int snd_atiixp_aclink_reset(struct atiixp_modem *chip)
480 {
481  int timeout;
482 
483  /* reset powerdoewn */
484  if (atiixp_update(chip, CMD, ATI_REG_CMD_POWERDOWN, 0))
485  udelay(10);
486 
487  /* perform a software reset */
489  atiixp_read(chip, CMD);
490  udelay(10);
492 
493  timeout = 10;
494  while (! (atiixp_read(chip, CMD) & ATI_REG_CMD_ACLINK_ACTIVE)) {
495  /* do a hard reset */
498  atiixp_read(chip, CMD);
499  msleep(1);
501  if (!--timeout) {
502  snd_printk(KERN_ERR "atiixp-modem: codec reset timeout\n");
503  break;
504  }
505  }
506 
507  /* deassert RESET and assert SYNC to make sure */
510 
511  return 0;
512 }
513 
514 #ifdef CONFIG_PM_SLEEP
515 static int snd_atiixp_aclink_down(struct atiixp_modem *chip)
516 {
517  // if (atiixp_read(chip, MODEM_MIRROR) & 0x1) /* modem running, too? */
518  // return -EBUSY;
519  atiixp_update(chip, CMD,
522  return 0;
523 }
524 #endif
525 
526 /*
527  * auto-detection of codecs
528  *
529  * the IXP chip can generate interrupts for the non-existing codecs.
530  * NEW_FRAME interrupt is used to make sure that the interrupt is generated
531  * even if all three codecs are connected.
532  */
533 
534 #define ALL_CODEC_NOT_READY \
535  (ATI_REG_ISR_CODEC0_NOT_READY |\
536  ATI_REG_ISR_CODEC1_NOT_READY |\
537  ATI_REG_ISR_CODEC2_NOT_READY)
538 #define CODEC_CHECK_BITS (ALL_CODEC_NOT_READY|ATI_REG_ISR_NEW_FRAME)
539 
540 static int snd_atiixp_codec_detect(struct atiixp_modem *chip)
541 {
542  int timeout;
543 
544  chip->codec_not_ready_bits = 0;
546  /* wait for the interrupts */
547  timeout = 50;
548  while (timeout-- > 0) {
549  msleep(1);
550  if (chip->codec_not_ready_bits)
551  break;
552  }
553  atiixp_write(chip, IER, 0); /* disable irqs */
554 
556  snd_printk(KERN_ERR "atiixp-modem: no codec detected!\n");
557  return -ENXIO;
558  }
559  return 0;
560 }
561 
562 
563 /*
564  * enable DMA and irqs
565  */
566 static int snd_atiixp_chip_start(struct atiixp_modem *chip)
567 {
568  unsigned int reg;
569 
570  /* set up spdif, enable burst mode */
571  reg = atiixp_read(chip, CMD);
572  reg |= ATI_REG_CMD_BURST_EN;
573  if(!(reg & ATI_REG_CMD_MODEM_PRESENT))
575  atiixp_write(chip, CMD, reg);
576 
577  /* clear all interrupt source */
578  atiixp_write(chip, ISR, 0xffffffff);
579  /* enable irqs */
580  atiixp_write(chip, IER,
584  return 0;
585 }
586 
587 
588 /*
589  * disable DMA and IRQs
590  */
591 static int snd_atiixp_chip_stop(struct atiixp_modem *chip)
592 {
593  /* clear interrupt source */
594  atiixp_write(chip, ISR, atiixp_read(chip, ISR));
595  /* disable irqs */
596  atiixp_write(chip, IER, 0);
597  return 0;
598 }
599 
600 
601 /*
602  * PCM section
603  */
604 
605 /*
606  * pointer callback simplly reads XXX_DMA_DT_CUR register as the current
607  * position. when SG-buffer is implemented, the offset must be calculated
608  * correctly...
609  */
610 static snd_pcm_uframes_t snd_atiixp_pcm_pointer(struct snd_pcm_substream *substream)
611 {
612  struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
613  struct snd_pcm_runtime *runtime = substream->runtime;
614  struct atiixp_dma *dma = runtime->private_data;
615  unsigned int curptr;
616  int timeout = 1000;
617 
618  while (timeout--) {
619  curptr = readl(chip->remap_addr + dma->ops->dt_cur);
620  if (curptr < dma->buf_addr)
621  continue;
622  curptr -= dma->buf_addr;
623  if (curptr >= dma->buf_bytes)
624  continue;
625  return bytes_to_frames(runtime, curptr);
626  }
627  snd_printd("atiixp-modem: invalid DMA pointer read 0x%x (buf=%x)\n",
628  readl(chip->remap_addr + dma->ops->dt_cur), dma->buf_addr);
629  return 0;
630 }
631 
632 /*
633  * XRUN detected, and stop the PCM substream
634  */
635 static void snd_atiixp_xrun_dma(struct atiixp_modem *chip,
636  struct atiixp_dma *dma)
637 {
638  if (! dma->substream || ! dma->running)
639  return;
640  snd_printdd("atiixp-modem: XRUN detected (DMA %d)\n", dma->ops->type);
642 }
643 
644 /*
645  * the period ack. update the substream.
646  */
647 static void snd_atiixp_update_dma(struct atiixp_modem *chip,
648  struct atiixp_dma *dma)
649 {
650  if (! dma->substream || ! dma->running)
651  return;
653 }
654 
655 /* set BUS_BUSY interrupt bit if any DMA is running */
656 /* call with spinlock held */
657 static void snd_atiixp_check_bus_busy(struct atiixp_modem *chip)
658 {
659  unsigned int bus_busy;
663  else
664  bus_busy = 0;
666 }
667 
668 /* common trigger callback
669  * calling the lowlevel callbacks in it
670  */
671 static int snd_atiixp_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
672 {
673  struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
674  struct atiixp_dma *dma = substream->runtime->private_data;
675  int err = 0;
676 
677  if (snd_BUG_ON(!dma->ops->enable_transfer ||
678  !dma->ops->flush_dma))
679  return -EINVAL;
680 
681  spin_lock(&chip->reg_lock);
682  switch(cmd) {
684  dma->ops->enable_transfer(chip, 1);
685  dma->running = 1;
686  break;
688  dma->ops->enable_transfer(chip, 0);
689  dma->running = 0;
690  break;
691  default:
692  err = -EINVAL;
693  break;
694  }
695  if (! err) {
696  snd_atiixp_check_bus_busy(chip);
697  if (cmd == SNDRV_PCM_TRIGGER_STOP) {
698  dma->ops->flush_dma(chip);
699  snd_atiixp_check_bus_busy(chip);
700  }
701  }
702  spin_unlock(&chip->reg_lock);
703  return err;
704 }
705 
706 
707 /*
708  * lowlevel callbacks for each DMA type
709  *
710  * every callback is supposed to be called in chip->reg_lock spinlock
711  */
712 
713 /* flush FIFO of analog OUT DMA */
714 static void atiixp_out_flush_dma(struct atiixp_modem *chip)
715 {
716  atiixp_write(chip, MODEM_FIFO_FLUSH, ATI_REG_MODEM_FIFO_OUT1_FLUSH);
717 }
718 
719 /* enable/disable analog OUT DMA */
720 static void atiixp_out_enable_dma(struct atiixp_modem *chip, int on)
721 {
722  unsigned int data;
723  data = atiixp_read(chip, CMD);
724  if (on) {
726  return;
727  atiixp_out_flush_dma(chip);
729  } else
731  atiixp_write(chip, CMD, data);
732 }
733 
734 /* start/stop transfer over OUT DMA */
735 static void atiixp_out_enable_transfer(struct atiixp_modem *chip, int on)
736 {
738  on ? ATI_REG_CMD_MODEM_SEND1_EN : 0);
739 }
740 
741 /* enable/disable analog IN DMA */
742 static void atiixp_in_enable_dma(struct atiixp_modem *chip, int on)
743 {
745  on ? ATI_REG_CMD_MODEM_IN_DMA_EN : 0);
746 }
747 
748 /* start/stop analog IN DMA */
749 static void atiixp_in_enable_transfer(struct atiixp_modem *chip, int on)
750 {
751  if (on) {
752  unsigned int data = atiixp_read(chip, CMD);
753  if (! (data & ATI_REG_CMD_MODEM_RECEIVE_EN)) {
755  atiixp_write(chip, CMD, data);
756  }
757  } else
759 }
760 
761 /* flush FIFO of analog IN DMA */
762 static void atiixp_in_flush_dma(struct atiixp_modem *chip)
763 {
764  atiixp_write(chip, MODEM_FIFO_FLUSH, ATI_REG_MODEM_FIFO_IN_FLUSH);
765 }
766 
767 /* set up slots and formats for analog OUT */
768 static int snd_atiixp_playback_prepare(struct snd_pcm_substream *substream)
769 {
770  struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
771  unsigned int data;
772 
773  spin_lock_irq(&chip->reg_lock);
774  /* set output threshold */
775  data = atiixp_read(chip, MODEM_OUT_FIFO);
778  atiixp_write(chip, MODEM_OUT_FIFO, data);
779  spin_unlock_irq(&chip->reg_lock);
780  return 0;
781 }
782 
783 /* set up slots and formats for analog IN */
784 static int snd_atiixp_capture_prepare(struct snd_pcm_substream *substream)
785 {
786  return 0;
787 }
788 
789 /*
790  * hw_params - allocate the buffer and set up buffer descriptors
791  */
792 static int snd_atiixp_pcm_hw_params(struct snd_pcm_substream *substream,
793  struct snd_pcm_hw_params *hw_params)
794 {
795  struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
796  struct atiixp_dma *dma = substream->runtime->private_data;
797  int err;
798  int i;
799 
800  err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
801  if (err < 0)
802  return err;
803  dma->buf_addr = substream->runtime->dma_addr;
804  dma->buf_bytes = params_buffer_bytes(hw_params);
805 
806  err = atiixp_build_dma_packets(chip, dma, substream,
807  params_periods(hw_params),
808  params_period_bytes(hw_params));
809  if (err < 0)
810  return err;
811 
812  /* set up modem rate */
813  for (i = 0; i < NUM_ATI_CODECS; i++) {
814  if (! chip->ac97[i])
815  continue;
816  snd_ac97_write(chip->ac97[i], AC97_LINE1_RATE, params_rate(hw_params));
817  snd_ac97_write(chip->ac97[i], AC97_LINE1_LEVEL, 0);
818  }
819 
820  return err;
821 }
822 
823 static int snd_atiixp_pcm_hw_free(struct snd_pcm_substream *substream)
824 {
825  struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
826  struct atiixp_dma *dma = substream->runtime->private_data;
827 
828  atiixp_clear_dma_packets(chip, dma, substream);
829  snd_pcm_lib_free_pages(substream);
830  return 0;
831 }
832 
833 
834 /*
835  * pcm hardware definition, identical for all DMA types
836  */
837 static struct snd_pcm_hardware snd_atiixp_pcm_hw =
838 {
846  .rate_min = 8000,
847  .rate_max = 16000,
848  .channels_min = 2,
849  .channels_max = 2,
850  .buffer_bytes_max = 256 * 1024,
851  .period_bytes_min = 32,
852  .period_bytes_max = 128 * 1024,
853  .periods_min = 2,
854  .periods_max = ATI_MAX_DESCRIPTORS,
855 };
856 
857 static int snd_atiixp_pcm_open(struct snd_pcm_substream *substream,
858  struct atiixp_dma *dma, int pcm_type)
859 {
860  struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
861  struct snd_pcm_runtime *runtime = substream->runtime;
862  int err;
863  static unsigned int rates[] = { 8000, 9600, 12000, 16000 };
864  static struct snd_pcm_hw_constraint_list hw_constraints_rates = {
865  .count = ARRAY_SIZE(rates),
866  .list = rates,
867  .mask = 0,
868  };
869 
870  if (snd_BUG_ON(!dma->ops || !dma->ops->enable_dma))
871  return -EINVAL;
872 
873  if (dma->opened)
874  return -EBUSY;
875  dma->substream = substream;
876  runtime->hw = snd_atiixp_pcm_hw;
877  dma->ac97_pcm_type = pcm_type;
878  if ((err = snd_pcm_hw_constraint_list(runtime, 0,
880  &hw_constraints_rates)) < 0)
881  return err;
882  if ((err = snd_pcm_hw_constraint_integer(runtime,
884  return err;
885  runtime->private_data = dma;
886 
887  /* enable DMA bits */
888  spin_lock_irq(&chip->reg_lock);
889  dma->ops->enable_dma(chip, 1);
890  spin_unlock_irq(&chip->reg_lock);
891  dma->opened = 1;
892 
893  return 0;
894 }
895 
896 static int snd_atiixp_pcm_close(struct snd_pcm_substream *substream,
897  struct atiixp_dma *dma)
898 {
899  struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
900  /* disable DMA bits */
901  if (snd_BUG_ON(!dma->ops || !dma->ops->enable_dma))
902  return -EINVAL;
903  spin_lock_irq(&chip->reg_lock);
904  dma->ops->enable_dma(chip, 0);
905  spin_unlock_irq(&chip->reg_lock);
906  dma->substream = NULL;
907  dma->opened = 0;
908  return 0;
909 }
910 
911 /*
912  */
913 static int snd_atiixp_playback_open(struct snd_pcm_substream *substream)
914 {
915  struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
916  int err;
917 
918  mutex_lock(&chip->open_mutex);
919  err = snd_atiixp_pcm_open(substream, &chip->dmas[ATI_DMA_PLAYBACK], 0);
920  mutex_unlock(&chip->open_mutex);
921  if (err < 0)
922  return err;
923  return 0;
924 }
925 
926 static int snd_atiixp_playback_close(struct snd_pcm_substream *substream)
927 {
928  struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
929  int err;
930  mutex_lock(&chip->open_mutex);
931  err = snd_atiixp_pcm_close(substream, &chip->dmas[ATI_DMA_PLAYBACK]);
932  mutex_unlock(&chip->open_mutex);
933  return err;
934 }
935 
936 static int snd_atiixp_capture_open(struct snd_pcm_substream *substream)
937 {
938  struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
939  return snd_atiixp_pcm_open(substream, &chip->dmas[ATI_DMA_CAPTURE], 1);
940 }
941 
942 static int snd_atiixp_capture_close(struct snd_pcm_substream *substream)
943 {
944  struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
945  return snd_atiixp_pcm_close(substream, &chip->dmas[ATI_DMA_CAPTURE]);
946 }
947 
948 
949 /* AC97 playback */
950 static struct snd_pcm_ops snd_atiixp_playback_ops = {
951  .open = snd_atiixp_playback_open,
952  .close = snd_atiixp_playback_close,
953  .ioctl = snd_pcm_lib_ioctl,
954  .hw_params = snd_atiixp_pcm_hw_params,
955  .hw_free = snd_atiixp_pcm_hw_free,
956  .prepare = snd_atiixp_playback_prepare,
957  .trigger = snd_atiixp_pcm_trigger,
958  .pointer = snd_atiixp_pcm_pointer,
959 };
960 
961 /* AC97 capture */
962 static struct snd_pcm_ops snd_atiixp_capture_ops = {
963  .open = snd_atiixp_capture_open,
964  .close = snd_atiixp_capture_close,
965  .ioctl = snd_pcm_lib_ioctl,
966  .hw_params = snd_atiixp_pcm_hw_params,
967  .hw_free = snd_atiixp_pcm_hw_free,
968  .prepare = snd_atiixp_capture_prepare,
969  .trigger = snd_atiixp_pcm_trigger,
970  .pointer = snd_atiixp_pcm_pointer,
971 };
972 
973 static struct atiixp_dma_ops snd_atiixp_playback_dma_ops = {
974  .type = ATI_DMA_PLAYBACK,
975  .llp_offset = ATI_REG_MODEM_OUT_DMA1_LINKPTR,
977  .enable_dma = atiixp_out_enable_dma,
978  .enable_transfer = atiixp_out_enable_transfer,
979  .flush_dma = atiixp_out_flush_dma,
980 };
981 
982 static struct atiixp_dma_ops snd_atiixp_capture_dma_ops = {
983  .type = ATI_DMA_CAPTURE,
984  .llp_offset = ATI_REG_MODEM_IN_DMA_LINKPTR,
985  .dt_cur = ATI_REG_MODEM_IN_DMA_DT_CUR,
986  .enable_dma = atiixp_in_enable_dma,
987  .enable_transfer = atiixp_in_enable_transfer,
988  .flush_dma = atiixp_in_flush_dma,
989 };
990 
991 static int __devinit snd_atiixp_pcm_new(struct atiixp_modem *chip)
992 {
993  struct snd_pcm *pcm;
994  int err;
995 
996  /* initialize constants */
997  chip->dmas[ATI_DMA_PLAYBACK].ops = &snd_atiixp_playback_dma_ops;
998  chip->dmas[ATI_DMA_CAPTURE].ops = &snd_atiixp_capture_dma_ops;
999 
1000  /* PCM #0: analog I/O */
1001  err = snd_pcm_new(chip->card, "ATI IXP MC97", ATI_PCMDEV_ANALOG, 1, 1, &pcm);
1002  if (err < 0)
1003  return err;
1004  snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_atiixp_playback_ops);
1005  snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_atiixp_capture_ops);
1007  pcm->private_data = chip;
1008  strcpy(pcm->name, "ATI IXP MC97");
1009  chip->pcmdevs[ATI_PCMDEV_ANALOG] = pcm;
1010 
1012  snd_dma_pci_data(chip->pci),
1013  64*1024, 128*1024);
1014 
1015  return 0;
1016 }
1017 
1018 
1019 
1020 /*
1021  * interrupt handler
1022  */
1023 static irqreturn_t snd_atiixp_interrupt(int irq, void *dev_id)
1024 {
1025  struct atiixp_modem *chip = dev_id;
1026  unsigned int status;
1027 
1028  status = atiixp_read(chip, ISR);
1029 
1030  if (! status)
1031  return IRQ_NONE;
1032 
1033  /* process audio DMA */
1034  if (status & ATI_REG_ISR_MODEM_OUT1_XRUN)
1035  snd_atiixp_xrun_dma(chip, &chip->dmas[ATI_DMA_PLAYBACK]);
1036  else if (status & ATI_REG_ISR_MODEM_OUT1_STATUS)
1037  snd_atiixp_update_dma(chip, &chip->dmas[ATI_DMA_PLAYBACK]);
1038  if (status & ATI_REG_ISR_MODEM_IN_XRUN)
1039  snd_atiixp_xrun_dma(chip, &chip->dmas[ATI_DMA_CAPTURE]);
1040  else if (status & ATI_REG_ISR_MODEM_IN_STATUS)
1041  snd_atiixp_update_dma(chip, &chip->dmas[ATI_DMA_CAPTURE]);
1042 
1043  /* for codec detection */
1044  if (status & CODEC_CHECK_BITS) {
1045  unsigned int detected;
1046  detected = status & CODEC_CHECK_BITS;
1047  spin_lock(&chip->reg_lock);
1048  chip->codec_not_ready_bits |= detected;
1049  atiixp_update(chip, IER, detected, 0); /* disable the detected irqs */
1050  spin_unlock(&chip->reg_lock);
1051  }
1052 
1053  /* ack */
1054  atiixp_write(chip, ISR, status);
1055 
1056  return IRQ_HANDLED;
1057 }
1058 
1059 
1060 /*
1061  * ac97 mixer section
1062  */
1063 
1064 static int __devinit snd_atiixp_mixer_new(struct atiixp_modem *chip, int clock)
1065 {
1066  struct snd_ac97_bus *pbus;
1067  struct snd_ac97_template ac97;
1068  int i, err;
1069  int codec_count;
1070  static struct snd_ac97_bus_ops ops = {
1071  .write = snd_atiixp_ac97_write,
1072  .read = snd_atiixp_ac97_read,
1073  };
1074  static unsigned int codec_skip[NUM_ATI_CODECS] = {
1078  };
1079 
1080  if (snd_atiixp_codec_detect(chip) < 0)
1081  return -ENXIO;
1082 
1083  if ((err = snd_ac97_bus(chip->card, 0, &ops, chip, &pbus)) < 0)
1084  return err;
1085  pbus->clock = clock;
1086  chip->ac97_bus = pbus;
1087 
1088  codec_count = 0;
1089  for (i = 0; i < NUM_ATI_CODECS; i++) {
1090  if (chip->codec_not_ready_bits & codec_skip[i])
1091  continue;
1092  memset(&ac97, 0, sizeof(ac97));
1093  ac97.private_data = chip;
1094  ac97.pci = chip->pci;
1095  ac97.num = i;
1097  if ((err = snd_ac97_mixer(pbus, &ac97, &chip->ac97[i])) < 0) {
1098  chip->ac97[i] = NULL; /* to be sure */
1099  snd_printdd("atiixp-modem: codec %d not available for modem\n", i);
1100  continue;
1101  }
1102  codec_count++;
1103  }
1104 
1105  if (! codec_count) {
1106  snd_printk(KERN_ERR "atiixp-modem: no codec available\n");
1107  return -ENODEV;
1108  }
1109 
1110  /* snd_ac97_tune_hardware(chip->ac97, ac97_quirks); */
1111 
1112  return 0;
1113 }
1114 
1115 
1116 #ifdef CONFIG_PM_SLEEP
1117 /*
1118  * power management
1119  */
1120 static int snd_atiixp_suspend(struct device *dev)
1121 {
1122  struct pci_dev *pci = to_pci_dev(dev);
1123  struct snd_card *card = dev_get_drvdata(dev);
1124  struct atiixp_modem *chip = card->private_data;
1125  int i;
1126 
1128  for (i = 0; i < NUM_ATI_PCMDEVS; i++)
1129  snd_pcm_suspend_all(chip->pcmdevs[i]);
1130  for (i = 0; i < NUM_ATI_CODECS; i++)
1131  snd_ac97_suspend(chip->ac97[i]);
1132  snd_atiixp_aclink_down(chip);
1133  snd_atiixp_chip_stop(chip);
1134 
1135  pci_disable_device(pci);
1136  pci_save_state(pci);
1138  return 0;
1139 }
1140 
1141 static int snd_atiixp_resume(struct device *dev)
1142 {
1143  struct pci_dev *pci = to_pci_dev(dev);
1144  struct snd_card *card = dev_get_drvdata(dev);
1145  struct atiixp_modem *chip = card->private_data;
1146  int i;
1147 
1149  pci_restore_state(pci);
1150  if (pci_enable_device(pci) < 0) {
1151  printk(KERN_ERR "atiixp-modem: pci_enable_device failed, "
1152  "disabling device\n");
1153  snd_card_disconnect(card);
1154  return -EIO;
1155  }
1156  pci_set_master(pci);
1157 
1158  snd_atiixp_aclink_reset(chip);
1159  snd_atiixp_chip_start(chip);
1160 
1161  for (i = 0; i < NUM_ATI_CODECS; i++)
1162  snd_ac97_resume(chip->ac97[i]);
1163 
1165  return 0;
1166 }
1167 
1168 static SIMPLE_DEV_PM_OPS(snd_atiixp_pm, snd_atiixp_suspend, snd_atiixp_resume);
1169 #define SND_ATIIXP_PM_OPS &snd_atiixp_pm
1170 #else
1171 #define SND_ATIIXP_PM_OPS NULL
1172 #endif /* CONFIG_PM_SLEEP */
1173 
1174 #ifdef CONFIG_PROC_FS
1175 /*
1176  * proc interface for register dump
1177  */
1178 
1179 static void snd_atiixp_proc_read(struct snd_info_entry *entry,
1180  struct snd_info_buffer *buffer)
1181 {
1182  struct atiixp_modem *chip = entry->private_data;
1183  int i;
1184 
1185  for (i = 0; i < 256; i += 4)
1186  snd_iprintf(buffer, "%02x: %08x\n", i, readl(chip->remap_addr + i));
1187 }
1188 
1189 static void __devinit snd_atiixp_proc_init(struct atiixp_modem *chip)
1190 {
1191  struct snd_info_entry *entry;
1192 
1193  if (! snd_card_proc_new(chip->card, "atiixp-modem", &entry))
1194  snd_info_set_text_ops(entry, chip, snd_atiixp_proc_read);
1195 }
1196 #else
1197 #define snd_atiixp_proc_init(chip)
1198 #endif
1199 
1200 
1201 /*
1202  * destructor
1203  */
1204 
1205 static int snd_atiixp_free(struct atiixp_modem *chip)
1206 {
1207  if (chip->irq < 0)
1208  goto __hw_end;
1209  snd_atiixp_chip_stop(chip);
1210 
1211  __hw_end:
1212  if (chip->irq >= 0)
1213  free_irq(chip->irq, chip);
1214  if (chip->remap_addr)
1215  iounmap(chip->remap_addr);
1216  pci_release_regions(chip->pci);
1217  pci_disable_device(chip->pci);
1218  kfree(chip);
1219  return 0;
1220 }
1221 
1222 static int snd_atiixp_dev_free(struct snd_device *device)
1223 {
1224  struct atiixp_modem *chip = device->device_data;
1225  return snd_atiixp_free(chip);
1226 }
1227 
1228 /*
1229  * constructor for chip instance
1230  */
1231 static int __devinit snd_atiixp_create(struct snd_card *card,
1232  struct pci_dev *pci,
1233  struct atiixp_modem **r_chip)
1234 {
1235  static struct snd_device_ops ops = {
1236  .dev_free = snd_atiixp_dev_free,
1237  };
1238  struct atiixp_modem *chip;
1239  int err;
1240 
1241  if ((err = pci_enable_device(pci)) < 0)
1242  return err;
1243 
1244  chip = kzalloc(sizeof(*chip), GFP_KERNEL);
1245  if (chip == NULL) {
1246  pci_disable_device(pci);
1247  return -ENOMEM;
1248  }
1249 
1250  spin_lock_init(&chip->reg_lock);
1251  mutex_init(&chip->open_mutex);
1252  chip->card = card;
1253  chip->pci = pci;
1254  chip->irq = -1;
1255  if ((err = pci_request_regions(pci, "ATI IXP MC97")) < 0) {
1256  kfree(chip);
1257  pci_disable_device(pci);
1258  return err;
1259  }
1260  chip->addr = pci_resource_start(pci, 0);
1261  chip->remap_addr = pci_ioremap_bar(pci, 0);
1262  if (chip->remap_addr == NULL) {
1263  snd_printk(KERN_ERR "AC'97 space ioremap problem\n");
1264  snd_atiixp_free(chip);
1265  return -EIO;
1266  }
1267 
1268  if (request_irq(pci->irq, snd_atiixp_interrupt, IRQF_SHARED,
1269  KBUILD_MODNAME, chip)) {
1270  snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
1271  snd_atiixp_free(chip);
1272  return -EBUSY;
1273  }
1274  chip->irq = pci->irq;
1275  pci_set_master(pci);
1276  synchronize_irq(chip->irq);
1277 
1278  if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
1279  snd_atiixp_free(chip);
1280  return err;
1281  }
1282 
1283  snd_card_set_dev(card, &pci->dev);
1284 
1285  *r_chip = chip;
1286  return 0;
1287 }
1288 
1289 
1290 static int __devinit snd_atiixp_probe(struct pci_dev *pci,
1291  const struct pci_device_id *pci_id)
1292 {
1293  struct snd_card *card;
1294  struct atiixp_modem *chip;
1295  int err;
1296 
1297  err = snd_card_create(index, id, THIS_MODULE, 0, &card);
1298  if (err < 0)
1299  return err;
1300 
1301  strcpy(card->driver, "ATIIXP-MODEM");
1302  strcpy(card->shortname, "ATI IXP Modem");
1303  if ((err = snd_atiixp_create(card, pci, &chip)) < 0)
1304  goto __error;
1305  card->private_data = chip;
1306 
1307  if ((err = snd_atiixp_aclink_reset(chip)) < 0)
1308  goto __error;
1309 
1310  if ((err = snd_atiixp_mixer_new(chip, ac97_clock)) < 0)
1311  goto __error;
1312 
1313  if ((err = snd_atiixp_pcm_new(chip)) < 0)
1314  goto __error;
1315 
1316  snd_atiixp_proc_init(chip);
1317 
1318  snd_atiixp_chip_start(chip);
1319 
1320  sprintf(card->longname, "%s rev %x at 0x%lx, irq %i",
1321  card->shortname, pci->revision, chip->addr, chip->irq);
1322 
1323  if ((err = snd_card_register(card)) < 0)
1324  goto __error;
1325 
1326  pci_set_drvdata(pci, card);
1327  return 0;
1328 
1329  __error:
1330  snd_card_free(card);
1331  return err;
1332 }
1333 
1334 static void __devexit snd_atiixp_remove(struct pci_dev *pci)
1335 {
1336  snd_card_free(pci_get_drvdata(pci));
1337  pci_set_drvdata(pci, NULL);
1338 }
1339 
1340 static struct pci_driver atiixp_modem_driver = {
1341  .name = KBUILD_MODNAME,
1342  .id_table = snd_atiixp_ids,
1343  .probe = snd_atiixp_probe,
1344  .remove = __devexit_p(snd_atiixp_remove),
1345  .driver = {
1346  .pm = SND_ATIIXP_PM_OPS,
1347  },
1348 };
1349 
1350 module_pci_driver(atiixp_modem_driver);