?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
WIP FPC-III support
[linux/fpc-iii.git] / sound / pci / asihpi / asihpi.c
blob5e1f9f10051bcb01d78451ddfd39079d93665f45
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 s->runtime->status->state = 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 int loops = 0;
729 u16 state;
730 u32 buffer_size, bytes_avail, samples_played, on_card_bytes;
731 char name[16];
732
733
734 snd_pcm_debug_name(substream, name, sizeof(name));
735
736 /* find minimum newdata and buffer pos in group */
737 snd_pcm_group_for_each_entry(s, substream) {
738 struct snd_card_asihpi_pcm *ds = s->runtime->private_data;
739 runtime = s->runtime;
740
741 if (snd_pcm_substream_chip(s) != card)
742 continue;
743
744 /* don't link Cap and Play */
745 if (substream->stream != s->stream)
746 continue;
747
748 hpi_handle_error(hpi_stream_get_info_ex(
749 ds->h_stream, &state,
750 &buffer_size, &bytes_avail,
751 &samples_played, &on_card_bytes));
752
753 /* number of bytes in on-card buffer */
754 runtime->delay = on_card_bytes;
755
756 if (!card->can_dma)
757 on_card_bytes = bytes_avail;
758
759 if (s->stream == SNDRV_PCM_STREAM_PLAYBACK) {
760 pcm_buf_dma_ofs = ds->pcm_buf_host_rw_ofs - bytes_avail;
761 if (state == HPI_STATE_STOPPED) {
762 if (bytes_avail == 0) {
763 hpi_handle_error(hpi_stream_start(ds->h_stream));
764 snd_printdd("P%d start\n", s->number);
765 ds->drained_count = 0;
766 }
767 } else if (state == HPI_STATE_DRAINED) {
768 snd_printd(KERN_WARNING "P%d drained\n",
769 s->number);
770 ds->drained_count++;
771 if (ds->drained_count > 20) {
772 snd_pcm_stop_xrun(s);
773 continue;
774 }
775 } else {
776 ds->drained_count = 0;
777 }
778 } else
779 pcm_buf_dma_ofs = bytes_avail + ds->pcm_buf_host_rw_ofs;
780
781 if (first) {
782 /* can't statically init min when wrap is involved */
783 min_buf_pos = pcm_buf_dma_ofs;
784 newdata = (pcm_buf_dma_ofs - ds->pcm_buf_elapsed_dma_ofs) % ds->buffer_bytes;
785 first = 0;
786 } else {
787 min_buf_pos =
788 modulo_min(min_buf_pos, pcm_buf_dma_ofs, UINT_MAX+1L);
789 newdata = min(
790 (pcm_buf_dma_ofs - ds->pcm_buf_elapsed_dma_ofs) % ds->buffer_bytes,
791 newdata);
792 }
793
794 snd_printddd(
795 "timer1, %s, %d, S=%d, elap=%d, rw=%d, dsp=%d, left=%d, aux=%d, space=%d, hw_ptr=%ld, appl_ptr=%ld\n",
796 name, s->number, state,
797 ds->pcm_buf_elapsed_dma_ofs,
798 ds->pcm_buf_host_rw_ofs,
799 pcm_buf_dma_ofs,
800 (int)bytes_avail,
801
802 (int)on_card_bytes,
803 buffer_size-bytes_avail,
804 (unsigned long)frames_to_bytes(runtime,
805 runtime->status->hw_ptr),
806 (unsigned long)frames_to_bytes(runtime,
807 runtime->control->appl_ptr)
808 );
809 loops++;
810 }
811 pcm_buf_dma_ofs = min_buf_pos;
812
813 remdata = newdata % dpcm->period_bytes;
814 xfercount = newdata - remdata; /* a multiple of period_bytes */
815 /* come back when on_card_bytes has decreased enough to allow
816 write to happen, or when data has been consumed to make another
817 period
818 */
819 if (xfercount && (on_card_bytes > dpcm->period_bytes))
820 next_jiffies = ((on_card_bytes - dpcm->period_bytes) * HZ / dpcm->bytes_per_sec);
821 else
822 next_jiffies = ((dpcm->period_bytes - remdata) * HZ / dpcm->bytes_per_sec);
823
824 next_jiffies = max(next_jiffies, 1U);
825 dpcm->timer.expires = jiffies + next_jiffies;
826 snd_printddd("timer2, jif=%d, buf_pos=%d, newdata=%d, xfer=%d\n",
827 next_jiffies, pcm_buf_dma_ofs, newdata, xfercount);
828
829 snd_pcm_group_for_each_entry(s, substream) {
830 struct snd_card_asihpi_pcm *ds = s->runtime->private_data;
831
832 /* don't link Cap and Play */
833 if (substream->stream != s->stream)
834 continue;
835
836 /* Store dma offset for use by pointer callback */
837 ds->pcm_buf_dma_ofs = pcm_buf_dma_ofs;
838
839 if (xfercount &&
840 /* Limit use of on card fifo for playback */
841 ((on_card_bytes <= ds->period_bytes) ||
842 (s->stream == SNDRV_PCM_STREAM_CAPTURE)))
843
844 {
845
846 unsigned int buf_ofs = ds->pcm_buf_host_rw_ofs % ds->buffer_bytes;
847 unsigned int xfer1, xfer2;
848 char *pd = &s->runtime->dma_area[buf_ofs];
849
850 if (card->can_dma) { /* buffer wrap is handled at lower level */
851 xfer1 = xfercount;
852 xfer2 = 0;
853 } else {
854 xfer1 = min(xfercount, ds->buffer_bytes - buf_ofs);
855 xfer2 = xfercount - xfer1;
856 }
857
858 if (s->stream == SNDRV_PCM_STREAM_PLAYBACK) {
859 snd_printddd("write1, P=%d, xfer=%d, buf_ofs=%d\n",
860 s->number, xfer1, buf_ofs);
861 hpi_handle_error(
862 hpi_outstream_write_buf(
863 ds->h_stream, pd, xfer1,
864 &ds->format));
865
866 if (xfer2) {
867 pd = s->runtime->dma_area;
868
869 snd_printddd("write2, P=%d, xfer=%d, buf_ofs=%d\n",
870 s->number,
871 xfercount - xfer1, buf_ofs);
872 hpi_handle_error(
873 hpi_outstream_write_buf(
874 ds->h_stream, pd,
875 xfercount - xfer1,
876 &ds->format));
877 }
878 } else {
879 snd_printddd("read1, C=%d, xfer=%d\n",
880 s->number, xfer1);
881 hpi_handle_error(
882 hpi_instream_read_buf(
883 ds->h_stream,
884 pd, xfer1));
885 if (xfer2) {
886 pd = s->runtime->dma_area;
887 snd_printddd("read2, C=%d, xfer=%d\n",
888 s->number, xfer2);
889 hpi_handle_error(
890 hpi_instream_read_buf(
891 ds->h_stream,
892 pd, xfer2));
893 }
894 }
895 /* ? host_rw_ofs always ahead of elapsed_dma_ofs by preload size? */
896 ds->pcm_buf_host_rw_ofs += xfercount;
897 ds->pcm_buf_elapsed_dma_ofs += xfercount;
898 snd_pcm_period_elapsed(s);
899 }
900 }
901
902 if (!card->hpi->interrupt_mode && dpcm->respawn_timer)
903 add_timer(&dpcm->timer);
904 }
905
906 static void snd_card_asihpi_isr(struct hpi_adapter *a)
907 {
908 struct snd_card_asihpi *asihpi;
909
910 WARN_ON(!a || !a->snd_card || !a->snd_card->private_data);
911 asihpi = (struct snd_card_asihpi *)a->snd_card->private_data;
912 if (asihpi->llmode_streampriv)
913 snd_card_asihpi_timer_function(
914 &asihpi->llmode_streampriv->timer);
915 }
916
917 /***************************** PLAYBACK OPS ****************/
918 static int snd_card_asihpi_playback_prepare(struct snd_pcm_substream *
919 substream)
920 {
921 struct snd_pcm_runtime *runtime = substream->runtime;
922 struct snd_card_asihpi_pcm *dpcm = runtime->private_data;
923
924 snd_printdd("P%d prepare\n", substream->number);
925
926 hpi_handle_error(hpi_outstream_reset(dpcm->h_stream));
927 dpcm->pcm_buf_host_rw_ofs = 0;
928 dpcm->pcm_buf_dma_ofs = 0;
929 dpcm->pcm_buf_elapsed_dma_ofs = 0;
930 return 0;
931 }
932
933 static snd_pcm_uframes_t
934 snd_card_asihpi_playback_pointer(struct snd_pcm_substream *substream)
935 {
936 struct snd_pcm_runtime *runtime = substream->runtime;
937 struct snd_card_asihpi_pcm *dpcm = runtime->private_data;
938 snd_pcm_uframes_t ptr;
939 char name[16];
940 snd_pcm_debug_name(substream, name, sizeof(name));
941
942 ptr = bytes_to_frames(runtime, dpcm->pcm_buf_dma_ofs % dpcm->buffer_bytes);
943 snd_printddd("%s, pointer=%ld\n", name, (unsigned long)ptr);
944 return ptr;
945 }
946
947 static u64 snd_card_asihpi_playback_formats(struct snd_card_asihpi *asihpi,
948 u32 h_stream)
949 {
950 struct hpi_format hpi_format;
951 u16 format;
952 u16 err;
953 u32 h_control;
954 u32 sample_rate = 48000;
955 u64 formats = 0;
956
957 /* on cards without SRC, must query at valid rate,
958 * maybe set by external sync
959 */
960 err = hpi_mixer_get_control(asihpi->h_mixer,
961 HPI_SOURCENODE_CLOCK_SOURCE, 0, 0, 0,
962 HPI_CONTROL_SAMPLECLOCK, &h_control);
963
964 if (!err)
965 err = hpi_sample_clock_get_sample_rate(h_control,
966 &sample_rate);
967
968 for (format = HPI_FORMAT_PCM8_UNSIGNED;
969 format <= HPI_FORMAT_PCM24_SIGNED; format++) {
970 err = hpi_format_create(&hpi_format, asihpi->out_max_chans,
971 format, sample_rate, 128000, 0);
972 if (!err)
973 err = hpi_outstream_query_format(h_stream, &hpi_format);
974 if (!err && (hpi_to_alsa_formats[format] != INVALID_FORMAT))
975 formats |= pcm_format_to_bits(hpi_to_alsa_formats[format]);
976 }
977 return formats;
978 }
979
980 static int snd_card_asihpi_playback_open(struct snd_pcm_substream *substream)
981 {
982 struct snd_pcm_runtime *runtime = substream->runtime;
983 struct snd_card_asihpi_pcm *dpcm;
984 struct snd_card_asihpi *card = snd_pcm_substream_chip(substream);
985 struct snd_pcm_hardware snd_card_asihpi_playback;
986 int err;
987
988 dpcm = kzalloc(sizeof(*dpcm), GFP_KERNEL);
989 if (dpcm == NULL)
990 return -ENOMEM;
991
992 err = hpi_outstream_open(card->hpi->adapter->index,
993 substream->number, &dpcm->h_stream);
994 hpi_handle_error(err);
995 if (err)
996 kfree(dpcm);
997 if (err == HPI_ERROR_OBJ_ALREADY_OPEN)
998 return -EBUSY;
999 if (err)
1000 return -EIO;
1001
1002 /*? also check ASI5000 samplerate source
1003 If external, only support external rate.
1004 If internal and other stream playing, can't switch
1005 */
1006
1007 timer_setup(&dpcm->timer, snd_card_asihpi_timer_function, 0);
1008 dpcm->substream = substream;
1009 runtime->private_data = dpcm;
1010 runtime->private_free = snd_card_asihpi_runtime_free;
1011
1012 memset(&snd_card_asihpi_playback, 0, sizeof(snd_card_asihpi_playback));
1013 if (!card->hpi->interrupt_mode) {
1014 snd_card_asihpi_playback.buffer_bytes_max = BUFFER_BYTES_MAX;
1015 snd_card_asihpi_playback.period_bytes_min = PERIOD_BYTES_MIN;
1016 snd_card_asihpi_playback.period_bytes_max = BUFFER_BYTES_MAX / PERIODS_MIN;
1017 snd_card_asihpi_playback.periods_min = PERIODS_MIN;
1018 snd_card_asihpi_playback.periods_max = BUFFER_BYTES_MAX / PERIOD_BYTES_MIN;
1019 } else {
1020 size_t pbmin = card->update_interval_frames *
1021 card->out_max_chans;
1022 snd_card_asihpi_playback.buffer_bytes_max = BUFFER_BYTES_MAX;
1023 snd_card_asihpi_playback.period_bytes_min = pbmin;
1024 snd_card_asihpi_playback.period_bytes_max = BUFFER_BYTES_MAX / PERIODS_MIN;
1025 snd_card_asihpi_playback.periods_min = PERIODS_MIN;
1026 snd_card_asihpi_playback.periods_max = BUFFER_BYTES_MAX / pbmin;
1027 }
1028
1029 /* snd_card_asihpi_playback.fifo_size = 0; */
1030 snd_card_asihpi_playback.channels_max = card->out_max_chans;
1031 snd_card_asihpi_playback.channels_min = card->out_min_chans;
1032 snd_card_asihpi_playback.formats =
1033 snd_card_asihpi_playback_formats(card, dpcm->h_stream);
1034
1035 snd_card_asihpi_pcm_samplerates(card, &snd_card_asihpi_playback);
1036
1037 snd_card_asihpi_playback.info = SNDRV_PCM_INFO_INTERLEAVED |
1038 SNDRV_PCM_INFO_DOUBLE |
1039 SNDRV_PCM_INFO_BATCH |
1040 SNDRV_PCM_INFO_BLOCK_TRANSFER |
1041 SNDRV_PCM_INFO_PAUSE |
1042 SNDRV_PCM_INFO_MMAP |
1043 SNDRV_PCM_INFO_MMAP_VALID;
1044
1045 if (card->support_grouping) {
1046 snd_card_asihpi_playback.info |= SNDRV_PCM_INFO_SYNC_START;
1047 snd_pcm_set_sync(substream);
1048 }
1049
1050 /* struct is copied, so can create initializer dynamically */
1051 runtime->hw = snd_card_asihpi_playback;
1052
1053 if (card->can_dma)
1054 err = snd_pcm_hw_constraint_pow2(runtime, 0,
1055 SNDRV_PCM_HW_PARAM_BUFFER_BYTES);
1056 if (err < 0)
1057 return err;
1058
1059 snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
1060 card->update_interval_frames);
1061
1062 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
1063 card->update_interval_frames, UINT_MAX);
1064
1065 snd_printdd("playback open\n");
1066
1067 return 0;
1068 }
1069
1070 static int snd_card_asihpi_playback_close(struct snd_pcm_substream *substream)
1071 {
1072 struct snd_pcm_runtime *runtime = substream->runtime;
1073 struct snd_card_asihpi_pcm *dpcm = runtime->private_data;
1074
1075 hpi_handle_error(hpi_outstream_close(dpcm->h_stream));
1076 snd_printdd("playback close\n");
1077
1078 return 0;
1079 }
1080
1081 static const struct snd_pcm_ops snd_card_asihpi_playback_mmap_ops = {
1082 .open = snd_card_asihpi_playback_open,
1083 .close = snd_card_asihpi_playback_close,
1084 .hw_params = snd_card_asihpi_pcm_hw_params,
1085 .hw_free = snd_card_asihpi_hw_free,
1086 .prepare = snd_card_asihpi_playback_prepare,
1087 .trigger = snd_card_asihpi_trigger,
1088 .pointer = snd_card_asihpi_playback_pointer,
1089 };
1090
1091 /***************************** CAPTURE OPS ****************/
1092 static snd_pcm_uframes_t
1093 snd_card_asihpi_capture_pointer(struct snd_pcm_substream *substream)
1094 {
1095 struct snd_pcm_runtime *runtime = substream->runtime;
1096 struct snd_card_asihpi_pcm *dpcm = runtime->private_data;
1097 char name[16];
1098 snd_pcm_debug_name(substream, name, sizeof(name));
1099
1100 snd_printddd("%s, pointer=%d\n", name, dpcm->pcm_buf_dma_ofs);
1101 /* NOTE Unlike playback can't use actual samples_played
1102 for the capture position, because those samples aren't yet in
1103 the local buffer available for reading.
1104 */
1105 return bytes_to_frames(runtime, dpcm->pcm_buf_dma_ofs % dpcm->buffer_bytes);
1106 }
1107
1108 static int snd_card_asihpi_capture_prepare(struct snd_pcm_substream *substream)
1109 {
1110 struct snd_pcm_runtime *runtime = substream->runtime;
1111 struct snd_card_asihpi_pcm *dpcm = runtime->private_data;
1112
1113 hpi_handle_error(hpi_instream_reset(dpcm->h_stream));
1114 dpcm->pcm_buf_host_rw_ofs = 0;
1115 dpcm->pcm_buf_dma_ofs = 0;
1116 dpcm->pcm_buf_elapsed_dma_ofs = 0;
1117
1118 snd_printdd("Capture Prepare %d\n", substream->number);
1119 return 0;
1120 }
1121
1122 static u64 snd_card_asihpi_capture_formats(struct snd_card_asihpi *asihpi,
1123 u32 h_stream)
1124 {
1125 struct hpi_format hpi_format;
1126 u16 format;
1127 u16 err;
1128 u32 h_control;
1129 u32 sample_rate = 48000;
1130 u64 formats = 0;
1131
1132 /* on cards without SRC, must query at valid rate,
1133 maybe set by external sync */
1134 err = hpi_mixer_get_control(asihpi->h_mixer,
1135 HPI_SOURCENODE_CLOCK_SOURCE, 0, 0, 0,
1136 HPI_CONTROL_SAMPLECLOCK, &h_control);
1137
1138 if (!err)
1139 err = hpi_sample_clock_get_sample_rate(h_control,
1140 &sample_rate);
1141
1142 for (format = HPI_FORMAT_PCM8_UNSIGNED;
1143 format <= HPI_FORMAT_PCM24_SIGNED; format++) {
1144
1145 err = hpi_format_create(&hpi_format, asihpi->in_max_chans,
1146 format, sample_rate, 128000, 0);
1147 if (!err)
1148 err = hpi_instream_query_format(h_stream, &hpi_format);
1149 if (!err && (hpi_to_alsa_formats[format] != INVALID_FORMAT))
1150 formats |= pcm_format_to_bits(hpi_to_alsa_formats[format]);
1151 }
1152 return formats;
1153 }
1154
1155 static int snd_card_asihpi_capture_open(struct snd_pcm_substream *substream)
1156 {
1157 struct snd_pcm_runtime *runtime = substream->runtime;
1158 struct snd_card_asihpi *card = snd_pcm_substream_chip(substream);
1159 struct snd_card_asihpi_pcm *dpcm;
1160 struct snd_pcm_hardware snd_card_asihpi_capture;
1161 int err;
1162
1163 dpcm = kzalloc(sizeof(*dpcm), GFP_KERNEL);
1164 if (dpcm == NULL)
1165 return -ENOMEM;
1166
1167 snd_printdd("capture open adapter %d stream %d\n",
1168 card->hpi->adapter->index, substream->number);
1169
1170 err = hpi_handle_error(
1171 hpi_instream_open(card->hpi->adapter->index,
1172 substream->number, &dpcm->h_stream));
1173 if (err)
1174 kfree(dpcm);
1175 if (err == HPI_ERROR_OBJ_ALREADY_OPEN)
1176 return -EBUSY;
1177 if (err)
1178 return -EIO;
1179
1180 timer_setup(&dpcm->timer, snd_card_asihpi_timer_function, 0);
1181 dpcm->substream = substream;
1182 runtime->private_data = dpcm;
1183 runtime->private_free = snd_card_asihpi_runtime_free;
1184
1185 memset(&snd_card_asihpi_capture, 0, sizeof(snd_card_asihpi_capture));
1186 if (!card->hpi->interrupt_mode) {
1187 snd_card_asihpi_capture.buffer_bytes_max = BUFFER_BYTES_MAX;
1188 snd_card_asihpi_capture.period_bytes_min = PERIOD_BYTES_MIN;
1189 snd_card_asihpi_capture.period_bytes_max = BUFFER_BYTES_MAX / PERIODS_MIN;
1190 snd_card_asihpi_capture.periods_min = PERIODS_MIN;
1191 snd_card_asihpi_capture.periods_max = BUFFER_BYTES_MAX / PERIOD_BYTES_MIN;
1192 } else {
1193 size_t pbmin = card->update_interval_frames *
1194 card->out_max_chans;
1195 snd_card_asihpi_capture.buffer_bytes_max = BUFFER_BYTES_MAX;
1196 snd_card_asihpi_capture.period_bytes_min = pbmin;
1197 snd_card_asihpi_capture.period_bytes_max = BUFFER_BYTES_MAX / PERIODS_MIN;
1198 snd_card_asihpi_capture.periods_min = PERIODS_MIN;
1199 snd_card_asihpi_capture.periods_max = BUFFER_BYTES_MAX / pbmin;
1200 }
1201 /* snd_card_asihpi_capture.fifo_size = 0; */
1202 snd_card_asihpi_capture.channels_max = card->in_max_chans;
1203 snd_card_asihpi_capture.channels_min = card->in_min_chans;
1204 snd_card_asihpi_capture.formats =
1205 snd_card_asihpi_capture_formats(card, dpcm->h_stream);
1206 snd_card_asihpi_pcm_samplerates(card, &snd_card_asihpi_capture);
1207 snd_card_asihpi_capture.info = SNDRV_PCM_INFO_INTERLEAVED |
1208 SNDRV_PCM_INFO_MMAP |
1209 SNDRV_PCM_INFO_MMAP_VALID;
1210
1211 if (card->support_grouping)
1212 snd_card_asihpi_capture.info |= SNDRV_PCM_INFO_SYNC_START;
1213
1214 runtime->hw = snd_card_asihpi_capture;
1215
1216 if (card->can_dma)
1217 err = snd_pcm_hw_constraint_pow2(runtime, 0,
1218 SNDRV_PCM_HW_PARAM_BUFFER_BYTES);
1219 if (err < 0)
1220 return err;
1221
1222 snd_pcm_hw_constraint_step(runtime, 0, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
1223 card->update_interval_frames);
1224 snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_SIZE,
1225 card->update_interval_frames, UINT_MAX);
1226
1227 snd_pcm_set_sync(substream);
1228
1229 return 0;
1230 }
1231
1232 static int snd_card_asihpi_capture_close(struct snd_pcm_substream *substream)
1233 {
1234 struct snd_card_asihpi_pcm *dpcm = substream->runtime->private_data;
1235
1236 hpi_handle_error(hpi_instream_close(dpcm->h_stream));
1237 return 0;
1238 }
1239
1240 static const struct snd_pcm_ops snd_card_asihpi_capture_mmap_ops = {
1241 .open = snd_card_asihpi_capture_open,
1242 .close = snd_card_asihpi_capture_close,
1243 .hw_params = snd_card_asihpi_pcm_hw_params,
1244 .hw_free = snd_card_asihpi_hw_free,
1245 .prepare = snd_card_asihpi_capture_prepare,
1246 .trigger = snd_card_asihpi_trigger,
1247 .pointer = snd_card_asihpi_capture_pointer,
1248 };
1249
1250 static int snd_card_asihpi_pcm_new(struct snd_card_asihpi *asihpi, int device)
1251 {
1252 struct snd_pcm *pcm;
1253 int err;
1254 u16 num_instreams, num_outstreams, x16;
1255 u32 x32;
1256
1257 err = hpi_adapter_get_info(asihpi->hpi->adapter->index,
1258 &num_outstreams, &num_instreams,
1259 &x16, &x32, &x16);
1260
1261 err = snd_pcm_new(asihpi->card, "Asihpi PCM", device,
1262 num_outstreams, num_instreams, &pcm);
1263 if (err < 0)
1264 return err;
1265
1266 /* pointer to ops struct is stored, dont change ops afterwards! */
1267 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK,
1268 &snd_card_asihpi_playback_mmap_ops);
1269 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE,
1270 &snd_card_asihpi_capture_mmap_ops);
1271
1272 pcm->private_data = asihpi;
1273 pcm->info_flags = 0;
1274 strcpy(pcm->name, "Asihpi PCM");
1275
1276 /*? do we want to emulate MMAP for non-BBM cards?
1277 Jack doesn't work with ALSAs MMAP emulation - WHY NOT? */
1278 snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV,
1279 &asihpi->pci->dev,
1280 64*1024, BUFFER_BYTES_MAX);
1281
1282 return 0;
1283 }
1284
1285 /***************************** MIXER CONTROLS ****************/
1286 struct hpi_control {
1287 u32 h_control;
1288 u16 control_type;
1289 u16 src_node_type;
1290 u16 src_node_index;
1291 u16 dst_node_type;
1292 u16 dst_node_index;
1293 u16 band;
1294 char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN]; /* copied to snd_ctl_elem_id.name[44]; */
1295 };
1296
1297 static const char * const asihpi_tuner_band_names[] = {
1298 "invalid",
1299 "AM",
1300 "FM mono",
1301 "TV NTSC-M",
1302 "FM stereo",
1303 "AUX",
1304 "TV PAL BG",
1305 "TV PAL I",
1306 "TV PAL DK",
1307 "TV SECAM",
1308 "TV DAB",
1309 };
1310 /* Number of strings must match the enumerations for HPI_TUNER_BAND in hpi.h */
1311 compile_time_assert(
1312 (ARRAY_SIZE(asihpi_tuner_band_names) ==
1313 (HPI_TUNER_BAND_LAST+1)),
1314 assert_tuner_band_names_size);
1315
1316 static const char * const asihpi_src_names[] = {
1317 "no source",
1318 "PCM",
1319 "Line",
1320 "Digital",
1321 "Tuner",
1322 "RF",
1323 "Clock",
1324 "Bitstream",
1325 "Mic",
1326 "Net",
1327 "Analog",
1328 "Adapter",
1329 "RTP",
1330 "Internal",
1331 "AVB",
1332 "BLU-Link"
1333 };
1334 /* Number of strings must match the enumerations for HPI_SOURCENODES in hpi.h */
1335 compile_time_assert(
1336 (ARRAY_SIZE(asihpi_src_names) ==
1337 (HPI_SOURCENODE_LAST_INDEX-HPI_SOURCENODE_NONE+1)),
1338 assert_src_names_size);
1339
1340 static const char * const asihpi_dst_names[] = {
1341 "no destination",
1342 "PCM",
1343 "Line",
1344 "Digital",
1345 "RF",
1346 "Speaker",
1347 "Net",
1348 "Analog",
1349 "RTP",
1350 "AVB",
1351 "Internal",
1352 "BLU-Link"
1353 };
1354 /* Number of strings must match the enumerations for HPI_DESTNODES in hpi.h */
1355 compile_time_assert(
1356 (ARRAY_SIZE(asihpi_dst_names) ==
1357 (HPI_DESTNODE_LAST_INDEX-HPI_DESTNODE_NONE+1)),
1358 assert_dst_names_size);
1359
1360 static inline int ctl_add(struct snd_card *card, struct snd_kcontrol_new *ctl,
1361 struct snd_card_asihpi *asihpi)
1362 {
1363 int err;
1364
1365 err = snd_ctl_add(card, snd_ctl_new1(ctl, asihpi));
1366 if (err < 0)
1367 return err;
1368 else if (mixer_dump)
1369 dev_info(&asihpi->pci->dev, "added %s(%d)\n", ctl->name, ctl->index);
1370
1371 return 0;
1372 }
1373
1374 /* Convert HPI control name and location into ALSA control name */
1375 static void asihpi_ctl_init(struct snd_kcontrol_new *snd_control,
1376 struct hpi_control *hpi_ctl,
1377 char *name)
1378 {
1379 char *dir;
1380 memset(snd_control, 0, sizeof(*snd_control));
1381 snd_control->name = hpi_ctl->name;
1382 snd_control->private_value = hpi_ctl->h_control;
1383 snd_control->iface = SNDRV_CTL_ELEM_IFACE_MIXER;
1384 snd_control->index = 0;
1385
1386 if (hpi_ctl->src_node_type + HPI_SOURCENODE_NONE == HPI_SOURCENODE_CLOCK_SOURCE)
1387 dir = ""; /* clock is neither capture nor playback */
1388 else if (hpi_ctl->dst_node_type + HPI_DESTNODE_NONE == HPI_DESTNODE_ISTREAM)
1389 dir = "Capture "; /* On or towards a PCM capture destination*/
1390 else if ((hpi_ctl->src_node_type + HPI_SOURCENODE_NONE != HPI_SOURCENODE_OSTREAM) &&
1391 (!hpi_ctl->dst_node_type))
1392 dir = "Capture "; /* On a source node that is not PCM playback */
1393 else if (hpi_ctl->src_node_type &&
1394 (hpi_ctl->src_node_type + HPI_SOURCENODE_NONE != HPI_SOURCENODE_OSTREAM) &&
1395 (hpi_ctl->dst_node_type))
1396 dir = "Monitor Playback "; /* Between an input and an output */
1397 else
1398 dir = "Playback "; /* PCM Playback source, or output node */
1399
1400 if (hpi_ctl->src_node_type && hpi_ctl->dst_node_type)
1401 sprintf(hpi_ctl->name, "%s %d %s %d %s%s",
1402 asihpi_src_names[hpi_ctl->src_node_type],
1403 hpi_ctl->src_node_index,
1404 asihpi_dst_names[hpi_ctl->dst_node_type],
1405 hpi_ctl->dst_node_index,
1406 dir, name);
1407 else if (hpi_ctl->dst_node_type) {
1408 sprintf(hpi_ctl->name, "%s %d %s%s",
1409 asihpi_dst_names[hpi_ctl->dst_node_type],
1410 hpi_ctl->dst_node_index,
1411 dir, name);
1412 } else {
1413 sprintf(hpi_ctl->name, "%s %d %s%s",
1414 asihpi_src_names[hpi_ctl->src_node_type],
1415 hpi_ctl->src_node_index,
1416 dir, name);
1417 }
1418 /* printk(KERN_INFO "Adding %s %d to %d ", hpi_ctl->name,
1419 hpi_ctl->wSrcNodeType, hpi_ctl->wDstNodeType); */
1420 }
1421
1422 /*------------------------------------------------------------
1423 Volume controls
1424 ------------------------------------------------------------*/
1425 #define VOL_STEP_mB 1
1426 static int snd_asihpi_volume_info(struct snd_kcontrol *kcontrol,
1427 struct snd_ctl_elem_info *uinfo)
1428 {
1429 u32 h_control = kcontrol->private_value;
1430 u32 count;
1431 u16 err;
1432 /* native gains are in millibels */
1433 short min_gain_mB;
1434 short max_gain_mB;
1435 short step_gain_mB;
1436
1437 err = hpi_volume_query_range(h_control,
1438 &min_gain_mB, &max_gain_mB, &step_gain_mB);
1439 if (err) {
1440 max_gain_mB = 0;
1441 min_gain_mB = -10000;
1442 step_gain_mB = VOL_STEP_mB;
1443 }
1444
1445 err = hpi_meter_query_channels(h_control, &count);
1446 if (err)
1447 count = HPI_MAX_CHANNELS;
1448
1449 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1450 uinfo->count = count;
1451 uinfo->value.integer.min = min_gain_mB / VOL_STEP_mB;
1452 uinfo->value.integer.max = max_gain_mB / VOL_STEP_mB;
1453 uinfo->value.integer.step = step_gain_mB / VOL_STEP_mB;
1454 return 0;
1455 }
1456
1457 static int snd_asihpi_volume_get(struct snd_kcontrol *kcontrol,
1458 struct snd_ctl_elem_value *ucontrol)
1459 {
1460 u32 h_control = kcontrol->private_value;
1461 short an_gain_mB[HPI_MAX_CHANNELS];
1462
1463 hpi_handle_error(hpi_volume_get_gain(h_control, an_gain_mB));
1464 ucontrol->value.integer.value[0] = an_gain_mB[0] / VOL_STEP_mB;
1465 ucontrol->value.integer.value[1] = an_gain_mB[1] / VOL_STEP_mB;
1466
1467 return 0;
1468 }
1469
1470 static int snd_asihpi_volume_put(struct snd_kcontrol *kcontrol,
1471 struct snd_ctl_elem_value *ucontrol)
1472 {
1473 u32 h_control = kcontrol->private_value;
1474 short an_gain_mB[HPI_MAX_CHANNELS];
1475
1476 an_gain_mB[0] =
1477 (ucontrol->value.integer.value[0]) * VOL_STEP_mB;
1478 an_gain_mB[1] =
1479 (ucontrol->value.integer.value[1]) * VOL_STEP_mB;
1480 /* change = asihpi->mixer_volume[addr][0] != left ||
1481 asihpi->mixer_volume[addr][1] != right;
1482 */
1483 hpi_handle_error(hpi_volume_set_gain(h_control, an_gain_mB));
1484 return 1;
1485 }
1486
1487 static const DECLARE_TLV_DB_SCALE(db_scale_100, -10000, VOL_STEP_mB, 0);
1488
1489 #define snd_asihpi_volume_mute_info snd_ctl_boolean_mono_info
1490
1491 static int snd_asihpi_volume_mute_get(struct snd_kcontrol *kcontrol,
1492 struct snd_ctl_elem_value *ucontrol)
1493 {
1494 u32 h_control = kcontrol->private_value;
1495 u32 mute;
1496
1497 hpi_handle_error(hpi_volume_get_mute(h_control, &mute));
1498 ucontrol->value.integer.value[0] = mute ? 0 : 1;
1499
1500 return 0;
1501 }
1502
1503 static int snd_asihpi_volume_mute_put(struct snd_kcontrol *kcontrol,
1504 struct snd_ctl_elem_value *ucontrol)
1505 {
1506 u32 h_control = kcontrol->private_value;
1507 /* HPI currently only supports all or none muting of multichannel volume
1508 ALSA Switch element has opposite sense to HPI mute: on==unmuted, off=muted
1509 */
1510 int mute = ucontrol->value.integer.value[0] ? 0 : HPI_BITMASK_ALL_CHANNELS;
1511 hpi_handle_error(hpi_volume_set_mute(h_control, mute));
1512 return 1;
1513 }
1514
1515 static int snd_asihpi_volume_add(struct snd_card_asihpi *asihpi,
1516 struct hpi_control *hpi_ctl)
1517 {
1518 struct snd_card *card = asihpi->card;
1519 struct snd_kcontrol_new snd_control;
1520 int err;
1521 u32 mute;
1522
1523 asihpi_ctl_init(&snd_control, hpi_ctl, "Volume");
1524 snd_control.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
1525 SNDRV_CTL_ELEM_ACCESS_TLV_READ;
1526 snd_control.info = snd_asihpi_volume_info;
1527 snd_control.get = snd_asihpi_volume_get;
1528 snd_control.put = snd_asihpi_volume_put;
1529 snd_control.tlv.p = db_scale_100;
1530
1531 err = ctl_add(card, &snd_control, asihpi);
1532 if (err)
1533 return err;
1534
1535 if (hpi_volume_get_mute(hpi_ctl->h_control, &mute) == 0) {
1536 asihpi_ctl_init(&snd_control, hpi_ctl, "Switch");
1537 snd_control.access = SNDRV_CTL_ELEM_ACCESS_READWRITE;
1538 snd_control.info = snd_asihpi_volume_mute_info;
1539 snd_control.get = snd_asihpi_volume_mute_get;
1540 snd_control.put = snd_asihpi_volume_mute_put;
1541 err = ctl_add(card, &snd_control, asihpi);
1542 }
1543 return err;
1544 }
1545
1546 /*------------------------------------------------------------
1547 Level controls
1548 ------------------------------------------------------------*/
1549 static int snd_asihpi_level_info(struct snd_kcontrol *kcontrol,
1550 struct snd_ctl_elem_info *uinfo)
1551 {
1552 u32 h_control = kcontrol->private_value;
1553 u16 err;
1554 short min_gain_mB;
1555 short max_gain_mB;
1556 short step_gain_mB;
1557
1558 err =
1559 hpi_level_query_range(h_control, &min_gain_mB,
1560 &max_gain_mB, &step_gain_mB);
1561 if (err) {
1562 max_gain_mB = 2400;
1563 min_gain_mB = -1000;
1564 step_gain_mB = 100;
1565 }
1566
1567 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1568 uinfo->count = 2;
1569 uinfo->value.integer.min = min_gain_mB / HPI_UNITS_PER_dB;
1570 uinfo->value.integer.max = max_gain_mB / HPI_UNITS_PER_dB;
1571 uinfo->value.integer.step = step_gain_mB / HPI_UNITS_PER_dB;
1572 return 0;
1573 }
1574
1575 static int snd_asihpi_level_get(struct snd_kcontrol *kcontrol,
1576 struct snd_ctl_elem_value *ucontrol)
1577 {
1578 u32 h_control = kcontrol->private_value;
1579 short an_gain_mB[HPI_MAX_CHANNELS];
1580
1581 hpi_handle_error(hpi_level_get_gain(h_control, an_gain_mB));
1582 ucontrol->value.integer.value[0] =
1583 an_gain_mB[0] / HPI_UNITS_PER_dB;
1584 ucontrol->value.integer.value[1] =
1585 an_gain_mB[1] / HPI_UNITS_PER_dB;
1586
1587 return 0;
1588 }
1589
1590 static int snd_asihpi_level_put(struct snd_kcontrol *kcontrol,
1591 struct snd_ctl_elem_value *ucontrol)
1592 {
1593 int change;
1594 u32 h_control = kcontrol->private_value;
1595 short an_gain_mB[HPI_MAX_CHANNELS];
1596
1597 an_gain_mB[0] =
1598 (ucontrol->value.integer.value[0]) * HPI_UNITS_PER_dB;
1599 an_gain_mB[1] =
1600 (ucontrol->value.integer.value[1]) * HPI_UNITS_PER_dB;
1601 /* change = asihpi->mixer_level[addr][0] != left ||
1602 asihpi->mixer_level[addr][1] != right;
1603 */
1604 change = 1;
1605 hpi_handle_error(hpi_level_set_gain(h_control, an_gain_mB));
1606 return change;
1607 }
1608
1609 static const DECLARE_TLV_DB_SCALE(db_scale_level, -1000, 100, 0);
1610
1611 static int snd_asihpi_level_add(struct snd_card_asihpi *asihpi,
1612 struct hpi_control *hpi_ctl)
1613 {
1614 struct snd_card *card = asihpi->card;
1615 struct snd_kcontrol_new snd_control;
1616
1617 /* can't use 'volume' cos some nodes have volume as well */
1618 asihpi_ctl_init(&snd_control, hpi_ctl, "Level");
1619 snd_control.access = SNDRV_CTL_ELEM_ACCESS_READWRITE |
1620 SNDRV_CTL_ELEM_ACCESS_TLV_READ;
1621 snd_control.info = snd_asihpi_level_info;
1622 snd_control.get = snd_asihpi_level_get;
1623 snd_control.put = snd_asihpi_level_put;
1624 snd_control.tlv.p = db_scale_level;
1625
1626 return ctl_add(card, &snd_control, asihpi);
1627 }
1628
1629 /*------------------------------------------------------------
1630 AESEBU controls
1631 ------------------------------------------------------------*/
1632
1633 /* AESEBU format */
1634 static const char * const asihpi_aesebu_format_names[] = {
1635 "N/A", "S/PDIF", "AES/EBU" };
1636
1637 static int snd_asihpi_aesebu_format_info(struct snd_kcontrol *kcontrol,
1638 struct snd_ctl_elem_info *uinfo)
1639 {
1640 return snd_ctl_enum_info(uinfo, 1, 3, asihpi_aesebu_format_names);
1641 }
1642
1643 static int snd_asihpi_aesebu_format_get(struct snd_kcontrol *kcontrol,
1644 struct snd_ctl_elem_value *ucontrol,
1645 u16 (*func)(u32, u16 *))
1646 {
1647 u32 h_control = kcontrol->private_value;
1648 u16 source, err;
1649
1650 err = func(h_control, &source);
1651
1652 /* default to N/A */
1653 ucontrol->value.enumerated.item[0] = 0;
1654 /* return success but set the control to N/A */
1655 if (err)
1656 return 0;
1657 if (source == HPI_AESEBU_FORMAT_SPDIF)
1658 ucontrol->value.enumerated.item[0] = 1;
1659 if (source == HPI_AESEBU_FORMAT_AESEBU)
1660 ucontrol->value.enumerated.item[0] = 2;
1661
1662 return 0;
1663 }
1664
1665 static int snd_asihpi_aesebu_format_put(struct snd_kcontrol *kcontrol,
1666 struct snd_ctl_elem_value *ucontrol,
1667 u16 (*func)(u32, u16))
1668 {
1669 u32 h_control = kcontrol->private_value;
1670
1671 /* default to S/PDIF */
1672 u16 source = HPI_AESEBU_FORMAT_SPDIF;
1673
1674 if (ucontrol->value.enumerated.item[0] == 1)
1675 source = HPI_AESEBU_FORMAT_SPDIF;
1676 if (ucontrol->value.enumerated.item[0] == 2)
1677 source = HPI_AESEBU_FORMAT_AESEBU;
1678
1679 if (func(h_control, source) != 0)
1680 return -EINVAL;
1681
1682 return 1;
1683 }
1684
1685 static int snd_asihpi_aesebu_rx_format_get(struct snd_kcontrol *kcontrol,
1686 struct snd_ctl_elem_value *ucontrol) {
1687 return snd_asihpi_aesebu_format_get(kcontrol, ucontrol,
1688 hpi_aesebu_receiver_get_format);
1689 }
1690
1691 static int snd_asihpi_aesebu_rx_format_put(struct snd_kcontrol *kcontrol,
1692 struct snd_ctl_elem_value *ucontrol) {
1693 return snd_asihpi_aesebu_format_put(kcontrol, ucontrol,
1694 hpi_aesebu_receiver_set_format);
1695 }
1696
1697 static int snd_asihpi_aesebu_rxstatus_info(struct snd_kcontrol *kcontrol,
1698 struct snd_ctl_elem_info *uinfo)
1699 {
1700 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1701 uinfo->count = 1;
1702
1703 uinfo->value.integer.min = 0;
1704 uinfo->value.integer.max = 0X1F;
1705 uinfo->value.integer.step = 1;
1706
1707 return 0;
1708 }
1709
1710 static int snd_asihpi_aesebu_rxstatus_get(struct snd_kcontrol *kcontrol,
1711 struct snd_ctl_elem_value *ucontrol) {
1712
1713 u32 h_control = kcontrol->private_value;
1714 u16 status;
1715
1716 hpi_handle_error(hpi_aesebu_receiver_get_error_status(
1717 h_control, &status));
1718 ucontrol->value.integer.value[0] = status;
1719 return 0;
1720 }
1721
1722 static int snd_asihpi_aesebu_rx_add(struct snd_card_asihpi *asihpi,
1723 struct hpi_control *hpi_ctl)
1724 {
1725 struct snd_card *card = asihpi->card;
1726 struct snd_kcontrol_new snd_control;
1727
1728 asihpi_ctl_init(&snd_control, hpi_ctl, "Format");
1729 snd_control.access = SNDRV_CTL_ELEM_ACCESS_READWRITE;
1730 snd_control.info = snd_asihpi_aesebu_format_info;
1731 snd_control.get = snd_asihpi_aesebu_rx_format_get;
1732 snd_control.put = snd_asihpi_aesebu_rx_format_put;
1733
1734
1735 if (ctl_add(card, &snd_control, asihpi) < 0)
1736 return -EINVAL;
1737
1738 asihpi_ctl_init(&snd_control, hpi_ctl, "Status");
1739 snd_control.access =
1740 SNDRV_CTL_ELEM_ACCESS_VOLATILE | SNDRV_CTL_ELEM_ACCESS_READ;
1741 snd_control.info = snd_asihpi_aesebu_rxstatus_info;
1742 snd_control.get = snd_asihpi_aesebu_rxstatus_get;
1743
1744 return ctl_add(card, &snd_control, asihpi);
1745 }
1746
1747 static int snd_asihpi_aesebu_tx_format_get(struct snd_kcontrol *kcontrol,
1748 struct snd_ctl_elem_value *ucontrol) {
1749 return snd_asihpi_aesebu_format_get(kcontrol, ucontrol,
1750 hpi_aesebu_transmitter_get_format);
1751 }
1752
1753 static int snd_asihpi_aesebu_tx_format_put(struct snd_kcontrol *kcontrol,
1754 struct snd_ctl_elem_value *ucontrol) {
1755 return snd_asihpi_aesebu_format_put(kcontrol, ucontrol,
1756 hpi_aesebu_transmitter_set_format);
1757 }
1758
1759
1760 static int snd_asihpi_aesebu_tx_add(struct snd_card_asihpi *asihpi,
1761 struct hpi_control *hpi_ctl)
1762 {
1763 struct snd_card *card = asihpi->card;
1764 struct snd_kcontrol_new snd_control;
1765
1766 asihpi_ctl_init(&snd_control, hpi_ctl, "Format");
1767 snd_control.access = SNDRV_CTL_ELEM_ACCESS_READWRITE;
1768 snd_control.info = snd_asihpi_aesebu_format_info;
1769 snd_control.get = snd_asihpi_aesebu_tx_format_get;
1770 snd_control.put = snd_asihpi_aesebu_tx_format_put;
1771
1772 return ctl_add(card, &snd_control, asihpi);
1773 }
1774
1775 /*------------------------------------------------------------
1776 Tuner controls
1777 ------------------------------------------------------------*/
1778
1779 /* Gain */
1780
1781 static int snd_asihpi_tuner_gain_info(struct snd_kcontrol *kcontrol,
1782 struct snd_ctl_elem_info *uinfo)
1783 {
1784 u32 h_control = kcontrol->private_value;
1785 u16 err;
1786 short idx;
1787 u16 gain_range[3];
1788
1789 for (idx = 0; idx < 3; idx++) {
1790 err = hpi_tuner_query_gain(h_control,
1791 idx, &gain_range[idx]);
1792 if (err != 0)
1793 return err;
1794 }
1795
1796 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1797 uinfo->count = 1;
1798 uinfo->value.integer.min = ((int)gain_range[0]) / HPI_UNITS_PER_dB;
1799 uinfo->value.integer.max = ((int)gain_range[1]) / HPI_UNITS_PER_dB;
1800 uinfo->value.integer.step = ((int) gain_range[2]) / HPI_UNITS_PER_dB;
1801 return 0;
1802 }
1803
1804 static int snd_asihpi_tuner_gain_get(struct snd_kcontrol *kcontrol,
1805 struct snd_ctl_elem_value *ucontrol)
1806 {
1807 /*
1808 struct snd_card_asihpi *asihpi = snd_kcontrol_chip(kcontrol);
1809 */
1810 u32 h_control = kcontrol->private_value;
1811 short gain;
1812
1813 hpi_handle_error(hpi_tuner_get_gain(h_control, &gain));
1814 ucontrol->value.integer.value[0] = gain / HPI_UNITS_PER_dB;
1815
1816 return 0;
1817 }
1818
1819 static int snd_asihpi_tuner_gain_put(struct snd_kcontrol *kcontrol,
1820 struct snd_ctl_elem_value *ucontrol)
1821 {
1822 /*
1823 struct snd_card_asihpi *asihpi = snd_kcontrol_chip(kcontrol);
1824 */
1825 u32 h_control = kcontrol->private_value;
1826 short gain;
1827
1828 gain = (ucontrol->value.integer.value[0]) * HPI_UNITS_PER_dB;
1829 hpi_handle_error(hpi_tuner_set_gain(h_control, gain));
1830
1831 return 1;
1832 }
1833
1834 /* Band */
1835
1836 static int asihpi_tuner_band_query(struct snd_kcontrol *kcontrol,
1837 u16 *band_list, u32 len) {
1838 u32 h_control = kcontrol->private_value;
1839 u16 err = 0;
1840 u32 i;
1841
1842 for (i = 0; i < len; i++) {
1843 err = hpi_tuner_query_band(
1844 h_control, i, &band_list[i]);
1845 if (err != 0)
1846 break;
1847 }
1848
1849 if (err && (err != HPI_ERROR_INVALID_OBJ_INDEX))
1850 return -EIO;
1851
1852 return i;
1853 }
1854
1855 static int snd_asihpi_tuner_band_info(struct snd_kcontrol *kcontrol,
1856 struct snd_ctl_elem_info *uinfo)
1857 {
1858 u16 tuner_bands[HPI_TUNER_BAND_LAST];
1859 int num_bands = 0;
1860
1861 num_bands = asihpi_tuner_band_query(kcontrol, tuner_bands,
1862 HPI_TUNER_BAND_LAST);
1863
1864 if (num_bands < 0)
1865 return num_bands;
1866
1867 return snd_ctl_enum_info(uinfo, 1, num_bands, asihpi_tuner_band_names);
1868 }
1869
1870 static int snd_asihpi_tuner_band_get(struct snd_kcontrol *kcontrol,
1871 struct snd_ctl_elem_value *ucontrol)
1872 {
1873 u32 h_control = kcontrol->private_value;
1874 /*
1875 struct snd_card_asihpi *asihpi = snd_kcontrol_chip(kcontrol);
1876 */
1877 u16 band, idx;
1878 u16 tuner_bands[HPI_TUNER_BAND_LAST];
1879 __always_unused u32 num_bands;
1880
1881 num_bands = asihpi_tuner_band_query(kcontrol, tuner_bands,
1882 HPI_TUNER_BAND_LAST);
1883
1884 hpi_handle_error(hpi_tuner_get_band(h_control, &band));
1885
1886 ucontrol->value.enumerated.item[0] = -1;
1887 for (idx = 0; idx < HPI_TUNER_BAND_LAST; idx++)
1888 if (tuner_bands[idx] == band) {
1889 ucontrol->value.enumerated.item[0] = idx;
1890 break;
1891 }
1892
1893 return 0;
1894 }
1895
1896 static int snd_asihpi_tuner_band_put(struct snd_kcontrol *kcontrol,
1897 struct snd_ctl_elem_value *ucontrol)
1898 {
1899 /*
1900 struct snd_card_asihpi *asihpi = snd_kcontrol_chip(kcontrol);
1901 */
1902 u32 h_control = kcontrol->private_value;
1903 unsigned int idx;
1904 u16 band;
1905 u16 tuner_bands[HPI_TUNER_BAND_LAST];
1906 __always_unused u32 num_bands;
1907
1908 num_bands = asihpi_tuner_band_query(kcontrol, tuner_bands,
1909 HPI_TUNER_BAND_LAST);
1910
1911 idx = ucontrol->value.enumerated.item[0];
1912 if (idx >= ARRAY_SIZE(tuner_bands))
1913 idx = ARRAY_SIZE(tuner_bands) - 1;
1914 band = tuner_bands[idx];
1915 hpi_handle_error(hpi_tuner_set_band(h_control, band));
1916
1917 return 1;
1918 }
1919
1920 /* Freq */
1921
1922 static int snd_asihpi_tuner_freq_info(struct snd_kcontrol *kcontrol,
1923 struct snd_ctl_elem_info *uinfo)
1924 {
1925 u32 h_control = kcontrol->private_value;
1926 u16 err;
1927 u16 tuner_bands[HPI_TUNER_BAND_LAST];
1928 u16 num_bands = 0, band_iter, idx;
1929 u32 freq_range[3], temp_freq_range[3];
1930
1931 num_bands = asihpi_tuner_band_query(kcontrol, tuner_bands,
1932 HPI_TUNER_BAND_LAST);
1933
1934 freq_range[0] = INT_MAX;
1935 freq_range[1] = 0;
1936 freq_range[2] = INT_MAX;
1937
1938 for (band_iter = 0; band_iter < num_bands; band_iter++) {
1939 for (idx = 0; idx < 3; idx++) {
1940 err = hpi_tuner_query_frequency(h_control,
1941 idx, tuner_bands[band_iter],
1942 &temp_freq_range[idx]);
1943 if (err != 0)
1944 return err;
1945 }
1946
1947 /* skip band with bogus stepping */
1948 if (temp_freq_range[2] <= 0)
1949 continue;
1950
1951 if (temp_freq_range[0] < freq_range[0])
1952 freq_range[0] = temp_freq_range[0];
1953 if (temp_freq_range[1] > freq_range[1])
1954 freq_range[1] = temp_freq_range[1];
1955 if (temp_freq_range[2] < freq_range[2])
1956 freq_range[2] = temp_freq_range[2];
1957 }
1958
1959 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1960 uinfo->count = 1;
1961 uinfo->value.integer.min = ((int)freq_range[0]);
1962 uinfo->value.integer.max = ((int)freq_range[1]);
1963 uinfo->value.integer.step = ((int)freq_range[2]);
1964 return 0;
1965 }
1966
1967 static int snd_asihpi_tuner_freq_get(struct snd_kcontrol *kcontrol,
1968 struct snd_ctl_elem_value *ucontrol)
1969 {
1970 u32 h_control = kcontrol->private_value;
1971 u32 freq;
1972
1973 hpi_handle_error(hpi_tuner_get_frequency(h_control, &freq));
1974 ucontrol->value.integer.value[0] = freq;
1975
1976 return 0;
1977 }
1978
1979 static int snd_asihpi_tuner_freq_put(struct snd_kcontrol *kcontrol,
1980 struct snd_ctl_elem_value *ucontrol)
1981 {
1982 u32 h_control = kcontrol->private_value;
1983 u32 freq;
1984
1985 freq = ucontrol->value.integer.value[0];
1986 hpi_handle_error(hpi_tuner_set_frequency(h_control, freq));
1987
1988 return 1;
1989 }
1990
1991 /* Tuner control group initializer */
1992 static int snd_asihpi_tuner_add(struct snd_card_asihpi *asihpi,
1993 struct hpi_control *hpi_ctl)
1994 {
1995 struct snd_card *card = asihpi->card;
1996 struct snd_kcontrol_new snd_control;
1997
1998 snd_control.private_value = hpi_ctl->h_control;
1999 snd_control.access = SNDRV_CTL_ELEM_ACCESS_READWRITE;
2000
2001 if (!hpi_tuner_get_gain(hpi_ctl->h_control, NULL)) {
2002 asihpi_ctl_init(&snd_control, hpi_ctl, "Gain");
2003 snd_control.info = snd_asihpi_tuner_gain_info;
2004 snd_control.get = snd_asihpi_tuner_gain_get;
2005 snd_control.put = snd_asihpi_tuner_gain_put;
2006
2007 if (ctl_add(card, &snd_control, asihpi) < 0)
2008 return -EINVAL;
2009 }
2010
2011 asihpi_ctl_init(&snd_control, hpi_ctl, "Band");
2012 snd_control.info = snd_asihpi_tuner_band_info;
2013 snd_control.get = snd_asihpi_tuner_band_get;
2014 snd_control.put = snd_asihpi_tuner_band_put;
2015
2016 if (ctl_add(card, &snd_control, asihpi) < 0)
2017 return -EINVAL;
2018
2019 asihpi_ctl_init(&snd_control, hpi_ctl, "Freq");
2020 snd_control.info = snd_asihpi_tuner_freq_info;
2021 snd_control.get = snd_asihpi_tuner_freq_get;
2022 snd_control.put = snd_asihpi_tuner_freq_put;
2023
2024 return ctl_add(card, &snd_control, asihpi);
2025 }
2026
2027 /*------------------------------------------------------------
2028 Meter controls
2029 ------------------------------------------------------------*/
2030 static int snd_asihpi_meter_info(struct snd_kcontrol *kcontrol,
2031 struct snd_ctl_elem_info *uinfo)
2032 {
2033 u32 h_control = kcontrol->private_value;
2034 u32 count;
2035 u16 err;
2036 err = hpi_meter_query_channels(h_control, &count);
2037 if (err)
2038 count = HPI_MAX_CHANNELS;
2039
2040 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2041 uinfo->count = count;
2042 uinfo->value.integer.min = 0;
2043 uinfo->value.integer.max = 0x7FFFFFFF;
2044 return 0;
2045 }
2046
2047 /* linear values for 10dB steps */
2048 static const int log2lin[] = {
2049 0x7FFFFFFF, /* 0dB */
2050 679093956,
2051 214748365,
2052 67909396,
2053 21474837,
2054 6790940,
2055 2147484, /* -60dB */
2056 679094,
2057 214748, /* -80 */
2058 67909,
2059 21475, /* -100 */
2060 6791,
2061 2147,
2062 679,
2063 214,
2064 68,
2065 21,
2066 7,
2067 2
2068 };
2069
2070 static int snd_asihpi_meter_get(struct snd_kcontrol *kcontrol,
2071 struct snd_ctl_elem_value *ucontrol)
2072 {
2073 u32 h_control = kcontrol->private_value;
2074 short an_gain_mB[HPI_MAX_CHANNELS], i;
2075 u16 err;
2076
2077 err = hpi_meter_get_peak(h_control, an_gain_mB);
2078
2079 for (i = 0; i < HPI_MAX_CHANNELS; i++) {
2080 if (err) {
2081 ucontrol->value.integer.value[i] = 0;
2082 } else if (an_gain_mB[i] >= 0) {
2083 ucontrol->value.integer.value[i] =
2084 an_gain_mB[i] << 16;
2085 } else {
2086 /* -ve is log value in millibels < -60dB,
2087 * convert to (roughly!) linear,
2088 */
2089 ucontrol->value.integer.value[i] =
2090 log2lin[an_gain_mB[i] / -1000];
2091 }
2092 }
2093 return 0;
2094 }
2095
2096 static int snd_asihpi_meter_add(struct snd_card_asihpi *asihpi,
2097 struct hpi_control *hpi_ctl, int subidx)
2098 {
2099 struct snd_card *card = asihpi->card;
2100 struct snd_kcontrol_new snd_control;
2101
2102 asihpi_ctl_init(&snd_control, hpi_ctl, "Meter");
2103 snd_control.access =
2104 SNDRV_CTL_ELEM_ACCESS_VOLATILE | SNDRV_CTL_ELEM_ACCESS_READ;
2105 snd_control.info = snd_asihpi_meter_info;
2106 snd_control.get = snd_asihpi_meter_get;
2107
2108 snd_control.index = subidx;
2109
2110 return ctl_add(card, &snd_control, asihpi);
2111 }
2112
2113 /*------------------------------------------------------------
2114 Multiplexer controls
2115 ------------------------------------------------------------*/
2116 static int snd_card_asihpi_mux_count_sources(struct snd_kcontrol *snd_control)
2117 {
2118 u32 h_control = snd_control->private_value;
2119 struct hpi_control hpi_ctl;
2120 int s, err;
2121 for (s = 0; s < 32; s++) {
2122 err = hpi_multiplexer_query_source(h_control, s,
2123 &hpi_ctl.
2124 src_node_type,
2125 &hpi_ctl.
2126 src_node_index);
2127 if (err)
2128 break;
2129 }
2130 return s;
2131 }
2132
2133 static int snd_asihpi_mux_info(struct snd_kcontrol *kcontrol,
2134 struct snd_ctl_elem_info *uinfo)
2135 {
2136 u16 src_node_type, src_node_index;
2137 u32 h_control = kcontrol->private_value;
2138
2139 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2140 uinfo->count = 1;
2141 uinfo->value.enumerated.items =
2142 snd_card_asihpi_mux_count_sources(kcontrol);
2143
2144 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
2145 uinfo->value.enumerated.item =
2146 uinfo->value.enumerated.items - 1;
2147
2148 hpi_multiplexer_query_source(h_control,
2149 uinfo->value.enumerated.item,
2150 &src_node_type, &src_node_index);
2151
2152 sprintf(uinfo->value.enumerated.name, "%s %d",
2153 asihpi_src_names[src_node_type - HPI_SOURCENODE_NONE],
2154 src_node_index);
2155 return 0;
2156 }
2157
2158 static int snd_asihpi_mux_get(struct snd_kcontrol *kcontrol,
2159 struct snd_ctl_elem_value *ucontrol)
2160 {
2161 u32 h_control = kcontrol->private_value;
2162 u16 source_type, source_index;
2163 u16 src_node_type, src_node_index;
2164 int s;
2165
2166 hpi_handle_error(hpi_multiplexer_get_source(h_control,
2167 &source_type, &source_index));
2168 /* Should cache this search result! */
2169 for (s = 0; s < 256; s++) {
2170 if (hpi_multiplexer_query_source(h_control, s,
2171 &src_node_type, &src_node_index))
2172 break;
2173
2174 if ((source_type == src_node_type)
2175 && (source_index == src_node_index)) {
2176 ucontrol->value.enumerated.item[0] = s;
2177 return 0;
2178 }
2179 }
2180 snd_printd(KERN_WARNING
2181 "Control %x failed to match mux source %hu %hu\n",
2182 h_control, source_type, source_index);
2183 ucontrol->value.enumerated.item[0] = 0;
2184 return 0;
2185 }
2186
2187 static int snd_asihpi_mux_put(struct snd_kcontrol *kcontrol,
2188 struct snd_ctl_elem_value *ucontrol)
2189 {
2190 int change;
2191 u32 h_control = kcontrol->private_value;
2192 u16 source_type, source_index;
2193 u16 e;
2194
2195 change = 1;
2196
2197 e = hpi_multiplexer_query_source(h_control,
2198 ucontrol->value.enumerated.item[0],
2199 &source_type, &source_index);
2200 if (!e)
2201 hpi_handle_error(
2202 hpi_multiplexer_set_source(h_control,
2203 source_type, source_index));
2204 return change;
2205 }
2206
2207
2208 static int snd_asihpi_mux_add(struct snd_card_asihpi *asihpi,
2209 struct hpi_control *hpi_ctl)
2210 {
2211 struct snd_card *card = asihpi->card;
2212 struct snd_kcontrol_new snd_control;
2213
2214 asihpi_ctl_init(&snd_control, hpi_ctl, "Route");
2215 snd_control.access = SNDRV_CTL_ELEM_ACCESS_READWRITE;
2216 snd_control.info = snd_asihpi_mux_info;
2217 snd_control.get = snd_asihpi_mux_get;
2218 snd_control.put = snd_asihpi_mux_put;
2219
2220 return ctl_add(card, &snd_control, asihpi);
2221
2222 }
2223
2224 /*------------------------------------------------------------
2225 Channel mode controls
2226 ------------------------------------------------------------*/
2227 static int snd_asihpi_cmode_info(struct snd_kcontrol *kcontrol,
2228 struct snd_ctl_elem_info *uinfo)
2229 {
2230 static const char * const mode_names[HPI_CHANNEL_MODE_LAST + 1] = {
2231 "invalid",
2232 "Normal", "Swap",
2233 "From Left", "From Right",
2234 "To Left", "To Right"
2235 };
2236
2237 u32 h_control = kcontrol->private_value;
2238 u16 mode;
2239 int i;
2240 const char *mapped_names[6];
2241 int valid_modes = 0;
2242
2243 /* HPI channel mode values can be from 1 to 6
2244 Some adapters only support a contiguous subset
2245 */
2246 for (i = 0; i < HPI_CHANNEL_MODE_LAST; i++)
2247 if (!hpi_channel_mode_query_mode(
2248 h_control, i, &mode)) {
2249 mapped_names[valid_modes] = mode_names[mode];
2250 valid_modes++;
2251 }
2252
2253 if (!valid_modes)
2254 return -EINVAL;
2255
2256 return snd_ctl_enum_info(uinfo, 1, valid_modes, mapped_names);
2257 }
2258
2259 static int snd_asihpi_cmode_get(struct snd_kcontrol *kcontrol,
2260 struct snd_ctl_elem_value *ucontrol)
2261 {
2262 u32 h_control = kcontrol->private_value;
2263 u16 mode;
2264
2265 if (hpi_channel_mode_get(h_control, &mode))
2266 mode = 1;
2267
2268 ucontrol->value.enumerated.item[0] = mode - 1;
2269
2270 return 0;
2271 }
2272
2273 static int snd_asihpi_cmode_put(struct snd_kcontrol *kcontrol,
2274 struct snd_ctl_elem_value *ucontrol)
2275 {
2276 int change;
2277 u32 h_control = kcontrol->private_value;
2278
2279 change = 1;
2280
2281 hpi_handle_error(hpi_channel_mode_set(h_control,
2282 ucontrol->value.enumerated.item[0] + 1));
2283 return change;
2284 }
2285
2286
2287 static int snd_asihpi_cmode_add(struct snd_card_asihpi *asihpi,
2288 struct hpi_control *hpi_ctl)
2289 {
2290 struct snd_card *card = asihpi->card;
2291 struct snd_kcontrol_new snd_control;
2292
2293 asihpi_ctl_init(&snd_control, hpi_ctl, "Mode");
2294 snd_control.access = SNDRV_CTL_ELEM_ACCESS_READWRITE;
2295 snd_control.info = snd_asihpi_cmode_info;
2296 snd_control.get = snd_asihpi_cmode_get;
2297 snd_control.put = snd_asihpi_cmode_put;
2298
2299 return ctl_add(card, &snd_control, asihpi);
2300 }
2301
2302 /*------------------------------------------------------------
2303 Sampleclock source controls
2304 ------------------------------------------------------------*/
2305 static const char * const sampleclock_sources[] = {
2306 "N/A", "Local PLL", "Digital Sync", "Word External", "Word Header",
2307 "SMPTE", "Digital1", "Auto", "Network", "Invalid",
2308 "Prev Module", "BLU-Link",
2309 "Digital2", "Digital3", "Digital4", "Digital5",
2310 "Digital6", "Digital7", "Digital8"};
2311
2312 /* Number of strings must match expected enumerated values */
2313 compile_time_assert(
2314 (ARRAY_SIZE(sampleclock_sources) == MAX_CLOCKSOURCES),
2315 assert_sampleclock_sources_size);
2316
2317 static int snd_asihpi_clksrc_info(struct snd_kcontrol *kcontrol,
2318 struct snd_ctl_elem_info *uinfo)
2319 {
2320 struct snd_card_asihpi *asihpi =
2321 (struct snd_card_asihpi *)(kcontrol->private_data);
2322 struct clk_cache *clkcache = &asihpi->cc;
2323 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2324 uinfo->count = 1;
2325 uinfo->value.enumerated.items = clkcache->count;
2326
2327 if (uinfo->value.enumerated.item >= uinfo->value.enumerated.items)
2328 uinfo->value.enumerated.item =
2329 uinfo->value.enumerated.items - 1;
2330
2331 strcpy(uinfo->value.enumerated.name,
2332 clkcache->s[uinfo->value.enumerated.item].name);
2333 return 0;
2334 }
2335
2336 static int snd_asihpi_clksrc_get(struct snd_kcontrol *kcontrol,
2337 struct snd_ctl_elem_value *ucontrol)
2338 {
2339 struct snd_card_asihpi *asihpi =
2340 (struct snd_card_asihpi *)(kcontrol->private_data);
2341 struct clk_cache *clkcache = &asihpi->cc;
2342 u32 h_control = kcontrol->private_value;
2343 u16 source, srcindex = 0;
2344 int i;
2345
2346 ucontrol->value.enumerated.item[0] = 0;
2347 if (hpi_sample_clock_get_source(h_control, &source))
2348 source = 0;
2349
2350 if (source == HPI_SAMPLECLOCK_SOURCE_AESEBU_INPUT)
2351 if (hpi_sample_clock_get_source_index(h_control, &srcindex))
2352 srcindex = 0;
2353
2354 for (i = 0; i < clkcache->count; i++)
2355 if ((clkcache->s[i].source == source) &&
2356 (clkcache->s[i].index == srcindex))
2357 break;
2358
2359 ucontrol->value.enumerated.item[0] = i;
2360
2361 return 0;
2362 }
2363
2364 static int snd_asihpi_clksrc_put(struct snd_kcontrol *kcontrol,
2365 struct snd_ctl_elem_value *ucontrol)
2366 {
2367 struct snd_card_asihpi *asihpi =
2368 (struct snd_card_asihpi *)(kcontrol->private_data);
2369 struct clk_cache *clkcache = &asihpi->cc;
2370 unsigned int item;
2371 int change;
2372 u32 h_control = kcontrol->private_value;
2373
2374 change = 1;
2375 item = ucontrol->value.enumerated.item[0];
2376 if (item >= clkcache->count)
2377 item = clkcache->count-1;
2378
2379 hpi_handle_error(hpi_sample_clock_set_source(
2380 h_control, clkcache->s[item].source));
2381
2382 if (clkcache->s[item].source == HPI_SAMPLECLOCK_SOURCE_AESEBU_INPUT)
2383 hpi_handle_error(hpi_sample_clock_set_source_index(
2384 h_control, clkcache->s[item].index));
2385 return change;
2386 }
2387
2388 /*------------------------------------------------------------
2389 Clkrate controls
2390 ------------------------------------------------------------*/
2391 /* Need to change this to enumerated control with list of rates */
2392 static int snd_asihpi_clklocal_info(struct snd_kcontrol *kcontrol,
2393 struct snd_ctl_elem_info *uinfo)
2394 {
2395 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2396 uinfo->count = 1;
2397 uinfo->value.integer.min = 8000;
2398 uinfo->value.integer.max = 192000;
2399 uinfo->value.integer.step = 100;
2400
2401 return 0;
2402 }
2403
2404 static int snd_asihpi_clklocal_get(struct snd_kcontrol *kcontrol,
2405 struct snd_ctl_elem_value *ucontrol)
2406 {
2407 u32 h_control = kcontrol->private_value;
2408 u32 rate;
2409 u16 e;
2410
2411 e = hpi_sample_clock_get_local_rate(h_control, &rate);
2412 if (!e)
2413 ucontrol->value.integer.value[0] = rate;
2414 else
2415 ucontrol->value.integer.value[0] = 0;
2416 return 0;
2417 }
2418
2419 static int snd_asihpi_clklocal_put(struct snd_kcontrol *kcontrol,
2420 struct snd_ctl_elem_value *ucontrol)
2421 {
2422 int change;
2423 u32 h_control = kcontrol->private_value;
2424
2425 /* change = asihpi->mixer_clkrate[addr][0] != left ||
2426 asihpi->mixer_clkrate[addr][1] != right;
2427 */
2428 change = 1;
2429 hpi_handle_error(hpi_sample_clock_set_local_rate(h_control,
2430 ucontrol->value.integer.value[0]));
2431 return change;
2432 }
2433
2434 static int snd_asihpi_clkrate_info(struct snd_kcontrol *kcontrol,
2435 struct snd_ctl_elem_info *uinfo)
2436 {
2437 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2438 uinfo->count = 1;
2439 uinfo->value.integer.min = 8000;
2440 uinfo->value.integer.max = 192000;
2441 uinfo->value.integer.step = 100;
2442
2443 return 0;
2444 }
2445
2446 static int snd_asihpi_clkrate_get(struct snd_kcontrol *kcontrol,
2447 struct snd_ctl_elem_value *ucontrol)
2448 {
2449 u32 h_control = kcontrol->private_value;
2450 u32 rate;
2451 u16 e;
2452
2453 e = hpi_sample_clock_get_sample_rate(h_control, &rate);
2454 if (!e)
2455 ucontrol->value.integer.value[0] = rate;
2456 else
2457 ucontrol->value.integer.value[0] = 0;
2458 return 0;
2459 }
2460
2461 static int snd_asihpi_sampleclock_add(struct snd_card_asihpi *asihpi,
2462 struct hpi_control *hpi_ctl)
2463 {
2464 struct snd_card *card;
2465 struct snd_kcontrol_new snd_control;
2466
2467 struct clk_cache *clkcache;
2468 u32 hSC = hpi_ctl->h_control;
2469 int has_aes_in = 0;
2470 int i, j;
2471 u16 source;
2472
2473 if (snd_BUG_ON(!asihpi))
2474 return -EINVAL;
2475 card = asihpi->card;
2476 clkcache = &asihpi->cc;
2477 snd_control.private_value = hpi_ctl->h_control;
2478
2479 clkcache->has_local = 0;
2480
2481 for (i = 0; i <= HPI_SAMPLECLOCK_SOURCE_LAST; i++) {
2482 if (hpi_sample_clock_query_source(hSC,
2483 i, &source))
2484 break;
2485 clkcache->s[i].source = source;
2486 clkcache->s[i].index = 0;
2487 clkcache->s[i].name = sampleclock_sources[source];
2488 if (source == HPI_SAMPLECLOCK_SOURCE_AESEBU_INPUT)
2489 has_aes_in = 1;
2490 if (source == HPI_SAMPLECLOCK_SOURCE_LOCAL)
2491 clkcache->has_local = 1;
2492 }
2493 if (has_aes_in)
2494 /* already will have picked up index 0 above */
2495 for (j = 1; j < 8; j++) {
2496 if (hpi_sample_clock_query_source_index(hSC,
2497 j, HPI_SAMPLECLOCK_SOURCE_AESEBU_INPUT,
2498 &source))
2499 break;
2500 clkcache->s[i].source =
2501 HPI_SAMPLECLOCK_SOURCE_AESEBU_INPUT;
2502 clkcache->s[i].index = j;
2503 clkcache->s[i].name = sampleclock_sources[
2504 j+HPI_SAMPLECLOCK_SOURCE_LAST];
2505 i++;
2506 }
2507 clkcache->count = i;
2508
2509 asihpi_ctl_init(&snd_control, hpi_ctl, "Source");
2510 snd_control.access = SNDRV_CTL_ELEM_ACCESS_READWRITE ;
2511 snd_control.info = snd_asihpi_clksrc_info;
2512 snd_control.get = snd_asihpi_clksrc_get;
2513 snd_control.put = snd_asihpi_clksrc_put;
2514 if (ctl_add(card, &snd_control, asihpi) < 0)
2515 return -EINVAL;
2516
2517
2518 if (clkcache->has_local) {
2519 asihpi_ctl_init(&snd_control, hpi_ctl, "Localrate");
2520 snd_control.access = SNDRV_CTL_ELEM_ACCESS_READWRITE ;
2521 snd_control.info = snd_asihpi_clklocal_info;
2522 snd_control.get = snd_asihpi_clklocal_get;
2523 snd_control.put = snd_asihpi_clklocal_put;
2524
2525
2526 if (ctl_add(card, &snd_control, asihpi) < 0)
2527 return -EINVAL;
2528 }
2529
2530 asihpi_ctl_init(&snd_control, hpi_ctl, "Rate");
2531 snd_control.access =
2532 SNDRV_CTL_ELEM_ACCESS_VOLATILE | SNDRV_CTL_ELEM_ACCESS_READ;
2533 snd_control.info = snd_asihpi_clkrate_info;
2534 snd_control.get = snd_asihpi_clkrate_get;
2535
2536 return ctl_add(card, &snd_control, asihpi);
2537 }
2538 /*------------------------------------------------------------
2539 Mixer
2540 ------------------------------------------------------------*/
2541
2542 static int snd_card_asihpi_mixer_new(struct snd_card_asihpi *asihpi)
2543 {
2544 struct snd_card *card;
2545 unsigned int idx = 0;
2546 unsigned int subindex = 0;
2547 int err;
2548 struct hpi_control hpi_ctl, prev_ctl;
2549
2550 if (snd_BUG_ON(!asihpi))
2551 return -EINVAL;
2552 card = asihpi->card;
2553 strcpy(card->mixername, "Asihpi Mixer");
2554
2555 err =
2556 hpi_mixer_open(asihpi->hpi->adapter->index,
2557 &asihpi->h_mixer);
2558 hpi_handle_error(err);
2559 if (err)
2560 return -err;
2561
2562 memset(&prev_ctl, 0, sizeof(prev_ctl));
2563 prev_ctl.control_type = -1;
2564
2565 for (idx = 0; idx < 2000; idx++) {
2566 err = hpi_mixer_get_control_by_index(
2567 asihpi->h_mixer,
2568 idx,
2569 &hpi_ctl.src_node_type,
2570 &hpi_ctl.src_node_index,
2571 &hpi_ctl.dst_node_type,
2572 &hpi_ctl.dst_node_index,
2573 &hpi_ctl.control_type,
2574 &hpi_ctl.h_control);
2575 if (err) {
2576 if (err == HPI_ERROR_CONTROL_DISABLED) {
2577 if (mixer_dump)
2578 dev_info(&asihpi->pci->dev,
2579 "Disabled HPI Control(%d)\n",
2580 idx);
2581 continue;
2582 } else
2583 break;
2584
2585 }
2586
2587 hpi_ctl.src_node_type -= HPI_SOURCENODE_NONE;
2588 hpi_ctl.dst_node_type -= HPI_DESTNODE_NONE;
2589
2590 /* ASI50xx in SSX mode has multiple meters on the same node.
2591 Use subindex to create distinct ALSA controls
2592 for any duplicated controls.
2593 */
2594 if ((hpi_ctl.control_type == prev_ctl.control_type) &&
2595 (hpi_ctl.src_node_type == prev_ctl.src_node_type) &&
2596 (hpi_ctl.src_node_index == prev_ctl.src_node_index) &&
2597 (hpi_ctl.dst_node_type == prev_ctl.dst_node_type) &&
2598 (hpi_ctl.dst_node_index == prev_ctl.dst_node_index))
2599 subindex++;
2600 else
2601 subindex = 0;
2602
2603 prev_ctl = hpi_ctl;
2604
2605 switch (hpi_ctl.control_type) {
2606 case HPI_CONTROL_VOLUME:
2607 err = snd_asihpi_volume_add(asihpi, &hpi_ctl);
2608 break;
2609 case HPI_CONTROL_LEVEL:
2610 err = snd_asihpi_level_add(asihpi, &hpi_ctl);
2611 break;
2612 case HPI_CONTROL_MULTIPLEXER:
2613 err = snd_asihpi_mux_add(asihpi, &hpi_ctl);
2614 break;
2615 case HPI_CONTROL_CHANNEL_MODE:
2616 err = snd_asihpi_cmode_add(asihpi, &hpi_ctl);
2617 break;
2618 case HPI_CONTROL_METER:
2619 err = snd_asihpi_meter_add(asihpi, &hpi_ctl, subindex);
2620 break;
2621 case HPI_CONTROL_SAMPLECLOCK:
2622 err = snd_asihpi_sampleclock_add(
2623 asihpi, &hpi_ctl);
2624 break;
2625 case HPI_CONTROL_CONNECTION: /* ignore these */
2626 continue;
2627 case HPI_CONTROL_TUNER:
2628 err = snd_asihpi_tuner_add(asihpi, &hpi_ctl);
2629 break;
2630 case HPI_CONTROL_AESEBU_TRANSMITTER:
2631 err = snd_asihpi_aesebu_tx_add(asihpi, &hpi_ctl);
2632 break;
2633 case HPI_CONTROL_AESEBU_RECEIVER:
2634 err = snd_asihpi_aesebu_rx_add(asihpi, &hpi_ctl);
2635 break;
2636 case HPI_CONTROL_VOX:
2637 case HPI_CONTROL_BITSTREAM:
2638 case HPI_CONTROL_MICROPHONE:
2639 case HPI_CONTROL_PARAMETRIC_EQ:
2640 case HPI_CONTROL_COMPANDER:
2641 default:
2642 if (mixer_dump)
2643 dev_info(&asihpi->pci->dev,
2644 "Untranslated HPI Control (%d) %d %d %d %d %d\n",
2645 idx,
2646 hpi_ctl.control_type,
2647 hpi_ctl.src_node_type,
2648 hpi_ctl.src_node_index,
2649 hpi_ctl.dst_node_type,
2650 hpi_ctl.dst_node_index);
2651 continue;
2652 }
2653 if (err < 0)
2654 return err;
2655 }
2656 if (HPI_ERROR_INVALID_OBJ_INDEX != err)
2657 hpi_handle_error(err);
2658
2659 dev_info(&asihpi->pci->dev, "%d mixer controls found\n", idx);
2660
2661 return 0;
2662 }
2663
2664 /*------------------------------------------------------------
2665 /proc interface
2666 ------------------------------------------------------------*/
2667
2668 static void
2669 snd_asihpi_proc_read(struct snd_info_entry *entry,
2670 struct snd_info_buffer *buffer)
2671 {
2672 struct snd_card_asihpi *asihpi = entry->private_data;
2673 u32 h_control;
2674 u32 rate = 0;
2675 u16 source = 0;
2676
2677 u16 num_outstreams;
2678 u16 num_instreams;
2679 u16 version;
2680 u32 serial_number;
2681 u16 type;
2682
2683 int err;
2684
2685 snd_iprintf(buffer, "ASIHPI driver proc file\n");
2686
2687 hpi_handle_error(hpi_adapter_get_info(asihpi->hpi->adapter->index,
2688 &num_outstreams, &num_instreams,
2689 &version, &serial_number, &type));
2690
2691 snd_iprintf(buffer,
2692 "Adapter type ASI%4X\nHardware Index %d\n"
2693 "%d outstreams\n%d instreams\n",
2694 type, asihpi->hpi->adapter->index,
2695 num_outstreams, num_instreams);
2696
2697 snd_iprintf(buffer,
2698 "Serial#%d\nHardware version %c%d\nDSP code version %03d\n",
2699 serial_number, ((version >> 3) & 0xf) + 'A', version & 0x7,
2700 ((version >> 13) * 100) + ((version >> 7) & 0x3f));
2701
2702 err = hpi_mixer_get_control(asihpi->h_mixer,
2703 HPI_SOURCENODE_CLOCK_SOURCE, 0, 0, 0,
2704 HPI_CONTROL_SAMPLECLOCK, &h_control);
2705
2706 if (!err) {
2707 err = hpi_sample_clock_get_sample_rate(h_control, &rate);
2708 err += hpi_sample_clock_get_source(h_control, &source);
2709
2710 if (!err)
2711 snd_iprintf(buffer, "Sample Clock %dHz, source %s\n",
2712 rate, sampleclock_sources[source]);
2713 }
2714 }
2715
2716 static void snd_asihpi_proc_init(struct snd_card_asihpi *asihpi)
2717 {
2718 snd_card_ro_proc_new(asihpi->card, "info", asihpi,
2719 snd_asihpi_proc_read);
2720 }
2721
2722 /*------------------------------------------------------------
2723 HWDEP
2724 ------------------------------------------------------------*/
2725
2726 static int snd_asihpi_hpi_open(struct snd_hwdep *hw, struct file *file)
2727 {
2728 if (enable_hpi_hwdep)
2729 return 0;
2730 else
2731 return -ENODEV;
2732
2733 }
2734
2735 static int snd_asihpi_hpi_release(struct snd_hwdep *hw, struct file *file)
2736 {
2737 if (enable_hpi_hwdep)
2738 return asihpi_hpi_release(file);
2739 else
2740 return -ENODEV;
2741 }
2742
2743 static int snd_asihpi_hpi_ioctl(struct snd_hwdep *hw, struct file *file,
2744 unsigned int cmd, unsigned long arg)
2745 {
2746 if (enable_hpi_hwdep)
2747 return asihpi_hpi_ioctl(file, cmd, arg);
2748 else
2749 return -ENODEV;
2750 }
2751
2752
2753 /* results in /dev/snd/hwC#D0 file for each card with index #
2754 also /proc/asound/hwdep will contain '#-00: asihpi (HPI) for each card'
2755 */
2756 static int snd_asihpi_hpi_new(struct snd_card_asihpi *asihpi, int device)
2757 {
2758 struct snd_hwdep *hw;
2759 int err;
2760
2761 err = snd_hwdep_new(asihpi->card, "HPI", device, &hw);
2762 if (err < 0)
2763 return err;
2764 strcpy(hw->name, "asihpi (HPI)");
2765 hw->iface = SNDRV_HWDEP_IFACE_LAST;
2766 hw->ops.open = snd_asihpi_hpi_open;
2767 hw->ops.ioctl = snd_asihpi_hpi_ioctl;
2768 hw->ops.release = snd_asihpi_hpi_release;
2769 hw->private_data = asihpi;
2770 return 0;
2771 }
2772
2773 /*------------------------------------------------------------
2774 CARD
2775 ------------------------------------------------------------*/
2776 static int snd_asihpi_probe(struct pci_dev *pci_dev,
2777 const struct pci_device_id *pci_id)
2778 {
2779 int err;
2780 struct hpi_adapter *hpi;
2781 struct snd_card *card;
2782 struct snd_card_asihpi *asihpi;
2783
2784 u32 h_control;
2785 u32 h_stream;
2786 u32 adapter_index;
2787
2788 static int dev;
2789 if (dev >= SNDRV_CARDS)
2790 return -ENODEV;
2791
2792 /* Should this be enable[hpi->index] ? */
2793 if (!enable[dev]) {
2794 dev++;
2795 return -ENOENT;
2796 }
2797
2798 /* Initialise low-level HPI driver */
2799 err = asihpi_adapter_probe(pci_dev, pci_id);
2800 if (err < 0)
2801 return err;
2802
2803 hpi = pci_get_drvdata(pci_dev);
2804 adapter_index = hpi->adapter->index;
2805 /* first try to give the card the same index as its hardware index */
2806 err = snd_card_new(&pci_dev->dev, adapter_index, id[adapter_index],
2807 THIS_MODULE, sizeof(struct snd_card_asihpi), &card);
2808 if (err < 0) {
2809 /* if that fails, try the default index==next available */
2810 err = snd_card_new(&pci_dev->dev, index[dev], id[dev],
2811 THIS_MODULE, sizeof(struct snd_card_asihpi),
2812 &card);
2813 if (err < 0)
2814 return err;
2815 dev_warn(&pci_dev->dev, "Adapter index %d->ALSA index %d\n",
2816 adapter_index, card->number);
2817 }
2818
2819 asihpi = card->private_data;
2820 asihpi->card = card;
2821 asihpi->pci = pci_dev;
2822 asihpi->hpi = hpi;
2823 hpi->snd_card = card;
2824
2825 err = hpi_adapter_get_property(adapter_index,
2826 HPI_ADAPTER_PROPERTY_CAPS1,
2827 NULL, &asihpi->support_grouping);
2828 if (err)
2829 asihpi->support_grouping = 0;
2830
2831 err = hpi_adapter_get_property(adapter_index,
2832 HPI_ADAPTER_PROPERTY_CAPS2,
2833 &asihpi->support_mrx, NULL);
2834 if (err)
2835 asihpi->support_mrx = 0;
2836
2837 err = hpi_adapter_get_property(adapter_index,
2838 HPI_ADAPTER_PROPERTY_INTERVAL,
2839 NULL, &asihpi->update_interval_frames);
2840 if (err)
2841 asihpi->update_interval_frames = 512;
2842
2843 if (hpi->interrupt_mode) {
2844 asihpi->pcm_start = snd_card_asihpi_pcm_int_start;
2845 asihpi->pcm_stop = snd_card_asihpi_pcm_int_stop;
2846 hpi->interrupt_callback = snd_card_asihpi_isr;
2847 } else {
2848 asihpi->pcm_start = snd_card_asihpi_pcm_timer_start;
2849 asihpi->pcm_stop = snd_card_asihpi_pcm_timer_stop;
2850 }
2851
2852 hpi_handle_error(hpi_instream_open(adapter_index,
2853 0, &h_stream));
2854
2855 err = hpi_instream_host_buffer_free(h_stream);
2856 asihpi->can_dma = (!err);
2857
2858 hpi_handle_error(hpi_instream_close(h_stream));
2859
2860 if (!asihpi->can_dma)
2861 asihpi->update_interval_frames *= 2;
2862
2863 err = hpi_adapter_get_property(adapter_index,
2864 HPI_ADAPTER_PROPERTY_CURCHANNELS,
2865 &asihpi->in_max_chans, &asihpi->out_max_chans);
2866 if (err) {
2867 asihpi->in_max_chans = 2;
2868 asihpi->out_max_chans = 2;
2869 }
2870
2871 if (asihpi->out_max_chans > 2) { /* assume LL mode */
2872 asihpi->out_min_chans = asihpi->out_max_chans;
2873 asihpi->in_min_chans = asihpi->in_max_chans;
2874 asihpi->support_grouping = 0;
2875 } else {
2876 asihpi->out_min_chans = 1;
2877 asihpi->in_min_chans = 1;
2878 }
2879
2880 dev_info(&pci_dev->dev, "Has dma:%d, grouping:%d, mrx:%d, uif:%d\n",
2881 asihpi->can_dma,
2882 asihpi->support_grouping,
2883 asihpi->support_mrx,
2884 asihpi->update_interval_frames
2885 );
2886
2887 err = snd_card_asihpi_pcm_new(asihpi, 0);
2888 if (err < 0) {
2889 dev_err(&pci_dev->dev, "pcm_new failed\n");
2890 goto __nodev;
2891 }
2892 err = snd_card_asihpi_mixer_new(asihpi);
2893 if (err < 0) {
2894 dev_err(&pci_dev->dev, "mixer_new failed\n");
2895 goto __nodev;
2896 }
2897
2898 err = hpi_mixer_get_control(asihpi->h_mixer,
2899 HPI_SOURCENODE_CLOCK_SOURCE, 0, 0, 0,
2900 HPI_CONTROL_SAMPLECLOCK, &h_control);
2901
2902 if (!err)
2903 err = hpi_sample_clock_set_local_rate(
2904 h_control, adapter_fs);
2905
2906 snd_asihpi_proc_init(asihpi);
2907
2908 /* always create, can be enabled or disabled dynamically
2909 by enable_hwdep module param*/
2910 snd_asihpi_hpi_new(asihpi, 0);
2911
2912 strcpy(card->driver, "ASIHPI");
2913
2914 sprintf(card->shortname, "AudioScience ASI%4X",
2915 asihpi->hpi->adapter->type);
2916 sprintf(card->longname, "%s %i",
2917 card->shortname, adapter_index);
2918 err = snd_card_register(card);
2919
2920 if (!err) {
2921 dev++;
2922 return 0;
2923 }
2924 __nodev:
2925 snd_card_free(card);
2926 dev_err(&pci_dev->dev, "snd_asihpi_probe error %d\n", err);
2927 return err;
2928
2929 }
2930
2931 static void snd_asihpi_remove(struct pci_dev *pci_dev)
2932 {
2933 struct hpi_adapter *hpi = pci_get_drvdata(pci_dev);
2934
2935 /* Stop interrupts */
2936 if (hpi->interrupt_mode) {
2937 hpi->interrupt_callback = NULL;
2938 hpi_handle_error(hpi_adapter_set_property(hpi->adapter->index,
2939 HPI_ADAPTER_PROPERTY_IRQ_RATE, 0, 0));
2940 }
2941
2942 snd_card_free(hpi->snd_card);
2943 hpi->snd_card = NULL;
2944 asihpi_adapter_remove(pci_dev);
2945 }
2946
2947 static const struct pci_device_id asihpi_pci_tbl[] = {
2948 {HPI_PCI_VENDOR_ID_TI, HPI_PCI_DEV_ID_DSP6205,
2949 HPI_PCI_VENDOR_ID_AUDIOSCIENCE, PCI_ANY_ID, 0, 0,
2950 (kernel_ulong_t)HPI_6205},
2951 {HPI_PCI_VENDOR_ID_TI, HPI_PCI_DEV_ID_PCI2040,
2952 HPI_PCI_VENDOR_ID_AUDIOSCIENCE, PCI_ANY_ID, 0, 0,
2953 (kernel_ulong_t)HPI_6000},
2954 {0,}
2955 };
2956 MODULE_DEVICE_TABLE(pci, asihpi_pci_tbl);
2957
2958 static struct pci_driver driver = {
2959 .name = KBUILD_MODNAME,
2960 .id_table = asihpi_pci_tbl,
2961 .probe = snd_asihpi_probe,
2962 .remove = snd_asihpi_remove,
2963 };
2964
2965 static int __init snd_asihpi_init(void)
2966 {
2967 asihpi_init();
2968 return pci_register_driver(&driver);
2969 }
2970
2971 static void __exit snd_asihpi_exit(void)
2972 {
2973
2974 pci_unregister_driver(&driver);
2975 asihpi_exit();
2976 }
2977
2978 module_init(snd_asihpi_init)
2979 module_exit(snd_asihpi_exit)
2980
Linux with added FPC-III support