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