?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] PCI: removed unneeded .owner field from struct pci_driver
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / sound / pci / atiixp.c
blob8bae10d93529b5c273ca6ebe8f12f42997bde39b
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)
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree