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