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