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