1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 ad1816a.c - lowlevel code for Analog Devices AD1816A chip.
4 Copyright (C) 1999-2000 by Massimo Piccioni <dafastidio@libero.it>
5
6*/
7
8#include <linux/delay.h>
9#include <linux/init.h>
10#include <linux/interrupt.h>
11#include <linux/slab.h>
12#include <linux/ioport.h>
13#include <linux/io.h>
14#include <sound/core.h>
15#include <sound/tlv.h>
16#include <sound/ad1816a.h>
17
18#include <asm/dma.h>
19
20static inline int snd_ad1816a_busy_wait(struct snd_ad1816a *chip)
21{
22 int timeout;
23
24 for (timeout = 1000; timeout-- > 0; udelay(usec: 10))
25 if (inb(AD1816A_REG(AD1816A_CHIP_STATUS)) & AD1816A_READY)
26 return 0;
27
28 dev_warn(chip->card->dev, "chip busy.\n");
29 return -EBUSY;
30}
31
32static inline unsigned char snd_ad1816a_in(struct snd_ad1816a *chip, unsigned char reg)
33{
34 snd_ad1816a_busy_wait(chip);
35 return inb(AD1816A_REG(reg));
36}
37
38static inline void snd_ad1816a_out(struct snd_ad1816a *chip, unsigned char reg,
39 unsigned char value)
40{
41 snd_ad1816a_busy_wait(chip);
42 outb(value, AD1816A_REG(reg));
43}
44
45static inline void snd_ad1816a_out_mask(struct snd_ad1816a *chip, unsigned char reg,
46 unsigned char mask, unsigned char value)
47{
48 snd_ad1816a_out(chip, reg,
49 value: (value & mask) | (snd_ad1816a_in(chip, reg) & ~mask));
50}
51
52static unsigned short snd_ad1816a_read(struct snd_ad1816a *chip, unsigned char reg)
53{
54 snd_ad1816a_out(chip, AD1816A_INDIR_ADDR, value: reg & 0x3f);
55 return snd_ad1816a_in(chip, AD1816A_INDIR_DATA_LOW) |
56 (snd_ad1816a_in(chip, AD1816A_INDIR_DATA_HIGH) << 8);
57}
58
59static void snd_ad1816a_write(struct snd_ad1816a *chip, unsigned char reg,
60 unsigned short value)
61{
62 snd_ad1816a_out(chip, AD1816A_INDIR_ADDR, value: reg & 0x3f);
63 snd_ad1816a_out(chip, AD1816A_INDIR_DATA_LOW, value: value & 0xff);
64 snd_ad1816a_out(chip, AD1816A_INDIR_DATA_HIGH, value: (value >> 8) & 0xff);
65}
66
67static void snd_ad1816a_write_mask(struct snd_ad1816a *chip, unsigned char reg,
68 unsigned short mask, unsigned short value)
69{
70 snd_ad1816a_write(chip, reg,
71 value: (value & mask) | (snd_ad1816a_read(chip, reg) & ~mask));
72}
73
74
75static unsigned char snd_ad1816a_get_format(struct snd_ad1816a *chip,
76 snd_pcm_format_t format,
77 int channels)
78{
79 unsigned char retval = AD1816A_FMT_LINEAR_8;
80
81 switch (format) {
82 case SNDRV_PCM_FORMAT_MU_LAW:
83 retval = AD1816A_FMT_ULAW_8;
84 break;
85 case SNDRV_PCM_FORMAT_A_LAW:
86 retval = AD1816A_FMT_ALAW_8;
87 break;
88 case SNDRV_PCM_FORMAT_S16_LE:
89 retval = AD1816A_FMT_LINEAR_16_LIT;
90 break;
91 case SNDRV_PCM_FORMAT_S16_BE:
92 retval = AD1816A_FMT_LINEAR_16_BIG;
93 }
94 return (channels > 1) ? (retval | AD1816A_FMT_STEREO) : retval;
95}
96
97static int snd_ad1816a_open(struct snd_ad1816a *chip, unsigned int mode)
98{
99 guard(spinlock_irqsave)(l: &chip->lock);
100
101 if (chip->mode & mode)
102 return -EAGAIN;
103
104 switch ((mode &= AD1816A_MODE_OPEN)) {
105 case AD1816A_MODE_PLAYBACK:
106 snd_ad1816a_out_mask(chip, AD1816A_INTERRUPT_STATUS,
107 AD1816A_PLAYBACK_IRQ_PENDING, value: 0x00);
108 snd_ad1816a_write_mask(chip, AD1816A_INTERRUPT_ENABLE,
109 AD1816A_PLAYBACK_IRQ_ENABLE, value: 0xffff);
110 break;
111 case AD1816A_MODE_CAPTURE:
112 snd_ad1816a_out_mask(chip, AD1816A_INTERRUPT_STATUS,
113 AD1816A_CAPTURE_IRQ_PENDING, value: 0x00);
114 snd_ad1816a_write_mask(chip, AD1816A_INTERRUPT_ENABLE,
115 AD1816A_CAPTURE_IRQ_ENABLE, value: 0xffff);
116 break;
117 case AD1816A_MODE_TIMER:
118 snd_ad1816a_out_mask(chip, AD1816A_INTERRUPT_STATUS,
119 AD1816A_TIMER_IRQ_PENDING, value: 0x00);
120 snd_ad1816a_write_mask(chip, AD1816A_INTERRUPT_ENABLE,
121 AD1816A_TIMER_IRQ_ENABLE, value: 0xffff);
122 }
123 chip->mode |= mode;
124
125 return 0;
126}
127
128static void snd_ad1816a_close(struct snd_ad1816a *chip, unsigned int mode)
129{
130 guard(spinlock_irqsave)(l: &chip->lock);
131
132 switch ((mode &= AD1816A_MODE_OPEN)) {
133 case AD1816A_MODE_PLAYBACK:
134 snd_ad1816a_out_mask(chip, AD1816A_INTERRUPT_STATUS,
135 AD1816A_PLAYBACK_IRQ_PENDING, value: 0x00);
136 snd_ad1816a_write_mask(chip, AD1816A_INTERRUPT_ENABLE,
137 AD1816A_PLAYBACK_IRQ_ENABLE, value: 0x0000);
138 break;
139 case AD1816A_MODE_CAPTURE:
140 snd_ad1816a_out_mask(chip, AD1816A_INTERRUPT_STATUS,
141 AD1816A_CAPTURE_IRQ_PENDING, value: 0x00);
142 snd_ad1816a_write_mask(chip, AD1816A_INTERRUPT_ENABLE,
143 AD1816A_CAPTURE_IRQ_ENABLE, value: 0x0000);
144 break;
145 case AD1816A_MODE_TIMER:
146 snd_ad1816a_out_mask(chip, AD1816A_INTERRUPT_STATUS,
147 AD1816A_TIMER_IRQ_PENDING, value: 0x00);
148 snd_ad1816a_write_mask(chip, AD1816A_INTERRUPT_ENABLE,
149 AD1816A_TIMER_IRQ_ENABLE, value: 0x0000);
150 }
151 chip->mode &= ~mode;
152 if (!(chip->mode & AD1816A_MODE_OPEN))
153 chip->mode = 0;
154}
155
156
157static int snd_ad1816a_trigger(struct snd_ad1816a *chip, unsigned char what,
158 int channel, int cmd, int iscapture)
159{
160 int error = 0;
161
162 switch (cmd) {
163 case SNDRV_PCM_TRIGGER_START:
164 case SNDRV_PCM_TRIGGER_STOP:
165 scoped_guard(spinlock, &chip->lock) {
166 cmd = (cmd == SNDRV_PCM_TRIGGER_START) ? 0xff: 0x00;
167 /* if (what & AD1816A_PLAYBACK_ENABLE) */
168 /* That is not valid, because playback and capture enable
169 * are the same bit pattern, just to different addresses
170 */
171 if (!iscapture)
172 snd_ad1816a_out_mask(chip, AD1816A_PLAYBACK_CONFIG,
173 AD1816A_PLAYBACK_ENABLE, value: cmd);
174 else
175 snd_ad1816a_out_mask(chip, AD1816A_CAPTURE_CONFIG,
176 AD1816A_CAPTURE_ENABLE, value: cmd);
177 }
178 break;
179 default:
180 dev_warn(chip->card->dev, "invalid trigger mode 0x%x.\n", what);
181 error = -EINVAL;
182 }
183
184 return error;
185}
186
187static int snd_ad1816a_playback_trigger(struct snd_pcm_substream *substream, int cmd)
188{
189 struct snd_ad1816a *chip = snd_pcm_substream_chip(substream);
190 return snd_ad1816a_trigger(chip, AD1816A_PLAYBACK_ENABLE,
191 channel: SNDRV_PCM_STREAM_PLAYBACK, cmd, iscapture: 0);
192}
193
194static int snd_ad1816a_capture_trigger(struct snd_pcm_substream *substream, int cmd)
195{
196 struct snd_ad1816a *chip = snd_pcm_substream_chip(substream);
197 return snd_ad1816a_trigger(chip, AD1816A_CAPTURE_ENABLE,
198 channel: SNDRV_PCM_STREAM_CAPTURE, cmd, iscapture: 1);
199}
200
201static int snd_ad1816a_playback_prepare(struct snd_pcm_substream *substream)
202{
203 struct snd_ad1816a *chip = snd_pcm_substream_chip(substream);
204 struct snd_pcm_runtime *runtime = substream->runtime;
205 unsigned int size, rate;
206
207 guard(spinlock_irqsave)(l: &chip->lock);
208
209 chip->p_dma_size = size = snd_pcm_lib_buffer_bytes(substream);
210 snd_ad1816a_out_mask(chip, AD1816A_PLAYBACK_CONFIG,
211 AD1816A_PLAYBACK_ENABLE | AD1816A_PLAYBACK_PIO, value: 0x00);
212
213 snd_dma_program(dma: chip->dma1, addr: runtime->dma_addr, size,
214 DMA_MODE_WRITE | DMA_AUTOINIT);
215
216 rate = runtime->rate;
217 if (chip->clock_freq)
218 rate = (rate * 33000) / chip->clock_freq;
219 snd_ad1816a_write(chip, AD1816A_PLAYBACK_SAMPLE_RATE, value: rate);
220 snd_ad1816a_out_mask(chip, AD1816A_PLAYBACK_CONFIG,
221 AD1816A_FMT_ALL | AD1816A_FMT_STEREO,
222 value: snd_ad1816a_get_format(chip, format: runtime->format,
223 channels: runtime->channels));
224
225 snd_ad1816a_write(chip, AD1816A_PLAYBACK_BASE_COUNT,
226 value: snd_pcm_lib_period_bytes(substream) / 4 - 1);
227 return 0;
228}
229
230static int snd_ad1816a_capture_prepare(struct snd_pcm_substream *substream)
231{
232 struct snd_ad1816a *chip = snd_pcm_substream_chip(substream);
233 struct snd_pcm_runtime *runtime = substream->runtime;
234 unsigned int size, rate;
235
236 guard(spinlock_irqsave)(l: &chip->lock);
237
238 chip->c_dma_size = size = snd_pcm_lib_buffer_bytes(substream);
239 snd_ad1816a_out_mask(chip, AD1816A_CAPTURE_CONFIG,
240 AD1816A_CAPTURE_ENABLE | AD1816A_CAPTURE_PIO, value: 0x00);
241
242 snd_dma_program(dma: chip->dma2, addr: runtime->dma_addr, size,
243 DMA_MODE_READ | DMA_AUTOINIT);
244
245 rate = runtime->rate;
246 if (chip->clock_freq)
247 rate = (rate * 33000) / chip->clock_freq;
248 snd_ad1816a_write(chip, AD1816A_CAPTURE_SAMPLE_RATE, value: rate);
249 snd_ad1816a_out_mask(chip, AD1816A_CAPTURE_CONFIG,
250 AD1816A_FMT_ALL | AD1816A_FMT_STEREO,
251 value: snd_ad1816a_get_format(chip, format: runtime->format,
252 channels: runtime->channels));
253
254 snd_ad1816a_write(chip, AD1816A_CAPTURE_BASE_COUNT,
255 value: snd_pcm_lib_period_bytes(substream) / 4 - 1);
256 return 0;
257}
258
259
260static snd_pcm_uframes_t snd_ad1816a_playback_pointer(struct snd_pcm_substream *substream)
261{
262 struct snd_ad1816a *chip = snd_pcm_substream_chip(substream);
263 size_t ptr;
264 if (!(chip->mode & AD1816A_MODE_PLAYBACK))
265 return 0;
266 ptr = snd_dma_pointer(dma: chip->dma1, size: chip->p_dma_size);
267 return bytes_to_frames(runtime: substream->runtime, size: ptr);
268}
269
270static snd_pcm_uframes_t snd_ad1816a_capture_pointer(struct snd_pcm_substream *substream)
271{
272 struct snd_ad1816a *chip = snd_pcm_substream_chip(substream);
273 size_t ptr;
274 if (!(chip->mode & AD1816A_MODE_CAPTURE))
275 return 0;
276 ptr = snd_dma_pointer(dma: chip->dma2, size: chip->c_dma_size);
277 return bytes_to_frames(runtime: substream->runtime, size: ptr);
278}
279
280
281static irqreturn_t snd_ad1816a_interrupt(int irq, void *dev_id)
282{
283 struct snd_ad1816a *chip = dev_id;
284 unsigned char status;
285
286 scoped_guard(spinlock, &chip->lock) {
287 status = snd_ad1816a_in(chip, AD1816A_INTERRUPT_STATUS);
288 }
289
290 if ((status & AD1816A_PLAYBACK_IRQ_PENDING) && chip->playback_substream)
291 snd_pcm_period_elapsed(substream: chip->playback_substream);
292
293 if ((status & AD1816A_CAPTURE_IRQ_PENDING) && chip->capture_substream)
294 snd_pcm_period_elapsed(substream: chip->capture_substream);
295
296 if ((status & AD1816A_TIMER_IRQ_PENDING) && chip->timer)
297 snd_timer_interrupt(timer: chip->timer, ticks_left: chip->timer->sticks);
298
299 scoped_guard(spinlock, &chip->lock) {
300 snd_ad1816a_out(chip, AD1816A_INTERRUPT_STATUS, value: 0x00);
301 }
302 return IRQ_HANDLED;
303}
304
305
306static const struct snd_pcm_hardware snd_ad1816a_playback = {
307 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
308 SNDRV_PCM_INFO_MMAP_VALID),
309 .formats = (SNDRV_PCM_FMTBIT_MU_LAW | SNDRV_PCM_FMTBIT_A_LAW |
310 SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE |
311 SNDRV_PCM_FMTBIT_S16_BE),
312 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
313 .rate_min = 4000,
314 .rate_max = 55200,
315 .channels_min = 1,
316 .channels_max = 2,
317 .buffer_bytes_max = (128*1024),
318 .period_bytes_min = 64,
319 .period_bytes_max = (128*1024),
320 .periods_min = 1,
321 .periods_max = 1024,
322 .fifo_size = 0,
323};
324
325static const struct snd_pcm_hardware snd_ad1816a_capture = {
326 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED |
327 SNDRV_PCM_INFO_MMAP_VALID),
328 .formats = (SNDRV_PCM_FMTBIT_MU_LAW | SNDRV_PCM_FMTBIT_A_LAW |
329 SNDRV_PCM_FMTBIT_U8 | SNDRV_PCM_FMTBIT_S16_LE |
330 SNDRV_PCM_FMTBIT_S16_BE),
331 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_8000_48000,
332 .rate_min = 4000,
333 .rate_max = 55200,
334 .channels_min = 1,
335 .channels_max = 2,
336 .buffer_bytes_max = (128*1024),
337 .period_bytes_min = 64,
338 .period_bytes_max = (128*1024),
339 .periods_min = 1,
340 .periods_max = 1024,
341 .fifo_size = 0,
342};
343
344static int snd_ad1816a_timer_close(struct snd_timer *timer)
345{
346 struct snd_ad1816a *chip = snd_timer_chip(timer);
347 snd_ad1816a_close(chip, AD1816A_MODE_TIMER);
348 return 0;
349}
350
351static int snd_ad1816a_timer_open(struct snd_timer *timer)
352{
353 struct snd_ad1816a *chip = snd_timer_chip(timer);
354 snd_ad1816a_open(chip, AD1816A_MODE_TIMER);
355 return 0;
356}
357
358static unsigned long snd_ad1816a_timer_resolution(struct snd_timer *timer)
359{
360 if (snd_BUG_ON(!timer))
361 return 0;
362
363 return 10000;
364}
365
366static int snd_ad1816a_timer_start(struct snd_timer *timer)
367{
368 unsigned short bits;
369 struct snd_ad1816a *chip = snd_timer_chip(timer);
370
371 guard(spinlock_irqsave)(l: &chip->lock);
372 bits = snd_ad1816a_read(chip, AD1816A_INTERRUPT_ENABLE);
373
374 if (!(bits & AD1816A_TIMER_ENABLE)) {
375 snd_ad1816a_write(chip, AD1816A_TIMER_BASE_COUNT,
376 value: timer->sticks & 0xffff);
377
378 snd_ad1816a_write_mask(chip, AD1816A_INTERRUPT_ENABLE,
379 AD1816A_TIMER_ENABLE, value: 0xffff);
380 }
381 return 0;
382}
383
384static int snd_ad1816a_timer_stop(struct snd_timer *timer)
385{
386 struct snd_ad1816a *chip = snd_timer_chip(timer);
387
388 guard(spinlock_irqsave)(l: &chip->lock);
389 snd_ad1816a_write_mask(chip, AD1816A_INTERRUPT_ENABLE,
390 AD1816A_TIMER_ENABLE, value: 0x0000);
391 return 0;
392}
393
394static const struct snd_timer_hardware snd_ad1816a_timer_table = {
395 .flags = SNDRV_TIMER_HW_AUTO,
396 .resolution = 10000,
397 .ticks = 65535,
398 .open = snd_ad1816a_timer_open,
399 .close = snd_ad1816a_timer_close,
400 .c_resolution = snd_ad1816a_timer_resolution,
401 .start = snd_ad1816a_timer_start,
402 .stop = snd_ad1816a_timer_stop,
403};
404
405static int snd_ad1816a_playback_open(struct snd_pcm_substream *substream)
406{
407 struct snd_ad1816a *chip = snd_pcm_substream_chip(substream);
408 struct snd_pcm_runtime *runtime = substream->runtime;
409 int error;
410
411 error = snd_ad1816a_open(chip, AD1816A_MODE_PLAYBACK);
412 if (error < 0)
413 return error;
414 runtime->hw = snd_ad1816a_playback;
415 snd_pcm_limit_isa_dma_size(dma: chip->dma1, max: &runtime->hw.buffer_bytes_max);
416 snd_pcm_limit_isa_dma_size(dma: chip->dma1, max: &runtime->hw.period_bytes_max);
417 chip->playback_substream = substream;
418 return 0;
419}
420
421static int snd_ad1816a_capture_open(struct snd_pcm_substream *substream)
422{
423 struct snd_ad1816a *chip = snd_pcm_substream_chip(substream);
424 struct snd_pcm_runtime *runtime = substream->runtime;
425 int error;
426
427 error = snd_ad1816a_open(chip, AD1816A_MODE_CAPTURE);
428 if (error < 0)
429 return error;
430 runtime->hw = snd_ad1816a_capture;
431 snd_pcm_limit_isa_dma_size(dma: chip->dma2, max: &runtime->hw.buffer_bytes_max);
432 snd_pcm_limit_isa_dma_size(dma: chip->dma2, max: &runtime->hw.period_bytes_max);
433 chip->capture_substream = substream;
434 return 0;
435}
436
437static int snd_ad1816a_playback_close(struct snd_pcm_substream *substream)
438{
439 struct snd_ad1816a *chip = snd_pcm_substream_chip(substream);
440
441 chip->playback_substream = NULL;
442 snd_ad1816a_close(chip, AD1816A_MODE_PLAYBACK);
443 return 0;
444}
445
446static int snd_ad1816a_capture_close(struct snd_pcm_substream *substream)
447{
448 struct snd_ad1816a *chip = snd_pcm_substream_chip(substream);
449
450 chip->capture_substream = NULL;
451 snd_ad1816a_close(chip, AD1816A_MODE_CAPTURE);
452 return 0;
453}
454
455
456static void snd_ad1816a_init(struct snd_ad1816a *chip)
457{
458 guard(spinlock_irqsave)(l: &chip->lock);
459
460 snd_ad1816a_out(chip, AD1816A_INTERRUPT_STATUS, value: 0x00);
461 snd_ad1816a_out_mask(chip, AD1816A_PLAYBACK_CONFIG,
462 AD1816A_PLAYBACK_ENABLE | AD1816A_PLAYBACK_PIO, value: 0x00);
463 snd_ad1816a_out_mask(chip, AD1816A_CAPTURE_CONFIG,
464 AD1816A_CAPTURE_ENABLE | AD1816A_CAPTURE_PIO, value: 0x00);
465 snd_ad1816a_write(chip, AD1816A_INTERRUPT_ENABLE, value: 0x0000);
466 snd_ad1816a_write_mask(chip, AD1816A_CHIP_CONFIG,
467 AD1816A_CAPTURE_NOT_EQUAL | AD1816A_WSS_ENABLE, value: 0xffff);
468 snd_ad1816a_write(chip, AD1816A_DSP_CONFIG, value: 0x0000);
469 snd_ad1816a_write(chip, AD1816A_POWERDOWN_CTRL, value: 0x0000);
470}
471
472#ifdef CONFIG_PM
473void snd_ad1816a_suspend(struct snd_ad1816a *chip)
474{
475 int reg;
476
477 guard(spinlock_irqsave)(l: &chip->lock);
478 for (reg = 0; reg < 48; reg++)
479 chip->image[reg] = snd_ad1816a_read(chip, reg);
480}
481
482void snd_ad1816a_resume(struct snd_ad1816a *chip)
483{
484 int reg;
485
486 snd_ad1816a_init(chip);
487 guard(spinlock_irqsave)(l: &chip->lock);
488 for (reg = 0; reg < 48; reg++)
489 snd_ad1816a_write(chip, reg, value: chip->image[reg]);
490}
491#endif
492
493static int snd_ad1816a_probe(struct snd_ad1816a *chip)
494{
495 guard(spinlock_irqsave)(l: &chip->lock);
496
497 switch (chip->version = snd_ad1816a_read(chip, AD1816A_VERSION_ID)) {
498 case 0:
499 chip->hardware = AD1816A_HW_AD1815;
500 break;
501 case 1:
502 chip->hardware = AD1816A_HW_AD18MAX10;
503 break;
504 case 3:
505 chip->hardware = AD1816A_HW_AD1816A;
506 break;
507 default:
508 chip->hardware = AD1816A_HW_AUTO;
509 }
510 return 0;
511}
512
513static const char *snd_ad1816a_chip_id(struct snd_ad1816a *chip)
514{
515 switch (chip->hardware) {
516 case AD1816A_HW_AD1816A: return "AD1816A";
517 case AD1816A_HW_AD1815: return "AD1815";
518 case AD1816A_HW_AD18MAX10: return "AD18max10";
519 default:
520 dev_warn(chip->card->dev, "Unknown chip version %d:%d.\n",
521 chip->version, chip->hardware);
522 return "AD1816A - unknown";
523 }
524}
525
526int snd_ad1816a_create(struct snd_card *card,
527 unsigned long port, int irq, int dma1, int dma2,
528 struct snd_ad1816a *chip)
529{
530 int error;
531
532 chip->irq = -1;
533 chip->dma1 = -1;
534 chip->dma2 = -1;
535
536 chip->res_port = devm_request_region(card->dev, port, 16, "AD1816A");
537 if (!chip->res_port) {
538 dev_err(card->dev, "ad1816a: can't grab port 0x%lx\n", port);
539 return -EBUSY;
540 }
541 if (devm_request_irq(dev: card->dev, irq, handler: snd_ad1816a_interrupt, irqflags: 0,
542 devname: "AD1816A", dev_id: (void *) chip)) {
543 dev_err(card->dev, "ad1816a: can't grab IRQ %d\n", irq);
544 return -EBUSY;
545 }
546 chip->irq = irq;
547 card->sync_irq = chip->irq;
548 if (snd_devm_request_dma(dev: card->dev, dma: dma1, name: "AD1816A - 1")) {
549 dev_err(card->dev, "ad1816a: can't grab DMA1 %d\n", dma1);
550 return -EBUSY;
551 }
552 chip->dma1 = dma1;
553 if (snd_devm_request_dma(dev: card->dev, dma: dma2, name: "AD1816A - 2")) {
554 dev_err(card->dev, "ad1816a: can't grab DMA2 %d\n", dma2);
555 return -EBUSY;
556 }
557 chip->dma2 = dma2;
558
559 chip->card = card;
560 chip->port = port;
561 spin_lock_init(&chip->lock);
562
563 error = snd_ad1816a_probe(chip);
564 if (error)
565 return error;
566
567 snd_ad1816a_init(chip);
568
569 return 0;
570}
571
572static const struct snd_pcm_ops snd_ad1816a_playback_ops = {
573 .open = snd_ad1816a_playback_open,
574 .close = snd_ad1816a_playback_close,
575 .prepare = snd_ad1816a_playback_prepare,
576 .trigger = snd_ad1816a_playback_trigger,
577 .pointer = snd_ad1816a_playback_pointer,
578};
579
580static const struct snd_pcm_ops snd_ad1816a_capture_ops = {
581 .open = snd_ad1816a_capture_open,
582 .close = snd_ad1816a_capture_close,
583 .prepare = snd_ad1816a_capture_prepare,
584 .trigger = snd_ad1816a_capture_trigger,
585 .pointer = snd_ad1816a_capture_pointer,
586};
587
588int snd_ad1816a_pcm(struct snd_ad1816a *chip, int device)
589{
590 int error;
591 struct snd_pcm *pcm;
592
593 error = snd_pcm_new(card: chip->card, id: "AD1816A", device, playback_count: 1, capture_count: 1, rpcm: &pcm);
594 if (error)
595 return error;
596
597 snd_pcm_set_ops(pcm, direction: SNDRV_PCM_STREAM_PLAYBACK, ops: &snd_ad1816a_playback_ops);
598 snd_pcm_set_ops(pcm, direction: SNDRV_PCM_STREAM_CAPTURE, ops: &snd_ad1816a_capture_ops);
599
600 pcm->private_data = chip;
601 pcm->info_flags = (chip->dma1 == chip->dma2 ) ? SNDRV_PCM_INFO_JOINT_DUPLEX : 0;
602
603 strscpy(pcm->name, snd_ad1816a_chip_id(chip));
604 snd_ad1816a_init(chip);
605
606 snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV, data: chip->card->dev,
607 size: 64*1024, max: chip->dma1 > 3 || chip->dma2 > 3 ? 128*1024 : 64*1024);
608
609 chip->pcm = pcm;
610 return 0;
611}
612
613int snd_ad1816a_timer(struct snd_ad1816a *chip, int device)
614{
615 struct snd_timer *timer;
616 struct snd_timer_id tid;
617 int error;
618
619 tid.dev_class = SNDRV_TIMER_CLASS_CARD;
620 tid.dev_sclass = SNDRV_TIMER_SCLASS_NONE;
621 tid.card = chip->card->number;
622 tid.device = device;
623 tid.subdevice = 0;
624 error = snd_timer_new(card: chip->card, id: "AD1816A", tid: &tid, rtimer: &timer);
625 if (error < 0)
626 return error;
627 strscpy(timer->name, snd_ad1816a_chip_id(chip));
628 timer->private_data = chip;
629 chip->timer = timer;
630 timer->hw = snd_ad1816a_timer_table;
631 return 0;
632}
633
634/*
635 *
636 */
637
638static int snd_ad1816a_info_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
639{
640 static const char * const texts[8] = {
641 "Line", "Mix", "CD", "Synth", "Video",
642 "Mic", "Phone",
643 };
644
645 return snd_ctl_enum_info(info: uinfo, channels: 2, items: 7, names: texts);
646}
647
648static int snd_ad1816a_get_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
649{
650 struct snd_ad1816a *chip = snd_kcontrol_chip(kcontrol);
651 unsigned short val;
652
653 guard(spinlock_irqsave)(l: &chip->lock);
654 val = snd_ad1816a_read(chip, AD1816A_ADC_SOURCE_SEL);
655 ucontrol->value.enumerated.item[0] = (val >> 12) & 7;
656 ucontrol->value.enumerated.item[1] = (val >> 4) & 7;
657 return 0;
658}
659
660static int snd_ad1816a_put_mux(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
661{
662 struct snd_ad1816a *chip = snd_kcontrol_chip(kcontrol);
663 unsigned short val;
664 int change;
665
666 if (ucontrol->value.enumerated.item[0] > 6 ||
667 ucontrol->value.enumerated.item[1] > 6)
668 return -EINVAL;
669 val = (ucontrol->value.enumerated.item[0] << 12) |
670 (ucontrol->value.enumerated.item[1] << 4);
671 guard(spinlock_irqsave)(l: &chip->lock);
672 change = snd_ad1816a_read(chip, AD1816A_ADC_SOURCE_SEL) != val;
673 snd_ad1816a_write(chip, AD1816A_ADC_SOURCE_SEL, value: val);
674 return change;
675}
676
677#define AD1816A_SINGLE_TLV(xname, reg, shift, mask, invert, xtlv) \
678{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
679 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ, \
680 .name = xname, .info = snd_ad1816a_info_single, \
681 .get = snd_ad1816a_get_single, .put = snd_ad1816a_put_single, \
682 .private_value = reg | (shift << 8) | (mask << 16) | (invert << 24), \
683 .tlv = { .p = (xtlv) } }
684#define AD1816A_SINGLE(xname, reg, shift, mask, invert) \
685{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .info = snd_ad1816a_info_single, \
686 .get = snd_ad1816a_get_single, .put = snd_ad1816a_put_single, \
687 .private_value = reg | (shift << 8) | (mask << 16) | (invert << 24) }
688
689static int snd_ad1816a_info_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
690{
691 int mask = (kcontrol->private_value >> 16) & 0xff;
692
693 uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
694 uinfo->count = 1;
695 uinfo->value.integer.min = 0;
696 uinfo->value.integer.max = mask;
697 return 0;
698}
699
700static int snd_ad1816a_get_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
701{
702 struct snd_ad1816a *chip = snd_kcontrol_chip(kcontrol);
703 int reg = kcontrol->private_value & 0xff;
704 int shift = (kcontrol->private_value >> 8) & 0xff;
705 int mask = (kcontrol->private_value >> 16) & 0xff;
706 int invert = (kcontrol->private_value >> 24) & 0xff;
707
708 guard(spinlock_irqsave)(l: &chip->lock);
709 ucontrol->value.integer.value[0] = (snd_ad1816a_read(chip, reg) >> shift) & mask;
710 if (invert)
711 ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
712 return 0;
713}
714
715static int snd_ad1816a_put_single(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
716{
717 struct snd_ad1816a *chip = snd_kcontrol_chip(kcontrol);
718 int reg = kcontrol->private_value & 0xff;
719 int shift = (kcontrol->private_value >> 8) & 0xff;
720 int mask = (kcontrol->private_value >> 16) & 0xff;
721 int invert = (kcontrol->private_value >> 24) & 0xff;
722 int change;
723 unsigned short old_val, val;
724
725 val = (ucontrol->value.integer.value[0] & mask);
726 if (invert)
727 val = mask - val;
728 val <<= shift;
729 guard(spinlock_irqsave)(l: &chip->lock);
730 old_val = snd_ad1816a_read(chip, reg);
731 val = (old_val & ~(mask << shift)) | val;
732 change = val != old_val;
733 snd_ad1816a_write(chip, reg, value: val);
734 return change;
735}
736
737#define AD1816A_DOUBLE_TLV(xname, reg, shift_left, shift_right, mask, invert, xtlv) \
738{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
739 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ, \
740 .name = xname, .info = snd_ad1816a_info_double, \
741 .get = snd_ad1816a_get_double, .put = snd_ad1816a_put_double, \
742 .private_value = reg | (shift_left << 8) | (shift_right << 12) | (mask << 16) | (invert << 24), \
743 .tlv = { .p = (xtlv) } }
744
745#define AD1816A_DOUBLE(xname, reg, shift_left, shift_right, mask, invert) \
746{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .info = snd_ad1816a_info_double, \
747 .get = snd_ad1816a_get_double, .put = snd_ad1816a_put_double, \
748 .private_value = reg | (shift_left << 8) | (shift_right << 12) | (mask << 16) | (invert << 24) }
749
750static int snd_ad1816a_info_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo)
751{
752 int mask = (kcontrol->private_value >> 16) & 0xff;
753
754 uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN : SNDRV_CTL_ELEM_TYPE_INTEGER;
755 uinfo->count = 2;
756 uinfo->value.integer.min = 0;
757 uinfo->value.integer.max = mask;
758 return 0;
759}
760
761static int snd_ad1816a_get_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
762{
763 struct snd_ad1816a *chip = snd_kcontrol_chip(kcontrol);
764 int reg = kcontrol->private_value & 0xff;
765 int shift_left = (kcontrol->private_value >> 8) & 0x0f;
766 int shift_right = (kcontrol->private_value >> 12) & 0x0f;
767 int mask = (kcontrol->private_value >> 16) & 0xff;
768 int invert = (kcontrol->private_value >> 24) & 0xff;
769 unsigned short val;
770
771 guard(spinlock_irqsave)(l: &chip->lock);
772 val = snd_ad1816a_read(chip, reg);
773 ucontrol->value.integer.value[0] = (val >> shift_left) & mask;
774 ucontrol->value.integer.value[1] = (val >> shift_right) & mask;
775 if (invert) {
776 ucontrol->value.integer.value[0] = mask - ucontrol->value.integer.value[0];
777 ucontrol->value.integer.value[1] = mask - ucontrol->value.integer.value[1];
778 }
779 return 0;
780}
781
782static int snd_ad1816a_put_double(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol)
783{
784 struct snd_ad1816a *chip = snd_kcontrol_chip(kcontrol);
785 int reg = kcontrol->private_value & 0xff;
786 int shift_left = (kcontrol->private_value >> 8) & 0x0f;
787 int shift_right = (kcontrol->private_value >> 12) & 0x0f;
788 int mask = (kcontrol->private_value >> 16) & 0xff;
789 int invert = (kcontrol->private_value >> 24) & 0xff;
790 int change;
791 unsigned short old_val, val1, val2;
792
793 val1 = ucontrol->value.integer.value[0] & mask;
794 val2 = ucontrol->value.integer.value[1] & mask;
795 if (invert) {
796 val1 = mask - val1;
797 val2 = mask - val2;
798 }
799 val1 <<= shift_left;
800 val2 <<= shift_right;
801 guard(spinlock_irqsave)(l: &chip->lock);
802 old_val = snd_ad1816a_read(chip, reg);
803 val1 = (old_val & ~((mask << shift_left) | (mask << shift_right))) | val1 | val2;
804 change = val1 != old_val;
805 snd_ad1816a_write(chip, reg, value: val1);
806 return change;
807}
808
809static const DECLARE_TLV_DB_SCALE(db_scale_4bit, -4500, 300, 0);
810static const DECLARE_TLV_DB_SCALE(db_scale_5bit, -4650, 150, 0);
811static const DECLARE_TLV_DB_SCALE(db_scale_6bit, -9450, 150, 0);
812static const DECLARE_TLV_DB_SCALE(db_scale_5bit_12db_max, -3450, 150, 0);
813static const DECLARE_TLV_DB_SCALE(db_scale_rec_gain, 0, 150, 0);
814
815static const struct snd_kcontrol_new snd_ad1816a_controls[] = {
816AD1816A_DOUBLE("Master Playback Switch", AD1816A_MASTER_ATT, 15, 7, 1, 1),
817AD1816A_DOUBLE_TLV("Master Playback Volume", AD1816A_MASTER_ATT, 8, 0, 31, 1,
818 db_scale_5bit),
819AD1816A_DOUBLE("PCM Playback Switch", AD1816A_VOICE_ATT, 15, 7, 1, 1),
820AD1816A_DOUBLE_TLV("PCM Playback Volume", AD1816A_VOICE_ATT, 8, 0, 63, 1,
821 db_scale_6bit),
822AD1816A_DOUBLE("Line Playback Switch", AD1816A_LINE_GAIN_ATT, 15, 7, 1, 1),
823AD1816A_DOUBLE_TLV("Line Playback Volume", AD1816A_LINE_GAIN_ATT, 8, 0, 31, 1,
824 db_scale_5bit_12db_max),
825AD1816A_DOUBLE("CD Playback Switch", AD1816A_CD_GAIN_ATT, 15, 7, 1, 1),
826AD1816A_DOUBLE_TLV("CD Playback Volume", AD1816A_CD_GAIN_ATT, 8, 0, 31, 1,
827 db_scale_5bit_12db_max),
828AD1816A_DOUBLE("Synth Playback Switch", AD1816A_SYNTH_GAIN_ATT, 15, 7, 1, 1),
829AD1816A_DOUBLE_TLV("Synth Playback Volume", AD1816A_SYNTH_GAIN_ATT, 8, 0, 31, 1,
830 db_scale_5bit_12db_max),
831AD1816A_DOUBLE("FM Playback Switch", AD1816A_FM_ATT, 15, 7, 1, 1),
832AD1816A_DOUBLE_TLV("FM Playback Volume", AD1816A_FM_ATT, 8, 0, 63, 1,
833 db_scale_6bit),
834AD1816A_SINGLE("Mic Playback Switch", AD1816A_MIC_GAIN_ATT, 15, 1, 1),
835AD1816A_SINGLE_TLV("Mic Playback Volume", AD1816A_MIC_GAIN_ATT, 8, 31, 1,
836 db_scale_5bit_12db_max),
837AD1816A_SINGLE("Mic Boost", AD1816A_MIC_GAIN_ATT, 14, 1, 0),
838AD1816A_DOUBLE("Video Playback Switch", AD1816A_VID_GAIN_ATT, 15, 7, 1, 1),
839AD1816A_DOUBLE_TLV("Video Playback Volume", AD1816A_VID_GAIN_ATT, 8, 0, 31, 1,
840 db_scale_5bit_12db_max),
841AD1816A_SINGLE("Phone Capture Switch", AD1816A_PHONE_IN_GAIN_ATT, 15, 1, 1),
842AD1816A_SINGLE_TLV("Phone Capture Volume", AD1816A_PHONE_IN_GAIN_ATT, 0, 15, 1,
843 db_scale_4bit),
844AD1816A_SINGLE("Phone Playback Switch", AD1816A_PHONE_OUT_ATT, 7, 1, 1),
845AD1816A_SINGLE_TLV("Phone Playback Volume", AD1816A_PHONE_OUT_ATT, 0, 31, 1,
846 db_scale_5bit),
847{
848 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
849 .name = "Capture Source",
850 .info = snd_ad1816a_info_mux,
851 .get = snd_ad1816a_get_mux,
852 .put = snd_ad1816a_put_mux,
853},
854AD1816A_DOUBLE("Capture Switch", AD1816A_ADC_PGA, 15, 7, 1, 1),
855AD1816A_DOUBLE_TLV("Capture Volume", AD1816A_ADC_PGA, 8, 0, 15, 0,
856 db_scale_rec_gain),
857AD1816A_SINGLE("3D Control - Switch", AD1816A_3D_PHAT_CTRL, 15, 1, 1),
858AD1816A_SINGLE("3D Control - Level", AD1816A_3D_PHAT_CTRL, 0, 15, 0),
859};
860
861int snd_ad1816a_mixer(struct snd_ad1816a *chip)
862{
863 struct snd_card *card;
864 unsigned int idx;
865 int err;
866
867 if (snd_BUG_ON(!chip || !chip->card))
868 return -EINVAL;
869
870 card = chip->card;
871
872 strscpy(card->mixername, snd_ad1816a_chip_id(chip));
873
874 for (idx = 0; idx < ARRAY_SIZE(snd_ad1816a_controls); idx++) {
875 err = snd_ctl_add(card, kcontrol: snd_ctl_new1(kcontrolnew: &snd_ad1816a_controls[idx], private_data: chip));
876 if (err < 0)
877 return err;
878 }
879 return 0;
880}
881

source code of linux/sound/isa/ad1816a/ad1816a_lib.c