3 ad1816a.c - lowlevel code for Analog Devices AD1816A chip.
4 Copyright (C) 1999-2000 by Massimo Piccioni <dafastidio@libero.it>
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.
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.
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
21 #include <sound/driver.h>
22 #include <linux/delay.h>
23 #include <linux/init.h>
24 #include <linux/interrupt.h>
25 #include <linux/slab.h>
26 #include <linux/ioport.h>
27 #include <sound/core.h>
28 #include <sound/ad1816a.h>
33 MODULE_AUTHOR("Massimo Piccioni <dafastidio@libero.it>");
34 MODULE_DESCRIPTION("lowlevel code for Analog Devices AD1816A chip");
35 MODULE_LICENSE("GPL");
37 #define chip_t ad1816a_t
39 static inline int snd_ad1816a_busy_wait(ad1816a_t *chip)
43 for (timeout = 1000; timeout-- > 0; udelay(10))
44 if (inb(AD1816A_REG(AD1816A_CHIP_STATUS)) & AD1816A_READY)
47 snd_printk("chip busy.\n");
51 inline unsigned char snd_ad1816a_in(ad1816a_t *chip, unsigned char reg)
53 snd_ad1816a_busy_wait(chip);
54 return inb(AD1816A_REG(reg));
57 inline void snd_ad1816a_out(ad1816a_t *chip, unsigned char reg,
60 snd_ad1816a_busy_wait(chip);
61 outb(value, AD1816A_REG(reg));
64 inline void snd_ad1816a_out_mask(ad1816a_t *chip, unsigned char reg,
65 unsigned char mask, unsigned char value)
67 snd_ad1816a_out(chip, reg,
68 (value & mask) | (snd_ad1816a_in(chip, reg) & ~mask));
71 static unsigned short snd_ad1816a_read(ad1816a_t *chip, unsigned char reg)
73 snd_ad1816a_out(chip, AD1816A_INDIR_ADDR, reg & 0x3f);
74 return snd_ad1816a_in(chip, AD1816A_INDIR_DATA_LOW) |
75 (snd_ad1816a_in(chip, AD1816A_INDIR_DATA_HIGH) << 8);
78 static void snd_ad1816a_write(ad1816a_t *chip, unsigned char reg,
81 snd_ad1816a_out(chip, AD1816A_INDIR_ADDR, reg & 0x3f);
82 snd_ad1816a_out(chip, AD1816A_INDIR_DATA_LOW, value & 0xff);
83 snd_ad1816a_out(chip, AD1816A_INDIR_DATA_HIGH, (value >> 8) & 0xff);
86 static void snd_ad1816a_write_mask(ad1816a_t *chip, unsigned char reg,
87 unsigned short mask, unsigned short value)
89 snd_ad1816a_write(chip, reg,
90 (value & mask) | (snd_ad1816a_read(chip, reg) & ~mask));
94 static unsigned char snd_ad1816a_get_format(ad1816a_t *chip,
95 unsigned int format, int channels)
97 unsigned char retval = AD1816A_FMT_LINEAR_8;
100 case SNDRV_PCM_FORMAT_MU_LAW:
101 retval = AD1816A_FMT_ULAW_8;
103 case SNDRV_PCM_FORMAT_A_LAW:
104 retval = AD1816A_FMT_ALAW_8;
106 case SNDRV_PCM_FORMAT_S16_LE:
107 retval = AD1816A_FMT_LINEAR_16_LIT;
109 case SNDRV_PCM_FORMAT_S16_BE:
110 retval = AD1816A_FMT_LINEAR_16_BIG;
112 return (channels > 1) ? (retval | AD1816A_FMT_STEREO) : retval;
115 static int snd_ad1816a_open(ad1816a_t *chip, unsigned int mode)
119 spin_lock_irqsave(&chip->lock, flags);
121 if (chip->mode & mode) {
122 spin_unlock_irqrestore(&chip->lock, flags);
126 switch ((mode &= AD1816A_MODE_OPEN)) {
127 case AD1816A_MODE_PLAYBACK:
128 snd_ad1816a_out_mask(chip, AD1816A_INTERRUPT_STATUS,
129 AD1816A_PLAYBACK_IRQ_PENDING, 0x00);
130 snd_ad1816a_write_mask(chip, AD1816A_INTERRUPT_ENABLE,
131 AD1816A_PLAYBACK_IRQ_ENABLE, 0xffff);
133 case AD1816A_MODE_CAPTURE:
134 snd_ad1816a_out_mask(chip, AD1816A_INTERRUPT_STATUS,
135 AD1816A_CAPTURE_IRQ_PENDING, 0x00);
136 snd_ad1816a_write_mask(chip, AD1816A_INTERRUPT_ENABLE,
137 AD1816A_CAPTURE_IRQ_ENABLE, 0xffff);
139 case AD1816A_MODE_TIMER:
140 snd_ad1816a_out_mask(chip, AD1816A_INTERRUPT_STATUS,
141 AD1816A_TIMER_IRQ_PENDING, 0x00);
142 snd_ad1816a_write_mask(chip, AD1816A_INTERRUPT_ENABLE,
143 AD1816A_TIMER_IRQ_ENABLE, 0xffff);
147 spin_unlock_irqrestore(&chip->lock, flags);
151 static void snd_ad1816a_close(ad1816a_t *chip, unsigned int mode)
155 spin_lock_irqsave(&chip->lock, flags);
157 switch ((mode &= AD1816A_MODE_OPEN)) {
158 case AD1816A_MODE_PLAYBACK:
159 snd_ad1816a_out_mask(chip, AD1816A_INTERRUPT_STATUS,
160 AD1816A_PLAYBACK_IRQ_PENDING, 0x00);
161 snd_ad1816a_write_mask(chip, AD1816A_INTERRUPT_ENABLE,
162 AD1816A_PLAYBACK_IRQ_ENABLE, 0x0000);
164 case AD1816A_MODE_CAPTURE:
165 snd_ad1816a_out_mask(chip, AD1816A_INTERRUPT_STATUS,
166 AD1816A_CAPTURE_IRQ_PENDING, 0x00);
167 snd_ad1816a_write_mask(chip, AD1816A_INTERRUPT_ENABLE,
168 AD1816A_CAPTURE_IRQ_ENABLE, 0x0000);
170 case AD1816A_MODE_TIMER:
171 snd_ad1816a_out_mask(chip, AD1816A_INTERRUPT_STATUS,
172 AD1816A_TIMER_IRQ_PENDING, 0x00);
173 snd_ad1816a_write_mask(chip, AD1816A_INTERRUPT_ENABLE,
174 AD1816A_TIMER_IRQ_ENABLE, 0x0000);
176 if (!((chip->mode &= ~mode) & AD1816A_MODE_OPEN))
179 spin_unlock_irqrestore(&chip->lock, flags);
183 static int snd_ad1816a_trigger(ad1816a_t *chip, unsigned char what,
184 int channel, int cmd)
189 case SNDRV_PCM_TRIGGER_START:
190 case SNDRV_PCM_TRIGGER_STOP:
191 spin_lock(&chip->lock);
192 cmd = (cmd == SNDRV_PCM_TRIGGER_START) ? 0xff: 0x00;
193 if (what & AD1816A_PLAYBACK_ENABLE)
194 snd_ad1816a_out_mask(chip, AD1816A_PLAYBACK_CONFIG,
195 AD1816A_PLAYBACK_ENABLE, cmd);
196 if (what & AD1816A_CAPTURE_ENABLE)
197 snd_ad1816a_out_mask(chip, AD1816A_CAPTURE_CONFIG,
198 AD1816A_CAPTURE_ENABLE, cmd);
199 spin_unlock(&chip->lock);
202 snd_printk("invalid trigger mode 0x%x.\n", what);
209 static int snd_ad1816a_playback_trigger(snd_pcm_substream_t *substream, int cmd)
211 ad1816a_t *chip = snd_pcm_substream_chip(substream);
212 return snd_ad1816a_trigger(chip, AD1816A_PLAYBACK_ENABLE,
213 SNDRV_PCM_STREAM_PLAYBACK, cmd);
216 static int snd_ad1816a_capture_trigger(snd_pcm_substream_t *substream, int cmd)
218 ad1816a_t *chip = snd_pcm_substream_chip(substream);
219 return snd_ad1816a_trigger(chip, AD1816A_CAPTURE_ENABLE,
220 SNDRV_PCM_STREAM_CAPTURE, cmd);
223 static int snd_ad1816a_hw_params(snd_pcm_substream_t * substream,
224 snd_pcm_hw_params_t * hw_params)
226 return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(hw_params));
229 static int snd_ad1816a_hw_free(snd_pcm_substream_t * substream)
231 return snd_pcm_lib_free_pages(substream);
234 static int snd_ad1816a_playback_prepare(snd_pcm_substream_t *substream)
236 ad1816a_t *chip = snd_pcm_substream_chip(substream);
238 snd_pcm_runtime_t *runtime = substream->runtime;
241 spin_lock_irqsave(&chip->lock, flags);
243 chip->p_dma_size = size = snd_pcm_lib_buffer_bytes(substream);
244 snd_ad1816a_out_mask(chip, AD1816A_PLAYBACK_CONFIG,
245 AD1816A_PLAYBACK_ENABLE | AD1816A_PLAYBACK_PIO, 0x00);
247 snd_dma_program(chip->dma1, runtime->dma_addr, size,
248 DMA_MODE_WRITE | DMA_AUTOINIT);
250 snd_ad1816a_write(chip, AD1816A_PLAYBACK_SAMPLE_RATE, runtime->rate);
251 snd_ad1816a_out_mask(chip, AD1816A_PLAYBACK_CONFIG,
252 AD1816A_FMT_ALL | AD1816A_FMT_STEREO,
253 snd_ad1816a_get_format(chip, runtime->format,
256 snd_ad1816a_write(chip, AD1816A_PLAYBACK_BASE_COUNT,
257 snd_pcm_lib_period_bytes(substream) / 4 - 1);
259 spin_unlock_irqrestore(&chip->lock, flags);
263 static int snd_ad1816a_capture_prepare(snd_pcm_substream_t *substream)
265 ad1816a_t *chip = snd_pcm_substream_chip(substream);
267 snd_pcm_runtime_t *runtime = substream->runtime;
270 spin_lock_irqsave(&chip->lock, flags);
272 chip->c_dma_size = size = snd_pcm_lib_buffer_bytes(substream);
273 snd_ad1816a_out_mask(chip, AD1816A_CAPTURE_CONFIG,
274 AD1816A_CAPTURE_ENABLE | AD1816A_CAPTURE_PIO, 0x00);
276 snd_dma_program(chip->dma2, runtime->dma_addr, size,
277 DMA_MODE_READ | DMA_AUTOINIT);
279 snd_ad1816a_write(chip, AD1816A_CAPTURE_SAMPLE_RATE, runtime->rate);
280 snd_ad1816a_out_mask(chip, AD1816A_CAPTURE_CONFIG,
281 AD1816A_FMT_ALL | AD1816A_FMT_STEREO,
282 snd_ad1816a_get_format(chip, runtime->format,
285 snd_ad1816a_write(chip, AD1816A_CAPTURE_BASE_COUNT,
286 snd_pcm_lib_period_bytes(substream) / 4 - 1);
288 spin_unlock_irqrestore(&chip->lock, flags);
293 static snd_pcm_uframes_t snd_ad1816a_playback_pointer(snd_pcm_substream_t *substream)
295 ad1816a_t *chip = snd_pcm_substream_chip(substream);
297 if (!(chip->mode & AD1816A_MODE_PLAYBACK))
299 ptr = snd_dma_pointer(chip->dma1, chip->p_dma_size);
300 return bytes_to_frames(substream->runtime, ptr);
303 static snd_pcm_uframes_t snd_ad1816a_capture_pointer(snd_pcm_substream_t *substream)
305 ad1816a_t *chip = snd_pcm_substream_chip(substream);
307 if (!(chip->mode & AD1816A_MODE_CAPTURE))
309 ptr = snd_dma_pointer(chip->dma2, chip->c_dma_size);
310 return bytes_to_frames(substream->runtime, ptr);
314 static irqreturn_t snd_ad1816a_interrupt(int irq, void *dev_id, struct pt_regs *regs)
316 ad1816a_t *chip = snd_magic_cast(ad1816a_t, dev_id, return IRQ_NONE);
317 unsigned char status;
319 spin_lock(&chip->lock);
320 status = snd_ad1816a_in(chip, AD1816A_INTERRUPT_STATUS);
321 spin_unlock(&chip->lock);
323 if ((status & AD1816A_PLAYBACK_IRQ_PENDING) && chip->playback_substream)
324 snd_pcm_period_elapsed(chip->playback_substream);
326 if ((status & AD1816A_CAPTURE_IRQ_PENDING) && chip->capture_substream)
327 snd_pcm_period_elapsed(chip->capture_substream);
329 if ((status & AD1816A_TIMER_IRQ_PENDING) && chip->timer)
330 snd_timer_interrupt(chip->timer, chip->timer->sticks);
332 spin_lock(&chip->lock);
333 snd_ad1816a_out(chip, AD1816A_INTERRUPT_STATUS, 0x00);
334 spin_unlock(&chip->lock);
339 static snd_pcm_hardware_t snd_ad1816a_playback = {
340 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
341 SNDRV_PCM_INFO_MMAP_VALID),
342 .formats = (SNDRV_PCM_FMTBIT_MU_LAW | SNDRV_PCM_FMTBIT_A_LAW |
343 SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE |
344 SNDRV_PCM_FMTBIT_S16_BE),
345 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
350 .buffer_bytes_max = (128*1024),
351 .period_bytes_min = 64,
352 .period_bytes_max = (128*1024),
358 static snd_pcm_hardware_t snd_ad1816a_capture = {
359 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
360 SNDRV_PCM_INFO_MMAP_VALID),
361 .formats = (SNDRV_PCM_FMTBIT_MU_LAW | SNDRV_PCM_FMTBIT_A_LAW |
362 SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE |
363 SNDRV_PCM_FMTBIT_S16_BE),
364 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
369 .buffer_bytes_max = (128*1024),
370 .period_bytes_min = 64,
371 .period_bytes_max = (128*1024),
377 static int snd_ad1816a_timer_close(snd_timer_t *timer)
379 ad1816a_t *chip = snd_timer_chip(timer);
380 snd_ad1816a_close(chip, AD1816A_MODE_TIMER);
384 static int snd_ad1816a_timer_open(snd_timer_t *timer)
386 ad1816a_t *chip = snd_timer_chip(timer);
387 snd_ad1816a_open(chip, AD1816A_MODE_TIMER);
391 static unsigned long snd_ad1816a_timer_resolution(snd_timer_t *timer)
393 snd_assert(timer != NULL, return 0);
398 static int snd_ad1816a_timer_start(snd_timer_t *timer)
402 ad1816a_t *chip = snd_timer_chip(timer);
403 spin_lock_irqsave(&chip->lock, flags);
404 bits = snd_ad1816a_read(chip, AD1816A_INTERRUPT_ENABLE);
406 if (!(bits & AD1816A_TIMER_ENABLE)) {
407 snd_ad1816a_write(chip, AD1816A_TIMER_BASE_COUNT,
408 timer->sticks & 0xffff);
410 snd_ad1816a_write_mask(chip, AD1816A_INTERRUPT_ENABLE,
411 AD1816A_TIMER_ENABLE, 0xffff);
413 spin_unlock_irqrestore(&chip->lock, flags);
417 static int snd_ad1816a_timer_stop(snd_timer_t *timer)
420 ad1816a_t *chip = snd_timer_chip(timer);
421 spin_lock_irqsave(&chip->lock, flags);
423 snd_ad1816a_write_mask(chip, AD1816A_INTERRUPT_ENABLE,
424 AD1816A_TIMER_ENABLE, 0x0000);
426 spin_unlock_irqrestore(&chip->lock, flags);
430 static struct _snd_timer_hardware snd_ad1816a_timer_table = {
431 .flags = SNDRV_TIMER_HW_AUTO,
434 .open = snd_ad1816a_timer_open,
435 .close = snd_ad1816a_timer_close,
436 .c_resolution = snd_ad1816a_timer_resolution,
437 .start = snd_ad1816a_timer_start,
438 .stop = snd_ad1816a_timer_stop,
442 static int snd_ad1816a_playback_open(snd_pcm_substream_t *substream)
444 ad1816a_t *chip = snd_pcm_substream_chip(substream);
445 snd_pcm_runtime_t *runtime = substream->runtime;
448 if ((error = snd_ad1816a_open(chip, AD1816A_MODE_PLAYBACK)) < 0)
450 snd_pcm_set_sync(substream);
451 runtime->hw = snd_ad1816a_playback;
452 snd_pcm_limit_isa_dma_size(chip->dma1, &runtime->hw.buffer_bytes_max);
453 snd_pcm_limit_isa_dma_size(chip->dma1, &runtime->hw.period_bytes_max);
454 chip->playback_substream = substream;
458 static int snd_ad1816a_capture_open(snd_pcm_substream_t *substream)
460 ad1816a_t *chip = snd_pcm_substream_chip(substream);
461 snd_pcm_runtime_t *runtime = substream->runtime;
464 if ((error = snd_ad1816a_open(chip, AD1816A_MODE_CAPTURE)) < 0)
466 snd_pcm_set_sync(substream);
467 runtime->hw = snd_ad1816a_capture;
468 snd_pcm_limit_isa_dma_size(chip->dma2, &runtime->hw.buffer_bytes_max);
469 snd_pcm_limit_isa_dma_size(chip->dma2, &runtime->hw.period_bytes_max);
470 chip->capture_substream = substream;
474 static int snd_ad1816a_playback_close(snd_pcm_substream_t *substream)
476 ad1816a_t *chip = snd_pcm_substream_chip(substream);
478 chip->playback_substream = NULL;
479 snd_ad1816a_close(chip, AD1816A_MODE_PLAYBACK);
483 static int snd_ad1816a_capture_close(snd_pcm_substream_t *substream)
485 ad1816a_t *chip = snd_pcm_substream_chip(substream);
487 chip->capture_substream = NULL;
488 snd_ad1816a_close(chip, AD1816A_MODE_CAPTURE);
493 static void snd_ad1816a_init(ad1816a_t *chip)
497 spin_lock_irqsave(&chip->lock, flags);
499 snd_ad1816a_out(chip, AD1816A_INTERRUPT_STATUS, 0x00);
500 snd_ad1816a_out_mask(chip, AD1816A_PLAYBACK_CONFIG,
501 AD1816A_PLAYBACK_ENABLE | AD1816A_PLAYBACK_PIO, 0x00);
502 snd_ad1816a_out_mask(chip, AD1816A_CAPTURE_CONFIG,
503 AD1816A_CAPTURE_ENABLE | AD1816A_CAPTURE_PIO, 0x00);
504 snd_ad1816a_write(chip, AD1816A_INTERRUPT_ENABLE, 0x0000);
505 snd_ad1816a_write_mask(chip, AD1816A_CHIP_CONFIG,
506 AD1816A_CAPTURE_NOT_EQUAL | AD1816A_WSS_ENABLE, 0xffff);
507 snd_ad1816a_write(chip, AD1816A_DSP_CONFIG, 0x0000);
508 snd_ad1816a_write(chip, AD1816A_POWERDOWN_CTRL, 0x0000);
510 spin_unlock_irqrestore(&chip->lock, flags);
513 static int snd_ad1816a_probe(ad1816a_t *chip)
517 spin_lock_irqsave(&chip->lock, flags);
519 switch (chip->version = snd_ad1816a_read(chip, AD1816A_VERSION_ID)) {
521 chip->hardware = AD1816A_HW_AD1815;
524 chip->hardware = AD1816A_HW_AD18MAX10;
527 chip->hardware = AD1816A_HW_AD1816A;
530 chip->hardware = AD1816A_HW_AUTO;
533 spin_unlock_irqrestore(&chip->lock, flags);
537 static int snd_ad1816a_free(ad1816a_t *chip)
539 if (chip->res_port) {
540 release_resource(chip->res_port);
541 kfree_nocheck(chip->res_port);
544 free_irq(chip->irq, (void *) chip);
545 if (chip->dma1 >= 0) {
546 snd_dma_disable(chip->dma1);
547 free_dma(chip->dma1);
549 if (chip->dma2 >= 0) {
550 snd_dma_disable(chip->dma2);
551 free_dma(chip->dma2);
553 snd_magic_kfree(chip);
557 static int snd_ad1816a_dev_free(snd_device_t *device)
559 ad1816a_t *chip = snd_magic_cast(ad1816a_t, device->device_data, return -ENXIO);
560 return snd_ad1816a_free(chip);
563 static const char *snd_ad1816a_chip_id(ad1816a_t *chip)
565 switch (chip->hardware) {
566 case AD1816A_HW_AD1816A: return "AD1816A";
567 case AD1816A_HW_AD1815: return "AD1815";
568 case AD1816A_HW_AD18MAX10: return "AD18max10";
570 snd_printk("Unknown chip version %d:%d.\n",
571 chip->version, chip->hardware);
572 return "AD1816A - unknown";
576 int snd_ad1816a_create(snd_card_t *card,
577 unsigned long port, int irq, int dma1, int dma2,
580 static snd_device_ops_t ops = {
581 .dev_free = snd_ad1816a_dev_free,
588 chip = snd_magic_kcalloc(ad1816a_t, 0, GFP_KERNEL);
595 if ((chip->res_port = request_region(port, 16, "AD1816A")) == NULL) {
596 snd_printk(KERN_ERR "ad1816a: can't grab port 0x%lx\n", port);
597 snd_ad1816a_free(chip);
600 if (request_irq(irq, snd_ad1816a_interrupt, SA_INTERRUPT, "AD1816A", (void *) chip)) {
601 snd_printk(KERN_ERR "ad1816a: can't grab IRQ %d\n", irq);
602 snd_ad1816a_free(chip);
606 if (request_dma(dma1, "AD1816A - 1")) {
607 snd_printk(KERN_ERR "ad1816a: can't grab DMA1 %d\n", dma1);
608 snd_ad1816a_free(chip);
612 if (request_dma(dma2, "AD1816A - 2")) {
613 snd_printk(KERN_ERR "ad1816a: can't grab DMA2 %d\n", dma2);
614 snd_ad1816a_free(chip);
621 spin_lock_init(&chip->lock);
623 if ((error = snd_ad1816a_probe(chip))) {
624 snd_ad1816a_free(chip);
628 snd_ad1816a_init(chip);
630 /* Register device */
631 if ((error = snd_device_new(card, SNDRV_DEV_LOWLEVEL, chip, &ops)) < 0) {
632 snd_ad1816a_free(chip);
640 static snd_pcm_ops_t snd_ad1816a_playback_ops = {
641 .open = snd_ad1816a_playback_open,
642 .close = snd_ad1816a_playback_close,
643 .ioctl = snd_pcm_lib_ioctl,
644 .hw_params = snd_ad1816a_hw_params,
645 .hw_free = snd_ad1816a_hw_free,
646 .prepare = snd_ad1816a_playback_prepare,
647 .trigger = snd_ad1816a_playback_trigger,
648 .pointer = snd_ad1816a_playback_pointer,
651 static snd_pcm_ops_t snd_ad1816a_capture_ops = {
652 .open = snd_ad1816a_capture_open,
653 .close = snd_ad1816a_capture_close,
654 .ioctl = snd_pcm_lib_ioctl,
655 .hw_params = snd_ad1816a_hw_params,
656 .hw_free = snd_ad1816a_hw_free,
657 .prepare = snd_ad1816a_capture_prepare,
658 .trigger = snd_ad1816a_capture_trigger,
659 .pointer = snd_ad1816a_capture_pointer,
662 static void snd_ad1816a_pcm_free(snd_pcm_t *pcm)
664 ad1816a_t *chip = snd_magic_cast(ad1816a_t, pcm->private_data, return);
666 snd_pcm_lib_preallocate_free_for_all(pcm);
669 int snd_ad1816a_pcm(ad1816a_t *chip, int device, snd_pcm_t **rpcm)
674 if ((error = snd_pcm_new(chip->card, "AD1816A", device, 1, 1, &pcm)))
677 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_ad1816a_playback_ops);
678 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_ad1816a_capture_ops);
680 pcm->private_data = chip;
681 pcm->private_free = snd_ad1816a_pcm_free;
682 pcm->info_flags = (chip->dma1 == chip->dma2 ) ? SNDRV_PCM_INFO_JOINT_DUPLEX : 0;
684 strcpy(pcm->name, snd_ad1816a_chip_id(chip));
685 snd_ad1816a_init(chip);
687 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_DEV,
689 64*1024, chip->dma1 > 3 || chip->dma2 > 3 ? 128*1024 : 64*1024);
697 static void snd_ad1816a_timer_free(snd_timer_t *timer)
699 ad1816a_t *chip = snd_magic_cast(ad1816a_t, timer->private_data, return);
703 int snd_ad1816a_timer(ad1816a_t *chip, int device, snd_timer_t **rtimer)
709 tid.dev_class = SNDRV_TIMER_CLASS_CARD;
710 tid.dev_sclass = SNDRV_TIMER_SCLASS_NONE;
711 tid.card = chip->card->number;
714 if ((error = snd_timer_new(chip->card, "AD1816A", &tid, &timer)) < 0)
716 strcpy(timer->name, snd_ad1816a_chip_id(chip));
717 timer->private_data = chip;
718 timer->private_free = snd_ad1816a_timer_free;
720 timer->hw = snd_ad1816a_timer_table;
730 static int snd_ad1816a_info_mux(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
732 static char *texts[8] = {
733 "Line", "Mix", "CD", "Synth", "Video",
737 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
739 uinfo->value.enumerated.items = 7;
740 if (uinfo->value.enumerated.item > 6)
741 uinfo->value.enumerated.item = 6;
742 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
746 static int snd_ad1816a_get_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
748 ad1816a_t *chip = snd_kcontrol_chip(kcontrol);
752 spin_lock_irqsave(&chip->lock, flags);
753 val = snd_ad1816a_read(chip, AD1816A_ADC_SOURCE_SEL);
754 spin_unlock_irqrestore(&chip->lock, flags);
755 ucontrol->value.enumerated.item[0] = (val >> 12) & 7;
756 ucontrol->value.enumerated.item[1] = (val >> 4) & 7;
760 static int snd_ad1816a_put_mux(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
762 ad1816a_t *chip = snd_kcontrol_chip(kcontrol);
767 if (ucontrol->value.enumerated.item[0] > 6 ||
768 ucontrol->value.enumerated.item[1] > 6)
770 val = (ucontrol->value.enumerated.item[0] << 12) |
771 (ucontrol->value.enumerated.item[1] << 4);
772 spin_lock_irqsave(&chip->lock, flags);
773 change = snd_ad1816a_read(chip, AD1816A_ADC_SOURCE_SEL) != val;
774 snd_ad1816a_write(chip, AD1816A_ADC_SOURCE_SEL, val);
775 spin_unlock_irqrestore(&chip->lock, flags);
779 #define AD1816A_SINGLE(xname, reg, shift, mask, invert) \
780 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .info = snd_ad1816a_info_single, \
781 .get = snd_ad1816a_get_single, .put = snd_ad1816a_put_single, \
782 .private_value = reg | (shift << 8) | (mask << 16) | (invert << 24) }
784 static int snd_ad1816a_info_single(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
786 int mask = (kcontrol->private_value >> 16) & 0xff;
788 uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
790 uinfo->value.integer.min = 0;
791 uinfo->value.integer.max = mask;
795 static int snd_ad1816a_get_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
797 ad1816a_t *chip = snd_kcontrol_chip(kcontrol);
799 int reg = kcontrol->private_value & 0xff;
800 int shift = (kcontrol->private_value >> 8) & 0xff;
801 int mask = (kcontrol->private_value >> 16) & 0xff;
802 int invert = (kcontrol->private_value >> 24) & 0xff;
804 spin_lock_irqsave(&chip->lock, flags);
805 ucontrol->value.integer.value[0] = (snd_ad1816a_read(chip, reg) >> shift) & mask;
806 spin_unlock_irqrestore(&chip->lock, flags);
808 ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
812 static int snd_ad1816a_put_single(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
814 ad1816a_t *chip = snd_kcontrol_chip(kcontrol);
816 int reg = kcontrol->private_value & 0xff;
817 int shift = (kcontrol->private_value >> 8) & 0xff;
818 int mask = (kcontrol->private_value >> 16) & 0xff;
819 int invert = (kcontrol->private_value >> 24) & 0xff;
821 unsigned short old_val, val;
823 val = (ucontrol->value.integer.value[0] & mask);
827 spin_lock_irqsave(&chip->lock, flags);
828 old_val = snd_ad1816a_read(chip, reg);
829 val = (old_val & ~(mask << shift)) | val;
830 change = val != old_val;
831 snd_ad1816a_write(chip, reg, val);
832 spin_unlock_irqrestore(&chip->lock, flags);
836 #define AD1816A_DOUBLE(xname, reg, shift_left, shift_right, mask, invert) \
837 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .info = snd_ad1816a_info_double, \
838 .get = snd_ad1816a_get_double, .put = snd_ad1816a_put_double, \
839 .private_value = reg | (shift_left << 8) | (shift_right << 12) | (mask << 16) | (invert << 24) }
841 static int snd_ad1816a_info_double(snd_kcontrol_t *kcontrol, snd_ctl_elem_info_t * uinfo)
843 int mask = (kcontrol->private_value >> 16) & 0xff;
845 uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
847 uinfo->value.integer.min = 0;
848 uinfo->value.integer.max = mask;
852 static int snd_ad1816a_get_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
854 ad1816a_t *chip = snd_kcontrol_chip(kcontrol);
856 int reg = kcontrol->private_value & 0xff;
857 int shift_left = (kcontrol->private_value >> 8) & 0x0f;
858 int shift_right = (kcontrol->private_value >> 12) & 0x0f;
859 int mask = (kcontrol->private_value >> 16) & 0xff;
860 int invert = (kcontrol->private_value >> 24) & 0xff;
863 spin_lock_irqsave(&chip->lock, flags);
864 val = snd_ad1816a_read(chip, reg);
865 ucontrol->value.integer.value[0] = (val >> shift_left) & mask;
866 ucontrol->value.integer.value[1] = (val >> shift_right) & mask;
867 spin_unlock_irqrestore(&chip->lock, flags);
869 ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
870 ucontrol->value.integer.value[1] = mask - ucontrol->value.integer.value[1];
875 static int snd_ad1816a_put_double(snd_kcontrol_t * kcontrol, snd_ctl_elem_value_t * ucontrol)
877 ad1816a_t *chip = snd_kcontrol_chip(kcontrol);
879 int reg = kcontrol->private_value & 0xff;
880 int shift_left = (kcontrol->private_value >> 8) & 0x0f;
881 int shift_right = (kcontrol->private_value >> 12) & 0x0f;
882 int mask = (kcontrol->private_value >> 16) & 0xff;
883 int invert = (kcontrol->private_value >> 24) & 0xff;
885 unsigned short old_val, val1, val2;
887 val1 = ucontrol->value.integer.value[0] & mask;
888 val2 = ucontrol->value.integer.value[1] & mask;
894 val2 <<= shift_right;
895 spin_lock_irqsave(&chip->lock, flags);
896 old_val = snd_ad1816a_read(chip, reg);
897 val1 = (old_val & ~((mask << shift_left) | (mask << shift_right))) | val1 | val2;
898 change = val1 != old_val;
899 snd_ad1816a_write(chip, reg, val1);
900 spin_unlock_irqrestore(&chip->lock, flags);
904 #define AD1816A_CONTROLS (sizeof(snd_ad1816a_controls)/sizeof(snd_kcontrol_new_t))
906 static snd_kcontrol_new_t snd_ad1816a_controls[] = {
907 AD1816A_DOUBLE("Master Playback Switch", AD1816A_MASTER_ATT, 15, 7, 1, 1),
908 AD1816A_DOUBLE("Master Playback Volume", AD1816A_MASTER_ATT, 8, 0, 31, 1),
909 AD1816A_DOUBLE("PCM Playback Switch", AD1816A_VOICE_ATT, 15, 7, 1, 1),
910 AD1816A_DOUBLE("PCM Playback Volume", AD1816A_VOICE_ATT, 8, 0, 63, 1),
911 AD1816A_DOUBLE("Line Playback Switch", AD1816A_LINE_GAIN_ATT, 15, 7, 1, 1),
912 AD1816A_DOUBLE("Line Playback Volume", AD1816A_LINE_GAIN_ATT, 8, 0, 31, 1),
913 AD1816A_DOUBLE("CD Playback Switch", AD1816A_CD_GAIN_ATT, 15, 7, 1, 1),
914 AD1816A_DOUBLE("CD Playback Volume", AD1816A_CD_GAIN_ATT, 8, 0, 31, 1),
915 AD1816A_DOUBLE("Synth Playback Switch", AD1816A_SYNTH_GAIN_ATT, 15, 7, 1, 1),
916 AD1816A_DOUBLE("Synth Playback Volume", AD1816A_SYNTH_GAIN_ATT, 8, 0, 31, 1),
917 AD1816A_DOUBLE("FM Playback Switch", AD1816A_FM_ATT, 15, 7, 1, 1),
918 AD1816A_DOUBLE("FM Playback Volume", AD1816A_FM_ATT, 8, 0, 63, 1),
919 AD1816A_SINGLE("Mic Playback Switch", AD1816A_MIC_GAIN_ATT, 15, 1, 1),
920 AD1816A_SINGLE("Mic Playback Volume", AD1816A_MIC_GAIN_ATT, 8, 31, 1),
921 AD1816A_SINGLE("Mic Boost", AD1816A_MIC_GAIN_ATT, 14, 1, 0),
922 AD1816A_DOUBLE("Video Playback Switch", AD1816A_VID_GAIN_ATT, 15, 7, 1, 1),
923 AD1816A_DOUBLE("Video Playback Volume", AD1816A_VID_GAIN_ATT, 8, 0, 31, 1),
924 AD1816A_SINGLE("Phone Capture Switch", AD1816A_PHONE_IN_GAIN_ATT, 15, 1, 1),
925 AD1816A_SINGLE("Phone Capture Volume", AD1816A_PHONE_IN_GAIN_ATT, 0, 15, 1),
926 AD1816A_SINGLE("Phone Playback Switch", AD1816A_PHONE_OUT_ATT, 7, 1, 1),
927 AD1816A_SINGLE("Phone Playback Volume", AD1816A_PHONE_OUT_ATT, 0, 31, 1),
929 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
930 .name = "Capture Source",
931 .info = snd_ad1816a_info_mux,
932 .get = snd_ad1816a_get_mux,
933 .put = snd_ad1816a_put_mux,
935 AD1816A_DOUBLE("Capture Switch", AD1816A_ADC_PGA, 15, 7, 1, 1),
936 AD1816A_DOUBLE("Capture Volume", AD1816A_ADC_PGA, 8, 0, 15, 0),
937 AD1816A_SINGLE("3D Control - Switch", AD1816A_3D_PHAT_CTRL, 15, 1, 1),
938 AD1816A_SINGLE("3D Control - Level", AD1816A_3D_PHAT_CTRL, 0, 15, 0),
941 int snd_ad1816a_mixer(ad1816a_t *chip)
947 snd_assert(chip != NULL && chip->card != NULL, return -EINVAL);
951 strcpy(card->mixername, snd_ad1816a_chip_id(chip));
953 for (idx = 0; idx < AD1816A_CONTROLS; idx++) {
954 if ((err = snd_ctl_add(card, snd_ctl_new1(&snd_ad1816a_controls[idx], chip))) < 0)
960 EXPORT_SYMBOL(snd_ad1816a_create);
961 EXPORT_SYMBOL(snd_ad1816a_pcm);
962 EXPORT_SYMBOL(snd_ad1816a_mixer);
964 static int __init alsa_ad1816a_init(void)
969 static void __exit alsa_ad1816a_exit(void)
973 module_init(alsa_ad1816a_init)
974 module_exit(alsa_ad1816a_exit)