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