aboutsummaryrefslogtreecommitdiffstats
path: root/sound/pci/cs5535audio
diff options
context:
space:
mode:
Diffstat (limited to 'sound/pci/cs5535audio')
-rw-r--r--sound/pci/cs5535audio/Makefile8
-rw-r--r--sound/pci/cs5535audio/cs5535audio.c410
-rw-r--r--sound/pci/cs5535audio/cs5535audio.h123
-rw-r--r--sound/pci/cs5535audio/cs5535audio_pcm.c430
4 files changed, 971 insertions, 0 deletions
diff --git a/sound/pci/cs5535audio/Makefile b/sound/pci/cs5535audio/Makefile
new file mode 100644
index 000000000000..08d8ee6547d3
--- /dev/null
+++ b/sound/pci/cs5535audio/Makefile
@@ -0,0 +1,8 @@
1#
2# Makefile for cs5535audio
3#
4
5snd-cs5535audio-objs := cs5535audio.o cs5535audio_pcm.o
6
7# Toplevel Module Dependency
8obj-$(CONFIG_SND_CS5535AUDIO) += snd-cs5535audio.o
diff --git a/sound/pci/cs5535audio/cs5535audio.c b/sound/pci/cs5535audio/cs5535audio.c
new file mode 100644
index 000000000000..920c857fc223
--- /dev/null
+++ b/sound/pci/cs5535audio/cs5535audio.c
@@ -0,0 +1,410 @@
1/*
2 * Driver for audio on multifunction CS5535 companion device
3 * Copyright (C) Jaya Kumar
4 *
5 * Based on Jaroslav Kysela and Takashi Iwai's examples.
6 * This work was sponsored by CIS(M) Sdn Bhd.
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 *
22 */
23
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 <asm/io.h>
31#include <sound/driver.h>
32#include <sound/core.h>
33#include <sound/control.h>
34#include <sound/pcm.h>
35#include <sound/rawmidi.h>
36#include <sound/ac97_codec.h>
37#include <sound/initval.h>
38#include <sound/asoundef.h>
39#include "cs5535audio.h"
40
41#define DRIVER_NAME "cs5535audio"
42
43
44static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
45static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;
46static int enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
47
48static struct pci_device_id snd_cs5535audio_ids[] = {
49 { PCI_VENDOR_ID_NS, PCI_DEVICE_ID_NS_CS5535_AUDIO, PCI_ANY_ID,
50 PCI_ANY_ID, 0, 0, 0, },
51 {}
52};
53
54MODULE_DEVICE_TABLE(pci, snd_cs5535audio_ids);
55
56static void wait_till_cmd_acked(cs5535audio_t *cs5535au, unsigned long timeout)
57{
58 unsigned long tmp;
59 do {
60 tmp = cs_readl(cs5535au, ACC_CODEC_CNTL);
61 if (!(tmp & CMD_NEW))
62 break;
63 msleep(10);
64 } while (--timeout);
65 if (!timeout)
66 snd_printk(KERN_ERR "Failure writing to cs5535 codec\n");
67}
68
69static unsigned short snd_cs5535audio_codec_read(cs5535audio_t *cs5535au,
70 unsigned short reg)
71{
72 unsigned long regdata;
73 unsigned long timeout;
74 unsigned long val;
75
76 regdata = ((unsigned long) reg) << 24;
77 regdata |= ACC_CODEC_CNTL_RD_CMD;
78 regdata |= CMD_NEW;
79
80 cs_writel(cs5535au, ACC_CODEC_CNTL, regdata);
81 wait_till_cmd_acked(cs5535au, 500);
82
83 timeout = 50;
84 do {
85 val = cs_readl(cs5535au, ACC_CODEC_STATUS);
86 if ( (val & STS_NEW) &&
87 ((unsigned long) reg == ((0xFF000000 & val)>>24)) )
88 break;
89 msleep(10);
90 } while (--timeout);
91 if (!timeout)
92 snd_printk(KERN_ERR "Failure reading cs5535 codec\n");
93
94 return ((unsigned short) val);
95}
96
97static void snd_cs5535audio_codec_write(cs5535audio_t *cs5535au,
98 unsigned short reg, unsigned short val)
99{
100 unsigned long regdata;
101
102 regdata = ((unsigned long) reg) << 24;
103 regdata |= (unsigned long) val;
104 regdata &= CMD_MASK;
105 regdata |= CMD_NEW;
106 regdata &= ACC_CODEC_CNTL_WR_CMD;
107
108 cs_writel(cs5535au, ACC_CODEC_CNTL, regdata);
109 wait_till_cmd_acked(cs5535au, 50);
110}
111
112static void snd_cs5535audio_ac97_codec_write(ac97_t *ac97,
113 unsigned short reg, unsigned short val)
114{
115 cs5535audio_t *cs5535au = ac97->private_data;
116 snd_cs5535audio_codec_write(cs5535au, reg, val);
117}
118
119static unsigned short snd_cs5535audio_ac97_codec_read(ac97_t *ac97,
120 unsigned short reg)
121{
122 cs5535audio_t *cs5535au = ac97->private_data;
123 return snd_cs5535audio_codec_read(cs5535au, reg);
124}
125
126static void snd_cs5535audio_mixer_free_ac97(ac97_t *ac97)
127{
128 cs5535audio_t *cs5535audio = ac97->private_data;
129 cs5535audio->ac97 = NULL;
130}
131
132static int snd_cs5535audio_mixer(cs5535audio_t *cs5535au)
133{
134 snd_card_t *card = cs5535au->card;
135 ac97_bus_t *pbus;
136 ac97_template_t ac97;
137 int err;
138 static ac97_bus_ops_t ops = {
139 .write = snd_cs5535audio_ac97_codec_write,
140 .read = snd_cs5535audio_ac97_codec_read,
141 };
142
143 if ((err = snd_ac97_bus(card, 0, &ops, NULL, &pbus)) < 0)
144 return err;
145
146 memset(&ac97, 0, sizeof(ac97));
147 ac97.scaps = AC97_SCAP_AUDIO|AC97_SCAP_SKIP_MODEM;
148 ac97.private_data = cs5535au;
149 ac97.pci = cs5535au->pci;
150 ac97.private_free = snd_cs5535audio_mixer_free_ac97;
151
152 if ((err = snd_ac97_mixer(pbus, &ac97, &cs5535au->ac97)) < 0) {
153 snd_printk("mixer failed\n");
154 return err;
155 }
156
157 return 0;
158}
159
160static void process_bm0_irq(cs5535audio_t *cs5535au)
161{
162 u8 bm_stat;
163 spin_lock(&cs5535au->reg_lock);
164 bm_stat = cs_readb(cs5535au, ACC_BM0_STATUS);
165 spin_unlock(&cs5535au->reg_lock);
166 if (bm_stat & EOP) {
167 cs5535audio_dma_t *dma;
168 dma = cs5535au->playback_substream->runtime->private_data;
169 snd_pcm_period_elapsed(cs5535au->playback_substream);
170 } else {
171 snd_printk(KERN_ERR "unexpected bm0 irq src, bm_stat=%x\n",
172 bm_stat);
173 }
174}
175
176static void process_bm1_irq(cs5535audio_t *cs5535au)
177{
178 u8 bm_stat;
179 spin_lock(&cs5535au->reg_lock);
180 bm_stat = cs_readb(cs5535au, ACC_BM1_STATUS);
181 spin_unlock(&cs5535au->reg_lock);
182 if (bm_stat & EOP) {
183 cs5535audio_dma_t *dma;
184 dma = cs5535au->capture_substream->runtime->private_data;
185 snd_pcm_period_elapsed(cs5535au->capture_substream);
186 }
187}
188
189static irqreturn_t snd_cs5535audio_interrupt(int irq, void *dev_id,
190 struct pt_regs *regs)
191{
192 u16 acc_irq_stat;
193 u8 bm_stat;
194 unsigned char count;
195 cs5535audio_t *cs5535au = dev_id;
196
197 if (cs5535au == NULL)
198 return IRQ_NONE;
199
200 acc_irq_stat = cs_readw(cs5535au, ACC_IRQ_STATUS);
201
202 if (!acc_irq_stat)
203 return IRQ_NONE;
204 for (count=0; count < 10; count++) {
205 if (acc_irq_stat & (1<<count)) {
206 switch (count) {
207 case IRQ_STS:
208 cs_readl(cs5535au, ACC_GPIO_STATUS);
209 break;
210 case WU_IRQ_STS:
211 cs_readl(cs5535au, ACC_GPIO_STATUS);
212 break;
213 case BM0_IRQ_STS:
214 process_bm0_irq(cs5535au);
215 break;
216 case BM1_IRQ_STS:
217 process_bm1_irq(cs5535au);
218 break;
219 case BM2_IRQ_STS:
220 bm_stat = cs_readb(cs5535au, ACC_BM2_STATUS);
221 break;
222 case BM3_IRQ_STS:
223 bm_stat = cs_readb(cs5535au, ACC_BM3_STATUS);
224 break;
225 case BM4_IRQ_STS:
226 bm_stat = cs_readb(cs5535au, ACC_BM4_STATUS);
227 break;
228 case BM5_IRQ_STS:
229 bm_stat = cs_readb(cs5535au, ACC_BM5_STATUS);
230 break;
231 case BM6_IRQ_STS:
232 bm_stat = cs_readb(cs5535au, ACC_BM6_STATUS);
233 break;
234 case BM7_IRQ_STS:
235 bm_stat = cs_readb(cs5535au, ACC_BM7_STATUS);
236 break;
237 default:
238 snd_printk(KERN_ERR "Unexpected irq src\n");
239 break;
240 }
241 }
242 }
243 return IRQ_HANDLED;
244}
245
246static int snd_cs5535audio_free(cs5535audio_t *cs5535au)
247{
248 synchronize_irq(cs5535au->irq);
249 pci_set_power_state(cs5535au->pci, 3);
250
251 if (cs5535au->irq >= 0)
252 free_irq(cs5535au->irq, cs5535au);
253
254 pci_release_regions(cs5535au->pci);
255 pci_disable_device(cs5535au->pci);
256 kfree(cs5535au);
257 return 0;
258}
259
260static int snd_cs5535audio_dev_free(snd_device_t *device)
261{
262 cs5535audio_t *cs5535au = device->device_data;
263 return snd_cs5535audio_free(cs5535au);
264}
265
266static int __devinit snd_cs5535audio_create(snd_card_t *card,
267 struct pci_dev *pci,
268 cs5535audio_t **rcs5535au)
269{
270 cs5535audio_t *cs5535au;
271
272 int err;
273 static snd_device_ops_t ops = {
274 .dev_free = snd_cs5535audio_dev_free,
275 };
276
277 *rcs5535au = NULL;
278 if ((err = pci_enable_device(pci)) < 0)
279 return err;
280
281 if (pci_set_dma_mask(pci, DMA_32BIT_MASK) < 0 ||
282 pci_set_consistent_dma_mask(pci, DMA_32BIT_MASK) < 0) {
283 printk(KERN_WARNING "unable to get 32bit dma\n");
284 err = -ENXIO;
285 goto pcifail;
286 }
287
288 cs5535au = kzalloc(sizeof(*cs5535au), GFP_KERNEL);
289 if (cs5535au == NULL) {
290 err = -ENOMEM;
291 goto pcifail;
292 }
293
294 spin_lock_init(&cs5535au->reg_lock);
295 cs5535au->card = card;
296 cs5535au->pci = pci;
297 cs5535au->irq = -1;
298
299 if ((err = pci_request_regions(pci, "CS5535 Audio")) < 0) {
300 kfree(cs5535au);
301 goto pcifail;
302 }
303
304 cs5535au->port = pci_resource_start(pci, 0);
305
306 if (request_irq(pci->irq, snd_cs5535audio_interrupt,
307 SA_INTERRUPT|SA_SHIRQ, "CS5535 Audio", cs5535au)) {
308 snd_printk("unable to grab IRQ %d\n", pci->irq);
309 err = -EBUSY;
310 goto sndfail;
311 }
312
313 cs5535au->irq = pci->irq;
314 pci_set_master(pci);
315
316 if ((err = snd_device_new(card, SNDRV_DEV_LOWLEVEL,
317 cs5535au, &ops)) < 0)
318 goto sndfail;
319
320 snd_card_set_dev(card, &pci->dev);
321
322 *rcs5535au = cs5535au;
323 return 0;
324
325sndfail: /* leave the device alive, just kill the snd */
326 snd_cs5535audio_free(cs5535au);
327 return err;
328
329pcifail:
330 pci_disable_device(pci);
331 return err;
332}
333
334static int __devinit snd_cs5535audio_probe(struct pci_dev *pci,
335 const struct pci_device_id *pci_id)
336{
337 static int dev;
338 snd_card_t *card;
339 cs5535audio_t *cs5535au;
340 int err;
341
342 if (dev >= SNDRV_CARDS)
343 return -ENODEV;
344 if (!enable[dev]) {
345 dev++;
346 return -ENOENT;
347 }
348
349 card = snd_card_new(index[dev], id[dev], THIS_MODULE, 0);
350 if (card == NULL)
351 return -ENOMEM;
352
353 if ((err = snd_cs5535audio_create(card, pci, &cs5535au)) < 0)
354 goto probefail_out;
355
356 if ((err = snd_cs5535audio_mixer(cs5535au)) < 0)
357 goto probefail_out;
358
359 if ((err = snd_cs5535audio_pcm(cs5535au)) < 0)
360 goto probefail_out;
361
362 strcpy(card->driver, DRIVER_NAME);
363
364 strcpy(card->shortname, "CS5535 Audio");
365 sprintf(card->longname, "%s %s at 0x%lx, irq %i",
366 card->shortname, card->driver,
367 cs5535au->port, cs5535au->irq);
368
369 if ((err = snd_card_register(card)) < 0)
370 goto probefail_out;
371
372 pci_set_drvdata(pci, card);
373 dev++;
374 return 0;
375
376probefail_out:
377 snd_card_free(card);
378 return err;
379}
380
381static void __devexit snd_cs5535audio_remove(struct pci_dev *pci)
382{
383 snd_card_free(pci_get_drvdata(pci));
384 pci_set_drvdata(pci, NULL);
385}
386
387static struct pci_driver driver = {
388 .name = DRIVER_NAME,
389 .id_table = snd_cs5535audio_ids,
390 .probe = snd_cs5535audio_probe,
391 .remove = __devexit_p(snd_cs5535audio_remove),
392};
393
394static int __init alsa_card_cs5535audio_init(void)
395{
396 return pci_module_init(&driver);
397}
398
399static void __exit alsa_card_cs5535audio_exit(void)
400{
401 pci_unregister_driver(&driver);
402}
403
404module_init(alsa_card_cs5535audio_init)
405module_exit(alsa_card_cs5535audio_exit)
406
407MODULE_AUTHOR("Jaya Kumar");
408MODULE_LICENSE("GPL");
409MODULE_DESCRIPTION("CS5535 Audio");
410MODULE_SUPPORTED_DEVICE("CS5535 Audio");
diff --git a/sound/pci/cs5535audio/cs5535audio.h b/sound/pci/cs5535audio/cs5535audio.h
new file mode 100644
index 000000000000..e28177fb0991
--- /dev/null
+++ b/sound/pci/cs5535audio/cs5535audio.h
@@ -0,0 +1,123 @@
1#ifndef __SOUND_CS5535AUDIO_H
2#define __SOUND_CS5535AUDIO_H
3
4#define cs_writel(cs5535au, reg, val) outl(val, (int) cs5535au->port + reg)
5#define cs_writeb(cs5535au, reg, val) outb(val, (int) cs5535au->port + reg)
6#define cs_readl(cs5535au, reg) inl((unsigned short) (cs5535au->port + reg))
7#define cs_readw(cs5535au, reg) inw((unsigned short) (cs5535au->port + reg))
8#define cs_readb(cs5535au, reg) inb((unsigned short) (cs5535au->port + reg))
9
10#define CS5535AUDIO_MAX_DESCRIPTORS 128
11
12/* acc_codec bar0 reg addrs */
13#define ACC_GPIO_STATUS 0x00
14#define ACC_CODEC_STATUS 0x08
15#define ACC_CODEC_CNTL 0x0C
16#define ACC_IRQ_STATUS 0x12
17#define ACC_BM0_CMD 0x20
18#define ACC_BM1_CMD 0x28
19#define ACC_BM2_CMD 0x30
20#define ACC_BM3_CMD 0x38
21#define ACC_BM4_CMD 0x40
22#define ACC_BM5_CMD 0x48
23#define ACC_BM6_CMD 0x50
24#define ACC_BM7_CMD 0x58
25#define ACC_BM0_PRD 0x24
26#define ACC_BM1_PRD 0x2C
27#define ACC_BM2_PRD 0x34
28#define ACC_BM3_PRD 0x3C
29#define ACC_BM4_PRD 0x44
30#define ACC_BM5_PRD 0x4C
31#define ACC_BM6_PRD 0x54
32#define ACC_BM7_PRD 0x5C
33#define ACC_BM0_STATUS 0x21
34#define ACC_BM1_STATUS 0x29
35#define ACC_BM2_STATUS 0x31
36#define ACC_BM3_STATUS 0x39
37#define ACC_BM4_STATUS 0x41
38#define ACC_BM5_STATUS 0x49
39#define ACC_BM6_STATUS 0x51
40#define ACC_BM7_STATUS 0x59
41#define ACC_BM0_PNTR 0x60
42#define ACC_BM1_PNTR 0x64
43#define ACC_BM2_PNTR 0x68
44#define ACC_BM3_PNTR 0x6C
45#define ACC_BM4_PNTR 0x70
46#define ACC_BM5_PNTR 0x74
47#define ACC_BM6_PNTR 0x78
48#define ACC_BM7_PNTR 0x7C
49/* acc_codec bar0 reg bits */
50/* ACC_IRQ_STATUS */
51#define IRQ_STS 0
52#define WU_IRQ_STS 1
53#define BM0_IRQ_STS 2
54#define BM1_IRQ_STS 3
55#define BM2_IRQ_STS 4
56#define BM3_IRQ_STS 5
57#define BM4_IRQ_STS 6
58#define BM5_IRQ_STS 7
59#define BM6_IRQ_STS 8
60#define BM7_IRQ_STS 9
61/* ACC_BMX_STATUS */
62#define EOP (1<<0)
63#define BM_EOP_ERR (1<<1)
64/* ACC_BMX_CTL */
65#define BM_CTL_EN 0x00000001
66#define BM_CTL_PAUSE 0x00000011
67#define BM_CTL_DIS 0x00000000
68#define BM_CTL_BYTE_ORD_LE 0x00000000
69#define BM_CTL_BYTE_ORD_BE 0x00000100
70/* cs5535 specific ac97 codec register defines */
71#define CMD_MASK 0xFF00FFFF
72#define CMD_NEW 0x00010000
73#define STS_NEW 0x00020000
74#define PRM_RDY_STS 0x00800000
75#define ACC_CODEC_CNTL_WR_CMD (~0x80000000)
76#define ACC_CODEC_CNTL_RD_CMD 0x80000000
77#define PRD_JMP 0x2000
78#define PRD_EOP 0x4000
79#define PRD_EOT 0x8000
80
81typedef struct _snd_cs5535audio cs5535audio_t;
82typedef struct snd_cs5535audio_dma cs5535audio_dma_t;
83typedef struct snd_cs5535audio_dma_ops cs5535audio_dma_ops_t;
84
85enum { CS5535AUDIO_DMA_PLAYBACK, CS5535AUDIO_DMA_CAPTURE, NUM_CS5535AUDIO_DMAS };
86struct snd_cs5535audio_dma_ops {
87 int type;
88 void (*enable_dma)(cs5535audio_t *cs5535au);
89 void (*disable_dma)(cs5535audio_t *cs5535au);
90 void (*pause_dma)(cs5535audio_t *cs5535au);
91 void (*setup_prd)(cs5535audio_t *cs5535au, u32 prd_addr);
92 u32 (*read_dma_pntr)(cs5535audio_t *cs5535au);
93};
94
95typedef struct cs5535audio_dma_desc {
96 u32 addr;
97 u16 size;
98 u16 ctlreserved;
99} cs5535audio_dma_desc_t;
100
101struct snd_cs5535audio_dma {
102 const cs5535audio_dma_ops_t *ops;
103 struct snd_dma_buffer desc_buf;
104 snd_pcm_substream_t *substream;
105 unsigned int buf_addr, buf_bytes;
106 unsigned int period_bytes, periods;
107};
108
109struct _snd_cs5535audio {
110 snd_card_t *card;
111 ac97_t *ac97;
112 int irq;
113 struct pci_dev *pci;
114 unsigned long port;
115 spinlock_t reg_lock;
116 snd_pcm_substream_t *playback_substream;
117 snd_pcm_substream_t *capture_substream;
118 cs5535audio_dma_t dmas[NUM_CS5535AUDIO_DMAS];
119};
120
121int __devinit snd_cs5535audio_pcm(cs5535audio_t *cs5535audio);
122#endif /* __SOUND_CS5535AUDIO_H */
123
diff --git a/sound/pci/cs5535audio/cs5535audio_pcm.c b/sound/pci/cs5535audio/cs5535audio_pcm.c
new file mode 100644
index 000000000000..5802ed9d57be
--- /dev/null
+++ b/sound/pci/cs5535audio/cs5535audio_pcm.c
@@ -0,0 +1,430 @@
1/*
2 * Driver for audio on multifunction CS5535 companion device
3 * Copyright (C) Jaya Kumar
4 *
5 * Based on Jaroslav Kysela and Takashi Iwai's examples.
6 * This work was sponsored by CIS(M) Sdn Bhd.
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 *
22 * todo: add be fmt support, spdif, pm
23 */
24
25#include <linux/init.h>
26#include <linux/slab.h>
27#include <linux/pci.h>
28#include <sound/driver.h>
29#include <sound/core.h>
30#include <sound/control.h>
31#include <sound/initval.h>
32#include <sound/asoundef.h>
33#include <sound/pcm.h>
34#include <sound/pcm_params.h>
35#include <sound/ac97_codec.h>
36#include "cs5535audio.h"
37
38static snd_pcm_hardware_t snd_cs5535audio_playback =
39{
40 .info = (
41 SNDRV_PCM_INFO_MMAP |
42 SNDRV_PCM_INFO_INTERLEAVED |
43 SNDRV_PCM_INFO_BLOCK_TRANSFER |
44 SNDRV_PCM_INFO_MMAP_VALID |
45 SNDRV_PCM_INFO_PAUSE |
46 SNDRV_PCM_INFO_SYNC_START
47 ),
48 .formats = (
49 SNDRV_PCM_FMTBIT_S16_LE
50 ),
51 .rates = (
52 SNDRV_PCM_RATE_CONTINUOUS |
53 SNDRV_PCM_RATE_8000_48000
54 ),
55 .rate_min = 4000,
56 .rate_max = 48000,
57 .channels_min = 2,
58 .channels_max = 2,
59 .buffer_bytes_max = (128*1024),
60 .period_bytes_min = 64,
61 .period_bytes_max = (64*1024 - 16),
62 .periods_min = 1,
63 .periods_max = CS5535AUDIO_MAX_DESCRIPTORS,
64 .fifo_size = 0,
65};
66
67static snd_pcm_hardware_t snd_cs5535audio_capture =
68{
69 .info = (
70 SNDRV_PCM_INFO_MMAP |
71 SNDRV_PCM_INFO_INTERLEAVED |
72 SNDRV_PCM_INFO_BLOCK_TRANSFER |
73 SNDRV_PCM_INFO_MMAP_VALID |
74 SNDRV_PCM_INFO_SYNC_START
75 ),
76 .formats = (
77 SNDRV_PCM_FMTBIT_S16_LE
78 ),
79 .rates = (
80 SNDRV_PCM_RATE_CONTINUOUS |
81 SNDRV_PCM_RATE_8000_48000
82 ),
83 .rate_min = 4000,
84 .rate_max = 48000,
85 .channels_min = 2,
86 .channels_max = 2,
87 .buffer_bytes_max = (128*1024),
88 .period_bytes_min = 64,
89 .period_bytes_max = (64*1024 - 16),
90 .periods_min = 1,
91 .periods_max = CS5535AUDIO_MAX_DESCRIPTORS,
92 .fifo_size = 0,
93};
94
95static int snd_cs5535audio_playback_open(snd_pcm_substream_t *substream)
96{
97 int err;
98 cs5535audio_t *cs5535au = snd_pcm_substream_chip(substream);
99 snd_pcm_runtime_t *runtime = substream->runtime;
100
101 runtime->hw = snd_cs5535audio_playback;
102 cs5535au->playback_substream = substream;
103 runtime->private_data = &(cs5535au->dmas[CS5535AUDIO_DMA_PLAYBACK]);
104 snd_pcm_set_sync(substream);
105 if ((err = snd_pcm_hw_constraint_integer(runtime,
106 SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
107 return err;
108
109 return 0;
110}
111
112static int snd_cs5535audio_playback_close(snd_pcm_substream_t *substream)
113{
114 return 0;
115}
116
117#define CS5535AUDIO_DESC_LIST_SIZE \
118 PAGE_ALIGN(CS5535AUDIO_MAX_DESCRIPTORS * sizeof(cs5535audio_dma_desc_t))
119
120static int cs5535audio_build_dma_packets(cs5535audio_t *cs5535au,
121 cs5535audio_dma_t *dma,
122 snd_pcm_substream_t *substream,
123 unsigned int periods,
124 unsigned int period_bytes)
125{
126 unsigned int i;
127 u32 addr, desc_addr, jmpprd_addr;
128 cs5535audio_dma_desc_t *lastdesc;
129
130 if (periods > CS5535AUDIO_MAX_DESCRIPTORS)
131 return -ENOMEM;
132
133 if (dma->desc_buf.area == NULL) {
134 if (snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV,
135 snd_dma_pci_data(cs5535au->pci),
136 CS5535AUDIO_DESC_LIST_SIZE+1,
137 &dma->desc_buf) < 0)
138 return -ENOMEM;
139 dma->period_bytes = dma->periods = 0;
140 }
141
142 if (dma->periods == periods && dma->period_bytes == period_bytes)
143 return 0;
144
145 /* the u32 cast is okay because in snd*create we succesfully told
146 pci alloc that we're only 32 bit capable so the uppper will be 0 */
147 addr = (u32) substream->runtime->dma_addr;
148 desc_addr = (u32) dma->desc_buf.addr;
149 for (i = 0; i < periods; i++) {
150 cs5535audio_dma_desc_t *desc =
151 &((cs5535audio_dma_desc_t *) dma->desc_buf.area)[i];
152 desc->addr = cpu_to_le32(addr);
153 desc->size = period_bytes;
154 desc->ctlreserved = PRD_EOP;
155 desc_addr += sizeof(cs5535audio_dma_desc_t);
156 addr += period_bytes;
157 }
158 /* we reserved one dummy descriptor at the end to do the PRD jump */
159 lastdesc = &((cs5535audio_dma_desc_t *) dma->desc_buf.area)[periods];
160 lastdesc->addr = cpu_to_le32((u32) dma->desc_buf.addr);
161 lastdesc->size = 0;
162 lastdesc->ctlreserved = PRD_JMP;
163 jmpprd_addr = cpu_to_le32(lastdesc->addr +
164 (sizeof(cs5535audio_dma_desc_t)*periods));
165
166 dma->period_bytes = period_bytes;
167 dma->periods = periods;
168 spin_lock_irq(&cs5535au->reg_lock);
169 dma->ops->disable_dma(cs5535au);
170 dma->ops->setup_prd(cs5535au, jmpprd_addr);
171 spin_unlock_irq(&cs5535au->reg_lock);
172 return 0;
173}
174
175static void cs5535audio_playback_enable_dma(cs5535audio_t *cs5535au)
176{
177 cs_writeb(cs5535au, ACC_BM0_CMD, BM_CTL_EN);
178}
179
180static void cs5535audio_playback_disable_dma(cs5535audio_t *cs5535au)
181{
182 cs_writeb(cs5535au, ACC_BM0_CMD, 0);
183}
184
185static void cs5535audio_playback_pause_dma(cs5535audio_t *cs5535au)
186{
187 cs_writeb(cs5535au, ACC_BM0_CMD, BM_CTL_PAUSE);
188}
189
190static void cs5535audio_playback_setup_prd(cs5535audio_t *cs5535au,
191 u32 prd_addr)
192{
193 cs_writel(cs5535au, ACC_BM0_PRD, prd_addr);
194}
195
196static u32 cs5535audio_playback_read_dma_pntr(cs5535audio_t *cs5535au)
197{
198 return cs_readl(cs5535au, ACC_BM0_PNTR);
199}
200
201static void cs5535audio_capture_enable_dma(cs5535audio_t *cs5535au)
202{
203 cs_writeb(cs5535au, ACC_BM1_CMD, BM_CTL_EN);
204}
205
206static void cs5535audio_capture_disable_dma(cs5535audio_t *cs5535au)
207{
208 cs_writeb(cs5535au, ACC_BM1_CMD, 0);
209}
210
211static void cs5535audio_capture_pause_dma(cs5535audio_t *cs5535au)
212{
213 cs_writeb(cs5535au, ACC_BM1_CMD, BM_CTL_PAUSE);
214}
215
216static void cs5535audio_capture_setup_prd(cs5535audio_t *cs5535au,
217 u32 prd_addr)
218{
219 cs_writel(cs5535au, ACC_BM1_PRD, prd_addr);
220}
221
222static u32 cs5535audio_capture_read_dma_pntr(cs5535audio_t *cs5535au)
223{
224 return cs_readl(cs5535au, ACC_BM1_PNTR);
225}
226
227static void cs5535audio_clear_dma_packets(cs5535audio_t *cs5535au,
228 cs5535audio_dma_t *dma,
229 snd_pcm_substream_t *substream)
230{
231 snd_dma_free_pages(&dma->desc_buf);
232 dma->desc_buf.area = NULL;
233}
234
235static int snd_cs5535audio_hw_params(snd_pcm_substream_t *substream,
236 snd_pcm_hw_params_t *hw_params)
237{
238 cs5535audio_t *cs5535au = snd_pcm_substream_chip(substream);
239 cs5535audio_dma_t *dma = substream->runtime->private_data;
240 int err;
241
242 err = snd_pcm_lib_malloc_pages(substream,
243 params_buffer_bytes(hw_params));
244 if (err < 0)
245 return err;
246 dma->buf_addr = substream->runtime->dma_addr;
247 dma->buf_bytes = params_buffer_bytes(hw_params);
248
249 err = cs5535audio_build_dma_packets(cs5535au, dma, substream,
250 params_periods(hw_params),
251 params_period_bytes(hw_params));
252 return err;
253}
254
255static int snd_cs5535audio_hw_free(snd_pcm_substream_t *substream)
256{
257 cs5535audio_t *cs5535au = snd_pcm_substream_chip(substream);
258 cs5535audio_dma_t *dma = substream->runtime->private_data;
259
260 cs5535audio_clear_dma_packets(cs5535au, dma, substream);
261 return snd_pcm_lib_free_pages(substream);
262}
263
264static int snd_cs5535audio_playback_prepare(snd_pcm_substream_t *substream)
265{
266 cs5535audio_t *cs5535au = snd_pcm_substream_chip(substream);
267 return snd_ac97_set_rate(cs5535au->ac97, AC97_PCM_FRONT_DAC_RATE,
268 substream->runtime->rate);
269}
270
271static int snd_cs5535audio_trigger(snd_pcm_substream_t *substream, int cmd)
272{
273 cs5535audio_t *cs5535au = snd_pcm_substream_chip(substream);
274 cs5535audio_dma_t *dma = substream->runtime->private_data;
275
276 switch (cmd) {
277 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
278 spin_lock_irq(&cs5535au->reg_lock);
279 dma->ops->pause_dma(cs5535au);
280 spin_unlock_irq(&cs5535au->reg_lock);
281 break;
282 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
283 spin_lock_irq(&cs5535au->reg_lock);
284 dma->ops->enable_dma(cs5535au);
285 spin_unlock_irq(&cs5535au->reg_lock);
286 break;
287 case SNDRV_PCM_TRIGGER_START:
288 spin_lock_irq(&cs5535au->reg_lock);
289 dma->ops->enable_dma(cs5535au);
290 spin_unlock_irq(&cs5535au->reg_lock);
291 break;
292 case SNDRV_PCM_TRIGGER_STOP:
293 spin_lock_irq(&cs5535au->reg_lock);
294 dma->ops->disable_dma(cs5535au);
295 spin_unlock_irq(&cs5535au->reg_lock);
296 break;
297 default:
298 snd_printk(KERN_ERR "unhandled trigger\n");
299 return -EINVAL;
300 break;
301 }
302 return 0;
303}
304
305static snd_pcm_uframes_t snd_cs5535audio_pcm_pointer(snd_pcm_substream_t
306 *substream)
307{
308 cs5535audio_t *cs5535au = snd_pcm_substream_chip(substream);
309 u32 curdma;
310 cs5535audio_dma_t *dma;
311
312 dma = substream->runtime->private_data;
313 curdma = dma->ops->read_dma_pntr(cs5535au);
314 if (curdma < dma->buf_addr) {
315 snd_printk(KERN_ERR "curdma=%x < %x bufaddr.\n",
316 curdma, dma->buf_addr);
317 return 0;
318 }
319 curdma -= dma->buf_addr;
320 if (curdma >= dma->buf_bytes) {
321 snd_printk(KERN_ERR "diff=%x >= %x buf_bytes.\n",
322 curdma, dma->buf_bytes);
323 return 0;
324 }
325 return bytes_to_frames(substream->runtime, curdma);
326}
327
328static int snd_cs5535audio_capture_open(snd_pcm_substream_t *substream)
329{
330 int err;
331 cs5535audio_t *cs5535au = snd_pcm_substream_chip(substream);
332 snd_pcm_runtime_t *runtime = substream->runtime;
333
334 runtime->hw = snd_cs5535audio_capture;
335 cs5535au->capture_substream = substream;
336 runtime->private_data = &(cs5535au->dmas[CS5535AUDIO_DMA_CAPTURE]);
337 snd_pcm_set_sync(substream);
338 if ((err = snd_pcm_hw_constraint_integer(runtime,
339 SNDRV_PCM_HW_PARAM_PERIODS)) < 0)
340 return err;
341 return 0;
342}
343
344static int snd_cs5535audio_capture_close(snd_pcm_substream_t *substream)
345{
346 return 0;
347}
348
349static int snd_cs5535audio_capture_prepare(snd_pcm_substream_t *substream)
350{
351 cs5535audio_t *cs5535au = snd_pcm_substream_chip(substream);
352 return snd_ac97_set_rate(cs5535au->ac97, AC97_PCM_LR_ADC_RATE,
353 substream->runtime->rate);
354}
355
356static snd_pcm_ops_t snd_cs5535audio_playback_ops = {
357 .open = snd_cs5535audio_playback_open,
358 .close = snd_cs5535audio_playback_close,
359 .ioctl = snd_pcm_lib_ioctl,
360 .hw_params = snd_cs5535audio_hw_params,
361 .hw_free = snd_cs5535audio_hw_free,
362 .prepare = snd_cs5535audio_playback_prepare,
363 .trigger = snd_cs5535audio_trigger,
364 .pointer = snd_cs5535audio_pcm_pointer,
365};
366
367static snd_pcm_ops_t snd_cs5535audio_capture_ops = {
368 .open = snd_cs5535audio_capture_open,
369 .close = snd_cs5535audio_capture_close,
370 .ioctl = snd_pcm_lib_ioctl,
371 .hw_params = snd_cs5535audio_hw_params,
372 .hw_free = snd_cs5535audio_hw_free,
373 .prepare = snd_cs5535audio_capture_prepare,
374 .trigger = snd_cs5535audio_trigger,
375 .pointer = snd_cs5535audio_pcm_pointer,
376};
377
378static void snd_cs5535audio_pcm_free(snd_pcm_t *pcm)
379{
380 snd_pcm_lib_preallocate_free_for_all(pcm);
381}
382
383static cs5535audio_dma_ops_t snd_cs5535audio_playback_dma_ops = {
384 .type = CS5535AUDIO_DMA_PLAYBACK,
385 .enable_dma = cs5535audio_playback_enable_dma,
386 .disable_dma = cs5535audio_playback_disable_dma,
387 .setup_prd = cs5535audio_playback_setup_prd,
388 .pause_dma = cs5535audio_playback_pause_dma,
389 .read_dma_pntr = cs5535audio_playback_read_dma_pntr,
390};
391
392static cs5535audio_dma_ops_t snd_cs5535audio_capture_dma_ops = {
393 .type = CS5535AUDIO_DMA_CAPTURE,
394 .enable_dma = cs5535audio_capture_enable_dma,
395 .disable_dma = cs5535audio_capture_disable_dma,
396 .setup_prd = cs5535audio_capture_setup_prd,
397 .pause_dma = cs5535audio_capture_pause_dma,
398 .read_dma_pntr = cs5535audio_capture_read_dma_pntr,
399};
400
401int __devinit snd_cs5535audio_pcm(cs5535audio_t *cs5535au)
402{
403 snd_pcm_t *pcm;
404 int err;
405
406 err = snd_pcm_new(cs5535au->card, "CS5535 Audio", 0, 1, 1, &pcm);
407 if (err < 0)
408 return err;
409
410 cs5535au->dmas[CS5535AUDIO_DMA_PLAYBACK].ops =
411 &snd_cs5535audio_playback_dma_ops;
412 cs5535au->dmas[CS5535AUDIO_DMA_CAPTURE].ops =
413 &snd_cs5535audio_capture_dma_ops;
414 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
415 &snd_cs5535audio_playback_ops);
416 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
417 &snd_cs5535audio_capture_ops);
418
419 pcm->private_data = cs5535au;
420 pcm->private_free = snd_cs5535audio_pcm_free;
421 pcm->info_flags = 0;
422 strcpy(pcm->name, "CS5535 Audio");
423
424 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
425 snd_dma_pci_data(cs5535au->pci),
426 64*1024, 128*1024);
427
428 return 0;
429}
430
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-22 13:09:37 -0500