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