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