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