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