PCI: Change all drivers to use pci_device->revision
[linux-2.6.git] / sound / pci / atiixp_modem.c
1 /*
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>
30 #include <linux/mutex.h>
31 #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
38 MODULE_AUTHOR("Takashi Iwai <tiwai@suse.de>");
39 MODULE_DESCRIPTION("ATI IXP MC97 controller");
40 MODULE_LICENSE("GPL");
41 MODULE_SUPPORTED_DEVICE("{{ATI,IXP150/200/250}}");
42
43 static int index = -2; /* Exclude the first card */
44 static char *id = SNDRV_DEFAULT_STR1;   /* ID for this card */
45 static int ac97_clock = 48000;
46
47 module_param(index, int, 0444);
48 MODULE_PARM_DESC(index, "Index value for ATI IXP controller.");
49 module_param(id, charp, 0444);
50 MODULE_PARM_DESC(id, "ID string for ATI IXP controller.");
51 module_param(ac97_clock, int, 0444);
52 MODULE_PARM_DESC(ac97_clock, "AC'97 codec clock (default 48000Hz).");
53
54 /* just for backward compatibility */
55 static int enable;
56 module_param(enable, bool, 0444);
57
58
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
180 struct atiixp_modem;
181
182 /*
183  * DMA packate descriptor
184  */
185
186 struct atiixp_dma_desc {
187         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 */
191 };
192
193 /*
194  * stream enum
195  */
196 enum { ATI_DMA_PLAYBACK, ATI_DMA_CAPTURE, NUM_ATI_DMAS }; /* DMAs */
197 enum { ATI_PCM_OUT, ATI_PCM_IN, NUM_ATI_PCMS }; /* AC97 pcm slots */
198 enum { 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  */
206 struct atiixp_dma_ops {
207         int type;                       /* ATI_DMA_XXX */
208         unsigned int llp_offset;        /* LINKPTR offset */
209         unsigned int dt_cur;            /* DT_CUR offset */
210         /* 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);
216 };
217
218 /*
219  * DMA stream
220  */
221 struct atiixp_dma {
222         const struct atiixp_dma_ops *ops;
223         struct snd_dma_buffer desc_buf;
224         struct snd_pcm_substream *substream;    /* assigned PCM substream */
225         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  */
236 struct atiixp_modem {
237         struct snd_card *card;
238         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         
245         struct snd_ac97_bus *ac97_bus;
246         struct snd_ac97 *ac97[NUM_ATI_CODECS];
247
248         spinlock_t reg_lock;
249
250         struct atiixp_dma dmas[NUM_ATI_DMAS];
251         struct ac97_pcm *pcms[NUM_ATI_PCMS];
252         struct snd_pcm *pcmdevs[NUM_ATI_PCMDEVS];
253
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 */
259         struct mutex open_mutex;        /* playback open mutex */
260 };
261
262
263 /*
264  */
265 static struct pci_device_id snd_atiixp_ids[] = {
266         { 0x1002, 0x434d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, /* SB200 */
267         { 0x1002, 0x4378, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, /* SB400 */
268         { 0, }
269 };
270
271 MODULE_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  */
282 static int snd_atiixp_update_bits(struct atiixp_modem *chip, unsigned int reg,
283                                   unsigned int mask, unsigned int value)
284 {
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
306 /*
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 \
314         PAGE_ALIGN(ATI_MAX_DESCRIPTORS * sizeof(struct atiixp_dma_desc))
315
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  */
325 static 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)
330 {
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++) {
359                 struct atiixp_dma_desc *desc;
360                 desc = &((struct atiixp_dma_desc *)dma->desc_buf.area)[i];
361                 desc->addr = cpu_to_le32(addr);
362                 desc->status = 0;
363                 desc->size = period_bytes >> 2; /* in dwords */
364                 desc_addr += sizeof(struct atiixp_dma_desc);
365                 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  */
384 static void atiixp_clear_dma_packets(struct atiixp_modem *chip,
385                                      struct atiixp_dma *dma,
386                                      struct snd_pcm_substream *substream)
387 {
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  */
398 static int snd_atiixp_acquire_codec(struct atiixp_modem *chip)
399 {
400         int timeout = 1000;
401
402         while (atiixp_read(chip, PHYS_OUT_ADDR) & ATI_REG_PHYS_OUT_ADDR_EN) {
403                 if (! timeout--) {
404                         snd_printk(KERN_WARNING "atiixp-modem: codec acquire timeout\n");
405                         return -EBUSY;
406                 }
407                 udelay(1);
408         }
409         return 0;
410 }
411
412 static unsigned short snd_atiixp_codec_read(struct atiixp_modem *chip,
413                                             unsigned short codec,
414                                             unsigned short reg)
415 {
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)
437                 snd_printk(KERN_WARNING "atiixp-modem: codec read timeout (reg %x)\n", reg);
438         return 0xffff;
439 }
440
441
442 static void snd_atiixp_codec_write(struct atiixp_modem *chip,
443                                    unsigned short codec,
444                                    unsigned short reg, unsigned short val)
445 {
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
457 static unsigned short snd_atiixp_ac97_read(struct snd_ac97 *ac97,
458                                            unsigned short reg)
459 {
460         struct atiixp_modem *chip = ac97->private_data;
461         return snd_atiixp_codec_read(chip, ac97->num, reg);
462     
463 }
464
465 static void snd_atiixp_ac97_write(struct snd_ac97 *ac97, unsigned short reg,
466                                   unsigned short val)
467 {
468         struct atiixp_modem *chip = ac97->private_data;
469         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         }
474         snd_atiixp_codec_write(chip, ac97->num, reg, val);
475 }
476
477 /*
478  * reset AC link
479  */
480 static int snd_atiixp_aclink_reset(struct atiixp_modem *chip)
481 {
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);
500                 msleep(1);
501                 atiixp_update(chip, CMD, ATI_REG_CMD_AC_RESET, ATI_REG_CMD_AC_RESET);
502                 if (--timeout) {
503                         snd_printk(KERN_ERR "atiixp-modem: codec reset timeout\n");
504                         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
516 static int snd_atiixp_aclink_down(struct atiixp_modem *chip)
517 {
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
541 static int snd_atiixp_codec_detect(struct atiixp_modem *chip)
542 {
543         int timeout;
544
545         chip->codec_not_ready_bits = 0;
546         atiixp_write(chip, IER, CODEC_CHECK_BITS);
547         /* wait for the interrupts */
548         timeout = 50;
549         while (timeout-- > 0) {
550                 msleep(1);
551                 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) {
557                 snd_printk(KERN_ERR "atiixp-modem: no codec detected!\n");
558                 return -ENXIO;
559         }
560         return 0;
561 }
562
563
564 /*
565  * enable DMA and irqs
566  */
567 static int snd_atiixp_chip_start(struct atiixp_modem *chip)
568 {
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  */
592 static int snd_atiixp_chip_stop(struct atiixp_modem *chip)
593 {
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  */
611 static snd_pcm_uframes_t snd_atiixp_pcm_pointer(struct snd_pcm_substream *substream)
612 {
613         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;
616         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  */
636 static void snd_atiixp_xrun_dma(struct atiixp_modem *chip,
637                                 struct atiixp_dma *dma)
638 {
639         if (! dma->substream || ! dma->running)
640                 return;
641         snd_printdd("atiixp-modem: XRUN detected (DMA %d)\n", dma->ops->type);
642         snd_pcm_stop(dma->substream, SNDRV_PCM_STATE_XRUN);
643 }
644
645 /*
646  * the period ack.  update the substream.
647  */
648 static void snd_atiixp_update_dma(struct atiixp_modem *chip,
649                                   struct atiixp_dma *dma)
650 {
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 */
658 static void snd_atiixp_check_bus_busy(struct atiixp_modem *chip)
659 {
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  */
672 static int snd_atiixp_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
673 {
674         struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
675         struct atiixp_dma *dma = substream->runtime->private_data;
676         int err = 0;
677
678         snd_assert(dma->ops->enable_transfer && dma->ops->flush_dma, return -EINVAL);
679
680         spin_lock(&chip->reg_lock);
681         switch(cmd) {
682         case SNDRV_PCM_TRIGGER_START:
683                 dma->ops->enable_transfer(chip, 1);
684                 dma->running = 1;
685                 break;
686         case SNDRV_PCM_TRIGGER_STOP:
687                 dma->ops->enable_transfer(chip, 0);
688                 dma->running = 0;
689                 break;
690         default:
691                 err = -EINVAL;
692                 break;
693         }
694         if (! err) {
695         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         }
700         }
701         spin_unlock(&chip->reg_lock);
702         return err;
703 }
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 */
713 static void atiixp_out_flush_dma(struct atiixp_modem *chip)
714 {
715         atiixp_write(chip, MODEM_FIFO_FLUSH, ATI_REG_MODEM_FIFO_OUT1_FLUSH);
716 }
717
718 /* enable/disable analog OUT DMA */
719 static void atiixp_out_enable_dma(struct atiixp_modem *chip, int on)
720 {
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 */
734 static void atiixp_out_enable_transfer(struct atiixp_modem *chip, int on)
735 {
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 */
741 static void atiixp_in_enable_dma(struct atiixp_modem *chip, int on)
742 {
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 */
748 static void atiixp_in_enable_transfer(struct atiixp_modem *chip, int on)
749 {
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 */
761 static void atiixp_in_flush_dma(struct atiixp_modem *chip)
762 {
763         atiixp_write(chip, MODEM_FIFO_FLUSH, ATI_REG_MODEM_FIFO_IN_FLUSH);
764 }
765
766 /* set up slots and formats for analog OUT */
767 static int snd_atiixp_playback_prepare(struct snd_pcm_substream *substream)
768 {
769         struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
770         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 */
783 static int snd_atiixp_capture_prepare(struct snd_pcm_substream *substream)
784 {
785         return 0;
786 }
787
788 /*
789  * hw_params - allocate the buffer and set up buffer descriptors
790  */
791 static int snd_atiixp_pcm_hw_params(struct snd_pcm_substream *substream,
792                                    struct snd_pcm_hw_params *hw_params)
793 {
794         struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
795         struct atiixp_dma *dma = substream->runtime->private_data;
796         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
822 static int snd_atiixp_pcm_hw_free(struct snd_pcm_substream *substream)
823 {
824         struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
825         struct atiixp_dma *dma = substream->runtime->private_data;
826
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  */
836 static struct snd_pcm_hardware snd_atiixp_pcm_hw =
837 {
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,
842         .rates =                (SNDRV_PCM_RATE_8000 |
843                                  SNDRV_PCM_RATE_16000 |
844                                  SNDRV_PCM_RATE_KNOT),
845         .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
856 static int snd_atiixp_pcm_open(struct snd_pcm_substream *substream,
857                                struct atiixp_dma *dma, int pcm_type)
858 {
859         struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
860         struct snd_pcm_runtime *runtime = substream->runtime;
861         int err;
862         static unsigned int rates[] = { 8000,  9600, 12000, 16000 };
863         static struct snd_pcm_hw_constraint_list hw_constraints_rates = {
864                 .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;
876         if ((err = snd_pcm_hw_constraint_list(runtime, 0,
877                                               SNDRV_PCM_HW_PARAM_RATE,
878                                               &hw_constraints_rates)) < 0)
879                 return err;
880         if ((err = snd_pcm_hw_constraint_integer(runtime,
881                                                  SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
882                 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
894 static int snd_atiixp_pcm_close(struct snd_pcm_substream *substream,
895                                 struct atiixp_dma *dma)
896 {
897         struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
898         /* 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  */
910 static int snd_atiixp_playback_open(struct snd_pcm_substream *substream)
911 {
912         struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
913         int err;
914
915         mutex_lock(&chip->open_mutex);
916         err = snd_atiixp_pcm_open(substream, &chip->dmas[ATI_DMA_PLAYBACK], 0);
917         mutex_unlock(&chip->open_mutex);
918         if (err < 0)
919                 return err;
920         return 0;
921 }
922
923 static int snd_atiixp_playback_close(struct snd_pcm_substream *substream)
924 {
925         struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
926         int err;
927         mutex_lock(&chip->open_mutex);
928         err = snd_atiixp_pcm_close(substream, &chip->dmas[ATI_DMA_PLAYBACK]);
929         mutex_unlock(&chip->open_mutex);
930         return err;
931 }
932
933 static int snd_atiixp_capture_open(struct snd_pcm_substream *substream)
934 {
935         struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
936         return snd_atiixp_pcm_open(substream, &chip->dmas[ATI_DMA_CAPTURE], 1);
937 }
938
939 static int snd_atiixp_capture_close(struct snd_pcm_substream *substream)
940 {
941         struct atiixp_modem *chip = snd_pcm_substream_chip(substream);
942         return snd_atiixp_pcm_close(substream, &chip->dmas[ATI_DMA_CAPTURE]);
943 }
944
945
946 /* AC97 playback */
947 static struct snd_pcm_ops snd_atiixp_playback_ops = {
948         .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 */
959 static struct snd_pcm_ops snd_atiixp_capture_ops = {
960         .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
970 static struct atiixp_dma_ops snd_atiixp_playback_dma_ops = {
971         .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         
979 static struct atiixp_dma_ops snd_atiixp_capture_dma_ops = {
980         .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
988 static int __devinit snd_atiixp_pcm_new(struct atiixp_modem *chip)
989 {
990         struct snd_pcm *pcm;
991         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);
1003         pcm->dev_class = SNDRV_PCM_CLASS_MODEM;
1004         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,
1009                                               snd_dma_pci_data(chip->pci),
1010                                               64*1024, 128*1024);
1011
1012         return 0;
1013 }
1014
1015
1016
1017 /*
1018  * interrupt handler
1019  */
1020 static irqreturn_t snd_atiixp_interrupt(int irq, void *dev_id)
1021 {
1022         struct atiixp_modem *chip = dev_id;
1023         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
1061 static int __devinit snd_atiixp_mixer_new(struct atiixp_modem *chip, int clock)
1062 {
1063         struct snd_ac97_bus *pbus;
1064         struct snd_ac97_template ac97;
1065         int i, err;
1066         int codec_count;
1067         static struct snd_ac97_bus_ops ops = {
1068                 .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;
1083         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 | AC97_SCAP_POWER_SAVE;
1094                 if ((err = snd_ac97_mixer(pbus, &ac97, &chip->ac97[i])) < 0) {
1095                         chip->ac97[i] = NULL; /* to be sure */
1096                         snd_printdd("atiixp-modem: codec %d not available for modem\n", i);
1097                         continue;
1098                 }
1099                 codec_count++;
1100         }
1101
1102         if (! codec_count) {
1103                 snd_printk(KERN_ERR "atiixp-modem: no codec available\n");
1104                 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  */
1117 static int snd_atiixp_suspend(struct pci_dev *pci, pm_message_t state)
1118 {
1119         struct snd_card *card = pci_get_drvdata(pci);
1120         struct atiixp_modem *chip = card->private_data;
1121         int i;
1122
1123         snd_power_change_state(card, SNDRV_CTL_POWER_D3hot);
1124         for (i = 0; i < NUM_ATI_PCMDEVS; i++)
1125                 snd_pcm_suspend_all(chip->pcmdevs[i]);
1126         for (i = 0; i < NUM_ATI_CODECS; i++)
1127                 snd_ac97_suspend(chip->ac97[i]);
1128         snd_atiixp_aclink_down(chip);
1129         snd_atiixp_chip_stop(chip);
1130
1131         pci_disable_device(pci);
1132         pci_save_state(pci);
1133         pci_set_power_state(pci, pci_choose_state(pci, state));
1134         return 0;
1135 }
1136
1137 static int snd_atiixp_resume(struct pci_dev *pci)
1138 {
1139         struct snd_card *card = pci_get_drvdata(pci);
1140         struct atiixp_modem *chip = card->private_data;
1141         int i;
1142
1143         pci_set_power_state(pci, PCI_D0);
1144         pci_restore_state(pci);
1145         if (pci_enable_device(pci) < 0) {
1146                 printk(KERN_ERR "atiixp-modem: pci_enable_device failed, "
1147                        "disabling device\n");
1148                 snd_card_disconnect(card);
1149                 return -EIO;
1150         }
1151         pci_set_master(pci);
1152
1153         snd_atiixp_aclink_reset(chip);
1154         snd_atiixp_chip_start(chip);
1155
1156         for (i = 0; i < NUM_ATI_CODECS; i++)
1157                 snd_ac97_resume(chip->ac97[i]);
1158
1159         snd_power_change_state(card, SNDRV_CTL_POWER_D0);
1160         return 0;
1161 }
1162 #endif /* CONFIG_PM */
1163
1164
1165 #ifdef CONFIG_PROC_FS
1166 /*
1167  * proc interface for register dump
1168  */
1169
1170 static void snd_atiixp_proc_read(struct snd_info_entry *entry,
1171                                  struct snd_info_buffer *buffer)
1172 {
1173         struct atiixp_modem *chip = entry->private_data;
1174         int i;
1175
1176         for (i = 0; i < 256; i += 4)
1177                 snd_iprintf(buffer, "%02x: %08x\n", i, readl(chip->remap_addr + i));
1178 }
1179
1180 static void __devinit snd_atiixp_proc_init(struct atiixp_modem *chip)
1181 {
1182         struct snd_info_entry *entry;
1183
1184         if (! snd_card_proc_new(chip->card, "atiixp-modem", &entry))
1185                 snd_info_set_text_ops(entry, chip, snd_atiixp_proc_read);
1186 }
1187 #else
1188 #define snd_atiixp_proc_init(chip)
1189 #endif
1190
1191
1192 /*
1193  * destructor
1194  */
1195
1196 static int snd_atiixp_free(struct atiixp_modem *chip)
1197 {
1198         if (chip->irq < 0)
1199                 goto __hw_end;
1200         snd_atiixp_chip_stop(chip);
1201         synchronize_irq(chip->irq);
1202       __hw_end:
1203         if (chip->irq >= 0)
1204                 free_irq(chip->irq, chip);
1205         if (chip->remap_addr)
1206                 iounmap(chip->remap_addr);
1207         pci_release_regions(chip->pci);
1208         pci_disable_device(chip->pci);
1209         kfree(chip);
1210         return 0;
1211 }
1212
1213 static int snd_atiixp_dev_free(struct snd_device *device)
1214 {
1215         struct atiixp_modem *chip = device->device_data;
1216         return snd_atiixp_free(chip);
1217 }
1218
1219 /*
1220  * constructor for chip instance
1221  */
1222 static int __devinit snd_atiixp_create(struct snd_card *card,
1223                                        struct pci_dev *pci,
1224                                        struct atiixp_modem **r_chip)
1225 {
1226         static struct snd_device_ops ops = {
1227                 .dev_free =     snd_atiixp_dev_free,
1228         };
1229         struct atiixp_modem *chip;
1230         int err;
1231
1232         if ((err = pci_enable_device(pci)) < 0)
1233                 return err;
1234
1235         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
1236         if (chip == NULL) {
1237                 pci_disable_device(pci);
1238                 return -ENOMEM;
1239         }
1240
1241         spin_lock_init(&chip->reg_lock);
1242         mutex_init(&chip->open_mutex);
1243         chip->card = card;
1244         chip->pci = pci;
1245         chip->irq = -1;
1246         if ((err = pci_request_regions(pci, "ATI IXP MC97")) < 0) {
1247                 kfree(chip);
1248                 pci_disable_device(pci);
1249                 return err;
1250         }
1251         chip->addr = pci_resource_start(pci, 0);
1252         chip->remap_addr = ioremap_nocache(chip->addr, pci_resource_len(pci, 0));
1253         if (chip->remap_addr == NULL) {
1254                 snd_printk(KERN_ERR "AC'97 space ioremap problem\n");
1255                 snd_atiixp_free(chip);
1256                 return -EIO;
1257         }
1258
1259         if (request_irq(pci->irq, snd_atiixp_interrupt, IRQF_SHARED,
1260                         card->shortname, chip)) {
1261                 snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
1262                 snd_atiixp_free(chip);
1263                 return -EBUSY;
1264         }
1265         chip->irq = pci->irq;
1266         pci_set_master(pci);
1267         synchronize_irq(chip->irq);
1268
1269         if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
1270                 snd_atiixp_free(chip);
1271                 return err;
1272         }
1273
1274         snd_card_set_dev(card, &pci->dev);
1275
1276         *r_chip = chip;
1277         return 0;
1278 }
1279
1280
1281 static int __devinit snd_atiixp_probe(struct pci_dev *pci,
1282                                       const struct pci_device_id *pci_id)
1283 {
1284         struct snd_card *card;
1285         struct atiixp_modem *chip;
1286         int err;
1287
1288         card = snd_card_new(index, id, THIS_MODULE, 0);
1289         if (card == NULL)
1290                 return -ENOMEM;
1291
1292         strcpy(card->driver, "ATIIXP-MODEM");
1293         strcpy(card->shortname, "ATI IXP Modem");
1294         if ((err = snd_atiixp_create(card, pci, &chip)) < 0)
1295                 goto __error;
1296         card->private_data = chip;
1297
1298         if ((err = snd_atiixp_aclink_reset(chip)) < 0)
1299                 goto __error;
1300
1301         if ((err = snd_atiixp_mixer_new(chip, ac97_clock)) < 0)
1302                 goto __error;
1303
1304         if ((err = snd_atiixp_pcm_new(chip)) < 0)
1305                 goto __error;
1306         
1307         snd_atiixp_proc_init(chip);
1308
1309         snd_atiixp_chip_start(chip);
1310
1311         sprintf(card->longname, "%s rev %x at 0x%lx, irq %i",
1312                 card->shortname, pci->revision, chip->addr, chip->irq);
1313
1314         if ((err = snd_card_register(card)) < 0)
1315                 goto __error;
1316
1317         pci_set_drvdata(pci, card);
1318         return 0;
1319
1320  __error:
1321         snd_card_free(card);
1322         return err;
1323 }
1324
1325 static void __devexit snd_atiixp_remove(struct pci_dev *pci)
1326 {
1327         snd_card_free(pci_get_drvdata(pci));
1328         pci_set_drvdata(pci, NULL);
1329 }
1330
1331 static struct pci_driver driver = {
1332         .name = "ATI IXP MC97 controller",
1333         .id_table = snd_atiixp_ids,
1334         .probe = snd_atiixp_probe,
1335         .remove = __devexit_p(snd_atiixp_remove),
1336 #ifdef CONFIG_PM
1337         .suspend = snd_atiixp_suspend,
1338         .resume = snd_atiixp_resume,
1339 #endif
1340 };
1341
1342
1343 static int __init alsa_card_atiixp_init(void)
1344 {
1345         return pci_register_driver(&driver);
1346 }
1347
1348 static void __exit alsa_card_atiixp_exit(void)
1349 {
1350         pci_unregister_driver(&driver);
1351 }
1352
1353 module_init(alsa_card_atiixp_init)
1354 module_exit(alsa_card_atiixp_exit)