1 /* 2 * 3 * Support for audio capture 4 * PCI function #1 of the cx2388x. 5 * 6 * (c) 2007 Trent Piepho <xyzzy@speakeasy.org> 7 * (c) 2005,2006 Ricardo Cerqueira <v4l@cerqueira.org> 8 * (c) 2005 Mauro Carvalho Chehab <mchehab@infradead.org> 9 * Based on a dummy cx88 module by Gerd Knorr <kraxel@bytesex.org> 10 * Based on dummy.c by Jaroslav Kysela <perex@perex.cz> 11 * 12 * This program is free software; you can redistribute it and/or modify 13 * it under the terms of the GNU General Public License as published by 14 * the Free Software Foundation; either version 2 of the License, or 15 * (at your option) any later version. 16 * 17 * This program is distributed in the hope that it will be useful, 18 * but WITHOUT ANY WARRANTY; without even the implied warranty of 19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 20 * GNU General Public License for more details. 21 * 22 * You should have received a copy of the GNU General Public License 23 * along with this program; if not, write to the Free Software 24 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 25 */ 26 27 #include <linux/module.h> 28 #include <linux/init.h> 29 #include <linux/device.h> 30 #include <linux/interrupt.h> 31 #include <linux/vmalloc.h> 32 #include <linux/dma-mapping.h> 33 #include <linux/pci.h> 34 #include <linux/slab.h> 35 36 #include <asm/delay.h> 37 #include <sound/core.h> 38 #include <sound/pcm.h> 39 #include <sound/pcm_params.h> 40 #include <sound/control.h> 41 #include <sound/initval.h> 42 #include <sound/tlv.h> 43 #include <media/wm8775.h> 44 45 #include "cx88.h" 46 #include "cx88-reg.h" 47 48 #define dprintk(level, fmt, arg...) do { \ 49 if (debug + 1 > level) \ 50 printk(KERN_INFO "%s/1: " fmt, chip->core->name , ## arg);\ 51 } while(0) 52 53 #define dprintk_core(level, fmt, arg...) do { \ 54 if (debug + 1 > level) \ 55 printk(KERN_DEBUG "%s/1: " fmt, chip->core->name , ## arg);\ 56 } while(0) 57 58 /**************************************************************************** 59 Data type declarations - Can be moded to a header file later 60 ****************************************************************************/ 61 62 struct cx88_audio_buffer { 63 unsigned int bpl; 64 struct btcx_riscmem risc; 65 struct videobuf_dmabuf dma; 66 }; 67 68 struct cx88_audio_dev { 69 struct cx88_core *core; 70 struct cx88_dmaqueue q; 71 72 /* pci i/o */ 73 struct pci_dev *pci; 74 75 /* audio controls */ 76 int irq; 77 78 struct snd_card *card; 79 80 spinlock_t reg_lock; 81 atomic_t count; 82 83 unsigned int dma_size; 84 unsigned int period_size; 85 unsigned int num_periods; 86 87 struct videobuf_dmabuf *dma_risc; 88 89 struct cx88_audio_buffer *buf; 90 91 struct snd_pcm_substream *substream; 92 }; 93 typedef struct cx88_audio_dev snd_cx88_card_t; 94 95 96 97 /**************************************************************************** 98 Module global static vars 99 ****************************************************************************/ 100 101 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */ 102 static const char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */ 103 static bool enable[SNDRV_CARDS] = {1, [1 ... (SNDRV_CARDS - 1)] = 1}; 104 105 module_param_array(enable, bool, NULL, 0444); 106 MODULE_PARM_DESC(enable, "Enable cx88x soundcard. default enabled."); 107 108 module_param_array(index, int, NULL, 0444); 109 MODULE_PARM_DESC(index, "Index value for cx88x capture interface(s)."); 110 111 112 /**************************************************************************** 113 Module macros 114 ****************************************************************************/ 115 116 MODULE_DESCRIPTION("ALSA driver module for cx2388x based TV cards"); 117 MODULE_AUTHOR("Ricardo Cerqueira"); 118 MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@infradead.org>"); 119 MODULE_LICENSE("GPL"); 120 MODULE_VERSION(CX88_VERSION); 121 122 MODULE_SUPPORTED_DEVICE("{{Conexant,23881}," 123 "{{Conexant,23882}," 124 "{{Conexant,23883}"); 125 static unsigned int debug; 126 module_param(debug,int,0644); 127 MODULE_PARM_DESC(debug,"enable debug messages"); 128 129 /**************************************************************************** 130 Module specific funtions 131 ****************************************************************************/ 132 133 /* 134 * BOARD Specific: Sets audio DMA 135 */ 136 137 static int _cx88_start_audio_dma(snd_cx88_card_t *chip) 138 { 139 struct cx88_audio_buffer *buf = chip->buf; 140 struct cx88_core *core=chip->core; 141 const struct sram_channel *audio_ch = &cx88_sram_channels[SRAM_CH25]; 142 143 /* Make sure RISC/FIFO are off before changing FIFO/RISC settings */ 144 cx_clear(MO_AUD_DMACNTRL, 0x11); 145 146 /* setup fifo + format - out channel */ 147 cx88_sram_channel_setup(chip->core, audio_ch, buf->bpl, buf->risc.dma); 148 149 /* sets bpl size */ 150 cx_write(MO_AUDD_LNGTH, buf->bpl); 151 152 /* reset counter */ 153 cx_write(MO_AUDD_GPCNTRL, GP_COUNT_CONTROL_RESET); 154 atomic_set(&chip->count, 0); 155 156 dprintk(1, "Start audio DMA, %d B/line, %d lines/FIFO, %d periods, %d " 157 "byte buffer\n", buf->bpl, cx_read(audio_ch->cmds_start + 8)>>1, 158 chip->num_periods, buf->bpl * chip->num_periods); 159 160 /* Enables corresponding bits at AUD_INT_STAT */ 161 cx_write(MO_AUD_INTMSK, AUD_INT_OPC_ERR | AUD_INT_DN_SYNC | 162 AUD_INT_DN_RISCI2 | AUD_INT_DN_RISCI1); 163 164 /* Clean any pending interrupt bits already set */ 165 cx_write(MO_AUD_INTSTAT, ~0); 166 167 /* enable audio irqs */ 168 cx_set(MO_PCI_INTMSK, chip->core->pci_irqmask | PCI_INT_AUDINT); 169 170 /* start dma */ 171 cx_set(MO_DEV_CNTRL2, (1<<5)); /* Enables Risc Processor */ 172 cx_set(MO_AUD_DMACNTRL, 0x11); /* audio downstream FIFO and RISC enable */ 173 174 if (debug) 175 cx88_sram_channel_dump(chip->core, audio_ch); 176 177 return 0; 178 } 179 180 /* 181 * BOARD Specific: Resets audio DMA 182 */ 183 static int _cx88_stop_audio_dma(snd_cx88_card_t *chip) 184 { 185 struct cx88_core *core=chip->core; 186 dprintk(1, "Stopping audio DMA\n"); 187 188 /* stop dma */ 189 cx_clear(MO_AUD_DMACNTRL, 0x11); 190 191 /* disable irqs */ 192 cx_clear(MO_PCI_INTMSK, PCI_INT_AUDINT); 193 cx_clear(MO_AUD_INTMSK, AUD_INT_OPC_ERR | AUD_INT_DN_SYNC | 194 AUD_INT_DN_RISCI2 | AUD_INT_DN_RISCI1); 195 196 if (debug) 197 cx88_sram_channel_dump(chip->core, &cx88_sram_channels[SRAM_CH25]); 198 199 return 0; 200 } 201 202 #define MAX_IRQ_LOOP 50 203 204 /* 205 * BOARD Specific: IRQ dma bits 206 */ 207 static const char *cx88_aud_irqs[32] = { 208 "dn_risci1", "up_risci1", "rds_dn_risc1", /* 0-2 */ 209 NULL, /* reserved */ 210 "dn_risci2", "up_risci2", "rds_dn_risc2", /* 4-6 */ 211 NULL, /* reserved */ 212 "dnf_of", "upf_uf", "rds_dnf_uf", /* 8-10 */ 213 NULL, /* reserved */ 214 "dn_sync", "up_sync", "rds_dn_sync", /* 12-14 */ 215 NULL, /* reserved */ 216 "opc_err", "par_err", "rip_err", /* 16-18 */ 217 "pci_abort", "ber_irq", "mchg_irq" /* 19-21 */ 218 }; 219 220 /* 221 * BOARD Specific: Threats IRQ audio specific calls 222 */ 223 static void cx8801_aud_irq(snd_cx88_card_t *chip) 224 { 225 struct cx88_core *core = chip->core; 226 u32 status, mask; 227 228 status = cx_read(MO_AUD_INTSTAT); 229 mask = cx_read(MO_AUD_INTMSK); 230 if (0 == (status & mask)) 231 return; 232 cx_write(MO_AUD_INTSTAT, status); 233 if (debug > 1 || (status & mask & ~0xff)) 234 cx88_print_irqbits(core->name, "irq aud", 235 cx88_aud_irqs, ARRAY_SIZE(cx88_aud_irqs), 236 status, mask); 237 /* risc op code error */ 238 if (status & AUD_INT_OPC_ERR) { 239 printk(KERN_WARNING "%s/1: Audio risc op code error\n",core->name); 240 cx_clear(MO_AUD_DMACNTRL, 0x11); 241 cx88_sram_channel_dump(core, &cx88_sram_channels[SRAM_CH25]); 242 } 243 if (status & AUD_INT_DN_SYNC) { 244 dprintk(1, "Downstream sync error\n"); 245 cx_write(MO_AUDD_GPCNTRL, GP_COUNT_CONTROL_RESET); 246 return; 247 } 248 /* risc1 downstream */ 249 if (status & AUD_INT_DN_RISCI1) { 250 atomic_set(&chip->count, cx_read(MO_AUDD_GPCNT)); 251 snd_pcm_period_elapsed(chip->substream); 252 } 253 /* FIXME: Any other status should deserve a special handling? */ 254 } 255 256 /* 257 * BOARD Specific: Handles IRQ calls 258 */ 259 static irqreturn_t cx8801_irq(int irq, void *dev_id) 260 { 261 snd_cx88_card_t *chip = dev_id; 262 struct cx88_core *core = chip->core; 263 u32 status; 264 int loop, handled = 0; 265 266 for (loop = 0; loop < MAX_IRQ_LOOP; loop++) { 267 status = cx_read(MO_PCI_INTSTAT) & 268 (core->pci_irqmask | PCI_INT_AUDINT); 269 if (0 == status) 270 goto out; 271 dprintk(3, "cx8801_irq loop %d/%d, status %x\n", 272 loop, MAX_IRQ_LOOP, status); 273 handled = 1; 274 cx_write(MO_PCI_INTSTAT, status); 275 276 if (status & core->pci_irqmask) 277 cx88_core_irq(core, status); 278 if (status & PCI_INT_AUDINT) 279 cx8801_aud_irq(chip); 280 } 281 282 if (MAX_IRQ_LOOP == loop) { 283 printk(KERN_ERR 284 "%s/1: IRQ loop detected, disabling interrupts\n", 285 core->name); 286 cx_clear(MO_PCI_INTMSK, PCI_INT_AUDINT); 287 } 288 289 out: 290 return IRQ_RETVAL(handled); 291 } 292 293 294 static int dsp_buffer_free(snd_cx88_card_t *chip) 295 { 296 BUG_ON(!chip->dma_size); 297 298 dprintk(2,"Freeing buffer\n"); 299 videobuf_dma_unmap(&chip->pci->dev, chip->dma_risc); 300 videobuf_dma_free(chip->dma_risc); 301 btcx_riscmem_free(chip->pci,&chip->buf->risc); 302 kfree(chip->buf); 303 304 chip->dma_risc = NULL; 305 chip->dma_size = 0; 306 307 return 0; 308 } 309 310 /**************************************************************************** 311 ALSA PCM Interface 312 ****************************************************************************/ 313 314 /* 315 * Digital hardware definition 316 */ 317 #define DEFAULT_FIFO_SIZE 4096 318 static const struct snd_pcm_hardware snd_cx88_digital_hw = { 319 .info = SNDRV_PCM_INFO_MMAP | 320 SNDRV_PCM_INFO_INTERLEAVED | 321 SNDRV_PCM_INFO_BLOCK_TRANSFER | 322 SNDRV_PCM_INFO_MMAP_VALID, 323 .formats = SNDRV_PCM_FMTBIT_S16_LE, 324 325 .rates = SNDRV_PCM_RATE_48000, 326 .rate_min = 48000, 327 .rate_max = 48000, 328 .channels_min = 2, 329 .channels_max = 2, 330 /* Analog audio output will be full of clicks and pops if there 331 are not exactly four lines in the SRAM FIFO buffer. */ 332 .period_bytes_min = DEFAULT_FIFO_SIZE/4, 333 .period_bytes_max = DEFAULT_FIFO_SIZE/4, 334 .periods_min = 1, 335 .periods_max = 1024, 336 .buffer_bytes_max = (1024*1024), 337 }; 338 339 /* 340 * audio pcm capture open callback 341 */ 342 static int snd_cx88_pcm_open(struct snd_pcm_substream *substream) 343 { 344 snd_cx88_card_t *chip = snd_pcm_substream_chip(substream); 345 struct snd_pcm_runtime *runtime = substream->runtime; 346 int err; 347 348 if (!chip) { 349 printk(KERN_ERR "BUG: cx88 can't find device struct." 350 " Can't proceed with open\n"); 351 return -ENODEV; 352 } 353 354 err = snd_pcm_hw_constraint_pow2(runtime, 0, SNDRV_PCM_HW_PARAM_PERIODS); 355 if (err < 0) 356 goto _error; 357 358 chip->substream = substream; 359 360 runtime->hw = snd_cx88_digital_hw; 361 362 if (cx88_sram_channels[SRAM_CH25].fifo_size != DEFAULT_FIFO_SIZE) { 363 unsigned int bpl = cx88_sram_channels[SRAM_CH25].fifo_size / 4; 364 bpl &= ~7; /* must be multiple of 8 */ 365 runtime->hw.period_bytes_min = bpl; 366 runtime->hw.period_bytes_max = bpl; 367 } 368 369 return 0; 370 _error: 371 dprintk(1,"Error opening PCM!\n"); 372 return err; 373 } 374 375 /* 376 * audio close callback 377 */ 378 static int snd_cx88_close(struct snd_pcm_substream *substream) 379 { 380 return 0; 381 } 382 383 /* 384 * hw_params callback 385 */ 386 static int snd_cx88_hw_params(struct snd_pcm_substream * substream, 387 struct snd_pcm_hw_params * hw_params) 388 { 389 snd_cx88_card_t *chip = snd_pcm_substream_chip(substream); 390 struct videobuf_dmabuf *dma; 391 392 struct cx88_audio_buffer *buf; 393 int ret; 394 395 if (substream->runtime->dma_area) { 396 dsp_buffer_free(chip); 397 substream->runtime->dma_area = NULL; 398 } 399 400 chip->period_size = params_period_bytes(hw_params); 401 chip->num_periods = params_periods(hw_params); 402 chip->dma_size = chip->period_size * params_periods(hw_params); 403 404 BUG_ON(!chip->dma_size); 405 BUG_ON(chip->num_periods & (chip->num_periods-1)); 406 407 buf = kzalloc(sizeof(*buf), GFP_KERNEL); 408 if (NULL == buf) 409 return -ENOMEM; 410 411 buf->bpl = chip->period_size; 412 413 dma = &buf->dma; 414 videobuf_dma_init(dma); 415 ret = videobuf_dma_init_kernel(dma, PCI_DMA_FROMDEVICE, 416 (PAGE_ALIGN(chip->dma_size) >> PAGE_SHIFT)); 417 if (ret < 0) 418 goto error; 419 420 ret = videobuf_dma_map(&chip->pci->dev, dma); 421 if (ret < 0) 422 goto error; 423 424 ret = cx88_risc_databuffer(chip->pci, &buf->risc, dma->sglist, 425 chip->period_size, chip->num_periods, 1); 426 if (ret < 0) 427 goto error; 428 429 /* Loop back to start of program */ 430 buf->risc.jmp[0] = cpu_to_le32(RISC_JUMP|RISC_IRQ1|RISC_CNT_INC); 431 buf->risc.jmp[1] = cpu_to_le32(buf->risc.dma); 432 433 chip->buf = buf; 434 chip->dma_risc = dma; 435 436 substream->runtime->dma_area = chip->dma_risc->vaddr; 437 substream->runtime->dma_bytes = chip->dma_size; 438 substream->runtime->dma_addr = 0; 439 return 0; 440 441 error: 442 kfree(buf); 443 return ret; 444 } 445 446 /* 447 * hw free callback 448 */ 449 static int snd_cx88_hw_free(struct snd_pcm_substream * substream) 450 { 451 452 snd_cx88_card_t *chip = snd_pcm_substream_chip(substream); 453 454 if (substream->runtime->dma_area) { 455 dsp_buffer_free(chip); 456 substream->runtime->dma_area = NULL; 457 } 458 459 return 0; 460 } 461 462 /* 463 * prepare callback 464 */ 465 static int snd_cx88_prepare(struct snd_pcm_substream *substream) 466 { 467 return 0; 468 } 469 470 /* 471 * trigger callback 472 */ 473 static int snd_cx88_card_trigger(struct snd_pcm_substream *substream, int cmd) 474 { 475 snd_cx88_card_t *chip = snd_pcm_substream_chip(substream); 476 int err; 477 478 /* Local interrupts are already disabled by ALSA */ 479 spin_lock(&chip->reg_lock); 480 481 switch (cmd) { 482 case SNDRV_PCM_TRIGGER_START: 483 err=_cx88_start_audio_dma(chip); 484 break; 485 case SNDRV_PCM_TRIGGER_STOP: 486 err=_cx88_stop_audio_dma(chip); 487 break; 488 default: 489 err=-EINVAL; 490 break; 491 } 492 493 spin_unlock(&chip->reg_lock); 494 495 return err; 496 } 497 498 /* 499 * pointer callback 500 */ 501 static snd_pcm_uframes_t snd_cx88_pointer(struct snd_pcm_substream *substream) 502 { 503 snd_cx88_card_t *chip = snd_pcm_substream_chip(substream); 504 struct snd_pcm_runtime *runtime = substream->runtime; 505 u16 count; 506 507 count = atomic_read(&chip->count); 508 509 // dprintk(2, "%s - count %d (+%u), period %d, frame %lu\n", __func__, 510 // count, new, count & (runtime->periods-1), 511 // runtime->period_size * (count & (runtime->periods-1))); 512 return runtime->period_size * (count & (runtime->periods-1)); 513 } 514 515 /* 516 * page callback (needed for mmap) 517 */ 518 static struct page *snd_cx88_page(struct snd_pcm_substream *substream, 519 unsigned long offset) 520 { 521 void *pageptr = substream->runtime->dma_area + offset; 522 return vmalloc_to_page(pageptr); 523 } 524 525 /* 526 * operators 527 */ 528 static struct snd_pcm_ops snd_cx88_pcm_ops = { 529 .open = snd_cx88_pcm_open, 530 .close = snd_cx88_close, 531 .ioctl = snd_pcm_lib_ioctl, 532 .hw_params = snd_cx88_hw_params, 533 .hw_free = snd_cx88_hw_free, 534 .prepare = snd_cx88_prepare, 535 .trigger = snd_cx88_card_trigger, 536 .pointer = snd_cx88_pointer, 537 .page = snd_cx88_page, 538 }; 539 540 /* 541 * create a PCM device 542 */ 543 static int snd_cx88_pcm(snd_cx88_card_t *chip, int device, const char *name) 544 { 545 int err; 546 struct snd_pcm *pcm; 547 548 err = snd_pcm_new(chip->card, name, device, 0, 1, &pcm); 549 if (err < 0) 550 return err; 551 pcm->private_data = chip; 552 strcpy(pcm->name, name); 553 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_cx88_pcm_ops); 554 555 return 0; 556 } 557 558 /**************************************************************************** 559 CONTROL INTERFACE 560 ****************************************************************************/ 561 static int snd_cx88_volume_info(struct snd_kcontrol *kcontrol, 562 struct snd_ctl_elem_info *info) 563 { 564 info->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 565 info->count = 2; 566 info->value.integer.min = 0; 567 info->value.integer.max = 0x3f; 568 569 return 0; 570 } 571 572 static int snd_cx88_volume_get(struct snd_kcontrol *kcontrol, 573 struct snd_ctl_elem_value *value) 574 { 575 snd_cx88_card_t *chip = snd_kcontrol_chip(kcontrol); 576 struct cx88_core *core=chip->core; 577 int vol = 0x3f - (cx_read(AUD_VOL_CTL) & 0x3f), 578 bal = cx_read(AUD_BAL_CTL); 579 580 value->value.integer.value[(bal & 0x40) ? 0 : 1] = vol; 581 vol -= (bal & 0x3f); 582 value->value.integer.value[(bal & 0x40) ? 1 : 0] = vol < 0 ? 0 : vol; 583 584 return 0; 585 } 586 587 static void snd_cx88_wm8775_volume_put(struct snd_kcontrol *kcontrol, 588 struct snd_ctl_elem_value *value) 589 { 590 snd_cx88_card_t *chip = snd_kcontrol_chip(kcontrol); 591 struct cx88_core *core = chip->core; 592 int left = value->value.integer.value[0]; 593 int right = value->value.integer.value[1]; 594 int v, b; 595 596 /* Pass volume & balance onto any WM8775 */ 597 if (left >= right) { 598 v = left << 10; 599 b = left ? (0x8000 * right) / left : 0x8000; 600 } else { 601 v = right << 10; 602 b = right ? 0xffff - (0x8000 * left) / right : 0x8000; 603 } 604 wm8775_s_ctrl(core, V4L2_CID_AUDIO_VOLUME, v); 605 wm8775_s_ctrl(core, V4L2_CID_AUDIO_BALANCE, b); 606 } 607 608 /* OK - TODO: test it */ 609 static int snd_cx88_volume_put(struct snd_kcontrol *kcontrol, 610 struct snd_ctl_elem_value *value) 611 { 612 snd_cx88_card_t *chip = snd_kcontrol_chip(kcontrol); 613 struct cx88_core *core=chip->core; 614 int left, right, v, b; 615 int changed = 0; 616 u32 old; 617 618 if (core->sd_wm8775) 619 snd_cx88_wm8775_volume_put(kcontrol, value); 620 621 left = value->value.integer.value[0] & 0x3f; 622 right = value->value.integer.value[1] & 0x3f; 623 b = right - left; 624 if (b < 0) { 625 v = 0x3f - left; 626 b = (-b) | 0x40; 627 } else { 628 v = 0x3f - right; 629 } 630 /* Do we really know this will always be called with IRQs on? */ 631 spin_lock_irq(&chip->reg_lock); 632 old = cx_read(AUD_VOL_CTL); 633 if (v != (old & 0x3f)) { 634 cx_swrite(SHADOW_AUD_VOL_CTL, AUD_VOL_CTL, (old & ~0x3f) | v); 635 changed = 1; 636 } 637 if ((cx_read(AUD_BAL_CTL) & 0x7f) != b) { 638 cx_write(AUD_BAL_CTL, b); 639 changed = 1; 640 } 641 spin_unlock_irq(&chip->reg_lock); 642 643 return changed; 644 } 645 646 static const DECLARE_TLV_DB_SCALE(snd_cx88_db_scale, -6300, 100, 0); 647 648 static const struct snd_kcontrol_new snd_cx88_volume = { 649 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 650 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | 651 SNDRV_CTL_ELEM_ACCESS_TLV_READ, 652 .name = "Analog-TV Volume", 653 .info = snd_cx88_volume_info, 654 .get = snd_cx88_volume_get, 655 .put = snd_cx88_volume_put, 656 .tlv.p = snd_cx88_db_scale, 657 }; 658 659 static int snd_cx88_switch_get(struct snd_kcontrol *kcontrol, 660 struct snd_ctl_elem_value *value) 661 { 662 snd_cx88_card_t *chip = snd_kcontrol_chip(kcontrol); 663 struct cx88_core *core = chip->core; 664 u32 bit = kcontrol->private_value; 665 666 value->value.integer.value[0] = !(cx_read(AUD_VOL_CTL) & bit); 667 return 0; 668 } 669 670 static int snd_cx88_switch_put(struct snd_kcontrol *kcontrol, 671 struct snd_ctl_elem_value *value) 672 { 673 snd_cx88_card_t *chip = snd_kcontrol_chip(kcontrol); 674 struct cx88_core *core = chip->core; 675 u32 bit = kcontrol->private_value; 676 int ret = 0; 677 u32 vol; 678 679 spin_lock_irq(&chip->reg_lock); 680 vol = cx_read(AUD_VOL_CTL); 681 if (value->value.integer.value[0] != !(vol & bit)) { 682 vol ^= bit; 683 cx_swrite(SHADOW_AUD_VOL_CTL, AUD_VOL_CTL, vol); 684 /* Pass mute onto any WM8775 */ 685 if (core->sd_wm8775 && ((1<<6) == bit)) 686 wm8775_s_ctrl(core, V4L2_CID_AUDIO_MUTE, 0 != (vol & bit)); 687 ret = 1; 688 } 689 spin_unlock_irq(&chip->reg_lock); 690 return ret; 691 } 692 693 static const struct snd_kcontrol_new snd_cx88_dac_switch = { 694 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 695 .name = "Audio-Out Switch", 696 .info = snd_ctl_boolean_mono_info, 697 .get = snd_cx88_switch_get, 698 .put = snd_cx88_switch_put, 699 .private_value = (1<<8), 700 }; 701 702 static const struct snd_kcontrol_new snd_cx88_source_switch = { 703 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 704 .name = "Analog-TV Switch", 705 .info = snd_ctl_boolean_mono_info, 706 .get = snd_cx88_switch_get, 707 .put = snd_cx88_switch_put, 708 .private_value = (1<<6), 709 }; 710 711 static int snd_cx88_alc_get(struct snd_kcontrol *kcontrol, 712 struct snd_ctl_elem_value *value) 713 { 714 snd_cx88_card_t *chip = snd_kcontrol_chip(kcontrol); 715 struct cx88_core *core = chip->core; 716 s32 val; 717 718 val = wm8775_g_ctrl(core, V4L2_CID_AUDIO_LOUDNESS); 719 value->value.integer.value[0] = val ? 1 : 0; 720 return 0; 721 } 722 723 static int snd_cx88_alc_put(struct snd_kcontrol *kcontrol, 724 struct snd_ctl_elem_value *value) 725 { 726 snd_cx88_card_t *chip = snd_kcontrol_chip(kcontrol); 727 struct cx88_core *core = chip->core; 728 struct v4l2_control client_ctl; 729 730 memset(&client_ctl, 0, sizeof(client_ctl)); 731 client_ctl.value = 0 != value->value.integer.value[0]; 732 client_ctl.id = V4L2_CID_AUDIO_LOUDNESS; 733 call_hw(core, WM8775_GID, core, s_ctrl, &client_ctl); 734 735 return 0; 736 } 737 738 static struct snd_kcontrol_new snd_cx88_alc_switch = { 739 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 740 .name = "Line-In ALC Switch", 741 .info = snd_ctl_boolean_mono_info, 742 .get = snd_cx88_alc_get, 743 .put = snd_cx88_alc_put, 744 }; 745 746 /**************************************************************************** 747 Basic Flow for Sound Devices 748 ****************************************************************************/ 749 750 /* 751 * PCI ID Table - 14f1:8801 and 14f1:8811 means function 1: Audio 752 * Only boards with eeprom and byte 1 at eeprom=1 have it 753 */ 754 755 static const struct pci_device_id cx88_audio_pci_tbl[] = { 756 {0x14f1,0x8801,PCI_ANY_ID,PCI_ANY_ID,0,0,0}, 757 {0x14f1,0x8811,PCI_ANY_ID,PCI_ANY_ID,0,0,0}, 758 {0, } 759 }; 760 MODULE_DEVICE_TABLE(pci, cx88_audio_pci_tbl); 761 762 /* 763 * Chip-specific destructor 764 */ 765 766 static int snd_cx88_free(snd_cx88_card_t *chip) 767 { 768 769 if (chip->irq >= 0) 770 free_irq(chip->irq, chip); 771 772 cx88_core_put(chip->core,chip->pci); 773 774 pci_disable_device(chip->pci); 775 return 0; 776 } 777 778 /* 779 * Component Destructor 780 */ 781 static void snd_cx88_dev_free(struct snd_card * card) 782 { 783 snd_cx88_card_t *chip = card->private_data; 784 785 snd_cx88_free(chip); 786 } 787 788 789 /* 790 * Alsa Constructor - Component probe 791 */ 792 793 static int devno; 794 static int snd_cx88_create(struct snd_card *card, struct pci_dev *pci, 795 snd_cx88_card_t **rchip, 796 struct cx88_core **core_ptr) 797 { 798 snd_cx88_card_t *chip; 799 struct cx88_core *core; 800 int err; 801 unsigned char pci_lat; 802 803 *rchip = NULL; 804 805 err = pci_enable_device(pci); 806 if (err < 0) 807 return err; 808 809 pci_set_master(pci); 810 811 chip = card->private_data; 812 813 core = cx88_core_get(pci); 814 if (NULL == core) { 815 err = -EINVAL; 816 return err; 817 } 818 819 if (!pci_dma_supported(pci,DMA_BIT_MASK(32))) { 820 dprintk(0, "%s/1: Oops: no 32bit PCI DMA ???\n",core->name); 821 err = -EIO; 822 cx88_core_put(core, pci); 823 return err; 824 } 825 826 827 /* pci init */ 828 chip->card = card; 829 chip->pci = pci; 830 chip->irq = -1; 831 spin_lock_init(&chip->reg_lock); 832 833 chip->core = core; 834 835 /* get irq */ 836 err = request_irq(chip->pci->irq, cx8801_irq, 837 IRQF_SHARED, chip->core->name, chip); 838 if (err < 0) { 839 dprintk(0, "%s: can't get IRQ %d\n", 840 chip->core->name, chip->pci->irq); 841 return err; 842 } 843 844 /* print pci info */ 845 pci_read_config_byte(pci, PCI_LATENCY_TIMER, &pci_lat); 846 847 dprintk(1,"ALSA %s/%i: found at %s, rev: %d, irq: %d, " 848 "latency: %d, mmio: 0x%llx\n", core->name, devno, 849 pci_name(pci), pci->revision, pci->irq, 850 pci_lat, (unsigned long long)pci_resource_start(pci,0)); 851 852 chip->irq = pci->irq; 853 synchronize_irq(chip->irq); 854 855 snd_card_set_dev(card, &pci->dev); 856 857 *rchip = chip; 858 *core_ptr = core; 859 860 return 0; 861 } 862 863 static int cx88_audio_initdev(struct pci_dev *pci, 864 const struct pci_device_id *pci_id) 865 { 866 struct snd_card *card; 867 snd_cx88_card_t *chip; 868 struct cx88_core *core = NULL; 869 int err; 870 871 if (devno >= SNDRV_CARDS) 872 return (-ENODEV); 873 874 if (!enable[devno]) { 875 ++devno; 876 return (-ENOENT); 877 } 878 879 err = snd_card_create(index[devno], id[devno], THIS_MODULE, 880 sizeof(snd_cx88_card_t), &card); 881 if (err < 0) 882 return err; 883 884 card->private_free = snd_cx88_dev_free; 885 886 err = snd_cx88_create(card, pci, &chip, &core); 887 if (err < 0) 888 goto error; 889 890 err = snd_cx88_pcm(chip, 0, "CX88 Digital"); 891 if (err < 0) 892 goto error; 893 894 err = snd_ctl_add(card, snd_ctl_new1(&snd_cx88_volume, chip)); 895 if (err < 0) 896 goto error; 897 err = snd_ctl_add(card, snd_ctl_new1(&snd_cx88_dac_switch, chip)); 898 if (err < 0) 899 goto error; 900 err = snd_ctl_add(card, snd_ctl_new1(&snd_cx88_source_switch, chip)); 901 if (err < 0) 902 goto error; 903 904 /* If there's a wm8775 then add a Line-In ALC switch */ 905 if (core->sd_wm8775) 906 snd_ctl_add(card, snd_ctl_new1(&snd_cx88_alc_switch, chip)); 907 908 strcpy (card->driver, "CX88x"); 909 sprintf(card->shortname, "Conexant CX%x", pci->device); 910 sprintf(card->longname, "%s at %#llx", 911 card->shortname,(unsigned long long)pci_resource_start(pci, 0)); 912 strcpy (card->mixername, "CX88"); 913 914 dprintk (0, "%s/%i: ALSA support for cx2388x boards\n", 915 card->driver,devno); 916 917 err = snd_card_register(card); 918 if (err < 0) 919 goto error; 920 pci_set_drvdata(pci,card); 921 922 devno++; 923 return 0; 924 925 error: 926 snd_card_free(card); 927 return err; 928 } 929 /* 930 * ALSA destructor 931 */ 932 static void cx88_audio_finidev(struct pci_dev *pci) 933 { 934 struct cx88_audio_dev *card = pci_get_drvdata(pci); 935 936 snd_card_free((void *)card); 937 938 devno--; 939 } 940 941 /* 942 * PCI driver definition 943 */ 944 945 static struct pci_driver cx88_audio_pci_driver = { 946 .name = "cx88_audio", 947 .id_table = cx88_audio_pci_tbl, 948 .probe = cx88_audio_initdev, 949 .remove = cx88_audio_finidev, 950 }; 951 952 module_pci_driver(cx88_audio_pci_driver); 953