1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Asihpi soundcard
4 * Copyright (c) by AudioScience Inc <support@audioscience.com>
5 *
6 * The following is not a condition of use, merely a request:
7 * If you modify this program, particularly if you fix errors, AudioScience Inc
8 * would appreciate it if you grant us the right to use those modifications
9 * for any purpose including commercial applications.
10 */
11
12 #include "hpi_internal.h"
13 #include "hpi_version.h"
14 #include "hpimsginit.h"
15 #include "hpioctl.h"
16 #include "hpicmn.h"
17
18 #include <linux/pci.h>
19 #include <linux/init.h>
20 #include <linux/jiffies.h>
21 #include <linux/slab.h>
22 #include <linux/time.h>
23 #include <linux/wait.h>
24 #include <linux/module.h>
25 #include <sound/core.h>
26 #include <sound/control.h>
27 #include <sound/pcm.h>
28 #include <sound/pcm_params.h>
29 #include <sound/info.h>
30 #include <sound/initval.h>
31 #include <sound/tlv.h>
32 #include <sound/hwdep.h>
33
34 MODULE_LICENSE("GPL");
35 MODULE_AUTHOR("AudioScience inc. <support@audioscience.com>");
36 MODULE_DESCRIPTION("AudioScience ALSA ASI5xxx ASI6xxx ASI87xx ASI89xx "
37 HPI_VER_STRING);
38
39 #if defined CONFIG_SND_DEBUG_VERBOSE
40 /**
41 * snd_printddd - very verbose debug printk
42 * @format: format string
43 *
44 * Works like snd_printk() for debugging purposes.
45 * Ignored when CONFIG_SND_DEBUG_VERBOSE is not set.
46 * Must set snd module debug parameter to 3 to enable at runtime.
47 */
48 #define snd_printddd(format, args...) \
49 __snd_printk(3, __FILE__, __LINE__, format, ##args)
50 #else
51 #define snd_printddd(format, args...) do { } while (0)
52 #endif
53
54 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* index 0-MAX */
55 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */
56 static bool enable[SNDRV_CARDS] = SNDRV_DEFAULT_ENABLE_PNP;
57 static bool enable_hpi_hwdep = 1;
58
59 module_param_array(index, int, NULL, 0444);
60 MODULE_PARM_DESC(index, "ALSA index value for AudioScience soundcard.");
61
62 module_param_array(id, charp, NULL, 0444);
63 MODULE_PARM_DESC(id, "ALSA ID string for AudioScience soundcard.");
64
65 module_param_array(enable, bool, NULL, 0444);
66 MODULE_PARM_DESC(enable, "ALSA enable AudioScience soundcard.");
67
68 module_param(enable_hpi_hwdep, bool, 0644);
69 MODULE_PARM_DESC(enable_hpi_hwdep,
70 "ALSA enable HPI hwdep for AudioScience soundcard ");
71
72 /* identify driver */
73 #ifdef KERNEL_ALSA_BUILD
74 static char *build_info = "Built using headers from kernel source";
75 module_param(build_info, charp, 0444);
76 MODULE_PARM_DESC(build_info, "Built using headers from kernel source");
77 #else
78 static char *build_info = "Built within ALSA source";
79 module_param(build_info, charp, 0444);
80 MODULE_PARM_DESC(build_info, "Built within ALSA source");
81 #endif
82
83 /* set to 1 to dump every control from adapter to log */
84 static const int mixer_dump;
85
86 #define DEFAULT_SAMPLERATE 44100
87 static int adapter_fs = DEFAULT_SAMPLERATE;
88
89 /* defaults */
90 #define PERIODS_MIN 2
91 #define PERIOD_BYTES_MIN 2048
92 #define BUFFER_BYTES_MAX (512 * 1024)
93
94 #define MAX_CLOCKSOURCES (HPI_SAMPLECLOCK_SOURCE_LAST + 1 + 7)
95
96 struct clk_source {
97 int source;
98 int index;
99 const char *name;
100 };
101
102 struct clk_cache {
103 int count;
104 int has_local;
105 struct clk_source s[MAX_CLOCKSOURCES];
106 };
107
108 /* Per card data */
109 struct snd_card_asihpi {
110 struct snd_card *card;
111 struct pci_dev *pci;
112 struct hpi_adapter *hpi;
113
114 /* In low latency mode there is only one stream, a pointer to its
115 * private data is stored here on trigger and cleared on stop.
116 * The interrupt handler uses it as a parameter when calling
117 * snd_card_asihpi_timer_function().
118 */
119 struct snd_card_asihpi_pcm *llmode_streampriv;
120 void (*pcm_start)(struct snd_pcm_substream *substream);
121 void (*pcm_stop)(struct snd_pcm_substream *substream);
122
123 u32 h_mixer;
124 struct clk_cache cc;
125
126 u16 can_dma;
127 u16 support_grouping;
128 u16 support_mrx;
129 u16 update_interval_frames;
130 u16 in_max_chans;
131 u16 out_max_chans;
132 u16 in_min_chans;
133 u16 out_min_chans;
134 };
135
136 /* Per stream data */
137 struct snd_card_asihpi_pcm {
138 struct timer_list timer;
139 unsigned int respawn_timer;
140 unsigned int hpi_buffer_attached;
141 unsigned int buffer_bytes;
142 unsigned int period_bytes;
143 unsigned int bytes_per_sec;
144 unsigned int pcm_buf_host_rw_ofs; /* Host R/W pos */
145 unsigned int pcm_buf_dma_ofs; /* DMA R/W offset in buffer */
146 unsigned int pcm_buf_elapsed_dma_ofs; /* DMA R/W offset in buffer */
147 unsigned int drained_count;
148 struct snd_pcm_substream *substream;
149 u32 h_stream;
150 struct hpi_format format;
151 };
152
153 /* universal stream verbs work with out or in stream handles */
154
155 /* Functions to allow driver to give a buffer to HPI for busmastering */
156
157 static u16 hpi_stream_host_buffer_attach(
158 u32 h_stream, /* handle to outstream. */
159 u32 size_in_bytes, /* size in bytes of bus mastering buffer */
160 u32 pci_address
161 )
162 {
163 struct hpi_message hm;
164 struct hpi_response hr;
165 unsigned int obj = hpi_handle_object(h_stream);
166
167 if (!h_stream)
168 return HPI_ERROR_INVALID_OBJ;
169 hpi_init_message_response(&hm, &hr, obj,
170 obj == HPI_OBJ_OSTREAM ?
171 HPI_OSTREAM_HOSTBUFFER_ALLOC :
172 HPI_ISTREAM_HOSTBUFFER_ALLOC);
173
174 hpi_handle_to_indexes(h_stream, &hm.adapter_index,
175 &hm.obj_index);
176
177 hm.u.d.u.buffer.buffer_size = size_in_bytes;
178 hm.u.d.u.buffer.pci_address = pci_address;
179 hm.u.d.u.buffer.command = HPI_BUFFER_CMD_INTERNAL_GRANTADAPTER;
180 hpi_send_recv(&hm, &hr);
181 return hr.error;
182 }
183
184 static u16 hpi_stream_host_buffer_detach(u32 h_stream)
185 {
186 struct hpi_message hm;
187 struct hpi_response hr;
188 unsigned int obj = hpi_handle_object(h_stream);
189
190 if (!h_stream)
191 return HPI_ERROR_INVALID_OBJ;
192
193 hpi_init_message_response(&hm, &hr, obj,
194 obj == HPI_OBJ_OSTREAM ?
195 HPI_OSTREAM_HOSTBUFFER_FREE :
196 HPI_ISTREAM_HOSTBUFFER_FREE);
197
198 hpi_handle_to_indexes(h_stream, &hm.adapter_index,
199 &hm.obj_index);
200 hm.u.d.u.buffer.command = HPI_BUFFER_CMD_INTERNAL_REVOKEADAPTER;
201 hpi_send_recv(&hm, &hr);
202 return hr.error;
203 }
204
205 static inline u16 hpi_stream_start(u32 h_stream)
206 {
207 if (hpi_handle_object(h_stream) == HPI_OBJ_OSTREAM)
208 return hpi_outstream_start(h_stream);
209 else
210 return hpi_instream_start(h_stream);
211 }
212
213 static inline u16 hpi_stream_stop(u32 h_stream)
214 {
215 if (hpi_handle_object(h_stream) == HPI_OBJ_OSTREAM)
216 return hpi_outstream_stop(h_stream);
217 else
218 return hpi_instream_stop(h_stream);
219 }
220
221 static inline u16 hpi_stream_get_info_ex(
222 u32 h_stream,
223 u16 *pw_state,
224 u32 *pbuffer_size,
225 u32 *pdata_in_buffer,
226 u32 *psample_count,
227 u32 *pauxiliary_data
228 )
229 {
230 u16 e;
231 if (hpi_handle_object(h_stream) == HPI_OBJ_OSTREAM)
232 e = hpi_outstream_get_info_ex(h_stream, pw_state,
233 pbuffer_size, pdata_in_buffer,
234 psample_count, pauxiliary_data);
235 else
236 e = hpi_instream_get_info_ex(h_stream, pw_state,
237 pbuffer_size, pdata_in_buffer,
238 psample_count, pauxiliary_data);
239 return e;
240 }
241
242 static inline u16 hpi_stream_group_add(
243 u32 h_master,
244 u32 h_stream)
245 {
246 if (hpi_handle_object(h_master) == HPI_OBJ_OSTREAM)
247 return hpi_outstream_group_add(h_master, h_stream);
248 else
249 return hpi_instream_group_add(h_master, h_stream);
250 }
251
252 static inline u16 hpi_stream_group_reset(u32 h_stream)
253 {
254 if (hpi_handle_object(h_stream) == HPI_OBJ_OSTREAM)
255 return hpi_outstream_group_reset(h_stream);
256 else
257 return hpi_instream_group_reset(h_stream);
258 }
259
260 static u16 handle_error(u16 err, int line, char *filename)
261 {
262 if (err)
263 printk(KERN_WARNING
264 "in file %s, line %d: HPI error %d\n",
265 filename, line, err);
266 return err;
267 }
268
269 #define hpi_handle_error(x) handle_error(x, __LINE__, __FILE__)
270
271 /***************************** GENERAL PCM ****************/
272
273 static void print_hwparams(struct snd_pcm_substream *substream,
274 struct snd_pcm_hw_params *p)
275 {
276 char name[16];
277 snd_pcm_debug_name(substream, name, sizeof(name));
278 snd_printdd("%s HWPARAMS\n", name);
279 snd_printdd(" samplerate=%dHz channels=%d format=%d subformat=%d\n",
280 params_rate(p), params_channels(p),
281 params_format(p), params_subformat(p));
282 snd_printdd(" buffer=%dB period=%dB period_size=%dB periods=%d\n",
283 params_buffer_bytes(p), params_period_bytes(p),
284 params_period_size(p), params_periods(p));
285 snd_printdd(" buffer_size=%d access=%d data_rate=%dB/s\n",
286 params_buffer_size(p), params_access(p),
287 params_rate(p) * params_channels(p) *
288 snd_pcm_format_width(params_format(p)) / 8);
289 }
290
291 #define INVALID_FORMAT (__force snd_pcm_format_t)(-1)
292
293 static const snd_pcm_format_t hpi_to_alsa_formats[] = {
294 INVALID_FORMAT, /* INVALID */
295 SNDRV_PCM_FORMAT_U8, /* HPI_FORMAT_PCM8_UNSIGNED 1 */
296 SNDRV_PCM_FORMAT_S16, /* HPI_FORMAT_PCM16_SIGNED 2 */
297 INVALID_FORMAT, /* HPI_FORMAT_MPEG_L1 3 */
298 SNDRV_PCM_FORMAT_MPEG, /* HPI_FORMAT_MPEG_L2 4 */
299 SNDRV_PCM_FORMAT_MPEG, /* HPI_FORMAT_MPEG_L3 5 */
300 INVALID_FORMAT, /* HPI_FORMAT_DOLBY_AC2 6 */
301 INVALID_FORMAT, /* HPI_FORMAT_DOLBY_AC3 7 */
302 SNDRV_PCM_FORMAT_S16_BE,/* HPI_FORMAT_PCM16_BIGENDIAN 8 */
303 INVALID_FORMAT, /* HPI_FORMAT_AA_TAGIT1_HITS 9 */
304 INVALID_FORMAT, /* HPI_FORMAT_AA_TAGIT1_INSERTS 10 */
305 SNDRV_PCM_FORMAT_S32, /* HPI_FORMAT_PCM32_SIGNED 11 */
306 INVALID_FORMAT, /* HPI_FORMAT_RAW_BITSTREAM 12 */
307 INVALID_FORMAT, /* HPI_FORMAT_AA_TAGIT1_HITS_EX1 13 */
308 SNDRV_PCM_FORMAT_FLOAT, /* HPI_FORMAT_PCM32_FLOAT 14 */
309 #if 1
310 /* ALSA can't handle 3 byte sample size together with power-of-2
311 * constraint on buffer_bytes, so disable this format
312 */
313 INVALID_FORMAT
314 #else
315 /* SNDRV_PCM_FORMAT_S24_3LE */ /* HPI_FORMAT_PCM24_SIGNED 15 */
316 #endif
317 };
318
319
320 static int snd_card_asihpi_format_alsa2hpi(snd_pcm_format_t alsa_format,
321 u16 *hpi_format)
322 {
323 u16 format;
324
325 for (format = HPI_FORMAT_PCM8_UNSIGNED;
326 format <= HPI_FORMAT_PCM24_SIGNED; format++) {
327 if (hpi_to_alsa_formats[format] == alsa_format) {
328 *hpi_format = format;
329 return 0;
330 }
331 }
332
333 snd_printd(KERN_WARNING "failed match for alsa format %d\n",
334 alsa_format);
335 *hpi_format = 0;
336 return -EINVAL;
337 }
338
339 static void snd_card_asihpi_pcm_samplerates(struct snd_card_asihpi *asihpi,
340 struct snd_pcm_hardware *pcmhw)
341 {
342 u16 err;
343 u32 h_control;
344 u32 sample_rate;
345 int idx;
346 unsigned int rate_min = 200000;
347 unsigned int rate_max = 0;
348 unsigned int rates = 0;
349
350 if (asihpi->support_mrx) {
351 rates |= SNDRV_PCM_RATE_CONTINUOUS;
352 rates |= SNDRV_PCM_RATE_8000_96000;
353 rate_min = 8000;
354 rate_max = 100000;
355 } else {
356 /* on cards without SRC,
357 valid rates are determined by sampleclock */
358 err = hpi_mixer_get_control(asihpi->h_mixer,
359 HPI_SOURCENODE_CLOCK_SOURCE, 0, 0, 0,
360 HPI_CONTROL_SAMPLECLOCK, &h_control);
361 if (err) {
362 dev_err(&asihpi->pci->dev,
363 "No local sampleclock, err %d\n", err);
364 }
365
366 for (idx = -1; idx < 100; idx++) {
367 if (idx == -1) {
368 if (hpi_sample_clock_get_sample_rate(h_control,
369 &sample_rate))
370 continue;
371 } else if (hpi_sample_clock_query_local_rate(h_control,
372 idx, &sample_rate)) {
373 break;
374 }
375
376 rate_min = min(rate_min, sample_rate);
377 rate_max = max(rate_max, sample_rate);
378
379 switch (sample_rate) {
380 case 5512:
381 rates |= SNDRV_PCM_RATE_5512;
382 break;
383 case 8000:
384 rates |= SNDRV_PCM_RATE_8000;
385 break;
386 case 11025:
387 rates |= SNDRV_PCM_RATE_11025;
388 break;
389 case 16000:
390 rates |= SNDRV_PCM_RATE_16000;
391 break;
392 case 22050:
393 rates |= SNDRV_PCM_RATE_22050;
394 break;
395 case 32000:
396 rates |= SNDRV_PCM_RATE_32000;
397 break;
398 case 44100:
399 rates |= SNDRV_PCM_RATE_44100;
400 break;
401 case 48000:
402 rates |= SNDRV_PCM_RATE_48000;
403 break;
404 case 64000:
405 rates |= SNDRV_PCM_RATE_64000;
406 break;
407 case 88200:
408 rates |= SNDRV_PCM_RATE_88200;
409 break;
410 case 96000:
411 rates |= SNDRV_PCM_RATE_96000;
412 break;
413 case 176400:
414 rates |= SNDRV_PCM_RATE_176400;
415 break;
416 case 192000:
417 rates |= SNDRV_PCM_RATE_192000;
418 break;
419 default: /* some other rate */
420 rates |= SNDRV_PCM_RATE_KNOT;
421 }
422 }
423 }
424
425 pcmhw->rates = rates;
426 pcmhw->rate_min = rate_min;
427 pcmhw->rate_max = rate_max;
428 }
429
430 static int snd_card_asihpi_pcm_hw_params(struct snd_pcm_substream *substream,
431 struct snd_pcm_hw_params *params)
432 {
433 struct snd_pcm_runtime *runtime = substream->runtime;
434 struct snd_card_asihpi_pcm *dpcm = runtime->private_data;
435 struct snd_card_asihpi *card = snd_pcm_substream_chip(substream);
436 int err;
437 u16 format;
438 int width;
439 unsigned int bytes_per_sec;
440
441 print_hwparams(substream, params);
442 err = snd_card_asihpi_format_alsa2hpi(params_format(params), &format);
443 if (err)
444 return err;
445
446 hpi_handle_error(hpi_format_create(&dpcm->format,
447 params_channels(params),
448 format, params_rate(params), 0, 0));
449
450 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
451 if (hpi_instream_reset(dpcm->h_stream) != 0)
452 return -EINVAL;
453
454 if (hpi_instream_set_format(
455 dpcm->h_stream, &dpcm->format) != 0)
456 return -EINVAL;
457 }
458
459 dpcm->hpi_buffer_attached = 0;
460 if (card->can_dma) {
461 err = hpi_stream_host_buffer_attach(dpcm->h_stream,
462 params_buffer_bytes(params), runtime->dma_addr);
463 if (err == 0) {
464 snd_printdd(
465 "stream_host_buffer_attach success %u %lu\n",
466 params_buffer_bytes(params),
467 (unsigned long)runtime->dma_addr);
468 } else {
469 snd_printd("stream_host_buffer_attach error %d\n",
470 err);
471 return -ENOMEM;
472 }
473
474 err = hpi_stream_get_info_ex(dpcm->h_stream, NULL,
475 &dpcm->hpi_buffer_attached, NULL, NULL, NULL);
476 }
477 bytes_per_sec = params_rate(params) * params_channels(params);
478 width = snd_pcm_format_width(params_format(params));
479 bytes_per_sec *= width;
480 bytes_per_sec /= 8;
481 if (width < 0 || bytes_per_sec == 0)
482 return -EINVAL;
483
484 dpcm->bytes_per_sec = bytes_per_sec;
485 dpcm->buffer_bytes = params_buffer_bytes(params);
486 dpcm->period_bytes = params_period_bytes(params);
487
488 return 0;
489 }
490
491 static int
492 snd_card_asihpi_hw_free(struct snd_pcm_substream *substream)
493 {
494 struct snd_pcm_runtime *runtime = substream->runtime;
495 struct snd_card_asihpi_pcm *dpcm = runtime->private_data;
496 if (dpcm->hpi_buffer_attached)
497 hpi_stream_host_buffer_detach(dpcm->h_stream);
498
499 return 0;
500 }
501
502 static void snd_card_asihpi_runtime_free(struct snd_pcm_runtime *runtime)
503 {
504 struct snd_card_asihpi_pcm *dpcm = runtime->private_data;
505 kfree(dpcm);
506 }
507
508 static void snd_card_asihpi_pcm_timer_start(struct snd_pcm_substream *
509 substream)
510 {
511 struct snd_pcm_runtime *runtime = substream->runtime;
512 struct snd_card_asihpi_pcm *dpcm = runtime->private_data;
513 int expiry;
514
515 expiry = HZ / 200;
516
517 expiry = max(expiry, 1); /* don't let it be zero! */
518 mod_timer(&dpcm->timer, jiffies + expiry);
519 dpcm->respawn_timer = 1;
520 }
521
522 static void snd_card_asihpi_pcm_timer_stop(struct snd_pcm_substream *substream)
523 {
524 struct snd_pcm_runtime *runtime = substream->runtime;
525 struct snd_card_asihpi_pcm *dpcm = runtime->private_data;
526
527 dpcm->respawn_timer = 0;
528 del_timer(&dpcm->timer);
529 }
530
531 static void snd_card_asihpi_pcm_int_start(struct snd_pcm_substream *substream)
532 {
533 struct snd_card_asihpi_pcm *dpcm;
534 struct snd_card_asihpi *card;
535
536 dpcm = (struct snd_card_asihpi_pcm *)substream->runtime->private_data;
537 card = snd_pcm_substream_chip(substream);
538
539 WARN_ON(in_interrupt());
540 card->llmode_streampriv = dpcm;
541
542 hpi_handle_error(hpi_adapter_set_property(card->hpi->adapter->index,
543 HPI_ADAPTER_PROPERTY_IRQ_RATE,
544 card->update_interval_frames, 0));
545 }
546
547 static void snd_card_asihpi_pcm_int_stop(struct snd_pcm_substream *substream)
548 {
549 struct snd_card_asihpi *card;
550
551 card = snd_pcm_substream_chip(substream);
552
553 hpi_handle_error(hpi_adapter_set_property(card->hpi->adapter->index,
554 HPI_ADAPTER_PROPERTY_IRQ_RATE, 0, 0));
555
556 card->llmode_streampriv = NULL;
557 }
558
559 static int snd_card_asihpi_trigger(struct snd_pcm_substream *substream,
560 int cmd)
561 {
562 struct snd_card_asihpi_pcm *dpcm = substream->runtime->private_data;
563 struct snd_card_asihpi *card = snd_pcm_substream_chip(substream);
564 struct snd_pcm_substream *s;
565 u16 e;
566 char name[16];
567
568 snd_pcm_debug_name(substream, name, sizeof(name));
569
570 switch (cmd) {
571 case SNDRV_PCM_TRIGGER_START:
572 snd_printdd("%s trigger start\n", name);
573 snd_pcm_group_for_each_entry(s, substream) {
574 struct snd_pcm_runtime *runtime = s->runtime;
575 struct snd_card_asihpi_pcm *ds = runtime->private_data;
576
577 if (snd_pcm_substream_chip(s) != card)
578 continue;
579
580 /* don't link Cap and Play */
581 if (substream->stream != s->stream)
582 continue;
583
584 ds->drained_count = 0;
585 if (s->stream == SNDRV_PCM_STREAM_PLAYBACK) {
586 /* How do I know how much valid data is present
587 * in buffer? Must be at least one period!
588 * Guessing 2 periods, but if
589 * buffer is bigger it may contain even more
590 * data??
591 */
592 unsigned int preload = ds->period_bytes * 1;
593 snd_printddd("%d preload %d\n", s->number, preload);
594 hpi_handle_error(hpi_outstream_write_buf(
595 ds->h_stream,
596 &runtime->dma_area[0],
597 preload,
598 &ds->format));
599 ds->pcm_buf_host_rw_ofs = preload;
600 }
601
602 if (card->support_grouping) {
603 snd_printdd("%d group\n", s->number);
604 e = hpi_stream_group_add(
605 dpcm->h_stream,
606 ds->h_stream);
607 if (!e) {
608 snd_pcm_trigger_done(s, substream);
609 } else {
610 hpi_handle_error(e);
611 break;
612 }
613 } else
614 break;
615 }
616 /* start the master stream */
617 card->pcm_start(substream);
618 if ((substream->stream == SNDRV_PCM_STREAM_CAPTURE) ||
619 !card->can_dma)
620 hpi_handle_error(hpi_stream_start(dpcm->h_stream));
621 break;
622
623 case SNDRV_PCM_TRIGGER_STOP:
624 snd_printdd("%s trigger stop\n", name);
625 card->pcm_stop(substream);
626 snd_pcm_group_for_each_entry(s, substream) {
627 if (snd_pcm_substream_chip(s) != card)
628 continue;
629 /* don't link Cap and Play */
630 if (substream->stream != s->stream)
631 continue;
632
633 /*? workaround linked streams don't
634 transition to SETUP 20070706*/
635 __snd_pcm_set_state(s->runtime, SNDRV_PCM_STATE_SETUP);
636
637 if (card->support_grouping) {
638 snd_printdd("%d group\n", s->number);
639 snd_pcm_trigger_done(s, substream);
640 } else
641 break;
642 }
643
644 /* _prepare and _hwparams reset the stream */
645 hpi_handle_error(hpi_stream_stop(dpcm->h_stream));
646 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
647 hpi_handle_error(
648 hpi_outstream_reset(dpcm->h_stream));
649
650 if (card->support_grouping)
651 hpi_handle_error(hpi_stream_group_reset(dpcm->h_stream));
652 break;
653
654 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
655 snd_printdd("%s trigger pause release\n", name);
656 card->pcm_start(substream);
657 hpi_handle_error(hpi_stream_start(dpcm->h_stream));
658 break;
659 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
660 snd_printdd("%s trigger pause push\n", name);
661 card->pcm_stop(substream);
662 hpi_handle_error(hpi_stream_stop(dpcm->h_stream));
663 break;
664 default:
665 snd_printd(KERN_ERR "\tINVALID\n");
666 return -EINVAL;
667 }
668
669 return 0;
670 }
671
672 /*algorithm outline
673 Without linking degenerates to getting single stream pos etc
674 Without mmap 2nd loop degenerates to snd_pcm_period_elapsed
675 */
676 /*
677 pcm_buf_dma_ofs=get_buf_pos(s);
678 for_each_linked_stream(s) {
679 pcm_buf_dma_ofs=get_buf_pos(s);
680 min_buf_pos = modulo_min(min_buf_pos, pcm_buf_dma_ofs, buffer_bytes)
681 new_data = min(new_data, calc_new_data(pcm_buf_dma_ofs,irq_pos)
682 }
683 timer.expires = jiffies + predict_next_period_ready(min_buf_pos);
684 for_each_linked_stream(s) {
685 s->pcm_buf_dma_ofs = min_buf_pos;
686 if (new_data > period_bytes) {
687 if (mmap) {
688 irq_pos = (irq_pos + period_bytes) % buffer_bytes;
689 if (playback) {
690 write(period_bytes);
691 } else {
692 read(period_bytes);
693 }
694 }
695 snd_pcm_period_elapsed(s);
696 }
697 }
698 */
699
700 /** Minimum of 2 modulo values. Works correctly when the difference between
701 * the values is less than half the modulus
702 */
703 static inline unsigned int modulo_min(unsigned int a, unsigned int b,
704 unsigned long int modulus)
705 {
706 unsigned int result;
707 if (((a-b) % modulus) < (modulus/2))
708 result = b;
709 else
710 result = a;
711
712 return result;
713 }
714
715 /** Timer function, equivalent to interrupt service routine for cards
716 */
717 static void snd_card_asihpi_timer_function(struct timer_list *t)
718 {
719 struct snd_card_asihpi_pcm *dpcm = from_timer(dpcm, t, timer);
720 struct snd_pcm_substream *substream = dpcm->substream;
721 struct snd_card_asihpi *card = snd_pcm_substream_chip(substream);
722 struct snd_pcm_runtime *runtime;
723 struct snd_pcm_substream *s;
724 unsigned int newdata = 0;
725 unsigned int pcm_buf_dma_ofs, min_buf_pos = 0;
726 unsigned int remdata, xfercount, next_jiffies;
727 int first = 1;
728 u16 state;
729 u32 buffer_size, bytes_avail, samples_played, on_card_bytes;
730 char name[16];
731
732
733 snd_pcm_debug_name(substream, name, sizeof(name));
734
735 /* find minimum newdata and buffer pos in group */
736 snd_pcm_group_for_each_entry(s, substream) {
737 struct snd_card_asihpi_pcm *ds = s->runtime->private_data;
738 runtime = s->runtime;
739
740 if (snd_pcm_substream_chip(s) != card)
741 continue;
742
743 /* don't link Cap and Play */
744 if (substream->stream != s->stream)
745 continue;
746
747 hpi_handle_error(hpi_stream_get_info_ex(
748 ds->h_stream, &state,
749 &buffer_size, &bytes_avail,
750 &samples_played, &on_card_bytes));
751
752 /* number of bytes in on-card buffer */
753 runtime->delay = on_card_bytes;
754
755 if (!card->can_dma)
756 on_card_bytes = bytes_avail;
757
758 if (s->stream == SNDRV_PCM_STREAM_PLAYBACK) {
759 pcm_buf_dma_ofs = ds->pcm_buf_host_rw_ofs - bytes_avail;
760 if (state == HPI_STATE_STOPPED) {
761 if (bytes_avail == 0) {
762 hpi_handle_error(hpi_stream_start(ds->h_stream));
763 snd_printdd("P%d start\n", s->number);
764 ds->drained_count = 0;
765 }
766 } else if (state == HPI_STATE_DRAINED) {
767 snd_printd(KERN_WARNING "P%d drained\n",
768 s->number);
769 ds->drained_count++;
770 if (ds->drained_count > 20) {
771 snd_pcm_stop_xrun(s);
772 continue;
773 }
774 } else {
775 ds->drained_count = 0;
776 }
777 } else
778 pcm_buf_dma_ofs = bytes_avail + ds->pcm_buf_host_rw_ofs;
779
780 if (first) {
781 /* can't statically init min when wrap is involved */
782 min_buf_pos = pcm_buf_dma_ofs;
783 newdata = (pcm_buf_dma_ofs - ds->pcm_buf_elapsed_dma_ofs) % ds->buffer_bytes;
784 first = 0;
785 } else {
786 min_buf_pos =
787 modulo_min(min_buf_pos, pcm_buf_dma_ofs, UINT_MAX+1L);
788 newdata = min(
789 (pcm_buf_dma_ofs - ds->pcm_buf_elapsed_dma_ofs) % ds->buffer_bytes,
790 newdata);
791 }
792
793 snd_printddd(
794 "timer1, %s, %d, S=%d, elap=%d, rw=%d, dsp=%d, left=%d, aux=%d, space=%d, hw_ptr=%ld, appl_ptr=%ld\n",
795 name, s->number, state,
796 ds->pcm_buf_elapsed_dma_ofs,
797 ds->pcm_buf_host_rw_ofs,
798 pcm_buf_dma_ofs,
799 (int)bytes_avail,
800
801 (int)on_card_bytes,
802 buffer_size-bytes_avail,
803 (unsigned long)frames_to_bytes(runtime,
804 runtime->status->hw_ptr),
805 (unsigned long)frames_to_bytes(runtime,
806 runtime->control->appl_ptr)
807 );
808 }
809 pcm_buf_dma_ofs = min_buf_pos;
810
811 remdata = newdata % dpcm->period_bytes;
812 xfercount = newdata - remdata; /* a multiple of period_bytes */
813 /* come back when on_card_bytes has decreased enough to allow
814 write to happen, or when data has been consumed to make another
815 period
816 */
817 if (xfercount && (on_card_bytes > dpcm->period_bytes))
818 next_jiffies = ((on_card_bytes - dpcm->period_bytes) * HZ / dpcm->bytes_per_sec);
819 else
820 next_jiffies = ((dpcm->period_bytes - remdata) * HZ / dpcm->bytes_per_sec);
821
822 next_jiffies = max(next_jiffies, 1U);
823 dpcm->timer.expires = jiffies + next_jiffies;
824 snd_printddd("timer2, jif=%d, buf_pos=%d, newdata=%d, xfer=%d\n",
825 next_jiffies, pcm_buf_dma_ofs, newdata, xfercount);
826
827 snd_pcm_group_for_each_entry(s, substream) {
828 struct snd_card_asihpi_pcm *ds = s->runtime->private_data;
829
830 /* don't link Cap and Play */
831 if (substream->stream != s->stream)
832 continue;
833
834 /* Store dma offset for use by pointer callback */
835 ds->pcm_buf_dma_ofs = pcm_buf_dma_ofs;
836
837 if (xfercount &&
838 /* Limit use of on card fifo for playback */
839 ((on_card_bytes <= ds->period_bytes) ||
840 (s->stream == SNDRV_PCM_STREAM_CAPTURE)))
841
842 {
843
844 unsigned int buf_ofs = ds->pcm_buf_host_rw_ofs % ds->buffer_bytes;
845 unsigned int xfer1, xfer2;
846 char *pd = &s->runtime->dma_area[buf_ofs];
847
848 if (card->can_dma) { /* buffer wrap is handled at lower level */
849 xfer1 = xfercount;
850 xfer2 = 0;
851 } else {
852 xfer1 = min(xfercount, ds->buffer_bytes - buf_ofs);
853 xfer2 = xfercount - xfer1;
854 }
855
856 if (s->stream == SNDRV_PCM_STREAM_PLAYBACK) {
857 snd_printddd("write1, P=%d, xfer=%d, buf_ofs=%d\n",
858 s->number, xfer1, buf_ofs);
859 hpi_handle_error(
860 hpi_outstream_write_buf(
861 ds->h_stream, pd, xfer1,
862 &ds->format));
863
864 if (xfer2) {
865 pd = s->runtime->dma_area;
866
867 snd_printddd("write2, P=%d, xfer=%d, buf_ofs=%d\n",
868 s->number,
869 xfercount - xfer1, buf_ofs);
870 hpi_handle_error(
871 hpi_outstream_write_buf(
872 ds->h_stream, pd,
873 xfercount - xfer1,
874 &ds->format));
875 }
876 } else {
877 snd_printddd("read1, C=%d, xfer=%d\n",
878 s->number, xfer1);
879 hpi_handle_error(
880 hpi_instream_read_buf(
881 ds->h_stream,
882 pd, xfer1));
883 if (xfer2) {
884 pd = s->runtime->dma_area;
885 snd_printddd("read2, C=%d, xfer=%d\n",
886 s->number, xfer2);
887 hpi_handle_error(
888 hpi_instream_read_buf(
889 ds->h_stream,
890 pd, xfer2));
891 }
892 }
893 /* ? host_rw_ofs always ahead of elapsed_dma_ofs by preload size? */
894 ds->pcm_buf_host_rw_ofs += xfercount;
895 ds->pcm_buf_elapsed_dma_ofs += xfercount;
896 snd_pcm_period_elapsed(s);
897 }
898 }
899
900 if (!card->hpi->interrupt_mode && dpcm->respawn_timer)
901 add_timer(&dpcm->timer);
902 }
903
904 static void snd_card_asihpi_isr(struct hpi_adapter *a)
905 {
906 struct snd_card_asihpi *asihpi;
907
908 WARN_ON(!a || !a->snd_card || !a->snd_card->private_data);
909 asihpi = (struct snd_card_asihpi *)a->snd_card->private_data;
910 if (asihpi->llmode_streampriv)
911 snd_card_asihpi_timer_function(
912 &asihpi->llmode_streampriv->timer);
913 }
914
915 /***************************** PLAYBACK OPS ****************/
916 static int snd_card_asihpi_playback_prepare(struct snd_pcm_substream *
917 substream)
918 {
919 struct snd_pcm_runtime *runtime = substream->runtime;
920 struct snd_card_asihpi_pcm *dpcm = runtime->private_data;
921
922 snd_printdd("P%d prepare\n", substream->number);
923
924 hpi_handle_error(hpi_outstream_reset(dpcm->h_stream));
925 dpcm->pcm_buf_host_rw_ofs = 0;
926 dpcm->pcm_buf_dma_ofs = 0;
927 dpcm->pcm_buf_elapsed_dma_ofs = 0;
928 return 0;
929 }
930
931 static snd_pcm_uframes_t
932 snd_card_asihpi_playback_pointer(struct snd_pcm_substream *substream)
933 {
934 struct snd_pcm_runtime *runtime = substream->runtime;
935 struct snd_card_asihpi_pcm *dpcm = runtime->private_data;
936 snd_pcm_uframes_t ptr;
937 char name[16];
938 snd_pcm_debug_name(substream, name, sizeof(name));
939
940 ptr = bytes_to_frames(runtime, dpcm->pcm_buf_dma_ofs % dpcm->buffer_bytes);
941 snd_printddd("%s, pointer=%ld\n", name, (unsigned long)ptr);
942 return ptr;
943 }
944
945 static u64 snd_card_asihpi_playback_formats(struct snd_card_asihpi *asihpi,
946 u32 h_stream)
947 {
948 struct hpi_format hpi_format;
949 u16 format;
950 u16 err;
951 u32 h_control;
952 u32 sample_rate = 48000;
953 u64 formats = 0;
954
955 /* on cards without SRC, must query at valid rate,
956 * maybe set by external sync
957 */
958 err = hpi_mixer_get_control(asihpi->h_mixer,
959 HPI_SOURCENODE_CLOCK_SOURCE, 0, 0, 0,
960 HPI_CONTROL_SAMPLECLOCK, &h_control);
961
962 if (!err)
963 err = hpi_sample_clock_get_sample_rate(h_control,
964 &sample_rate);
965
966 for (format = HPI_FORMAT_PCM8_UNSIGNED;
967 format <= HPI_FORMAT_PCM24_SIGNED; format++) {
968 err = hpi_format_create(&hpi_format, asihpi->out_max_chans,
969 format, sample_rate, 128000, 0);
970 if (!err)
971 err = hpi_outstream_query_format(h_stream, &hpi_format);
972 if (!err && (hpi_to_alsa_formats[format] != INVALID_FORMAT))
973 formats |= pcm_format_to_bits(hpi_to_alsa_formats[format]);
974 }
975 return formats;
976 }
977
978 static int snd_card_asihpi_playback_open(struct snd_pcm_substream *substream)
979 {
980 struct snd_pcm_runtime *runtime = substream->runtime;
981 struct snd_card_asihpi_pcm *dpcm;
982 struct snd_card_asihpi *card = snd_pcm_substream_chip(substream);
983 struct snd_pcm_hardware snd_card_asihpi_playback;
984 int err;
985
986 dpcm = kzalloc(sizeof(*dpcm), GFP_KERNEL);
987 if (dpcm == NULL)
988 return -ENOMEM;
989
990 err = hpi_outstream_open(card->hpi->adapter->index,
991 substream->number, &dpcm->h_stream);
992 hpi_handle_error(err);
993 if (err)
994 kfree(dpcm);
995 if (err == HPI_ERROR_OBJ_ALREADY_OPEN)
996 return -EBUSY;
997 if (err)
998 return -EIO;
999
1000 /*? also check ASI5000 samplerate source
1001 If external, only support external rate.
1002 If internal and other stream playing, can't switch
1003 */
1004
1005 timer_setup(&dpcm->timer, snd_card_asihpi_timer_function, 0);
1006 dpcm->substream = substream;
1007 runtime->private_data = dpcm;
1008 runtime->private_free = snd_card_asihpi_runtime_free;
1009
1010 memset(&snd_card_asihpi_playback, 0, sizeof(snd_card_asihpi_playback));
1011 if (!card->hpi->interrupt_mode) {
1012 snd_card_asihpi_playback.buffer_bytes_max = BUFFER_BYTES_MAX;
1013 snd_card_asihpi_playback.period_bytes_min = PERIOD_BYTES_MIN;
1014 snd_card_asihpi_playback.period_bytes_max = BUFFER_BYTES_MAX / PERIODS_MIN;
1015 snd_card_asihpi_playback.periods_min = PERIODS_MIN;
1016 snd_card_asihpi_playback.periods_max = BUFFER_BYTES_MAX / PERIOD_BYTES_MIN;
1017 } else {
1018 size_t pbmin = card->update_interval_frames *
1019 card->out_max_chans;
1020 snd_card_asihpi_playback.buffer_bytes_max = BUFFER_BYTES_MAX;
1021 snd_card_asihpi_playback.period_bytes_min = pbmin;
1022 snd_card_asihpi_playback.period_bytes_max = BUFFER_BYTES_MAX / PERIODS_MIN;
1023 snd_card_asihpi_playback.periods_min = PERIODS_MIN;
1024 snd_card_asihpi_playback.periods_max = BUFFER_BYTES_MAX / pbmin;
1025 }
1026
1027 /* snd_card_asihpi_playback.fifo_size = 0; */
1028 snd_card_asihpi_playback.channels_max = card->out_max_chans;
1029 snd_card_asihpi_playback.channels_min = card->out_min_chans;
1030 snd_card_asihpi_playback.formats =
1031 snd_card_asihpi_playback_formats(card, dpcm->h_stream);
1032
1033 snd_card_asihpi_pcm_samplerates(card, &snd_card_asihpi_playback);
1034
1035 snd_card_asihpi_playback.info = SNDRV_PCM_INFO_INTERLEAVED |
1036 SNDRV_PCM_INFO_DOUBLE |
1037 SNDRV_PCM_INFO_BATCH |
1038 SNDRV_PCM_INFO_BLOCK_TRANSFER |
1039 SNDRV_PCM_INFO_PAUSE |
1040 SNDRV_PCM_INFO_MMAP |
1041 SNDRV_PCM_INFO_MMAP_VALID;
1042
1043 if (card->support_grouping) {
1044 snd_card_asihpi_playback.info |= SNDRV_PCM_INFO_SYNC_START;
1045 snd_pcm_set_sync(substream);
1046 }
1047
1048 /* struct is copied, so can create initializer dynamically */
1049 runtime->hw = snd_card_asihpi_playback;
1050
1051 if (card->can_dma)
1052 err = snd_pcm_hw_constraint_pow2(runtime, 0,
1053 SNDRV_PCM_HW_PARAM_BUFFER_BYTES);
1054 if (err < 0)
1055 return err;
1056
1057 snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
1058 card->update_interval_frames);
1059
1060 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
1061 card->update_interval_frames, UINT_MAX);
1062
1063 snd_printdd("playback open\n");
1064
1065 return 0;
1066 }
1067
1068 static int snd_card_asihpi_playback_close(struct snd_pcm_substream *substream)
1069 {
1070 struct snd_pcm_runtime *runtime = substream->runtime;
1071 struct snd_card_asihpi_pcm *dpcm = runtime->private_data;
1072
1073 hpi_handle_error(hpi_outstream_close(dpcm->h_stream));
1074 snd_printdd("playback close\n");
1075
1076 return 0;
1077 }
1078
1079 static const struct snd_pcm_ops snd_card_asihpi_playback_mmap_ops = {
1080 .open = snd_card_asihpi_playback_open,
1081 .close = snd_card_asihpi_playback_close,
1082 .hw_params = snd_card_asihpi_pcm_hw_params,
1083 .hw_free = snd_card_asihpi_hw_free,
1084 .prepare = snd_card_asihpi_playback_prepare,
1085 .trigger = snd_card_asihpi_trigger,
1086 .pointer = snd_card_asihpi_playback_pointer,
1087 };
1088
1089 /***************************** CAPTURE OPS ****************/
1090 static snd_pcm_uframes_t
1091 snd_card_asihpi_capture_pointer(struct snd_pcm_substream *substream)
1092 {
1093 struct snd_pcm_runtime *runtime = substream->runtime;
1094 struct snd_card_asihpi_pcm *dpcm = runtime->private_data;
1095 char name[16];
1096 snd_pcm_debug_name(substream, name, sizeof(name));
1097
1098 snd_printddd("%s, pointer=%d\n", name, dpcm->pcm_buf_dma_ofs);
1099 /* NOTE Unlike playback can't use actual samples_played
1100 for the capture position, because those samples aren't yet in
1101 the local buffer available for reading.
1102 */
1103 return bytes_to_frames(runtime, dpcm->pcm_buf_dma_ofs % dpcm->buffer_bytes);
1104 }
1105
1106 static int snd_card_asihpi_capture_prepare(struct snd_pcm_substream *substream)
1107 {
1108 struct snd_pcm_runtime *runtime = substream->runtime;
1109 struct snd_card_asihpi_pcm *dpcm = runtime->private_data;
1110
1111 hpi_handle_error(hpi_instream_reset(dpcm->h_stream));
1112 dpcm->pcm_buf_host_rw_ofs = 0;
1113 dpcm->pcm_buf_dma_ofs = 0;
1114 dpcm->pcm_buf_elapsed_dma_ofs = 0;
1115
1116 snd_printdd("Capture Prepare %d\n", substream->number);
1117 return 0;
1118 }
1119
1120 static u64 snd_card_asihpi_capture_formats(struct snd_card_asihpi *asihpi,
1121 u32 h_stream)
1122 {
1123 struct hpi_format hpi_format;
1124 u16 format;
1125 u16 err;
1126 u32 h_control;
1127 u32 sample_rate = 48000;
1128 u64 formats = 0;
1129
1130 /* on cards without SRC, must query at valid rate,
1131 maybe set by external sync */
1132 err = hpi_mixer_get_control(asihpi->h_mixer,
1133 HPI_SOURCENODE_CLOCK_SOURCE, 0, 0, 0,
1134 HPI_CONTROL_SAMPLECLOCK, &h_control);
1135
1136 if (!err)
1137 err = hpi_sample_clock_get_sample_rate(h_control,
1138 &sample_rate);
1139
1140 for (format = HPI_FORMAT_PCM8_UNSIGNED;
1141 format <= HPI_FORMAT_PCM24_SIGNED; format++) {
1142
1143 err = hpi_format_create(&hpi_format, asihpi->in_max_chans,
1144 format, sample_rate, 128000, 0);
1145 if (!err)
1146 err = hpi_instream_query_format(h_stream, &hpi_format);
1147 if (!err && (hpi_to_alsa_formats[format] != INVALID_FORMAT))
1148 formats |= pcm_format_to_bits(hpi_to_alsa_formats[format]);
1149 }
1150 return formats;
1151 }
1152
1153 static int snd_card_asihpi_capture_open(struct snd_pcm_substream *substream)
1154 {
1155 struct snd_pcm_runtime *runtime = substream->runtime;
1156 struct snd_card_asihpi *card = snd_pcm_substream_chip(substream);
1157 struct snd_card_asihpi_pcm *dpcm;
1158 struct snd_pcm_hardware snd_card_asihpi_capture;
1159 int err;
1160
1161 dpcm = kzalloc(sizeof(*dpcm), GFP_KERNEL);
1162 if (dpcm == NULL)
1163 return -ENOMEM;
1164
1165 snd_printdd("capture open adapter %d stream %d\n",
1166 card->hpi->adapter->index, substream->number);
1167
1168 err = hpi_handle_error(
1169 hpi_instream_open(card->hpi->adapter->index,
1170 substream->number, &dpcm->h_stream));
1171 if (err)
1172 kfree(dpcm);
1173 if (err == HPI_ERROR_OBJ_ALREADY_OPEN)
1174 return -EBUSY;
1175 if (err)
1176 return -EIO;
1177
1178 timer_setup(&dpcm->timer, snd_card_asihpi_timer_function, 0);
1179 dpcm->substream = substream;
1180 runtime->private_data = dpcm;
1181 runtime->private_free = snd_card_asihpi_runtime_free;
1182
1183 memset(&snd_card_asihpi_capture, 0, sizeof(snd_card_asihpi_capture));
1184 if (!card->hpi->interrupt_mode) {
1185 snd_card_asihpi_capture.buffer_bytes_max = BUFFER_BYTES_MAX;
1186 snd_card_asihpi_capture.period_bytes_min = PERIOD_BYTES_MIN;
1187 snd_card_asihpi_capture.period_bytes_max = BUFFER_BYTES_MAX / PERIODS_MIN;
1188 snd_card_asihpi_capture.periods_min = PERIODS_MIN;
1189 snd_card_asihpi_capture.periods_max = BUFFER_BYTES_MAX / PERIOD_BYTES_MIN;
1190 } else {
1191 size_t pbmin = card->update_interval_frames *
1192 card->out_max_chans;
1193 snd_card_asihpi_capture.buffer_bytes_max = BUFFER_BYTES_MAX;
1194 snd_card_asihpi_capture.period_bytes_min = pbmin;
1195 snd_card_asihpi_capture.period_bytes_max = BUFFER_BYTES_MAX / PERIODS_MIN;
1196 snd_card_asihpi_capture.periods_min = PERIODS_MIN;
1197 snd_card_asihpi_capture.periods_max = BUFFER_BYTES_MAX / pbmin;
1198 }
1199 /* snd_card_asihpi_capture.fifo_size = 0; */
1200 snd_card_asihpi_capture.channels_max = card->in_max_chans;
1201 snd_card_asihpi_capture.channels_min = card->in_min_chans;
1202 snd_card_asihpi_capture.formats =
1203 snd_card_asihpi_capture_formats(card, dpcm->h_stream);
1204 snd_card_asihpi_pcm_samplerates(card, &snd_card_asihpi_capture);
1205 snd_card_asihpi_capture.info = SNDRV_PCM_INFO_INTERLEAVED |
1206 SNDRV_PCM_INFO_MMAP |
1207 SNDRV_PCM_INFO_MMAP_VALID;
1208
1209 if (card->support_grouping)
1210 snd_card_asihpi_capture.info |= SNDRV_PCM_INFO_SYNC_START;
1211
1212 runtime->hw = snd_card_asihpi_capture;
1213
1214 if (card->can_dma)
1215 err = snd_pcm_hw_constraint_pow2(runtime, 0,
1216 SNDRV_PCM_HW_PARAM_BUFFER_BYTES);
1217 if (err < 0)
1218 return err;
1219
1220 snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
1221 card->update_interval_frames);
1222 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
1223 card->update_interval_frames, UINT_MAX);
1224
1225 snd_pcm_set_sync(substream);
1226
1227 return 0;
1228 }
1229
1230 static int snd_card_asihpi_capture_close(struct snd_pcm_substream *substream)
1231 {
1232 struct snd_card_asihpi_pcm *dpcm = substream->runtime->private_data;
1233
1234 hpi_handle_error(hpi_instream_close(dpcm->h_stream));
1235 return 0;
1236 }
1237
1238 static const struct snd_pcm_ops snd_card_asihpi_capture_mmap_ops = {
1239 .open = snd_card_asihpi_capture_open,
1240 .close = snd_card_asihpi_capture_close,
1241 .hw_params = snd_card_asihpi_pcm_hw_params,
1242 .hw_free = snd_card_asihpi_hw_free,
1243 .prepare = snd_card_asihpi_capture_prepare,
1244 .trigger = snd_card_asihpi_trigger,
1245 .pointer = snd_card_asihpi_capture_pointer,
1246 };
1247
1248 static int snd_card_asihpi_pcm_new(struct snd_card_asihpi *asihpi, int device)
1249 {
1250 struct snd_pcm *pcm;
1251 int err;
1252 u16 num_instreams, num_outstreams, x16;
1253 u32 x32;
1254
1255 err = hpi_adapter_get_info(asihpi->hpi->adapter->index,
1256 &num_outstreams, &num_instreams,
1257 &x16, &x32, &x16);
1258
1259 err = snd_pcm_new(asihpi->card, "Asihpi PCM", device,
1260 num_outstreams, num_instreams, &pcm);
1261 if (err < 0)
1262 return err;
1263
1264 /* pointer to ops struct is stored, dont change ops afterwards! */
1265 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
1266 &snd_card_asihpi_playback_mmap_ops);
1267 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
1268 &snd_card_asihpi_capture_mmap_ops);
1269
1270 pcm->private_data = asihpi;
1271 pcm->info_flags = 0;
1272 strcpy(pcm->name, "Asihpi PCM");
1273
1274 /*? do we want to emulate MMAP for non-BBM cards?
1275 Jack doesn't work with ALSAs MMAP emulation - WHY NOT? */
1276 snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV,
1277 &asihpi->pci->dev,
1278 64*1024, BUFFER_BYTES_MAX);
1279
1280 return 0;
1281 }
1282
1283 /***************************** MIXER CONTROLS ****************/
1284 struct hpi_control {
1285 u32 h_control;
1286 u16 control_type;
1287 u16 src_node_type;
1288 u16 src_node_index;
1289 u16 dst_node_type;
1290 u16 dst_node_index;
1291 u16 band;
1292 char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; /* copied to snd_ctl_elem_id.name[44]; */
1293 };
1294
1295 static const char * const asihpi_tuner_band_names[] = {
1296 "invalid",
1297 "AM",
1298 "FM mono",
1299 "TV NTSC-M",
1300 "FM stereo",
1301 "AUX",
1302 "TV PAL BG",
1303 "TV PAL I",
1304 "TV PAL DK",
1305 "TV SECAM",
1306 "TV DAB",
1307 };
1308 /* Number of strings must match the enumerations for HPI_TUNER_BAND in hpi.h */
1309 compile_time_assert(
1310 (ARRAY_SIZE(asihpi_tuner_band_names) ==
1311 (HPI_TUNER_BAND_LAST+1)),
1312 assert_tuner_band_names_size);
1313
1314 static const char * const asihpi_src_names[] = {
1315 "no source",
1316 "PCM",
1317 "Line",
1318 "Digital",
1319 "Tuner",
1320 "RF",
1321 "Clock",
1322 "Bitstream",
1323 "Mic",
1324 "Net",
1325 "Analog",
1326 "Adapter",
1327 "RTP",
1328 "Internal",
1329 "AVB",
1330 "BLU-Link"
1331 };
1332 /* Number of strings must match the enumerations for HPI_SOURCENODES in hpi.h */
1333 compile_time_assert(
1334 (ARRAY_SIZE(asihpi_src_names) ==
1335 (HPI_SOURCENODE_LAST_INDEX-HPI_SOURCENODE_NONE+1)),
1336 assert_src_names_size);
1337
1338 static const char * const asihpi_dst_names[] = {
1339 "no destination",
1340 "PCM",
1341 "Line",
1342 "Digital",
1343 "RF",
1344 "Speaker",
1345 "Net",
1346 "Analog",
1347 "RTP",
1348 "AVB",
1349 "Internal",
1350 "BLU-Link"
1351 };
1352 /* Number of strings must match the enumerations for HPI_DESTNODES in hpi.h */
1353 compile_time_assert(
1354 (ARRAY_SIZE(asihpi_dst_names) ==
1355 (HPI_DESTNODE_LAST_INDEX-HPI_DESTNODE_NONE+1)),
1356 assert_dst_names_size);
1357
1358 static inline int ctl_add(struct snd_card *card, struct snd_kcontrol_new *ctl,
1359 struct snd_card_asihpi *asihpi)
1360 {
1361 int err;
1362
1363 err = snd_ctl_add(card, snd_ctl_new1(ctl, asihpi));
1364 if (err < 0)
1365 return err;
1366 else if (mixer_dump)
1367 dev_info(&asihpi->pci->dev, "added %s(%d)\n", ctl->name, ctl->index);
1368
1369 return 0;
1370 }
1371
1372 /* Convert HPI control name and location into ALSA control name */
1373 static void asihpi_ctl_init(struct snd_kcontrol_new *snd_control,
1374 struct hpi_control *hpi_ctl,
1375 char *name)
1376 {
1377 char *dir;
1378 memset(snd_control, 0, sizeof(*snd_control));
1379 snd_control->name = hpi_ctl->name;
1380 snd_control->private_value = hpi_ctl->h_control;
1381 snd_control->iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1382 snd_control->index = 0;
1383
1384 if (hpi_ctl->src_node_type + HPI_SOURCENODE_NONE == HPI_SOURCENODE_CLOCK_SOURCE)
1385 dir = ""; /* clock is neither capture nor playback */
1386 else if (hpi_ctl->dst_node_type + HPI_DESTNODE_NONE == HPI_DESTNODE_ISTREAM)
1387 dir = "Capture "; /* On or towards a PCM capture destination*/
1388 else if ((hpi_ctl->src_node_type + HPI_SOURCENODE_NONE != HPI_SOURCENODE_OSTREAM) &&
1389 (!hpi_ctl->dst_node_type))
1390 dir = "Capture "; /* On a source node that is not PCM playback */
1391 else if (hpi_ctl->src_node_type &&
1392 (hpi_ctl->src_node_type + HPI_SOURCENODE_NONE != HPI_SOURCENODE_OSTREAM) &&
1393 (hpi_ctl->dst_node_type))
1394 dir = "Monitor Playback "; /* Between an input and an output */
1395 else
1396 dir = "Playback "; /* PCM Playback source, or output node */
1397
1398 if (hpi_ctl->src_node_type && hpi_ctl->dst_node_type)
1399 sprintf(hpi_ctl->name, "%s %d %s %d %s%s",
1400 asihpi_src_names[hpi_ctl->src_node_type],
1401 hpi_ctl->src_node_index,
1402 asihpi_dst_names[hpi_ctl->dst_node_type],
1403 hpi_ctl->dst_node_index,
1404 dir, name);
1405 else if (hpi_ctl->dst_node_type) {
1406 sprintf(hpi_ctl->name, "%s %d %s%s",
1407 asihpi_dst_names[hpi_ctl->dst_node_type],
1408 hpi_ctl->dst_node_index,
1409 dir, name);
1410 } else {
1411 sprintf(hpi_ctl->name, "%s %d %s%s",
1412 asihpi_src_names[hpi_ctl->src_node_type],
1413 hpi_ctl->src_node_index,
1414 dir, name);
1415 }
1416 /* printk(KERN_INFO "Adding %s %d to %d ", hpi_ctl->name,
1417 hpi_ctl->wSrcNodeType, hpi_ctl->wDstNodeType); */
1418 }
1419
1420 /*------------------------------------------------------------
1421 Volume controls
1422 ------------------------------------------------------------*/
1423 #define VOL_STEP_mB 1
1424 static int snd_asihpi_volume_info(struct snd_kcontrol *kcontrol,
1425 struct snd_ctl_elem_info *uinfo)
1426 {
1427 u32 h_control = kcontrol->private_value;
1428 u32 count;
1429 u16 err;
1430 /* native gains are in millibels */
1431 short min_gain_mB;
1432 short max_gain_mB;
1433 short step_gain_mB;
1434
1435 err = hpi_volume_query_range(h_control,
1436 &min_gain_mB, &max_gain_mB, &step_gain_mB);
1437 if (err) {
1438 max_gain_mB = 0;
1439 min_gain_mB = -10000;
1440 step_gain_mB = VOL_STEP_mB;
1441 }
1442
1443 err = hpi_meter_query_channels(h_control, &count);
1444 if (err)
1445 count = HPI_MAX_CHANNELS;
1446
1447 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1448 uinfo->count = count;
1449 uinfo->value.integer.min = min_gain_mB / VOL_STEP_mB;
1450 uinfo->value.integer.max = max_gain_mB / VOL_STEP_mB;
1451 uinfo->value.integer.step = step_gain_mB / VOL_STEP_mB;
1452 return 0;
1453 }
1454
1455 static int snd_asihpi_volume_get(struct snd_kcontrol *kcontrol,
1456 struct snd_ctl_elem_value *ucontrol)
1457 {
1458 u32 h_control = kcontrol->private_value;
1459 short an_gain_mB[HPI_MAX_CHANNELS];
1460
1461 hpi_handle_error(hpi_volume_get_gain(h_control, an_gain_mB));
1462 ucontrol->value.integer.value[0] = an_gain_mB[0] / VOL_STEP_mB;
1463 ucontrol->value.integer.value[1] = an_gain_mB[1] / VOL_STEP_mB;
1464
1465 return 0;
1466 }
1467
1468 static int snd_asihpi_volume_put(struct snd_kcontrol *kcontrol,
1469 struct snd_ctl_elem_value *ucontrol)
1470 {
1471 u32 h_control = kcontrol->private_value;
1472 short an_gain_mB[HPI_MAX_CHANNELS];
1473
1474 an_gain_mB[0] =
1475 (ucontrol->value.integer.value[0]) * VOL_STEP_mB;
1476 an_gain_mB[1] =
1477 (ucontrol->value.integer.value[1]) * VOL_STEP_mB;
1478 /* change = asihpi->mixer_volume[addr][0] != left ||
1479 asihpi->mixer_volume[addr][1] != right;
1480 */
1481 hpi_handle_error(hpi_volume_set_gain(h_control, an_gain_mB));
1482 return 1;
1483 }
1484
1485 static const DECLARE_TLV_DB_SCALE(db_scale_100, -10000, VOL_STEP_mB, 0);
1486
1487 #define snd_asihpi_volume_mute_info snd_ctl_boolean_mono_info
1488
1489 static int snd_asihpi_volume_mute_get(struct snd_kcontrol *kcontrol,
1490 struct snd_ctl_elem_value *ucontrol)
1491 {
1492 u32 h_control = kcontrol->private_value;
1493 u32 mute;
1494
1495 hpi_handle_error(hpi_volume_get_mute(h_control, &mute));
1496 ucontrol->value.integer.value[0] = mute ? 0 : 1;
1497
1498 return 0;
1499 }
1500
1501 static int snd_asihpi_volume_mute_put(struct snd_kcontrol *kcontrol,
1502 struct snd_ctl_elem_value *ucontrol)
1503 {
1504 u32 h_control = kcontrol->private_value;
1505 /* HPI currently only supports all or none muting of multichannel volume
1506 ALSA Switch element has opposite sense to HPI mute: on==unmuted, off=muted
1507 */
1508 int mute = ucontrol->value.integer.value[0] ? 0 : HPI_BITMASK_ALL_CHANNELS;
1509 hpi_handle_error(hpi_volume_set_mute(h_control, mute));
1510 return 1;
1511 }
1512
1513 static int snd_asihpi_volume_add(struct snd_card_asihpi *asihpi,
1514 struct hpi_control *hpi_ctl)
1515 {
1516 struct snd_card *card = asihpi->card;
1517 struct snd_kcontrol_new snd_control;
1518 int err;
1519 u32 mute;
1520
1521 asihpi_ctl_init(&snd_control, hpi_ctl, "Volume");
1522 snd_control.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
1523 SNDRV_CTL_ELEM_ACCESS_TLV_READ;
1524 snd_control.info = snd_asihpi_volume_info;
1525 snd_control.get = snd_asihpi_volume_get;
1526 snd_control.put = snd_asihpi_volume_put;
1527 snd_control.tlv.p = db_scale_100;
1528
1529 err = ctl_add(card, &snd_control, asihpi);
1530 if (err)
1531 return err;
1532
1533 if (hpi_volume_get_mute(hpi_ctl->h_control, &mute) == 0) {
1534 asihpi_ctl_init(&snd_control, hpi_ctl, "Switch");
1535 snd_control.access = SNDRV_CTL_ELEM_ACCESS_READWRITE;
1536 snd_control.info = snd_asihpi_volume_mute_info;
1537 snd_control.get = snd_asihpi_volume_mute_get;
1538 snd_control.put = snd_asihpi_volume_mute_put;
1539 err = ctl_add(card, &snd_control, asihpi);
1540 }
1541 return err;
1542 }
1543
1544 /*------------------------------------------------------------
1545 Level controls
1546 ------------------------------------------------------------*/
1547 static int snd_asihpi_level_info(struct snd_kcontrol *kcontrol,
1548 struct snd_ctl_elem_info *uinfo)
1549 {
1550 u32 h_control = kcontrol->private_value;
1551 u16 err;
1552 short min_gain_mB;
1553 short max_gain_mB;
1554 short step_gain_mB;
1555
1556 err =
1557 hpi_level_query_range(h_control, &min_gain_mB,
1558 &max_gain_mB, &step_gain_mB);
1559 if (err) {
1560 max_gain_mB = 2400;
1561 min_gain_mB = -1000;
1562 step_gain_mB = 100;
1563 }
1564
1565 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1566 uinfo->count = 2;
1567 uinfo->value.integer.min = min_gain_mB / HPI_UNITS_PER_dB;
1568 uinfo->value.integer.max = max_gain_mB / HPI_UNITS_PER_dB;
1569 uinfo->value.integer.step = step_gain_mB / HPI_UNITS_PER_dB;
1570 return 0;
1571 }
1572
1573 static int snd_asihpi_level_get(struct snd_kcontrol *kcontrol,
1574 struct snd_ctl_elem_value *ucontrol)
1575 {
1576 u32 h_control = kcontrol->private_value;
1577 short an_gain_mB[HPI_MAX_CHANNELS];
1578
1579 hpi_handle_error(hpi_level_get_gain(h_control, an_gain_mB));
1580 ucontrol->value.integer.value[0] =
1581 an_gain_mB[0] / HPI_UNITS_PER_dB;
1582 ucontrol->value.integer.value[1] =
1583 an_gain_mB[1] / HPI_UNITS_PER_dB;
1584
1585 return 0;
1586 }
1587
1588 static int snd_asihpi_level_put(struct snd_kcontrol *kcontrol,
1589 struct snd_ctl_elem_value *ucontrol)
1590 {
1591 int change;
1592 u32 h_control = kcontrol->private_value;
1593 short an_gain_mB[HPI_MAX_CHANNELS];
1594
1595 an_gain_mB[0] =
1596 (ucontrol->value.integer.value[0]) * HPI_UNITS_PER_dB;
1597 an_gain_mB[1] =
1598 (ucontrol->value.integer.value[1]) * HPI_UNITS_PER_dB;
1599 /* change = asihpi->mixer_level[addr][0] != left ||
1600 asihpi->mixer_level[addr][1] != right;
1601 */
1602 change = 1;
1603 hpi_handle_error(hpi_level_set_gain(h_control, an_gain_mB));
1604 return change;
1605 }
1606
1607 static const DECLARE_TLV_DB_SCALE(db_scale_level, -1000, 100, 0);
1608
1609 static int snd_asihpi_level_add(struct snd_card_asihpi *asihpi,
1610 struct hpi_control *hpi_ctl)
1611 {
1612 struct snd_card *card = asihpi->card;
1613 struct snd_kcontrol_new snd_control;
1614
1615 /* can't use 'volume' cos some nodes have volume as well */
1616 asihpi_ctl_init(&snd_control, hpi_ctl, "Level");
1617 snd_control.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
1618 SNDRV_CTL_ELEM_ACCESS_TLV_READ;
1619 snd_control.info = snd_asihpi_level_info;
1620 snd_control.get = snd_asihpi_level_get;
1621 snd_control.put = snd_asihpi_level_put;
1622 snd_control.tlv.p = db_scale_level;
1623
1624 return ctl_add(card, &snd_control, asihpi);
1625 }
1626
1627 /*------------------------------------------------------------
1628 AESEBU controls
1629 ------------------------------------------------------------*/
1630
1631 /* AESEBU format */
1632 static const char * const asihpi_aesebu_format_names[] = {
1633 "N/A", "S/PDIF", "AES/EBU" };
1634
1635 static int snd_asihpi_aesebu_format_info(struct snd_kcontrol *kcontrol,
1636 struct snd_ctl_elem_info *uinfo)
1637 {
1638 return snd_ctl_enum_info(uinfo, 1, 3, asihpi_aesebu_format_names);
1639 }
1640
1641 static int snd_asihpi_aesebu_format_get(struct snd_kcontrol *kcontrol,
1642 struct snd_ctl_elem_value *ucontrol,
1643 u16 (*func)(u32, u16 *))
1644 {
1645 u32 h_control = kcontrol->private_value;
1646 u16 source, err;
1647
1648 err = func(h_control, &source);
1649
1650 /* default to N/A */
1651 ucontrol->value.enumerated.item[0] = 0;
1652 /* return success but set the control to N/A */
1653 if (err)
1654 return 0;
1655 if (source == HPI_AESEBU_FORMAT_SPDIF)
1656 ucontrol->value.enumerated.item[0] = 1;
1657 if (source == HPI_AESEBU_FORMAT_AESEBU)
1658 ucontrol->value.enumerated.item[0] = 2;
1659
1660 return 0;
1661 }
1662
1663 static int snd_asihpi_aesebu_format_put(struct snd_kcontrol *kcontrol,
1664 struct snd_ctl_elem_value *ucontrol,
1665 u16 (*func)(u32, u16))
1666 {
1667 u32 h_control = kcontrol->private_value;
1668
1669 /* default to S/PDIF */
1670 u16 source = HPI_AESEBU_FORMAT_SPDIF;
1671
1672 if (ucontrol->value.enumerated.item[0] == 1)
1673 source = HPI_AESEBU_FORMAT_SPDIF;
1674 if (ucontrol->value.enumerated.item[0] == 2)
1675 source = HPI_AESEBU_FORMAT_AESEBU;
1676
1677 if (func(h_control, source) != 0)
1678 return -EINVAL;
1679
1680 return 1;
1681 }
1682
1683 static int snd_asihpi_aesebu_rx_format_get(struct snd_kcontrol *kcontrol,
1684 struct snd_ctl_elem_value *ucontrol) {
1685 return snd_asihpi_aesebu_format_get(kcontrol, ucontrol,
1686 hpi_aesebu_receiver_get_format);
1687 }
1688
1689 static int snd_asihpi_aesebu_rx_format_put(struct snd_kcontrol *kcontrol,
1690 struct snd_ctl_elem_value *ucontrol) {
1691 return snd_asihpi_aesebu_format_put(kcontrol, ucontrol,
1692 hpi_aesebu_receiver_set_format);
1693 }
1694
1695 static int snd_asihpi_aesebu_rxstatus_info(struct snd_kcontrol *kcontrol,
1696 struct snd_ctl_elem_info *uinfo)
1697 {
1698 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1699 uinfo->count = 1;
1700
1701 uinfo->value.integer.min = 0;
1702 uinfo->value.integer.max = 0X1F;
1703 uinfo->value.integer.step = 1;
1704
1705 return 0;
1706 }
1707
1708 static int snd_asihpi_aesebu_rxstatus_get(struct snd_kcontrol *kcontrol,
1709 struct snd_ctl_elem_value *ucontrol) {
1710
1711 u32 h_control = kcontrol->private_value;
1712 u16 status;
1713
1714 hpi_handle_error(hpi_aesebu_receiver_get_error_status(
1715 h_control, &status));
1716 ucontrol->value.integer.value[0] = status;
1717 return 0;
1718 }
1719
1720 static int snd_asihpi_aesebu_rx_add(struct snd_card_asihpi *asihpi,
1721 struct hpi_control *hpi_ctl)
1722 {
1723 struct snd_card *card = asihpi->card;
1724 struct snd_kcontrol_new snd_control;
1725
1726 asihpi_ctl_init(&snd_control, hpi_ctl, "Format");
1727 snd_control.access = SNDRV_CTL_ELEM_ACCESS_READWRITE;
1728 snd_control.info = snd_asihpi_aesebu_format_info;
1729 snd_control.get = snd_asihpi_aesebu_rx_format_get;
1730 snd_control.put = snd_asihpi_aesebu_rx_format_put;
1731
1732
1733 if (ctl_add(card, &snd_control, asihpi) < 0)
1734 return -EINVAL;
1735
1736 asihpi_ctl_init(&snd_control, hpi_ctl, "Status");
1737 snd_control.access =
1738 SNDRV_CTL_ELEM_ACCESS_VOLATILE | SNDRV_CTL_ELEM_ACCESS_READ;
1739 snd_control.info = snd_asihpi_aesebu_rxstatus_info;
1740 snd_control.get = snd_asihpi_aesebu_rxstatus_get;
1741
1742 return ctl_add(card, &snd_control, asihpi);
1743 }
1744
1745 static int snd_asihpi_aesebu_tx_format_get(struct snd_kcontrol *kcontrol,
1746 struct snd_ctl_elem_value *ucontrol) {
1747 return snd_asihpi_aesebu_format_get(kcontrol, ucontrol,
1748 hpi_aesebu_transmitter_get_format);
1749 }
1750
1751 static int snd_asihpi_aesebu_tx_format_put(struct snd_kcontrol *kcontrol,
1752 struct snd_ctl_elem_value *ucontrol) {
1753 return snd_asihpi_aesebu_format_put(kcontrol, ucontrol,
1754 hpi_aesebu_transmitter_set_format);
1755 }
1756
1757
1758 static int snd_asihpi_aesebu_tx_add(struct snd_card_asihpi *asihpi,
1759 struct hpi_control *hpi_ctl)
1760 {
1761 struct snd_card *card = asihpi->card;
1762 struct snd_kcontrol_new snd_control;
1763
1764 asihpi_ctl_init(&snd_control, hpi_ctl, "Format");
1765 snd_control.access = SNDRV_CTL_ELEM_ACCESS_READWRITE;
1766 snd_control.info = snd_asihpi_aesebu_format_info;
1767 snd_control.get = snd_asihpi_aesebu_tx_format_get;
1768 snd_control.put = snd_asihpi_aesebu_tx_format_put;
1769
1770 return ctl_add(card, &snd_control, asihpi);
1771 }
1772
1773 /*------------------------------------------------------------
1774 Tuner controls
1775 ------------------------------------------------------------*/
1776
1777 /* Gain */
1778
1779 static int snd_asihpi_tuner_gain_info(struct snd_kcontrol *kcontrol,
1780 struct snd_ctl_elem_info *uinfo)
1781 {
1782 u32 h_control = kcontrol->private_value;
1783 u16 err;
1784 short idx;
1785 u16 gain_range[3];
1786
1787 for (idx = 0; idx < 3; idx++) {
1788 err = hpi_tuner_query_gain(h_control,
1789 idx, &gain_range[idx]);
1790 if (err != 0)
1791 return err;
1792 }
1793
1794 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1795 uinfo->count = 1;
1796 uinfo->value.integer.min = ((int)gain_range[0]) / HPI_UNITS_PER_dB;
1797 uinfo->value.integer.max = ((int)gain_range[1]) / HPI_UNITS_PER_dB;
1798 uinfo->value.integer.step = ((int) gain_range[2]) / HPI_UNITS_PER_dB;
1799 return 0;
1800 }
1801
1802 static int snd_asihpi_tuner_gain_get(struct snd_kcontrol *kcontrol,
1803 struct snd_ctl_elem_value *ucontrol)
1804 {
1805 /*
1806 struct snd_card_asihpi *asihpi = snd_kcontrol_chip(kcontrol);
1807 */
1808 u32 h_control = kcontrol->private_value;
1809 short gain;
1810
1811 hpi_handle_error(hpi_tuner_get_gain(h_control, &gain));
1812 ucontrol->value.integer.value[0] = gain / HPI_UNITS_PER_dB;
1813
1814 return 0;
1815 }
1816
1817 static int snd_asihpi_tuner_gain_put(struct snd_kcontrol *kcontrol,
1818 struct snd_ctl_elem_value *ucontrol)
1819 {
1820 /*
1821 struct snd_card_asihpi *asihpi = snd_kcontrol_chip(kcontrol);
1822 */
1823 u32 h_control = kcontrol->private_value;
1824 short gain;
1825
1826 gain = (ucontrol->value.integer.value[0]) * HPI_UNITS_PER_dB;
1827 hpi_handle_error(hpi_tuner_set_gain(h_control, gain));
1828
1829 return 1;
1830 }
1831
1832 /* Band */
1833
1834 static int asihpi_tuner_band_query(struct snd_kcontrol *kcontrol,
1835 u16 *band_list, u32 len) {
1836 u32 h_control = kcontrol->private_value;
1837 u16 err = 0;
1838 u32 i;
1839
1840 for (i = 0; i < len; i++) {
1841 err = hpi_tuner_query_band(
1842 h_control, i, &band_list[i]);
1843 if (err != 0)
1844 break;
1845 }
1846
1847 if (err && (err != HPI_ERROR_INVALID_OBJ_INDEX))
1848 return -EIO;
1849
1850 return i;
1851 }
1852
1853 static int snd_asihpi_tuner_band_info(struct snd_kcontrol *kcontrol,
1854 struct snd_ctl_elem_info *uinfo)
1855 {
1856 u16 tuner_bands[HPI_TUNER_BAND_LAST];
1857 int num_bands = 0;
1858
1859 num_bands = asihpi_tuner_band_query(kcontrol, tuner_bands,
1860 HPI_TUNER_BAND_LAST);
1861
1862 if (num_bands < 0)
1863 return num_bands;
1864
1865 return snd_ctl_enum_info(uinfo, 1, num_bands, asihpi_tuner_band_names);
1866 }
1867
1868 static int snd_asihpi_tuner_band_get(struct snd_kcontrol *kcontrol,
1869 struct snd_ctl_elem_value *ucontrol)
1870 {
1871 u32 h_control = kcontrol->private_value;
1872 /*
1873 struct snd_card_asihpi *asihpi = snd_kcontrol_chip(kcontrol);
1874 */
1875 u16 band, idx;
1876 u16 tuner_bands[HPI_TUNER_BAND_LAST];
1877 __always_unused u32 num_bands;
1878
1879 num_bands = asihpi_tuner_band_query(kcontrol, tuner_bands,
1880 HPI_TUNER_BAND_LAST);
1881
1882 hpi_handle_error(hpi_tuner_get_band(h_control, &band));
1883
1884 ucontrol->value.enumerated.item[0] = -1;
1885 for (idx = 0; idx < HPI_TUNER_BAND_LAST; idx++)
1886 if (tuner_bands[idx] == band) {
1887 ucontrol->value.enumerated.item[0] = idx;
1888 break;
1889 }
1890
1891 return 0;
1892 }
1893
1894 static int snd_asihpi_tuner_band_put(struct snd_kcontrol *kcontrol,
1895 struct snd_ctl_elem_value *ucontrol)
1896 {
1897 /*
1898 struct snd_card_asihpi *asihpi = snd_kcontrol_chip(kcontrol);
1899 */
1900 u32 h_control = kcontrol->private_value;
1901 unsigned int idx;
1902 u16 band;
1903 u16 tuner_bands[HPI_TUNER_BAND_LAST];
1904 __always_unused u32 num_bands;
1905
1906 num_bands = asihpi_tuner_band_query(kcontrol, tuner_bands,
1907 HPI_TUNER_BAND_LAST);
1908
1909 idx = ucontrol->value.enumerated.item[0];
1910 if (idx >= ARRAY_SIZE(tuner_bands))
1911 idx = ARRAY_SIZE(tuner_bands) - 1;
1912 band = tuner_bands[idx];
1913 hpi_handle_error(hpi_tuner_set_band(h_control, band));
1914
1915 return 1;
1916 }
1917
1918 /* Freq */
1919
1920 static int snd_asihpi_tuner_freq_info(struct snd_kcontrol *kcontrol,
1921 struct snd_ctl_elem_info *uinfo)
1922 {
1923 u32 h_control = kcontrol->private_value;
1924 u16 err;
1925 u16 tuner_bands[HPI_TUNER_BAND_LAST];
1926 u16 num_bands = 0, band_iter, idx;
1927 u32 freq_range[3], temp_freq_range[3];
1928
1929 num_bands = asihpi_tuner_band_query(kcontrol, tuner_bands,
1930 HPI_TUNER_BAND_LAST);
1931
1932 freq_range[0] = INT_MAX;
1933 freq_range[1] = 0;
1934 freq_range[2] = INT_MAX;
1935
1936 for (band_iter = 0; band_iter < num_bands; band_iter++) {
1937 for (idx = 0; idx < 3; idx++) {
1938 err = hpi_tuner_query_frequency(h_control,
1939 idx, tuner_bands[band_iter],
1940 &temp_freq_range[idx]);
1941 if (err != 0)
1942 return err;
1943 }
1944
1945 /* skip band with bogus stepping */
1946 if (temp_freq_range[2] <= 0)
1947 continue;
1948
1949 if (temp_freq_range[0] < freq_range[0])
1950 freq_range[0] = temp_freq_range[0];
1951 if (temp_freq_range[1] > freq_range[1])
1952 freq_range[1] = temp_freq_range[1];
1953 if (temp_freq_range[2] < freq_range[2])
1954 freq_range[2] = temp_freq_range[2];
1955 }
1956
1957 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1958 uinfo->count = 1;
1959 uinfo->value.integer.min = ((int)freq_range[0]);
1960 uinfo->value.integer.max = ((int)freq_range[1]);
1961 uinfo->value.integer.step = ((int)freq_range[2]);
1962 return 0;
1963 }
1964
1965 static int snd_asihpi_tuner_freq_get(struct snd_kcontrol *kcontrol,
1966 struct snd_ctl_elem_value *ucontrol)
1967 {
1968 u32 h_control = kcontrol->private_value;
1969 u32 freq;
1970
1971 hpi_handle_error(hpi_tuner_get_frequency(h_control, &freq));
1972 ucontrol->value.integer.value[0] = freq;
1973
1974 return 0;
1975 }
1976
1977 static int snd_asihpi_tuner_freq_put(struct snd_kcontrol *kcontrol,
1978 struct snd_ctl_elem_value *ucontrol)
1979 {
1980 u32 h_control = kcontrol->private_value;
1981 u32 freq;
1982
1983 freq = ucontrol->value.integer.value[0];
1984 hpi_handle_error(hpi_tuner_set_frequency(h_control, freq));
1985
1986 return 1;
1987 }
1988
1989 /* Tuner control group initializer */
1990 static int snd_asihpi_tuner_add(struct snd_card_asihpi *asihpi,
1991 struct hpi_control *hpi_ctl)
1992 {
1993 struct snd_card *card = asihpi->card;
1994 struct snd_kcontrol_new snd_control;
1995
1996 snd_control.private_value = hpi_ctl->h_control;
1997 snd_control.access = SNDRV_CTL_ELEM_ACCESS_READWRITE;
1998
1999 if (!hpi_tuner_get_gain(hpi_ctl->h_control, NULL)) {
2000 asihpi_ctl_init(&snd_control, hpi_ctl, "Gain");
2001 snd_control.info = snd_asihpi_tuner_gain_info;
2002 snd_control.get = snd_asihpi_tuner_gain_get;
2003 snd_control.put = snd_asihpi_tuner_gain_put;
2004
2005 if (ctl_add(card, &snd_control, asihpi) < 0)
2006 return -EINVAL;
2007 }
2008
2009 asihpi_ctl_init(&snd_control, hpi_ctl, "Band");
2010 snd_control.info = snd_asihpi_tuner_band_info;
2011 snd_control.get = snd_asihpi_tuner_band_get;
2012 snd_control.put = snd_asihpi_tuner_band_put;
2013
2014 if (ctl_add(card, &snd_control, asihpi) < 0)
2015 return -EINVAL;
2016
2017 asihpi_ctl_init(&snd_control, hpi_ctl, "Freq");
2018 snd_control.info = snd_asihpi_tuner_freq_info;
2019 snd_control.get = snd_asihpi_tuner_freq_get;
2020 snd_control.put = snd_asihpi_tuner_freq_put;
2021
2022 return ctl_add(card, &snd_control, asihpi);
2023 }
2024
2025 /*------------------------------------------------------------
2026 Meter controls
2027 ------------------------------------------------------------*/
2028 static int snd_asihpi_meter_info(struct snd_kcontrol *kcontrol,
2029 struct snd_ctl_elem_info *uinfo)
2030 {
2031 u32 h_control = kcontrol->private_value;
2032 u32 count;
2033 u16 err;
2034 err = hpi_meter_query_channels(h_control, &count);
2035 if (err)
2036 count = HPI_MAX_CHANNELS;
2037
2038 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2039 uinfo->count = count;
2040 uinfo->value.integer.min = 0;
2041 uinfo->value.integer.max = 0x7FFFFFFF;
2042 return 0;
2043 }
2044
2045 /* linear values for 10dB steps */
2046 static const int log2lin[] = {
2047 0x7FFFFFFF, /* 0dB */
2048 679093956,
2049 214748365,
2050 67909396,
2051 21474837,
2052 6790940,
2053 2147484, /* -60dB */
2054 679094,
2055 214748, /* -80 */
2056 67909,
2057 21475, /* -100 */
2058 6791,
2059 2147,
2060 679,
2061 214,
2062 68,
2063 21,
2064 7,
2065 2
2066 };
2067
2068 static int snd_asihpi_meter_get(struct snd_kcontrol *kcontrol,
2069 struct snd_ctl_elem_value *ucontrol)
2070 {
2071 u32 h_control = kcontrol->private_value;
2072 short an_gain_mB[HPI_MAX_CHANNELS], i;
2073 u16 err;
2074
2075 err = hpi_meter_get_peak(h_control, an_gain_mB);
2076
2077 for (i = 0; i < HPI_MAX_CHANNELS; i++) {
2078 if (err) {
2079 ucontrol->value.integer.value[i] = 0;
2080 } else if (an_gain_mB[i] >= 0) {
2081 ucontrol->value.integer.value[i] =
2082 an_gain_mB[i] << 16;
2083 } else {
2084 /* -ve is log value in millibels < -60dB,
2085 * convert to (roughly!) linear,
2086 */
2087 ucontrol->value.integer.value[i] =
2088 log2lin[an_gain_mB[i] / -1000];
2089 }
2090 }
2091 return 0;
2092 }
2093
2094 static int snd_asihpi_meter_add(struct snd_card_asihpi *asihpi,
2095 struct hpi_control *hpi_ctl, int subidx)
2096 {
2097 struct snd_card *card = asihpi->card;
2098 struct snd_kcontrol_new snd_control;
2099
2100 asihpi_ctl_init(&snd_control, hpi_ctl, "Meter");
2101 snd_control.access =
2102 SNDRV_CTL_ELEM_ACCESS_VOLATILE | SNDRV_CTL_ELEM_ACCESS_READ;
2103 snd_control.info = snd_asihpi_meter_info;
2104 snd_control.get = snd_asihpi_meter_get;
2105
2106 snd_control.index = subidx;
2107
2108 return ctl_add(card, &snd_control, asihpi);
2109 }
2110
2111 /*------------------------------------------------------------
2112 Multiplexer controls
2113 ------------------------------------------------------------*/
2114 static int snd_card_asihpi_mux_count_sources(struct snd_kcontrol *snd_control)
2115 {
2116 u32 h_control = snd_control->private_value;
2117 struct hpi_control hpi_ctl;
2118 int s, err;
2119 for (s = 0; s < 32; s++) {
2120 err = hpi_multiplexer_query_source(h_control, s,
2121 &hpi_ctl.
2122 src_node_type,
2123 &hpi_ctl.
2124 src_node_index);
2125 if (err)
2126 break;
2127 }
2128 return s;
2129 }
2130
2131 static int snd_asihpi_mux_info(struct snd_kcontrol *kcontrol,
2132 struct snd_ctl_elem_info *uinfo)
2133 {
2134 u16 src_node_type, src_node_index;
2135 u32 h_control = kcontrol->private_value;
2136
2137 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2138 uinfo->count = 1;
2139 uinfo->value.enumerated.items =
2140 snd_card_asihpi_mux_count_sources(kcontrol);
2141
2142 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
2143 uinfo->value.enumerated.item =
2144 uinfo->value.enumerated.items - 1;
2145
2146 hpi_multiplexer_query_source(h_control,
2147 uinfo->value.enumerated.item,
2148 &src_node_type, &src_node_index);
2149
2150 sprintf(uinfo->value.enumerated.name, "%s %d",
2151 asihpi_src_names[src_node_type - HPI_SOURCENODE_NONE],
2152 src_node_index);
2153 return 0;
2154 }
2155
2156 static int snd_asihpi_mux_get(struct snd_kcontrol *kcontrol,
2157 struct snd_ctl_elem_value *ucontrol)
2158 {
2159 u32 h_control = kcontrol->private_value;
2160 u16 source_type, source_index;
2161 u16 src_node_type, src_node_index;
2162 int s;
2163
2164 hpi_handle_error(hpi_multiplexer_get_source(h_control,
2165 &source_type, &source_index));
2166 /* Should cache this search result! */
2167 for (s = 0; s < 256; s++) {
2168 if (hpi_multiplexer_query_source(h_control, s,
2169 &src_node_type, &src_node_index))
2170 break;
2171
2172 if ((source_type == src_node_type)
2173 && (source_index == src_node_index)) {
2174 ucontrol->value.enumerated.item[0] = s;
2175 return 0;
2176 }
2177 }
2178 snd_printd(KERN_WARNING
2179 "Control %x failed to match mux source %hu %hu\n",
2180 h_control, source_type, source_index);
2181 ucontrol->value.enumerated.item[0] = 0;
2182 return 0;
2183 }
2184
2185 static int snd_asihpi_mux_put(struct snd_kcontrol *kcontrol,
2186 struct snd_ctl_elem_value *ucontrol)
2187 {
2188 int change;
2189 u32 h_control = kcontrol->private_value;
2190 u16 source_type, source_index;
2191 u16 e;
2192
2193 change = 1;
2194
2195 e = hpi_multiplexer_query_source(h_control,
2196 ucontrol->value.enumerated.item[0],
2197 &source_type, &source_index);
2198 if (!e)
2199 hpi_handle_error(
2200 hpi_multiplexer_set_source(h_control,
2201 source_type, source_index));
2202 return change;
2203 }
2204
2205
2206 static int snd_asihpi_mux_add(struct snd_card_asihpi *asihpi,
2207 struct hpi_control *hpi_ctl)
2208 {
2209 struct snd_card *card = asihpi->card;
2210 struct snd_kcontrol_new snd_control;
2211
2212 asihpi_ctl_init(&snd_control, hpi_ctl, "Route");
2213 snd_control.access = SNDRV_CTL_ELEM_ACCESS_READWRITE;
2214 snd_control.info = snd_asihpi_mux_info;
2215 snd_control.get = snd_asihpi_mux_get;
2216 snd_control.put = snd_asihpi_mux_put;
2217
2218 return ctl_add(card, &snd_control, asihpi);
2219
2220 }
2221
2222 /*------------------------------------------------------------
2223 Channel mode controls
2224 ------------------------------------------------------------*/
2225 static int snd_asihpi_cmode_info(struct snd_kcontrol *kcontrol,
2226 struct snd_ctl_elem_info *uinfo)
2227 {
2228 static const char * const mode_names[HPI_CHANNEL_MODE_LAST + 1] = {
2229 "invalid",
2230 "Normal", "Swap",
2231 "From Left", "From Right",
2232 "To Left", "To Right"
2233 };
2234
2235 u32 h_control = kcontrol->private_value;
2236 u16 mode;
2237 int i;
2238 const char *mapped_names[6];
2239 int valid_modes = 0;
2240
2241 /* HPI channel mode values can be from 1 to 6
2242 Some adapters only support a contiguous subset
2243 */
2244 for (i = 0; i < HPI_CHANNEL_MODE_LAST; i++)
2245 if (!hpi_channel_mode_query_mode(
2246 h_control, i, &mode)) {
2247 mapped_names[valid_modes] = mode_names[mode];
2248 valid_modes++;
2249 }
2250
2251 if (!valid_modes)
2252 return -EINVAL;
2253
2254 return snd_ctl_enum_info(uinfo, 1, valid_modes, mapped_names);
2255 }
2256
2257 static int snd_asihpi_cmode_get(struct snd_kcontrol *kcontrol,
2258 struct snd_ctl_elem_value *ucontrol)
2259 {
2260 u32 h_control = kcontrol->private_value;
2261 u16 mode;
2262
2263 if (hpi_channel_mode_get(h_control, &mode))
2264 mode = 1;
2265
2266 ucontrol->value.enumerated.item[0] = mode - 1;
2267
2268 return 0;
2269 }
2270
2271 static int snd_asihpi_cmode_put(struct snd_kcontrol *kcontrol,
2272 struct snd_ctl_elem_value *ucontrol)
2273 {
2274 int change;
2275 u32 h_control = kcontrol->private_value;
2276
2277 change = 1;
2278
2279 hpi_handle_error(hpi_channel_mode_set(h_control,
2280 ucontrol->value.enumerated.item[0] + 1));
2281 return change;
2282 }
2283
2284
2285 static int snd_asihpi_cmode_add(struct snd_card_asihpi *asihpi,
2286 struct hpi_control *hpi_ctl)
2287 {
2288 struct snd_card *card = asihpi->card;
2289 struct snd_kcontrol_new snd_control;
2290
2291 asihpi_ctl_init(&snd_control, hpi_ctl, "Mode");
2292 snd_control.access = SNDRV_CTL_ELEM_ACCESS_READWRITE;
2293 snd_control.info = snd_asihpi_cmode_info;
2294 snd_control.get = snd_asihpi_cmode_get;
2295 snd_control.put = snd_asihpi_cmode_put;
2296
2297 return ctl_add(card, &snd_control, asihpi);
2298 }
2299
2300 /*------------------------------------------------------------
2301 Sampleclock source controls
2302 ------------------------------------------------------------*/
2303 static const char * const sampleclock_sources[] = {
2304 "N/A", "Local PLL", "Digital Sync", "Word External", "Word Header",
2305 "SMPTE", "Digital1", "Auto", "Network", "Invalid",
2306 "Prev Module", "BLU-Link",
2307 "Digital2", "Digital3", "Digital4", "Digital5",
2308 "Digital6", "Digital7", "Digital8"};
2309
2310 /* Number of strings must match expected enumerated values */
2311 compile_time_assert(
2312 (ARRAY_SIZE(sampleclock_sources) == MAX_CLOCKSOURCES),
2313 assert_sampleclock_sources_size);
2314
2315 static int snd_asihpi_clksrc_info(struct snd_kcontrol *kcontrol,
2316 struct snd_ctl_elem_info *uinfo)
2317 {
2318 struct snd_card_asihpi *asihpi =
2319 (struct snd_card_asihpi *)(kcontrol->private_data);
2320 struct clk_cache *clkcache = &asihpi->cc;
2321 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2322 uinfo->count = 1;
2323 uinfo->value.enumerated.items = clkcache->count;
2324
2325 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
2326 uinfo->value.enumerated.item =
2327 uinfo->value.enumerated.items - 1;
2328
2329 strcpy(uinfo->value.enumerated.name,
2330 clkcache->s[uinfo->value.enumerated.item].name);
2331 return 0;
2332 }
2333
2334 static int snd_asihpi_clksrc_get(struct snd_kcontrol *kcontrol,
2335 struct snd_ctl_elem_value *ucontrol)
2336 {
2337 struct snd_card_asihpi *asihpi =
2338 (struct snd_card_asihpi *)(kcontrol->private_data);
2339 struct clk_cache *clkcache = &asihpi->cc;
2340 u32 h_control = kcontrol->private_value;
2341 u16 source, srcindex = 0;
2342 int i;
2343
2344 ucontrol->value.enumerated.item[0] = 0;
2345 if (hpi_sample_clock_get_source(h_control, &source))
2346 source = 0;
2347
2348 if (source == HPI_SAMPLECLOCK_SOURCE_AESEBU_INPUT)
2349 if (hpi_sample_clock_get_source_index(h_control, &srcindex))
2350 srcindex = 0;
2351
2352 for (i = 0; i < clkcache->count; i++)
2353 if ((clkcache->s[i].source == source) &&
2354 (clkcache->s[i].index == srcindex))
2355 break;
2356
2357 ucontrol->value.enumerated.item[0] = i;
2358
2359 return 0;
2360 }
2361
2362 static int snd_asihpi_clksrc_put(struct snd_kcontrol *kcontrol,
2363 struct snd_ctl_elem_value *ucontrol)
2364 {
2365 struct snd_card_asihpi *asihpi =
2366 (struct snd_card_asihpi *)(kcontrol->private_data);
2367 struct clk_cache *clkcache = &asihpi->cc;
2368 unsigned int item;
2369 int change;
2370 u32 h_control = kcontrol->private_value;
2371
2372 change = 1;
2373 item = ucontrol->value.enumerated.item[0];
2374 if (item >= clkcache->count)
2375 item = clkcache->count-1;
2376
2377 hpi_handle_error(hpi_sample_clock_set_source(
2378 h_control, clkcache->s[item].source));
2379
2380 if (clkcache->s[item].source == HPI_SAMPLECLOCK_SOURCE_AESEBU_INPUT)
2381 hpi_handle_error(hpi_sample_clock_set_source_index(
2382 h_control, clkcache->s[item].index));
2383 return change;
2384 }
2385
2386 /*------------------------------------------------------------
2387 Clkrate controls
2388 ------------------------------------------------------------*/
2389 /* Need to change this to enumerated control with list of rates */
2390 static int snd_asihpi_clklocal_info(struct snd_kcontrol *kcontrol,
2391 struct snd_ctl_elem_info *uinfo)
2392 {
2393 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2394 uinfo->count = 1;
2395 uinfo->value.integer.min = 8000;
2396 uinfo->value.integer.max = 192000;
2397 uinfo->value.integer.step = 100;
2398
2399 return 0;
2400 }
2401
2402 static int snd_asihpi_clklocal_get(struct snd_kcontrol *kcontrol,
2403 struct snd_ctl_elem_value *ucontrol)
2404 {
2405 u32 h_control = kcontrol->private_value;
2406 u32 rate;
2407 u16 e;
2408
2409 e = hpi_sample_clock_get_local_rate(h_control, &rate);
2410 if (!e)
2411 ucontrol->value.integer.value[0] = rate;
2412 else
2413 ucontrol->value.integer.value[0] = 0;
2414 return 0;
2415 }
2416
2417 static int snd_asihpi_clklocal_put(struct snd_kcontrol *kcontrol,
2418 struct snd_ctl_elem_value *ucontrol)
2419 {
2420 int change;
2421 u32 h_control = kcontrol->private_value;
2422
2423 /* change = asihpi->mixer_clkrate[addr][0] != left ||
2424 asihpi->mixer_clkrate[addr][1] != right;
2425 */
2426 change = 1;
2427 hpi_handle_error(hpi_sample_clock_set_local_rate(h_control,
2428 ucontrol->value.integer.value[0]));
2429 return change;
2430 }
2431
2432 static int snd_asihpi_clkrate_info(struct snd_kcontrol *kcontrol,
2433 struct snd_ctl_elem_info *uinfo)
2434 {
2435 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2436 uinfo->count = 1;
2437 uinfo->value.integer.min = 8000;
2438 uinfo->value.integer.max = 192000;
2439 uinfo->value.integer.step = 100;
2440
2441 return 0;
2442 }
2443
2444 static int snd_asihpi_clkrate_get(struct snd_kcontrol *kcontrol,
2445 struct snd_ctl_elem_value *ucontrol)
2446 {
2447 u32 h_control = kcontrol->private_value;
2448 u32 rate;
2449 u16 e;
2450
2451 e = hpi_sample_clock_get_sample_rate(h_control, &rate);
2452 if (!e)
2453 ucontrol->value.integer.value[0] = rate;
2454 else
2455 ucontrol->value.integer.value[0] = 0;
2456 return 0;
2457 }
2458
2459 static int snd_asihpi_sampleclock_add(struct snd_card_asihpi *asihpi,
2460 struct hpi_control *hpi_ctl)
2461 {
2462 struct snd_card *card;
2463 struct snd_kcontrol_new snd_control;
2464
2465 struct clk_cache *clkcache;
2466 u32 hSC = hpi_ctl->h_control;
2467 int has_aes_in = 0;
2468 int i, j;
2469 u16 source;
2470
2471 if (snd_BUG_ON(!asihpi))
2472 return -EINVAL;
2473 card = asihpi->card;
2474 clkcache = &asihpi->cc;
2475 snd_control.private_value = hpi_ctl->h_control;
2476
2477 clkcache->has_local = 0;
2478
2479 for (i = 0; i <= HPI_SAMPLECLOCK_SOURCE_LAST; i++) {
2480 if (hpi_sample_clock_query_source(hSC,
2481 i, &source))
2482 break;
2483 clkcache->s[i].source = source;
2484 clkcache->s[i].index = 0;
2485 clkcache->s[i].name = sampleclock_sources[source];
2486 if (source == HPI_SAMPLECLOCK_SOURCE_AESEBU_INPUT)
2487 has_aes_in = 1;
2488 if (source == HPI_SAMPLECLOCK_SOURCE_LOCAL)
2489 clkcache->has_local = 1;
2490 }
2491 if (has_aes_in)
2492 /* already will have picked up index 0 above */
2493 for (j = 1; j < 8; j++) {
2494 if (hpi_sample_clock_query_source_index(hSC,
2495 j, HPI_SAMPLECLOCK_SOURCE_AESEBU_INPUT,
2496 &source))
2497 break;
2498 clkcache->s[i].source =
2499 HPI_SAMPLECLOCK_SOURCE_AESEBU_INPUT;
2500 clkcache->s[i].index = j;
2501 clkcache->s[i].name = sampleclock_sources[
2502 j+HPI_SAMPLECLOCK_SOURCE_LAST];
2503 i++;
2504 }
2505 clkcache->count = i;
2506
2507 asihpi_ctl_init(&snd_control, hpi_ctl, "Source");
2508 snd_control.access = SNDRV_CTL_ELEM_ACCESS_READWRITE ;
2509 snd_control.info = snd_asihpi_clksrc_info;
2510 snd_control.get = snd_asihpi_clksrc_get;
2511 snd_control.put = snd_asihpi_clksrc_put;
2512 if (ctl_add(card, &snd_control, asihpi) < 0)
2513 return -EINVAL;
2514
2515
2516 if (clkcache->has_local) {
2517 asihpi_ctl_init(&snd_control, hpi_ctl, "Localrate");
2518 snd_control.access = SNDRV_CTL_ELEM_ACCESS_READWRITE ;
2519 snd_control.info = snd_asihpi_clklocal_info;
2520 snd_control.get = snd_asihpi_clklocal_get;
2521 snd_control.put = snd_asihpi_clklocal_put;
2522
2523
2524 if (ctl_add(card, &snd_control, asihpi) < 0)
2525 return -EINVAL;
2526 }
2527
2528 asihpi_ctl_init(&snd_control, hpi_ctl, "Rate");
2529 snd_control.access =
2530 SNDRV_CTL_ELEM_ACCESS_VOLATILE | SNDRV_CTL_ELEM_ACCESS_READ;
2531 snd_control.info = snd_asihpi_clkrate_info;
2532 snd_control.get = snd_asihpi_clkrate_get;
2533
2534 return ctl_add(card, &snd_control, asihpi);
2535 }
2536 /*------------------------------------------------------------
2537 Mixer
2538 ------------------------------------------------------------*/
2539
2540 static int snd_card_asihpi_mixer_new(struct snd_card_asihpi *asihpi)
2541 {
2542 struct snd_card *card;
2543 unsigned int idx = 0;
2544 unsigned int subindex = 0;
2545 int err;
2546 struct hpi_control hpi_ctl, prev_ctl;
2547
2548 if (snd_BUG_ON(!asihpi))
2549 return -EINVAL;
2550 card = asihpi->card;
2551 strcpy(card->mixername, "Asihpi Mixer");
2552
2553 err =
2554 hpi_mixer_open(asihpi->hpi->adapter->index,
2555 &asihpi->h_mixer);
2556 hpi_handle_error(err);
2557 if (err)
2558 return -err;
2559
2560 memset(&prev_ctl, 0, sizeof(prev_ctl));
2561 prev_ctl.control_type = -1;
2562
2563 for (idx = 0; idx < 2000; idx++) {
2564 err = hpi_mixer_get_control_by_index(
2565 asihpi->h_mixer,
2566 idx,
2567 &hpi_ctl.src_node_type,
2568 &hpi_ctl.src_node_index,
2569 &hpi_ctl.dst_node_type,
2570 &hpi_ctl.dst_node_index,
2571 &hpi_ctl.control_type,
2572 &hpi_ctl.h_control);
2573 if (err) {
2574 if (err == HPI_ERROR_CONTROL_DISABLED) {
2575 if (mixer_dump)
2576 dev_info(&asihpi->pci->dev,
2577 "Disabled HPI Control(%d)\n",
2578 idx);
2579 continue;
2580 } else
2581 break;
2582
2583 }
2584
2585 hpi_ctl.src_node_type -= HPI_SOURCENODE_NONE;
2586 hpi_ctl.dst_node_type -= HPI_DESTNODE_NONE;
2587
2588 /* ASI50xx in SSX mode has multiple meters on the same node.
2589 Use subindex to create distinct ALSA controls
2590 for any duplicated controls.
2591 */
2592 if ((hpi_ctl.control_type == prev_ctl.control_type) &&
2593 (hpi_ctl.src_node_type == prev_ctl.src_node_type) &&
2594 (hpi_ctl.src_node_index == prev_ctl.src_node_index) &&
2595 (hpi_ctl.dst_node_type == prev_ctl.dst_node_type) &&
2596 (hpi_ctl.dst_node_index == prev_ctl.dst_node_index))
2597 subindex++;
2598 else
2599 subindex = 0;
2600
2601 prev_ctl = hpi_ctl;
2602
2603 switch (hpi_ctl.control_type) {
2604 case HPI_CONTROL_VOLUME:
2605 err = snd_asihpi_volume_add(asihpi, &hpi_ctl);
2606 break;
2607 case HPI_CONTROL_LEVEL:
2608 err = snd_asihpi_level_add(asihpi, &hpi_ctl);
2609 break;
2610 case HPI_CONTROL_MULTIPLEXER:
2611 err = snd_asihpi_mux_add(asihpi, &hpi_ctl);
2612 break;
2613 case HPI_CONTROL_CHANNEL_MODE:
2614 err = snd_asihpi_cmode_add(asihpi, &hpi_ctl);
2615 break;
2616 case HPI_CONTROL_METER:
2617 err = snd_asihpi_meter_add(asihpi, &hpi_ctl, subindex);
2618 break;
2619 case HPI_CONTROL_SAMPLECLOCK:
2620 err = snd_asihpi_sampleclock_add(
2621 asihpi, &hpi_ctl);
2622 break;
2623 case HPI_CONTROL_CONNECTION: /* ignore these */
2624 continue;
2625 case HPI_CONTROL_TUNER:
2626 err = snd_asihpi_tuner_add(asihpi, &hpi_ctl);
2627 break;
2628 case HPI_CONTROL_AESEBU_TRANSMITTER:
2629 err = snd_asihpi_aesebu_tx_add(asihpi, &hpi_ctl);
2630 break;
2631 case HPI_CONTROL_AESEBU_RECEIVER:
2632 err = snd_asihpi_aesebu_rx_add(asihpi, &hpi_ctl);
2633 break;
2634 case HPI_CONTROL_VOX:
2635 case HPI_CONTROL_BITSTREAM:
2636 case HPI_CONTROL_MICROPHONE:
2637 case HPI_CONTROL_PARAMETRIC_EQ:
2638 case HPI_CONTROL_COMPANDER:
2639 default:
2640 if (mixer_dump)
2641 dev_info(&asihpi->pci->dev,
2642 "Untranslated HPI Control (%d) %d %d %d %d %d\n",
2643 idx,
2644 hpi_ctl.control_type,
2645 hpi_ctl.src_node_type,
2646 hpi_ctl.src_node_index,
2647 hpi_ctl.dst_node_type,
2648 hpi_ctl.dst_node_index);
2649 continue;
2650 }
2651 if (err < 0)
2652 return err;
2653 }
2654 if (HPI_ERROR_INVALID_OBJ_INDEX != err)
2655 hpi_handle_error(err);
2656
2657 dev_info(&asihpi->pci->dev, "%d mixer controls found\n", idx);
2658
2659 return 0;
2660 }
2661
2662 /*------------------------------------------------------------
2663 /proc interface
2664 ------------------------------------------------------------*/
2665
2666 static void
2667 snd_asihpi_proc_read(struct snd_info_entry *entry,
2668 struct snd_info_buffer *buffer)
2669 {
2670 struct snd_card_asihpi *asihpi = entry->private_data;
2671 u32 h_control;
2672 u32 rate = 0;
2673 u16 source = 0;
2674
2675 u16 num_outstreams;
2676 u16 num_instreams;
2677 u16 version;
2678 u32 serial_number;
2679 u16 type;
2680
2681 int err;
2682
2683 snd_iprintf(buffer, "ASIHPI driver proc file\n");
2684
2685 hpi_handle_error(hpi_adapter_get_info(asihpi->hpi->adapter->index,
2686 &num_outstreams, &num_instreams,
2687 &version, &serial_number, &type));
2688
2689 snd_iprintf(buffer,
2690 "Adapter type ASI%4X\nHardware Index %d\n"
2691 "%d outstreams\n%d instreams\n",
2692 type, asihpi->hpi->adapter->index,
2693 num_outstreams, num_instreams);
2694
2695 snd_iprintf(buffer,
2696 "Serial#%d\nHardware version %c%d\nDSP code version %03d\n",
2697 serial_number, ((version >> 3) & 0xf) + 'A', version & 0x7,
2698 ((version >> 13) * 100) + ((version >> 7) & 0x3f));
2699
2700 err = hpi_mixer_get_control(asihpi->h_mixer,
2701 HPI_SOURCENODE_CLOCK_SOURCE, 0, 0, 0,
2702 HPI_CONTROL_SAMPLECLOCK, &h_control);
2703
2704 if (!err) {
2705 err = hpi_sample_clock_get_sample_rate(h_control, &rate);
2706 err += hpi_sample_clock_get_source(h_control, &source);
2707
2708 if (!err)
2709 snd_iprintf(buffer, "Sample Clock %dHz, source %s\n",
2710 rate, sampleclock_sources[source]);
2711 }
2712 }
2713
2714 static void snd_asihpi_proc_init(struct snd_card_asihpi *asihpi)
2715 {
2716 snd_card_ro_proc_new(asihpi->card, "info", asihpi,
2717 snd_asihpi_proc_read);
2718 }
2719
2720 /*------------------------------------------------------------
2721 HWDEP
2722 ------------------------------------------------------------*/
2723
2724 static int snd_asihpi_hpi_open(struct snd_hwdep *hw, struct file *file)
2725 {
2726 if (enable_hpi_hwdep)
2727 return 0;
2728 else
2729 return -ENODEV;
2730
2731 }
2732
2733 static int snd_asihpi_hpi_release(struct snd_hwdep *hw, struct file *file)
2734 {
2735 if (enable_hpi_hwdep)
2736 return asihpi_hpi_release(file);
2737 else
2738 return -ENODEV;
2739 }
2740
2741 static int snd_asihpi_hpi_ioctl(struct snd_hwdep *hw, struct file *file,
2742 unsigned int cmd, unsigned long arg)
2743 {
2744 if (enable_hpi_hwdep)
2745 return asihpi_hpi_ioctl(file, cmd, arg);
2746 else
2747 return -ENODEV;
2748 }
2749
2750
2751 /* results in /dev/snd/hwC#D0 file for each card with index #
2752 also /proc/asound/hwdep will contain '#-00: asihpi (HPI) for each card'
2753 */
2754 static int snd_asihpi_hpi_new(struct snd_card_asihpi *asihpi, int device)
2755 {
2756 struct snd_hwdep *hw;
2757 int err;
2758
2759 err = snd_hwdep_new(asihpi->card, "HPI", device, &hw);
2760 if (err < 0)
2761 return err;
2762 strcpy(hw->name, "asihpi (HPI)");
2763 hw->iface = SNDRV_HWDEP_IFACE_LAST;
2764 hw->ops.open = snd_asihpi_hpi_open;
2765 hw->ops.ioctl = snd_asihpi_hpi_ioctl;
2766 hw->ops.release = snd_asihpi_hpi_release;
2767 hw->private_data = asihpi;
2768 return 0;
2769 }
2770
2771 /*------------------------------------------------------------
2772 CARD
2773 ------------------------------------------------------------*/
2774 static int snd_asihpi_probe(struct pci_dev *pci_dev,
2775 const struct pci_device_id *pci_id)
2776 {
2777 int err;
2778 struct hpi_adapter *hpi;
2779 struct snd_card *card;
2780 struct snd_card_asihpi *asihpi;
2781
2782 u32 h_control;
2783 u32 h_stream;
2784 u32 adapter_index;
2785
2786 static int dev;
2787 if (dev >= SNDRV_CARDS)
2788 return -ENODEV;
2789
2790 /* Should this be enable[hpi->index] ? */
2791 if (!enable[dev]) {
2792 dev++;
2793 return -ENOENT;
2794 }
2795
2796 /* Initialise low-level HPI driver */
2797 err = asihpi_adapter_probe(pci_dev, pci_id);
2798 if (err < 0)
2799 return err;
2800
2801 hpi = pci_get_drvdata(pci_dev);
2802 adapter_index = hpi->adapter->index;
2803 /* first try to give the card the same index as its hardware index */
2804 err = snd_card_new(&pci_dev->dev, adapter_index, id[adapter_index],
2805 THIS_MODULE, sizeof(struct snd_card_asihpi), &card);
2806 if (err < 0) {
2807 /* if that fails, try the default index==next available */
2808 err = snd_card_new(&pci_dev->dev, index[dev], id[dev],
2809 THIS_MODULE, sizeof(struct snd_card_asihpi),
2810 &card);
2811 if (err < 0)
2812 return err;
2813 dev_warn(&pci_dev->dev, "Adapter index %d->ALSA index %d\n",
2814 adapter_index, card->number);
2815 }
2816
2817 asihpi = card->private_data;
2818 asihpi->card = card;
2819 asihpi->pci = pci_dev;
2820 asihpi->hpi = hpi;
2821 hpi->snd_card = card;
2822
2823 err = hpi_adapter_get_property(adapter_index,
2824 HPI_ADAPTER_PROPERTY_CAPS1,
2825 NULL, &asihpi->support_grouping);
2826 if (err)
2827 asihpi->support_grouping = 0;
2828
2829 err = hpi_adapter_get_property(adapter_index,
2830 HPI_ADAPTER_PROPERTY_CAPS2,
2831 &asihpi->support_mrx, NULL);
2832 if (err)
2833 asihpi->support_mrx = 0;
2834
2835 err = hpi_adapter_get_property(adapter_index,
2836 HPI_ADAPTER_PROPERTY_INTERVAL,
2837 NULL, &asihpi->update_interval_frames);
2838 if (err)
2839 asihpi->update_interval_frames = 512;
2840
2841 if (hpi->interrupt_mode) {
2842 asihpi->pcm_start = snd_card_asihpi_pcm_int_start;
2843 asihpi->pcm_stop = snd_card_asihpi_pcm_int_stop;
2844 hpi->interrupt_callback = snd_card_asihpi_isr;
2845 } else {
2846 asihpi->pcm_start = snd_card_asihpi_pcm_timer_start;
2847 asihpi->pcm_stop = snd_card_asihpi_pcm_timer_stop;
2848 }
2849
2850 hpi_handle_error(hpi_instream_open(adapter_index,
2851 0, &h_stream));
2852
2853 err = hpi_instream_host_buffer_free(h_stream);
2854 asihpi->can_dma = (!err);
2855
2856 hpi_handle_error(hpi_instream_close(h_stream));
2857
2858 if (!asihpi->can_dma)
2859 asihpi->update_interval_frames *= 2;
2860
2861 err = hpi_adapter_get_property(adapter_index,
2862 HPI_ADAPTER_PROPERTY_CURCHANNELS,
2863 &asihpi->in_max_chans, &asihpi->out_max_chans);
2864 if (err) {
2865 asihpi->in_max_chans = 2;
2866 asihpi->out_max_chans = 2;
2867 }
2868
2869 if (asihpi->out_max_chans > 2) { /* assume LL mode */
2870 asihpi->out_min_chans = asihpi->out_max_chans;
2871 asihpi->in_min_chans = asihpi->in_max_chans;
2872 asihpi->support_grouping = 0;
2873 } else {
2874 asihpi->out_min_chans = 1;
2875 asihpi->in_min_chans = 1;
2876 }
2877
2878 dev_info(&pci_dev->dev, "Has dma:%d, grouping:%d, mrx:%d, uif:%d\n",
2879 asihpi->can_dma,
2880 asihpi->support_grouping,
2881 asihpi->support_mrx,
2882 asihpi->update_interval_frames
2883 );
2884
2885 err = snd_card_asihpi_pcm_new(asihpi, 0);
2886 if (err < 0) {
2887 dev_err(&pci_dev->dev, "pcm_new failed\n");
2888 goto __nodev;
2889 }
2890 err = snd_card_asihpi_mixer_new(asihpi);
2891 if (err < 0) {
2892 dev_err(&pci_dev->dev, "mixer_new failed\n");
2893 goto __nodev;
2894 }
2895
2896 err = hpi_mixer_get_control(asihpi->h_mixer,
2897 HPI_SOURCENODE_CLOCK_SOURCE, 0, 0, 0,
2898 HPI_CONTROL_SAMPLECLOCK, &h_control);
2899
2900 if (!err)
2901 err = hpi_sample_clock_set_local_rate(
2902 h_control, adapter_fs);
2903
2904 snd_asihpi_proc_init(asihpi);
2905
2906 /* always create, can be enabled or disabled dynamically
2907 by enable_hwdep module param*/
2908 snd_asihpi_hpi_new(asihpi, 0);
2909
2910 strcpy(card->driver, "ASIHPI");
2911
2912 sprintf(card->shortname, "AudioScience ASI%4X",
2913 asihpi->hpi->adapter->type);
2914 sprintf(card->longname, "%s %i",
2915 card->shortname, adapter_index);
2916 err = snd_card_register(card);
2917
2918 if (!err) {
2919 dev++;
2920 return 0;
2921 }
2922 __nodev:
2923 snd_card_free(card);
2924 dev_err(&pci_dev->dev, "snd_asihpi_probe error %d\n", err);
2925 return err;
2926
2927 }
2928
2929 static void snd_asihpi_remove(struct pci_dev *pci_dev)
2930 {
2931 struct hpi_adapter *hpi = pci_get_drvdata(pci_dev);
2932
2933 /* Stop interrupts */
2934 if (hpi->interrupt_mode) {
2935 hpi->interrupt_callback = NULL;
2936 hpi_handle_error(hpi_adapter_set_property(hpi->adapter->index,
2937 HPI_ADAPTER_PROPERTY_IRQ_RATE, 0, 0));
2938 }
2939
2940 snd_card_free(hpi->snd_card);
2941 hpi->snd_card = NULL;
2942 asihpi_adapter_remove(pci_dev);
2943 }
2944
2945 static const struct pci_device_id asihpi_pci_tbl[] = {
2946 {HPI_PCI_VENDOR_ID_TI, HPI_PCI_DEV_ID_DSP6205,
2947 HPI_PCI_VENDOR_ID_AUDIOSCIENCE, PCI_ANY_ID, 0, 0,
2948 (kernel_ulong_t)HPI_6205},
2949 {HPI_PCI_VENDOR_ID_TI, HPI_PCI_DEV_ID_PCI2040,
2950 HPI_PCI_VENDOR_ID_AUDIOSCIENCE, PCI_ANY_ID, 0, 0,
2951 (kernel_ulong_t)HPI_6000},
2952 {0,}
2953 };
2954 MODULE_DEVICE_TABLE(pci, asihpi_pci_tbl);
2955
2956 static struct pci_driver driver = {
2957 .name = KBUILD_MODNAME,
2958 .id_table = asihpi_pci_tbl,
2959 .probe = snd_asihpi_probe,
2960 .remove = snd_asihpi_remove,
2961 };
2962
2963 static int __init snd_asihpi_init(void)
2964 {
2965 asihpi_init();
2966 return pci_register_driver(&driver);
2967 }
2968
2969 static void __exit snd_asihpi_exit(void)
2970 {
2971
2972 pci_unregister_driver(&driver);
2973 asihpi_exit();
2974 }
2975
2976 module_init(snd_asihpi_init)
2977 module_exit(snd_asihpi_exit)
2978
2979
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.