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