projects / deliverable / linux.git / blob
? search:


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