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