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