[PATCH] PCI: removed unneeded .owner field from struct pci_driver
[linux-2.6.git] / sound / pci / atiixp.c
1 /*
2  *   ALSA driver for ATI IXP 150/200/250/300 AC97 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 <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 <tiwai@suse.de>");
38 MODULE_DESCRIPTION("ATI IXP AC97 controller");
39 MODULE_LICENSE("GPL");
40 MODULE_SUPPORTED_DEVICE("{{ATI,IXP150/200/250/300/400}}");
41
42 static int index = SNDRV_DEFAULT_IDX1;  /* Index 0-MAX */
43 static char *id = SNDRV_DEFAULT_STR1;   /* ID for this card */
44 static int ac97_clock = 48000;
45 static char *ac97_quirk;
46 static int spdif_aclink = 1;
47
48 module_param(index, int, 0444);
49 MODULE_PARM_DESC(index, "Index value for ATI IXP controller.");
50 module_param(id, charp, 0444);
51 MODULE_PARM_DESC(id, "ID string for ATI IXP controller.");
52 module_param(ac97_clock, int, 0444);
53 MODULE_PARM_DESC(ac97_clock, "AC'97 codec clock (default 48000Hz).");
54 module_param(ac97_quirk, charp, 0444);
55 MODULE_PARM_DESC(ac97_quirk, "AC'97 workaround for strange hardware.");
56 module_param(spdif_aclink, bool, 0444);
57 MODULE_PARM_DESC(spdif_aclink, "S/PDIF over AC-link.");
58
59 /* just for backward compatibility */
60 static int enable;
61 module_param(enable, bool, 0444);
62
63
64 /*
65  */
66
67 #define ATI_REG_ISR                     0x00    /* interrupt source */
68 #define  ATI_REG_ISR_IN_XRUN            (1U<<0)
69 #define  ATI_REG_ISR_IN_STATUS          (1U<<1)
70 #define  ATI_REG_ISR_OUT_XRUN           (1U<<2)
71 #define  ATI_REG_ISR_OUT_STATUS         (1U<<3)
72 #define  ATI_REG_ISR_SPDF_XRUN          (1U<<4)
73 #define  ATI_REG_ISR_SPDF_STATUS        (1U<<5)
74 #define  ATI_REG_ISR_PHYS_INTR          (1U<<8)
75 #define  ATI_REG_ISR_PHYS_MISMATCH      (1U<<9)
76 #define  ATI_REG_ISR_CODEC0_NOT_READY   (1U<<10)
77 #define  ATI_REG_ISR_CODEC1_NOT_READY   (1U<<11)
78 #define  ATI_REG_ISR_CODEC2_NOT_READY   (1U<<12)
79 #define  ATI_REG_ISR_NEW_FRAME          (1U<<13)
80
81 #define ATI_REG_IER                     0x04    /* interrupt enable */
82 #define  ATI_REG_IER_IN_XRUN_EN         (1U<<0)
83 #define  ATI_REG_IER_IO_STATUS_EN       (1U<<1)
84 #define  ATI_REG_IER_OUT_XRUN_EN        (1U<<2)
85 #define  ATI_REG_IER_OUT_XRUN_COND      (1U<<3)
86 #define  ATI_REG_IER_SPDF_XRUN_EN       (1U<<4)
87 #define  ATI_REG_IER_SPDF_STATUS_EN     (1U<<5)
88 #define  ATI_REG_IER_PHYS_INTR_EN       (1U<<8)
89 #define  ATI_REG_IER_PHYS_MISMATCH_EN   (1U<<9)
90 #define  ATI_REG_IER_CODEC0_INTR_EN     (1U<<10)
91 #define  ATI_REG_IER_CODEC1_INTR_EN     (1U<<11)
92 #define  ATI_REG_IER_CODEC2_INTR_EN     (1U<<12)
93 #define  ATI_REG_IER_NEW_FRAME_EN       (1U<<13)        /* (RO */
94 #define  ATI_REG_IER_SET_BUS_BUSY       (1U<<14)        /* (WO) audio is running */
95
96 #define ATI_REG_CMD                     0x08    /* command */
97 #define  ATI_REG_CMD_POWERDOWN          (1U<<0)
98 #define  ATI_REG_CMD_RECEIVE_EN         (1U<<1)
99 #define  ATI_REG_CMD_SEND_EN            (1U<<2)
100 #define  ATI_REG_CMD_STATUS_MEM         (1U<<3)
101 #define  ATI_REG_CMD_SPDF_OUT_EN        (1U<<4)
102 #define  ATI_REG_CMD_SPDF_STATUS_MEM    (1U<<5)
103 #define  ATI_REG_CMD_SPDF_THRESHOLD     (3U<<6)
104 #define  ATI_REG_CMD_SPDF_THRESHOLD_SHIFT       6
105 #define  ATI_REG_CMD_IN_DMA_EN          (1U<<8)
106 #define  ATI_REG_CMD_OUT_DMA_EN         (1U<<9)
107 #define  ATI_REG_CMD_SPDF_DMA_EN        (1U<<10)
108 #define  ATI_REG_CMD_SPDF_OUT_STOPPED   (1U<<11)
109 #define  ATI_REG_CMD_SPDF_CONFIG_MASK   (7U<<12)
110 #define   ATI_REG_CMD_SPDF_CONFIG_34    (1U<<12)
111 #define   ATI_REG_CMD_SPDF_CONFIG_78    (2U<<12)
112 #define   ATI_REG_CMD_SPDF_CONFIG_69    (3U<<12)
113 #define   ATI_REG_CMD_SPDF_CONFIG_01    (4U<<12)
114 #define  ATI_REG_CMD_INTERLEAVE_SPDF    (1U<<16)
115 #define  ATI_REG_CMD_AUDIO_PRESENT      (1U<<20)
116 #define  ATI_REG_CMD_INTERLEAVE_IN      (1U<<21)
117 #define  ATI_REG_CMD_INTERLEAVE_OUT     (1U<<22)
118 #define  ATI_REG_CMD_LOOPBACK_EN        (1U<<23)
119 #define  ATI_REG_CMD_PACKED_DIS         (1U<<24)
120 #define  ATI_REG_CMD_BURST_EN           (1U<<25)
121 #define  ATI_REG_CMD_PANIC_EN           (1U<<26)
122 #define  ATI_REG_CMD_MODEM_PRESENT      (1U<<27)
123 #define  ATI_REG_CMD_ACLINK_ACTIVE      (1U<<28)
124 #define  ATI_REG_CMD_AC_SOFT_RESET      (1U<<29)
125 #define  ATI_REG_CMD_AC_SYNC            (1U<<30)
126 #define  ATI_REG_CMD_AC_RESET           (1U<<31)
127
128 #define ATI_REG_PHYS_OUT_ADDR           0x0c
129 #define  ATI_REG_PHYS_OUT_CODEC_MASK    (3U<<0)
130 #define  ATI_REG_PHYS_OUT_RW            (1U<<2)
131 #define  ATI_REG_PHYS_OUT_ADDR_EN       (1U<<8)
132 #define  ATI_REG_PHYS_OUT_ADDR_SHIFT    9
133 #define  ATI_REG_PHYS_OUT_DATA_SHIFT    16
134
135 #define ATI_REG_PHYS_IN_ADDR            0x10
136 #define  ATI_REG_PHYS_IN_READ_FLAG      (1U<<8)
137 #define  ATI_REG_PHYS_IN_ADDR_SHIFT     9
138 #define  ATI_REG_PHYS_IN_DATA_SHIFT     16
139
140 #define ATI_REG_SLOTREQ                 0x14
141
142 #define ATI_REG_COUNTER                 0x18
143 #define  ATI_REG_COUNTER_SLOT           (3U<<0) /* slot # */
144 #define  ATI_REG_COUNTER_BITCLOCK       (31U<<8)
145
146 #define ATI_REG_IN_FIFO_THRESHOLD       0x1c
147
148 #define ATI_REG_IN_DMA_LINKPTR          0x20
149 #define ATI_REG_IN_DMA_DT_START         0x24    /* RO */
150 #define ATI_REG_IN_DMA_DT_NEXT          0x28    /* RO */
151 #define ATI_REG_IN_DMA_DT_CUR           0x2c    /* RO */
152 #define ATI_REG_IN_DMA_DT_SIZE          0x30
153
154 #define ATI_REG_OUT_DMA_SLOT            0x34
155 #define  ATI_REG_OUT_DMA_SLOT_BIT(x)    (1U << ((x) - 3))
156 #define  ATI_REG_OUT_DMA_SLOT_MASK      0x1ff
157 #define  ATI_REG_OUT_DMA_THRESHOLD_MASK 0xf800
158 #define  ATI_REG_OUT_DMA_THRESHOLD_SHIFT        11
159
160 #define ATI_REG_OUT_DMA_LINKPTR         0x38
161 #define ATI_REG_OUT_DMA_DT_START        0x3c    /* RO */
162 #define ATI_REG_OUT_DMA_DT_NEXT         0x40    /* RO */
163 #define ATI_REG_OUT_DMA_DT_CUR          0x44    /* RO */
164 #define ATI_REG_OUT_DMA_DT_SIZE         0x48
165
166 #define ATI_REG_SPDF_CMD                0x4c
167 #define  ATI_REG_SPDF_CMD_LFSR          (1U<<4)
168 #define  ATI_REG_SPDF_CMD_SINGLE_CH     (1U<<5)
169 #define  ATI_REG_SPDF_CMD_LFSR_ACC      (0xff<<8)       /* RO */
170
171 #define ATI_REG_SPDF_DMA_LINKPTR        0x50
172 #define ATI_REG_SPDF_DMA_DT_START       0x54    /* RO */
173 #define ATI_REG_SPDF_DMA_DT_NEXT        0x58    /* RO */
174 #define ATI_REG_SPDF_DMA_DT_CUR         0x5c    /* RO */
175 #define ATI_REG_SPDF_DMA_DT_SIZE        0x60
176
177 #define ATI_REG_MODEM_MIRROR            0x7c
178 #define ATI_REG_AUDIO_MIRROR            0x80
179
180 #define ATI_REG_6CH_REORDER             0x84    /* reorder slots for 6ch */
181 #define  ATI_REG_6CH_REORDER_EN         (1U<<0) /* 3,4,7,8,6,9 -> 3,4,6,9,7,8 */
182
183 #define ATI_REG_FIFO_FLUSH              0x88
184 #define  ATI_REG_FIFO_OUT_FLUSH         (1U<<0)
185 #define  ATI_REG_FIFO_IN_FLUSH          (1U<<1)
186
187 /* LINKPTR */
188 #define  ATI_REG_LINKPTR_EN             (1U<<0)
189
190 /* [INT|OUT|SPDIF]_DMA_DT_SIZE */
191 #define  ATI_REG_DMA_DT_SIZE            (0xffffU<<0)
192 #define  ATI_REG_DMA_FIFO_USED          (0x1fU<<16)
193 #define  ATI_REG_DMA_FIFO_FREE          (0x1fU<<21)
194 #define  ATI_REG_DMA_STATE              (7U<<26)
195
196
197 #define ATI_MAX_DESCRIPTORS     256     /* max number of descriptor packets */
198
199
200 /*
201  */
202
203 typedef struct snd_atiixp atiixp_t;
204 typedef struct snd_atiixp_dma atiixp_dma_t;
205 typedef struct snd_atiixp_dma_ops atiixp_dma_ops_t;
206
207
208 /*
209  * DMA packate descriptor
210  */
211
212 typedef struct atiixp_dma_desc {
213         u32 addr;       /* DMA buffer address */
214         u16 status;     /* status bits */
215         u16 size;       /* size of the packet in dwords */
216         u32 next;       /* address of the next packet descriptor */
217 } atiixp_dma_desc_t;
218
219 /*
220  * stream enum
221  */
222 enum { ATI_DMA_PLAYBACK, ATI_DMA_CAPTURE, ATI_DMA_SPDIF, NUM_ATI_DMAS }; /* DMAs */
223 enum { ATI_PCM_OUT, ATI_PCM_IN, ATI_PCM_SPDIF, NUM_ATI_PCMS }; /* AC97 pcm slots */
224 enum { ATI_PCMDEV_ANALOG, ATI_PCMDEV_DIGITAL, NUM_ATI_PCMDEVS }; /* pcm devices */
225
226 #define NUM_ATI_CODECS  3
227
228
229 /*
230  * constants and callbacks for each DMA type
231  */
232 struct snd_atiixp_dma_ops {
233         int type;                       /* ATI_DMA_XXX */
234         unsigned int llp_offset;        /* LINKPTR offset */
235         unsigned int dt_cur;            /* DT_CUR offset */
236         void (*enable_dma)(atiixp_t *chip, int on);     /* called from open callback */
237         void (*enable_transfer)(atiixp_t *chip, int on); /* called from trigger (START/STOP) */
238         void (*flush_dma)(atiixp_t *chip);              /* called from trigger (STOP only) */
239 };
240
241 /*
242  * DMA stream
243  */
244 struct snd_atiixp_dma {
245         const atiixp_dma_ops_t *ops;
246         struct snd_dma_buffer desc_buf;
247         snd_pcm_substream_t *substream; /* assigned PCM substream */
248         unsigned int buf_addr, buf_bytes;       /* DMA buffer address, bytes */
249         unsigned int period_bytes, periods;
250         int opened;
251         int running;
252         int suspended;
253         int pcm_open_flag;
254         int ac97_pcm_type;      /* index # of ac97_pcm to access, -1 = not used */
255         unsigned int saved_curptr;
256 };
257
258 /*
259  * ATI IXP chip
260  */
261 struct snd_atiixp {
262         snd_card_t *card;
263         struct pci_dev *pci;
264
265         unsigned long addr;
266         void __iomem *remap_addr;
267         int irq;
268         
269         ac97_bus_t *ac97_bus;
270         ac97_t *ac97[NUM_ATI_CODECS];
271
272         spinlock_t reg_lock;
273
274         atiixp_dma_t dmas[NUM_ATI_DMAS];
275         struct ac97_pcm *pcms[NUM_ATI_PCMS];
276         snd_pcm_t *pcmdevs[NUM_ATI_PCMDEVS];
277
278         int max_channels;               /* max. channels for PCM out */
279
280         unsigned int codec_not_ready_bits;      /* for codec detection */
281
282         int spdif_over_aclink;          /* passed from the module option */
283         struct semaphore open_mutex;    /* playback open mutex */
284 };
285
286
287 /*
288  */
289 static struct pci_device_id snd_atiixp_ids[] = {
290         { 0x1002, 0x4341, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, /* SB200 */
291         { 0x1002, 0x4361, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, /* SB300 */
292         { 0x1002, 0x4370, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 }, /* SB400 */
293         { 0, }
294 };
295
296 MODULE_DEVICE_TABLE(pci, snd_atiixp_ids);
297
298
299 /*
300  * lowlevel functions
301  */
302
303 /*
304  * update the bits of the given register.
305  * return 1 if the bits changed.
306  */
307 static int snd_atiixp_update_bits(atiixp_t *chip, unsigned int reg,
308                                  unsigned int mask, unsigned int value)
309 {
310         void __iomem *addr = chip->remap_addr + reg;
311         unsigned int data, old_data;
312         old_data = data = readl(addr);
313         data &= ~mask;
314         data |= value;
315         if (old_data == data)
316                 return 0;
317         writel(data, addr);
318         return 1;
319 }
320
321 /*
322  * macros for easy use
323  */
324 #define atiixp_write(chip,reg,value) \
325         writel(value, chip->remap_addr + ATI_REG_##reg)
326 #define atiixp_read(chip,reg) \
327         readl(chip->remap_addr + ATI_REG_##reg)
328 #define atiixp_update(chip,reg,mask,val) \
329         snd_atiixp_update_bits(chip, ATI_REG_##reg, mask, val)
330
331 /* delay for one tick */
332 #define do_delay() do { \
333         schedule_timeout_uninterruptible(1); \
334 } while (0)
335
336
337 /*
338  * handling DMA packets
339  *
340  * we allocate a linear buffer for the DMA, and split it to  each packet.
341  * in a future version, a scatter-gather buffer should be implemented.
342  */
343
344 #define ATI_DESC_LIST_SIZE \
345         PAGE_ALIGN(ATI_MAX_DESCRIPTORS * sizeof(atiixp_dma_desc_t))
346
347 /*
348  * build packets ring for the given buffer size.
349  *
350  * IXP handles the buffer descriptors, which are connected as a linked
351  * list.  although we can change the list dynamically, in this version,
352  * a static RING of buffer descriptors is used.
353  *
354  * the ring is built in this function, and is set up to the hardware. 
355  */
356 static int atiixp_build_dma_packets(atiixp_t *chip, atiixp_dma_t *dma,
357                                    snd_pcm_substream_t *substream,
358                                    unsigned int periods,
359                                    unsigned int period_bytes)
360 {
361         unsigned int i;
362         u32 addr, desc_addr;
363         unsigned long flags;
364
365         if (periods > ATI_MAX_DESCRIPTORS)
366                 return -ENOMEM;
367
368         if (dma->desc_buf.area == NULL) {
369                 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, snd_dma_pci_data(chip->pci),
370                                         ATI_DESC_LIST_SIZE, &dma->desc_buf) < 0)
371                         return -ENOMEM;
372                 dma->period_bytes = dma->periods = 0; /* clear */
373         }
374
375         if (dma->periods == periods && dma->period_bytes == period_bytes)
376                 return 0;
377
378         /* reset DMA before changing the descriptor table */
379         spin_lock_irqsave(&chip->reg_lock, flags);
380         writel(0, chip->remap_addr + dma->ops->llp_offset);
381         dma->ops->enable_dma(chip, 0);
382         dma->ops->enable_dma(chip, 1);
383         spin_unlock_irqrestore(&chip->reg_lock, flags);
384
385         /* fill the entries */
386         addr = (u32)substream->runtime->dma_addr;
387         desc_addr = (u32)dma->desc_buf.addr;
388         for (i = 0; i < periods; i++) {
389                 atiixp_dma_desc_t *desc = &((atiixp_dma_desc_t *)dma->desc_buf.area)[i];
390                 desc->addr = cpu_to_le32(addr);
391                 desc->status = 0;
392                 desc->size = period_bytes >> 2; /* in dwords */
393                 desc_addr += sizeof(atiixp_dma_desc_t);
394                 if (i == periods - 1)
395                         desc->next = cpu_to_le32((u32)dma->desc_buf.addr);
396                 else
397                         desc->next = cpu_to_le32(desc_addr);
398                 addr += period_bytes;
399         }
400
401         writel((u32)dma->desc_buf.addr | ATI_REG_LINKPTR_EN,
402                chip->remap_addr + dma->ops->llp_offset);
403
404         dma->period_bytes = period_bytes;
405         dma->periods = periods;
406
407         return 0;
408 }
409
410 /*
411  * remove the ring buffer and release it if assigned
412  */
413 static void atiixp_clear_dma_packets(atiixp_t *chip, atiixp_dma_t *dma, snd_pcm_substream_t *substream)
414 {
415         if (dma->desc_buf.area) {
416                 writel(0, chip->remap_addr + dma->ops->llp_offset);
417                 snd_dma_free_pages(&dma->desc_buf);
418                 dma->desc_buf.area = NULL;
419         }
420 }
421
422 /*
423  * AC97 interface
424  */
425 static int snd_atiixp_acquire_codec(atiixp_t *chip)
426 {
427         int timeout = 1000;
428
429         while (atiixp_read(chip, PHYS_OUT_ADDR) & ATI_REG_PHYS_OUT_ADDR_EN) {
430                 if (! timeout--) {
431                         snd_printk(KERN_WARNING "atiixp: codec acquire timeout\n");
432                         return -EBUSY;
433                 }
434                 udelay(1);
435         }
436         return 0;
437 }
438
439 static unsigned short snd_atiixp_codec_read(atiixp_t *chip, unsigned short codec, unsigned short reg)
440 {
441         unsigned int data;
442         int timeout;
443
444         if (snd_atiixp_acquire_codec(chip) < 0)
445                 return 0xffff;
446         data = (reg << ATI_REG_PHYS_OUT_ADDR_SHIFT) |
447                 ATI_REG_PHYS_OUT_ADDR_EN |
448                 ATI_REG_PHYS_OUT_RW |
449                 codec;
450         atiixp_write(chip, PHYS_OUT_ADDR, data);
451         if (snd_atiixp_acquire_codec(chip) < 0)
452                 return 0xffff;
453         timeout = 1000;
454         do {
455                 data = atiixp_read(chip, PHYS_IN_ADDR);
456                 if (data & ATI_REG_PHYS_IN_READ_FLAG)
457                         return data >> ATI_REG_PHYS_IN_DATA_SHIFT;
458                 udelay(1);
459         } while (--timeout);
460         /* time out may happen during reset */
461         if (reg < 0x7c)
462                 snd_printk(KERN_WARNING "atiixp: codec read timeout (reg %x)\n", reg);
463         return 0xffff;
464 }
465
466
467 static void snd_atiixp_codec_write(atiixp_t *chip, unsigned short codec, unsigned short reg, unsigned short val)
468 {
469         unsigned int data;
470     
471         if (snd_atiixp_acquire_codec(chip) < 0)
472                 return;
473         data = ((unsigned int)val << ATI_REG_PHYS_OUT_DATA_SHIFT) |
474                 ((unsigned int)reg << ATI_REG_PHYS_OUT_ADDR_SHIFT) |
475                 ATI_REG_PHYS_OUT_ADDR_EN | codec;
476         atiixp_write(chip, PHYS_OUT_ADDR, data);
477 }
478
479
480 static unsigned short snd_atiixp_ac97_read(ac97_t *ac97, unsigned short reg)
481 {
482         atiixp_t *chip = ac97->private_data;
483         return snd_atiixp_codec_read(chip, ac97->num, reg);
484     
485 }
486
487 static void snd_atiixp_ac97_write(ac97_t *ac97, unsigned short reg, unsigned short val)
488 {
489         atiixp_t *chip = ac97->private_data;
490         snd_atiixp_codec_write(chip, ac97->num, reg, val);
491 }
492
493 /*
494  * reset AC link
495  */
496 static int snd_atiixp_aclink_reset(atiixp_t *chip)
497 {
498         int timeout;
499
500         /* reset powerdoewn */
501         if (atiixp_update(chip, CMD, ATI_REG_CMD_POWERDOWN, 0))
502                 udelay(10);
503
504         /* perform a software reset */
505         atiixp_update(chip, CMD, ATI_REG_CMD_AC_SOFT_RESET, ATI_REG_CMD_AC_SOFT_RESET);
506         atiixp_read(chip, CMD);
507         udelay(10);
508         atiixp_update(chip, CMD, ATI_REG_CMD_AC_SOFT_RESET, 0);
509     
510         timeout = 10;
511         while (! (atiixp_read(chip, CMD) & ATI_REG_CMD_ACLINK_ACTIVE)) {
512                 /* do a hard reset */
513                 atiixp_update(chip, CMD, ATI_REG_CMD_AC_SYNC|ATI_REG_CMD_AC_RESET,
514                               ATI_REG_CMD_AC_SYNC);
515                 atiixp_read(chip, CMD);
516                 do_delay();
517                 atiixp_update(chip, CMD, ATI_REG_CMD_AC_RESET, ATI_REG_CMD_AC_RESET);
518                 if (--timeout) {
519                         snd_printk(KERN_ERR "atiixp: codec reset timeout\n");
520                         break;
521                 }
522         }
523
524         /* deassert RESET and assert SYNC to make sure */
525         atiixp_update(chip, CMD, ATI_REG_CMD_AC_SYNC|ATI_REG_CMD_AC_RESET,
526                       ATI_REG_CMD_AC_SYNC|ATI_REG_CMD_AC_RESET);
527
528         return 0;
529 }
530
531 #ifdef CONFIG_PM
532 static int snd_atiixp_aclink_down(atiixp_t *chip)
533 {
534         // if (atiixp_read(chip, MODEM_MIRROR) & 0x1) /* modem running, too? */
535         //      return -EBUSY;
536         atiixp_update(chip, CMD,
537                      ATI_REG_CMD_POWERDOWN | ATI_REG_CMD_AC_RESET,
538                      ATI_REG_CMD_POWERDOWN);
539         return 0;
540 }
541 #endif
542
543 /*
544  * auto-detection of codecs
545  *
546  * the IXP chip can generate interrupts for the non-existing codecs.
547  * NEW_FRAME interrupt is used to make sure that the interrupt is generated
548  * even if all three codecs are connected.
549  */
550
551 #define ALL_CODEC_NOT_READY \
552             (ATI_REG_ISR_CODEC0_NOT_READY |\
553              ATI_REG_ISR_CODEC1_NOT_READY |\
554              ATI_REG_ISR_CODEC2_NOT_READY)
555 #define CODEC_CHECK_BITS (ALL_CODEC_NOT_READY|ATI_REG_ISR_NEW_FRAME)
556
557 static int snd_atiixp_codec_detect(atiixp_t *chip)
558 {
559         int timeout;
560
561         chip->codec_not_ready_bits = 0;
562         atiixp_write(chip, IER, CODEC_CHECK_BITS);
563         /* wait for the interrupts */
564         timeout = HZ / 10;
565         while (timeout-- > 0) {
566                 do_delay();
567                 if (chip->codec_not_ready_bits)
568                         break;
569         }
570         atiixp_write(chip, IER, 0); /* disable irqs */
571
572         if ((chip->codec_not_ready_bits & ALL_CODEC_NOT_READY) == ALL_CODEC_NOT_READY) {
573                 snd_printk(KERN_ERR "atiixp: no codec detected!\n");
574                 return -ENXIO;
575         }
576         return 0;
577 }
578
579
580 /*
581  * enable DMA and irqs
582  */
583 static int snd_atiixp_chip_start(atiixp_t *chip)
584 {
585         unsigned int reg;
586
587         /* set up spdif, enable burst mode */
588         reg = atiixp_read(chip, CMD);
589         reg |= 0x02 << ATI_REG_CMD_SPDF_THRESHOLD_SHIFT;
590         reg |= ATI_REG_CMD_BURST_EN;
591         atiixp_write(chip, CMD, reg);
592
593         reg = atiixp_read(chip, SPDF_CMD);
594         reg &= ~(ATI_REG_SPDF_CMD_LFSR|ATI_REG_SPDF_CMD_SINGLE_CH);
595         atiixp_write(chip, SPDF_CMD, reg);
596
597         /* clear all interrupt source */
598         atiixp_write(chip, ISR, 0xffffffff);
599         /* enable irqs */
600         atiixp_write(chip, IER,
601                      ATI_REG_IER_IO_STATUS_EN |
602                      ATI_REG_IER_IN_XRUN_EN |
603                      ATI_REG_IER_OUT_XRUN_EN |
604                      ATI_REG_IER_SPDF_XRUN_EN |
605                      ATI_REG_IER_SPDF_STATUS_EN);
606         return 0;
607 }
608
609
610 /*
611  * disable DMA and IRQs
612  */
613 static int snd_atiixp_chip_stop(atiixp_t *chip)
614 {
615         /* clear interrupt source */
616         atiixp_write(chip, ISR, atiixp_read(chip, ISR));
617         /* disable irqs */
618         atiixp_write(chip, IER, 0);
619         return 0;
620 }
621
622
623 /*
624  * PCM section
625  */
626
627 /*
628  * pointer callback simplly reads XXX_DMA_DT_CUR register as the current
629  * position.  when SG-buffer is implemented, the offset must be calculated
630  * correctly...
631  */
632 static snd_pcm_uframes_t snd_atiixp_pcm_pointer(snd_pcm_substream_t *substream)
633 {
634         atiixp_t *chip = snd_pcm_substream_chip(substream);
635         snd_pcm_runtime_t *runtime = substream->runtime;
636         atiixp_dma_t *dma = (atiixp_dma_t *)runtime->private_data;
637         unsigned int curptr;
638         int timeout = 1000;
639
640         while (timeout--) {
641                 curptr = readl(chip->remap_addr + dma->ops->dt_cur);
642                 if (curptr < dma->buf_addr)
643                         continue;
644                 curptr -= dma->buf_addr;
645                 if (curptr >= dma->buf_bytes)
646                         continue;
647                 return bytes_to_frames(runtime, curptr);
648         }
649         snd_printd("atiixp: invalid DMA pointer read 0x%x (buf=%x)\n",
650                    readl(chip->remap_addr + dma->ops->dt_cur), dma->buf_addr);
651         return 0;
652 }
653
654 /*
655  * XRUN detected, and stop the PCM substream
656  */
657 static void snd_atiixp_xrun_dma(atiixp_t *chip, atiixp_dma_t *dma)
658 {
659         if (! dma->substream || ! dma->running)
660                 return;
661         snd_printdd("atiixp: XRUN detected (DMA %d)\n", dma->ops->type);
662         snd_pcm_stop(dma->substream, SNDRV_PCM_STATE_XRUN);
663 }
664
665 /*
666  * the period ack.  update the substream.
667  */
668 static void snd_atiixp_update_dma(atiixp_t *chip, atiixp_dma_t *dma)
669 {
670         if (! dma->substream || ! dma->running)
671                 return;
672         snd_pcm_period_elapsed(dma->substream);
673 }
674
675 /* set BUS_BUSY interrupt bit if any DMA is running */
676 /* call with spinlock held */
677 static void snd_atiixp_check_bus_busy(atiixp_t *chip)
678 {
679         unsigned int bus_busy;
680         if (atiixp_read(chip, CMD) & (ATI_REG_CMD_SEND_EN |
681                                       ATI_REG_CMD_RECEIVE_EN |
682                                       ATI_REG_CMD_SPDF_OUT_EN))
683                 bus_busy = ATI_REG_IER_SET_BUS_BUSY;
684         else
685                 bus_busy = 0;
686         atiixp_update(chip, IER, ATI_REG_IER_SET_BUS_BUSY, bus_busy);
687 }
688
689 /* common trigger callback
690  * calling the lowlevel callbacks in it
691  */
692 static int snd_atiixp_pcm_trigger(snd_pcm_substream_t *substream, int cmd)
693 {
694         atiixp_t *chip = snd_pcm_substream_chip(substream);
695         atiixp_dma_t *dma = (atiixp_dma_t *)substream->runtime->private_data;
696         int err = 0;
697
698         snd_assert(dma->ops->enable_transfer && dma->ops->flush_dma, return -EINVAL);
699
700         spin_lock(&chip->reg_lock);
701         switch (cmd) {
702         case SNDRV_PCM_TRIGGER_START:
703         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
704         case SNDRV_PCM_TRIGGER_RESUME:
705                 dma->ops->enable_transfer(chip, 1);
706                 dma->running = 1;
707                 dma->suspended = 0;
708                 break;
709         case SNDRV_PCM_TRIGGER_STOP:
710         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
711         case SNDRV_PCM_TRIGGER_SUSPEND:
712                 dma->ops->enable_transfer(chip, 0);
713                 dma->running = 0;
714                 dma->suspended = cmd == SNDRV_PCM_TRIGGER_SUSPEND;
715                 break;
716         default:
717                 err = -EINVAL;
718                 break;
719         }
720         if (! err) {
721                 snd_atiixp_check_bus_busy(chip);
722                 if (cmd == SNDRV_PCM_TRIGGER_STOP) {
723                         dma->ops->flush_dma(chip);
724                         snd_atiixp_check_bus_busy(chip);
725                 }
726         }
727         spin_unlock(&chip->reg_lock);
728         return err;
729 }
730
731
732 /*
733  * lowlevel callbacks for each DMA type
734  *
735  * every callback is supposed to be called in chip->reg_lock spinlock
736  */
737
738 /* flush FIFO of analog OUT DMA */
739 static void atiixp_out_flush_dma(atiixp_t *chip)
740 {
741         atiixp_write(chip, FIFO_FLUSH, ATI_REG_FIFO_OUT_FLUSH);
742 }
743
744 /* enable/disable analog OUT DMA */
745 static void atiixp_out_enable_dma(atiixp_t *chip, int on)
746 {
747         unsigned int data;
748         data = atiixp_read(chip, CMD);
749         if (on) {
750                 if (data & ATI_REG_CMD_OUT_DMA_EN)
751                         return;
752                 atiixp_out_flush_dma(chip);
753                 data |= ATI_REG_CMD_OUT_DMA_EN;
754         } else
755                 data &= ~ATI_REG_CMD_OUT_DMA_EN;
756         atiixp_write(chip, CMD, data);
757 }
758
759 /* start/stop transfer over OUT DMA */
760 static void atiixp_out_enable_transfer(atiixp_t *chip, int on)
761 {
762         atiixp_update(chip, CMD, ATI_REG_CMD_SEND_EN,
763                       on ? ATI_REG_CMD_SEND_EN : 0);
764 }
765
766 /* enable/disable analog IN DMA */
767 static void atiixp_in_enable_dma(atiixp_t *chip, int on)
768 {
769         atiixp_update(chip, CMD, ATI_REG_CMD_IN_DMA_EN,
770                       on ? ATI_REG_CMD_IN_DMA_EN : 0);
771 }
772
773 /* start/stop analog IN DMA */
774 static void atiixp_in_enable_transfer(atiixp_t *chip, int on)
775 {
776         if (on) {
777                 unsigned int data = atiixp_read(chip, CMD);
778                 if (! (data & ATI_REG_CMD_RECEIVE_EN)) {
779                         data |= ATI_REG_CMD_RECEIVE_EN;
780 #if 0 /* FIXME: this causes the endless loop */
781                         /* wait until slot 3/4 are finished */
782                         while ((atiixp_read(chip, COUNTER) &
783                                 ATI_REG_COUNTER_SLOT) != 5)
784                                 ;
785 #endif
786                         atiixp_write(chip, CMD, data);
787                 }
788         } else
789                 atiixp_update(chip, CMD, ATI_REG_CMD_RECEIVE_EN, 0);
790 }
791
792 /* flush FIFO of analog IN DMA */
793 static void atiixp_in_flush_dma(atiixp_t *chip)
794 {
795         atiixp_write(chip, FIFO_FLUSH, ATI_REG_FIFO_IN_FLUSH);
796 }
797
798 /* enable/disable SPDIF OUT DMA */
799 static void atiixp_spdif_enable_dma(atiixp_t *chip, int on)
800 {
801         atiixp_update(chip, CMD, ATI_REG_CMD_SPDF_DMA_EN,
802                       on ? ATI_REG_CMD_SPDF_DMA_EN : 0);
803 }
804
805 /* start/stop SPDIF OUT DMA */
806 static void atiixp_spdif_enable_transfer(atiixp_t *chip, int on)
807 {
808         unsigned int data;
809         data = atiixp_read(chip, CMD);
810         if (on)
811                 data |= ATI_REG_CMD_SPDF_OUT_EN;
812         else
813                 data &= ~ATI_REG_CMD_SPDF_OUT_EN;
814         atiixp_write(chip, CMD, data);
815 }
816
817 /* flush FIFO of SPDIF OUT DMA */
818 static void atiixp_spdif_flush_dma(atiixp_t *chip)
819 {
820         int timeout;
821
822         /* DMA off, transfer on */
823         atiixp_spdif_enable_dma(chip, 0);
824         atiixp_spdif_enable_transfer(chip, 1);
825         
826         timeout = 100;
827         do {
828                 if (! (atiixp_read(chip, SPDF_DMA_DT_SIZE) & ATI_REG_DMA_FIFO_USED))
829                         break;
830                 udelay(1);
831         } while (timeout-- > 0);
832
833         atiixp_spdif_enable_transfer(chip, 0);
834 }
835
836 /* set up slots and formats for SPDIF OUT */
837 static int snd_atiixp_spdif_prepare(snd_pcm_substream_t *substream)
838 {
839         atiixp_t *chip = snd_pcm_substream_chip(substream);
840
841         spin_lock_irq(&chip->reg_lock);
842         if (chip->spdif_over_aclink) {
843                 unsigned int data;
844                 /* enable slots 10/11 */
845                 atiixp_update(chip, CMD, ATI_REG_CMD_SPDF_CONFIG_MASK,
846                               ATI_REG_CMD_SPDF_CONFIG_01);
847                 data = atiixp_read(chip, OUT_DMA_SLOT) & ~ATI_REG_OUT_DMA_SLOT_MASK;
848                 data |= ATI_REG_OUT_DMA_SLOT_BIT(10) |
849                         ATI_REG_OUT_DMA_SLOT_BIT(11);
850                 data |= 0x04 << ATI_REG_OUT_DMA_THRESHOLD_SHIFT;
851                 atiixp_write(chip, OUT_DMA_SLOT, data);
852                 atiixp_update(chip, CMD, ATI_REG_CMD_INTERLEAVE_OUT,
853                               substream->runtime->format == SNDRV_PCM_FORMAT_S16_LE ?
854                               ATI_REG_CMD_INTERLEAVE_OUT : 0);
855         } else {
856                 atiixp_update(chip, CMD, ATI_REG_CMD_SPDF_CONFIG_MASK, 0);
857                 atiixp_update(chip, CMD, ATI_REG_CMD_INTERLEAVE_SPDF, 0);
858         }
859         spin_unlock_irq(&chip->reg_lock);
860         return 0;
861 }
862
863 /* set up slots and formats for analog OUT */
864 static int snd_atiixp_playback_prepare(snd_pcm_substream_t *substream)
865 {
866         atiixp_t *chip = snd_pcm_substream_chip(substream);
867         unsigned int data;
868
869         spin_lock_irq(&chip->reg_lock);
870         data = atiixp_read(chip, OUT_DMA_SLOT) & ~ATI_REG_OUT_DMA_SLOT_MASK;
871         switch (substream->runtime->channels) {
872         case 8:
873                 data |= ATI_REG_OUT_DMA_SLOT_BIT(10) |
874                         ATI_REG_OUT_DMA_SLOT_BIT(11);
875                 /* fallthru */
876         case 6:
877                 data |= ATI_REG_OUT_DMA_SLOT_BIT(7) |
878                         ATI_REG_OUT_DMA_SLOT_BIT(8);
879                 /* fallthru */
880         case 4:
881                 data |= ATI_REG_OUT_DMA_SLOT_BIT(6) |
882                         ATI_REG_OUT_DMA_SLOT_BIT(9);
883                 /* fallthru */
884         default:
885                 data |= ATI_REG_OUT_DMA_SLOT_BIT(3) |
886                         ATI_REG_OUT_DMA_SLOT_BIT(4);
887                 break;
888         }
889
890         /* set output threshold */
891         data |= 0x04 << ATI_REG_OUT_DMA_THRESHOLD_SHIFT;
892         atiixp_write(chip, OUT_DMA_SLOT, data);
893
894         atiixp_update(chip, CMD, ATI_REG_CMD_INTERLEAVE_OUT,
895                       substream->runtime->format == SNDRV_PCM_FORMAT_S16_LE ?
896                       ATI_REG_CMD_INTERLEAVE_OUT : 0);
897
898         /*
899          * enable 6 channel re-ordering bit if needed
900          */
901         atiixp_update(chip, 6CH_REORDER, ATI_REG_6CH_REORDER_EN,
902                       substream->runtime->channels >= 6 ? ATI_REG_6CH_REORDER_EN: 0);
903     
904         spin_unlock_irq(&chip->reg_lock);
905         return 0;
906 }
907
908 /* set up slots and formats for analog IN */
909 static int snd_atiixp_capture_prepare(snd_pcm_substream_t *substream)
910 {
911         atiixp_t *chip = snd_pcm_substream_chip(substream);
912
913         spin_lock_irq(&chip->reg_lock);
914         atiixp_update(chip, CMD, ATI_REG_CMD_INTERLEAVE_IN,
915                       substream->runtime->format == SNDRV_PCM_FORMAT_S16_LE ?
916                       ATI_REG_CMD_INTERLEAVE_IN : 0);
917         spin_unlock_irq(&chip->reg_lock);
918         return 0;
919 }
920
921 /*
922  * hw_params - allocate the buffer and set up buffer descriptors
923  */
924 static int snd_atiixp_pcm_hw_params(snd_pcm_substream_t *substream,
925                                    snd_pcm_hw_params_t *hw_params)
926 {
927         atiixp_t *chip = snd_pcm_substream_chip(substream);
928         atiixp_dma_t *dma = (atiixp_dma_t *)substream->runtime->private_data;
929         int err;
930
931         err = snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
932         if (err < 0)
933                 return err;
934         dma->buf_addr = substream->runtime->dma_addr;
935         dma->buf_bytes = params_buffer_bytes(hw_params);
936
937         err = atiixp_build_dma_packets(chip, dma, substream,
938                                        params_periods(hw_params),
939                                        params_period_bytes(hw_params));
940         if (err < 0)
941                 return err;
942
943         if (dma->ac97_pcm_type >= 0) {
944                 struct ac97_pcm *pcm = chip->pcms[dma->ac97_pcm_type];
945                 /* PCM is bound to AC97 codec(s)
946                  * set up the AC97 codecs
947                  */
948                 if (dma->pcm_open_flag) {
949                         snd_ac97_pcm_close(pcm);
950                         dma->pcm_open_flag = 0;
951                 }
952                 err = snd_ac97_pcm_open(pcm, params_rate(hw_params),
953                                         params_channels(hw_params),
954                                         pcm->r[0].slots);
955                 if (err >= 0)
956                         dma->pcm_open_flag = 1;
957         }
958
959         return err;
960 }
961
962 static int snd_atiixp_pcm_hw_free(snd_pcm_substream_t * substream)
963 {
964         atiixp_t *chip = snd_pcm_substream_chip(substream);
965         atiixp_dma_t *dma = (atiixp_dma_t *)substream->runtime->private_data;
966
967         if (dma->pcm_open_flag) {
968                 struct ac97_pcm *pcm = chip->pcms[dma->ac97_pcm_type];
969                 snd_ac97_pcm_close(pcm);
970                 dma->pcm_open_flag = 0;
971         }
972         atiixp_clear_dma_packets(chip, dma, substream);
973         snd_pcm_lib_free_pages(substream);
974         return 0;
975 }
976
977
978 /*
979  * pcm hardware definition, identical for all DMA types
980  */
981 static snd_pcm_hardware_t snd_atiixp_pcm_hw =
982 {
983         .info =                 (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
984                                  SNDRV_PCM_INFO_BLOCK_TRANSFER |
985                                  SNDRV_PCM_INFO_PAUSE |
986                                  SNDRV_PCM_INFO_RESUME |
987                                  SNDRV_PCM_INFO_MMAP_VALID),
988         .formats =              SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S32_LE,
989         .rates =                SNDRV_PCM_RATE_48000,
990         .rate_min =             48000,
991         .rate_max =             48000,
992         .channels_min =         2,
993         .channels_max =         2,
994         .buffer_bytes_max =     256 * 1024,
995         .period_bytes_min =     32,
996         .period_bytes_max =     128 * 1024,
997         .periods_min =          2,
998         .periods_max =          ATI_MAX_DESCRIPTORS,
999 };
1000
1001 static int snd_atiixp_pcm_open(snd_pcm_substream_t *substream, atiixp_dma_t *dma, int pcm_type)
1002 {
1003         atiixp_t *chip = snd_pcm_substream_chip(substream);
1004         snd_pcm_runtime_t *runtime = substream->runtime;
1005         int err;
1006
1007         snd_assert(dma->ops && dma->ops->enable_dma, return -EINVAL);
1008
1009         if (dma->opened)
1010                 return -EBUSY;
1011         dma->substream = substream;
1012         runtime->hw = snd_atiixp_pcm_hw;
1013         dma->ac97_pcm_type = pcm_type;
1014         if (pcm_type >= 0) {
1015                 runtime->hw.rates = chip->pcms[pcm_type]->rates;
1016                 snd_pcm_limit_hw_rates(runtime);
1017         } else {
1018                 /* direct SPDIF */
1019                 runtime->hw.formats = SNDRV_PCM_FMTBIT_IEC958_SUBFRAME_LE;
1020         }
1021         if ((err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
1022                 return err;
1023         runtime->private_data = dma;
1024
1025         /* enable DMA bits */
1026         spin_lock_irq(&chip->reg_lock);
1027         dma->ops->enable_dma(chip, 1);
1028         spin_unlock_irq(&chip->reg_lock);
1029         dma->opened = 1;
1030
1031         return 0;
1032 }
1033
1034 static int snd_atiixp_pcm_close(snd_pcm_substream_t *substream, atiixp_dma_t *dma)
1035 {
1036         atiixp_t *chip = snd_pcm_substream_chip(substream);
1037         /* disable DMA bits */
1038         snd_assert(dma->ops && dma->ops->enable_dma, return -EINVAL);
1039         spin_lock_irq(&chip->reg_lock);
1040         dma->ops->enable_dma(chip, 0);
1041         spin_unlock_irq(&chip->reg_lock);
1042         dma->substream = NULL;
1043         dma->opened = 0;
1044         return 0;
1045 }
1046
1047 /*
1048  */
1049 static int snd_atiixp_playback_open(snd_pcm_substream_t *substream)
1050 {
1051         atiixp_t *chip = snd_pcm_substream_chip(substream);
1052         int err;
1053
1054         down(&chip->open_mutex);
1055         err = snd_atiixp_pcm_open(substream, &chip->dmas[ATI_DMA_PLAYBACK], 0);
1056         up(&chip->open_mutex);
1057         if (err < 0)
1058                 return err;
1059         substream->runtime->hw.channels_max = chip->max_channels;
1060         if (chip->max_channels > 2)
1061                 /* channels must be even */
1062                 snd_pcm_hw_constraint_step(substream->runtime, 0,
1063                                            SNDRV_PCM_HW_PARAM_CHANNELS, 2);
1064         return 0;
1065 }
1066
1067 static int snd_atiixp_playback_close(snd_pcm_substream_t *substream)
1068 {
1069         atiixp_t *chip = snd_pcm_substream_chip(substream);
1070         int err;
1071         down(&chip->open_mutex);
1072         err = snd_atiixp_pcm_close(substream, &chip->dmas[ATI_DMA_PLAYBACK]);
1073         up(&chip->open_mutex);
1074         return err;
1075 }
1076
1077 static int snd_atiixp_capture_open(snd_pcm_substream_t *substream)
1078 {
1079         atiixp_t *chip = snd_pcm_substream_chip(substream);
1080         return snd_atiixp_pcm_open(substream, &chip->dmas[ATI_DMA_CAPTURE], 1);
1081 }
1082
1083 static int snd_atiixp_capture_close(snd_pcm_substream_t *substream)
1084 {
1085         atiixp_t *chip = snd_pcm_substream_chip(substream);
1086         return snd_atiixp_pcm_close(substream, &chip->dmas[ATI_DMA_CAPTURE]);
1087 }
1088
1089 static int snd_atiixp_spdif_open(snd_pcm_substream_t *substream)
1090 {
1091         atiixp_t *chip = snd_pcm_substream_chip(substream);
1092         int err;
1093         down(&chip->open_mutex);
1094         if (chip->spdif_over_aclink) /* share DMA_PLAYBACK */
1095                 err = snd_atiixp_pcm_open(substream, &chip->dmas[ATI_DMA_PLAYBACK], 2);
1096         else
1097                 err = snd_atiixp_pcm_open(substream, &chip->dmas[ATI_DMA_SPDIF], -1);
1098         up(&chip->open_mutex);
1099         return err;
1100 }
1101
1102 static int snd_atiixp_spdif_close(snd_pcm_substream_t *substream)
1103 {
1104         atiixp_t *chip = snd_pcm_substream_chip(substream);
1105         int err;
1106         down(&chip->open_mutex);
1107         if (chip->spdif_over_aclink)
1108                 err = snd_atiixp_pcm_close(substream, &chip->dmas[ATI_DMA_PLAYBACK]);
1109         else
1110                 err = snd_atiixp_pcm_close(substream, &chip->dmas[ATI_DMA_SPDIF]);
1111         up(&chip->open_mutex);
1112         return err;
1113 }
1114
1115 /* AC97 playback */
1116 static snd_pcm_ops_t snd_atiixp_playback_ops = {
1117         .open =         snd_atiixp_playback_open,
1118         .close =        snd_atiixp_playback_close,
1119         .ioctl =        snd_pcm_lib_ioctl,
1120         .hw_params =    snd_atiixp_pcm_hw_params,
1121         .hw_free =      snd_atiixp_pcm_hw_free,
1122         .prepare =      snd_atiixp_playback_prepare,
1123         .trigger =      snd_atiixp_pcm_trigger,
1124         .pointer =      snd_atiixp_pcm_pointer,
1125 };
1126
1127 /* AC97 capture */
1128 static snd_pcm_ops_t snd_atiixp_capture_ops = {
1129         .open =         snd_atiixp_capture_open,
1130         .close =        snd_atiixp_capture_close,
1131         .ioctl =        snd_pcm_lib_ioctl,
1132         .hw_params =    snd_atiixp_pcm_hw_params,
1133         .hw_free =      snd_atiixp_pcm_hw_free,
1134         .prepare =      snd_atiixp_capture_prepare,
1135         .trigger =      snd_atiixp_pcm_trigger,
1136         .pointer =      snd_atiixp_pcm_pointer,
1137 };
1138
1139 /* SPDIF playback */
1140 static snd_pcm_ops_t snd_atiixp_spdif_ops = {
1141         .open =         snd_atiixp_spdif_open,
1142         .close =        snd_atiixp_spdif_close,
1143         .ioctl =        snd_pcm_lib_ioctl,
1144         .hw_params =    snd_atiixp_pcm_hw_params,
1145         .hw_free =      snd_atiixp_pcm_hw_free,
1146         .prepare =      snd_atiixp_spdif_prepare,
1147         .trigger =      snd_atiixp_pcm_trigger,
1148         .pointer =      snd_atiixp_pcm_pointer,
1149 };
1150
1151 static struct ac97_pcm atiixp_pcm_defs[] __devinitdata = {
1152         /* front PCM */
1153         {
1154                 .exclusive = 1,
1155                 .r = {  {
1156                                 .slots = (1 << AC97_SLOT_PCM_LEFT) |
1157                                          (1 << AC97_SLOT_PCM_RIGHT) |
1158                                          (1 << AC97_SLOT_PCM_CENTER) |
1159                                          (1 << AC97_SLOT_PCM_SLEFT) |
1160                                          (1 << AC97_SLOT_PCM_SRIGHT) |
1161                                          (1 << AC97_SLOT_LFE)
1162                         }
1163                 }
1164         },
1165         /* PCM IN #1 */
1166         {
1167                 .stream = 1,
1168                 .exclusive = 1,
1169                 .r = {  {
1170                                 .slots = (1 << AC97_SLOT_PCM_LEFT) |
1171                                          (1 << AC97_SLOT_PCM_RIGHT)
1172                         }
1173                 }
1174         },
1175         /* S/PDIF OUT (optional) */
1176         {
1177                 .exclusive = 1,
1178                 .spdif = 1,
1179                 .r = {  {
1180                                 .slots = (1 << AC97_SLOT_SPDIF_LEFT2) |
1181                                          (1 << AC97_SLOT_SPDIF_RIGHT2)
1182                         }
1183                 }
1184         },
1185 };
1186
1187 static atiixp_dma_ops_t snd_atiixp_playback_dma_ops = {
1188         .type = ATI_DMA_PLAYBACK,
1189         .llp_offset = ATI_REG_OUT_DMA_LINKPTR,
1190         .dt_cur = ATI_REG_OUT_DMA_DT_CUR,
1191         .enable_dma = atiixp_out_enable_dma,
1192         .enable_transfer = atiixp_out_enable_transfer,
1193         .flush_dma = atiixp_out_flush_dma,
1194 };
1195         
1196 static atiixp_dma_ops_t snd_atiixp_capture_dma_ops = {
1197         .type = ATI_DMA_CAPTURE,
1198         .llp_offset = ATI_REG_IN_DMA_LINKPTR,
1199         .dt_cur = ATI_REG_IN_DMA_DT_CUR,
1200         .enable_dma = atiixp_in_enable_dma,
1201         .enable_transfer = atiixp_in_enable_transfer,
1202         .flush_dma = atiixp_in_flush_dma,
1203 };
1204         
1205 static atiixp_dma_ops_t snd_atiixp_spdif_dma_ops = {
1206         .type = ATI_DMA_SPDIF,
1207         .llp_offset = ATI_REG_SPDF_DMA_LINKPTR,
1208         .dt_cur = ATI_REG_SPDF_DMA_DT_CUR,
1209         .enable_dma = atiixp_spdif_enable_dma,
1210         .enable_transfer = atiixp_spdif_enable_transfer,
1211         .flush_dma = atiixp_spdif_flush_dma,
1212 };
1213         
1214
1215 static int __devinit snd_atiixp_pcm_new(atiixp_t *chip)
1216 {
1217         snd_pcm_t *pcm;
1218         ac97_bus_t *pbus = chip->ac97_bus;
1219         int err, i, num_pcms;
1220
1221         /* initialize constants */
1222         chip->dmas[ATI_DMA_PLAYBACK].ops = &snd_atiixp_playback_dma_ops;
1223         chip->dmas[ATI_DMA_CAPTURE].ops = &snd_atiixp_capture_dma_ops;
1224         if (! chip->spdif_over_aclink)
1225                 chip->dmas[ATI_DMA_SPDIF].ops = &snd_atiixp_spdif_dma_ops;
1226
1227         /* assign AC97 pcm */
1228         if (chip->spdif_over_aclink)
1229                 num_pcms = 3;
1230         else
1231                 num_pcms = 2;
1232         err = snd_ac97_pcm_assign(pbus, num_pcms, atiixp_pcm_defs);
1233         if (err < 0)
1234                 return err;
1235         for (i = 0; i < num_pcms; i++)
1236                 chip->pcms[i] = &pbus->pcms[i];
1237
1238         chip->max_channels = 2;
1239         if (pbus->pcms[ATI_PCM_OUT].r[0].slots & (1 << AC97_SLOT_PCM_SLEFT)) {
1240                 if (pbus->pcms[ATI_PCM_OUT].r[0].slots & (1 << AC97_SLOT_LFE))
1241                         chip->max_channels = 6;
1242                 else
1243                         chip->max_channels = 4;
1244         }
1245
1246         /* PCM #0: analog I/O */
1247         err = snd_pcm_new(chip->card, "ATI IXP AC97", ATI_PCMDEV_ANALOG, 1, 1, &pcm);
1248         if (err < 0)
1249                 return err;
1250         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_atiixp_playback_ops);
1251         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_atiixp_capture_ops);
1252         pcm->private_data = chip;
1253         strcpy(pcm->name, "ATI IXP AC97");
1254         chip->pcmdevs[ATI_PCMDEV_ANALOG] = pcm;
1255
1256         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
1257                                               snd_dma_pci_data(chip->pci), 64*1024, 128*1024);
1258
1259         /* no SPDIF support on codec? */
1260         if (chip->pcms[ATI_PCM_SPDIF] && ! chip->pcms[ATI_PCM_SPDIF]->rates)
1261                 return 0;
1262                 
1263         /* FIXME: non-48k sample rate doesn't work on my test machine with AD1888 */
1264         if (chip->pcms[ATI_PCM_SPDIF])
1265                 chip->pcms[ATI_PCM_SPDIF]->rates = SNDRV_PCM_RATE_48000;
1266
1267         /* PCM #1: spdif playback */
1268         err = snd_pcm_new(chip->card, "ATI IXP IEC958", ATI_PCMDEV_DIGITAL, 1, 0, &pcm);
1269         if (err < 0)
1270                 return err;
1271         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_atiixp_spdif_ops);
1272         pcm->private_data = chip;
1273         if (chip->spdif_over_aclink)
1274                 strcpy(pcm->name, "ATI IXP IEC958 (AC97)");
1275         else
1276                 strcpy(pcm->name, "ATI IXP IEC958 (Direct)");
1277         chip->pcmdevs[ATI_PCMDEV_DIGITAL] = pcm;
1278
1279         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
1280                                               snd_dma_pci_data(chip->pci), 64*1024, 128*1024);
1281
1282         /* pre-select AC97 SPDIF slots 10/11 */
1283         for (i = 0; i < NUM_ATI_CODECS; i++) {
1284                 if (chip->ac97[i])
1285                         snd_ac97_update_bits(chip->ac97[i], AC97_EXTENDED_STATUS, 0x03 << 4, 0x03 << 4);
1286         }
1287
1288         return 0;
1289 }
1290
1291
1292
1293 /*
1294  * interrupt handler
1295  */
1296 static irqreturn_t snd_atiixp_interrupt(int irq, void *dev_id, struct pt_regs *regs)
1297 {
1298         atiixp_t *chip = dev_id;
1299         unsigned int status;
1300
1301         status = atiixp_read(chip, ISR);
1302
1303         if (! status)
1304                 return IRQ_NONE;
1305
1306         /* process audio DMA */
1307         if (status & ATI_REG_ISR_OUT_XRUN)
1308                 snd_atiixp_xrun_dma(chip,  &chip->dmas[ATI_DMA_PLAYBACK]);
1309         else if (status & ATI_REG_ISR_OUT_STATUS)
1310                 snd_atiixp_update_dma(chip, &chip->dmas[ATI_DMA_PLAYBACK]);
1311         if (status & ATI_REG_ISR_IN_XRUN)
1312                 snd_atiixp_xrun_dma(chip,  &chip->dmas[ATI_DMA_CAPTURE]);
1313         else if (status & ATI_REG_ISR_IN_STATUS)
1314                 snd_atiixp_update_dma(chip, &chip->dmas[ATI_DMA_CAPTURE]);
1315         if (! chip->spdif_over_aclink) {
1316                 if (status & ATI_REG_ISR_SPDF_XRUN)
1317                         snd_atiixp_xrun_dma(chip,  &chip->dmas[ATI_DMA_SPDIF]);
1318                 else if (status & ATI_REG_ISR_SPDF_STATUS)
1319                         snd_atiixp_update_dma(chip, &chip->dmas[ATI_DMA_SPDIF]);
1320         }
1321
1322         /* for codec detection */
1323         if (status & CODEC_CHECK_BITS) {
1324                 unsigned int detected;
1325                 detected = status & CODEC_CHECK_BITS;
1326                 spin_lock(&chip->reg_lock);
1327                 chip->codec_not_ready_bits |= detected;
1328                 atiixp_update(chip, IER, detected, 0); /* disable the detected irqs */
1329                 spin_unlock(&chip->reg_lock);
1330         }
1331
1332         /* ack */
1333         atiixp_write(chip, ISR, status);
1334
1335         return IRQ_HANDLED;
1336 }
1337
1338
1339 /*
1340  * ac97 mixer section
1341  */
1342
1343 static struct ac97_quirk ac97_quirks[] __devinitdata = {
1344         {
1345                 .subvendor = 0x103c,
1346                 .subdevice = 0x006b,
1347                 .name = "HP Pavilion ZV5030US",
1348                 .type = AC97_TUNE_MUTE_LED
1349         },
1350         { } /* terminator */
1351 };
1352
1353 static int __devinit snd_atiixp_mixer_new(atiixp_t *chip, int clock, const char *quirk_override)
1354 {
1355         ac97_bus_t *pbus;
1356         ac97_template_t ac97;
1357         int i, err;
1358         int codec_count;
1359         static ac97_bus_ops_t ops = {
1360                 .write = snd_atiixp_ac97_write,
1361                 .read = snd_atiixp_ac97_read,
1362         };
1363         static unsigned int codec_skip[NUM_ATI_CODECS] = {
1364                 ATI_REG_ISR_CODEC0_NOT_READY,
1365                 ATI_REG_ISR_CODEC1_NOT_READY,
1366                 ATI_REG_ISR_CODEC2_NOT_READY,
1367         };
1368
1369         if (snd_atiixp_codec_detect(chip) < 0)
1370                 return -ENXIO;
1371
1372         if ((err = snd_ac97_bus(chip->card, 0, &ops, chip, &pbus)) < 0)
1373                 return err;
1374         pbus->clock = clock;
1375         chip->ac97_bus = pbus;
1376
1377         codec_count = 0;
1378         for (i = 0; i < NUM_ATI_CODECS; i++) {
1379                 if (chip->codec_not_ready_bits & codec_skip[i])
1380                         continue;
1381                 memset(&ac97, 0, sizeof(ac97));
1382                 ac97.private_data = chip;
1383                 ac97.pci = chip->pci;
1384                 ac97.num = i;
1385                 ac97.scaps = AC97_SCAP_SKIP_MODEM;
1386                 if (! chip->spdif_over_aclink)
1387                         ac97.scaps |= AC97_SCAP_NO_SPDIF;
1388                 if ((err = snd_ac97_mixer(pbus, &ac97, &chip->ac97[i])) < 0) {
1389                         chip->ac97[i] = NULL; /* to be sure */
1390                         snd_printdd("atiixp: codec %d not available for audio\n", i);
1391                         continue;
1392                 }
1393                 codec_count++;
1394         }
1395
1396         if (! codec_count) {
1397                 snd_printk(KERN_ERR "atiixp: no codec available\n");
1398                 return -ENODEV;
1399         }
1400
1401         snd_ac97_tune_hardware(chip->ac97[0], ac97_quirks, quirk_override);
1402
1403         return 0;
1404 }
1405
1406
1407 #ifdef CONFIG_PM
1408 /*
1409  * power management
1410  */
1411 static int snd_atiixp_suspend(snd_card_t *card, pm_message_t state)
1412 {
1413         atiixp_t *chip = card->pm_private_data;
1414         int i;
1415
1416         for (i = 0; i < NUM_ATI_PCMDEVS; i++)
1417                 if (chip->pcmdevs[i]) {
1418                         atiixp_dma_t *dma = &chip->dmas[i];
1419                         if (dma->substream && dma->running)
1420                                 dma->saved_curptr = readl(chip->remap_addr + dma->ops->dt_cur);
1421                         snd_pcm_suspend_all(chip->pcmdevs[i]);
1422                 }
1423         for (i = 0; i < NUM_ATI_CODECS; i++)
1424                 if (chip->ac97[i])
1425                         snd_ac97_suspend(chip->ac97[i]);
1426         snd_atiixp_aclink_down(chip);
1427         snd_atiixp_chip_stop(chip);
1428
1429         pci_set_power_state(chip->pci, PCI_D3hot);
1430         pci_disable_device(chip->pci);
1431         return 0;
1432 }
1433
1434 static int snd_atiixp_resume(snd_card_t *card)
1435 {
1436         atiixp_t *chip = card->pm_private_data;
1437         int i;
1438
1439         pci_enable_device(chip->pci);
1440         pci_set_power_state(chip->pci, PCI_D0);
1441         pci_set_master(chip->pci);
1442
1443         snd_atiixp_aclink_reset(chip);
1444         snd_atiixp_chip_start(chip);
1445
1446         for (i = 0; i < NUM_ATI_CODECS; i++)
1447                 if (chip->ac97[i])
1448                         snd_ac97_resume(chip->ac97[i]);
1449
1450         for (i = 0; i < NUM_ATI_PCMDEVS; i++)
1451                 if (chip->pcmdevs[i]) {
1452                         atiixp_dma_t *dma = &chip->dmas[i];
1453                         if (dma->substream && dma->suspended) {
1454                                 dma->ops->enable_dma(chip, 1);
1455                                 dma->substream->ops->prepare(dma->substream);
1456                                 writel((u32)dma->desc_buf.addr | ATI_REG_LINKPTR_EN,
1457                                        chip->remap_addr + dma->ops->llp_offset);
1458                                 writel(dma->saved_curptr, chip->remap_addr + dma->ops->dt_cur);
1459                         }
1460                 }
1461
1462         return 0;
1463 }
1464 #endif /* CONFIG_PM */
1465
1466
1467 /*
1468  * proc interface for register dump
1469  */
1470
1471 static void snd_atiixp_proc_read(snd_info_entry_t *entry, snd_info_buffer_t *buffer)
1472 {
1473         atiixp_t *chip = entry->private_data;
1474         int i;
1475
1476         for (i = 0; i < 256; i += 4)
1477                 snd_iprintf(buffer, "%02x: %08x\n", i, readl(chip->remap_addr + i));
1478 }
1479
1480 static void __devinit snd_atiixp_proc_init(atiixp_t *chip)
1481 {
1482         snd_info_entry_t *entry;
1483
1484         if (! snd_card_proc_new(chip->card, "atiixp", &entry))
1485                 snd_info_set_text_ops(entry, chip, 1024, snd_atiixp_proc_read);
1486 }
1487
1488
1489
1490 /*
1491  * destructor
1492  */
1493
1494 static int snd_atiixp_free(atiixp_t *chip)
1495 {
1496         if (chip->irq < 0)
1497                 goto __hw_end;
1498         snd_atiixp_chip_stop(chip);
1499         synchronize_irq(chip->irq);
1500       __hw_end:
1501         if (chip->irq >= 0)
1502                 free_irq(chip->irq, (void *)chip);
1503         if (chip->remap_addr)
1504                 iounmap(chip->remap_addr);
1505         pci_release_regions(chip->pci);
1506         pci_disable_device(chip->pci);
1507         kfree(chip);
1508         return 0;
1509 }
1510
1511 static int snd_atiixp_dev_free(snd_device_t *device)
1512 {
1513         atiixp_t *chip = device->device_data;
1514         return snd_atiixp_free(chip);
1515 }
1516
1517 /*
1518  * constructor for chip instance
1519  */
1520 static int __devinit snd_atiixp_create(snd_card_t *card,
1521                                       struct pci_dev *pci,
1522                                       atiixp_t **r_chip)
1523 {
1524         static snd_device_ops_t ops = {
1525                 .dev_free =     snd_atiixp_dev_free,
1526         };
1527         atiixp_t *chip;
1528         int err;
1529
1530         if ((err = pci_enable_device(pci)) < 0)
1531                 return err;
1532
1533         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
1534         if (chip == NULL) {
1535                 pci_disable_device(pci);
1536                 return -ENOMEM;
1537         }
1538
1539         spin_lock_init(&chip->reg_lock);
1540         init_MUTEX(&chip->open_mutex);
1541         chip->card = card;
1542         chip->pci = pci;
1543         chip->irq = -1;
1544         if ((err = pci_request_regions(pci, "ATI IXP AC97")) < 0) {
1545                 pci_disable_device(pci);
1546                 kfree(chip);
1547                 return err;
1548         }
1549         chip->addr = pci_resource_start(pci, 0);
1550         chip->remap_addr = ioremap_nocache(chip->addr, pci_resource_len(pci, 0));
1551         if (chip->remap_addr == NULL) {
1552                 snd_printk(KERN_ERR "AC'97 space ioremap problem\n");
1553                 snd_atiixp_free(chip);
1554                 return -EIO;
1555         }
1556
1557         if (request_irq(pci->irq, snd_atiixp_interrupt, SA_INTERRUPT|SA_SHIRQ, card->shortname, (void *)chip)) {
1558                 snd_printk(KERN_ERR "unable to grab IRQ %d\n", pci->irq);
1559                 snd_atiixp_free(chip);
1560                 return -EBUSY;
1561         }
1562         chip->irq = pci->irq;
1563         pci_set_master(pci);
1564         synchronize_irq(chip->irq);
1565
1566         if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
1567                 snd_atiixp_free(chip);
1568                 return err;
1569         }
1570
1571         snd_card_set_dev(card, &pci->dev);
1572
1573         *r_chip = chip;
1574         return 0;
1575 }
1576
1577
1578 static int __devinit snd_atiixp_probe(struct pci_dev *pci,
1579                                      const struct pci_device_id *pci_id)
1580 {
1581         snd_card_t *card;
1582         atiixp_t *chip;
1583         unsigned char revision;
1584         int err;
1585
1586         card = snd_card_new(index, id, THIS_MODULE, 0);
1587         if (card == NULL)
1588                 return -ENOMEM;
1589
1590         pci_read_config_byte(pci, PCI_REVISION_ID, &revision);
1591
1592         strcpy(card->driver, spdif_aclink ? "ATIIXP" : "ATIIXP-SPDMA");
1593         strcpy(card->shortname, "ATI IXP");
1594         if ((err = snd_atiixp_create(card, pci, &chip)) < 0)
1595                 goto __error;
1596
1597         if ((err = snd_atiixp_aclink_reset(chip)) < 0)
1598                 goto __error;
1599
1600         chip->spdif_over_aclink = spdif_aclink;
1601
1602         if ((err = snd_atiixp_mixer_new(chip, ac97_clock, ac97_quirk)) < 0)
1603                 goto __error;
1604
1605         if ((err = snd_atiixp_pcm_new(chip)) < 0)
1606                 goto __error;
1607         
1608         snd_atiixp_proc_init(chip);
1609
1610         snd_atiixp_chip_start(chip);
1611
1612         snprintf(card->longname, sizeof(card->longname),
1613                  "%s rev %x with %s at %#lx, irq %i", card->shortname, revision,
1614                  chip->ac97[0] ? snd_ac97_get_short_name(chip->ac97[0]) : "?",
1615                  chip->addr, chip->irq);
1616
1617         snd_card_set_pm_callback(card, snd_atiixp_suspend, snd_atiixp_resume, chip);
1618
1619         if ((err = snd_card_register(card)) < 0)
1620                 goto __error;
1621
1622         pci_set_drvdata(pci, card);
1623         return 0;
1624
1625  __error:
1626         snd_card_free(card);
1627         return err;
1628 }
1629
1630 static void __devexit snd_atiixp_remove(struct pci_dev *pci)
1631 {
1632         snd_card_free(pci_get_drvdata(pci));
1633         pci_set_drvdata(pci, NULL);
1634 }
1635
1636 static struct pci_driver driver = {
1637         .name = "ATI IXP AC97 controller",
1638         .id_table = snd_atiixp_ids,
1639         .probe = snd_atiixp_probe,
1640         .remove = __devexit_p(snd_atiixp_remove),
1641         SND_PCI_PM_CALLBACKS
1642 };
1643
1644
1645 static int __init alsa_card_atiixp_init(void)
1646 {
1647         return pci_register_driver(&driver);
1648 }
1649
1650 static void __exit alsa_card_atiixp_exit(void)
1651 {
1652         pci_unregister_driver(&driver);
1653 }
1654
1655 module_init(alsa_card_atiixp_init)
1656 module_exit(alsa_card_atiixp_exit)