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