1/* 2 * SAA713x ALSA support for V4L 3 * 4 * This program is free software; you can redistribute it and/or modify 5 * it under the terms of the GNU General Public License as published by 6 * the Free Software Foundation, version 2 7 * 8 * This program is distributed in the hope that it will be useful, 9 * but WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 11 * GNU General Public License for more details. 12 * 13 * You should have received a copy of the GNU General Public License 14 * along with this program; if not, write to the Free Software 15 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 16 * 17 */ 18 19#include <linux/init.h> 20#include <linux/slab.h> 21#include <linux/time.h> 22#include <linux/wait.h> 23#include <linux/moduleparam.h> 24#include <linux/module.h> 25#include <sound/driver.h> 26#include <sound/core.h> 27#include <sound/control.h> 28#include <sound/pcm.h> 29#include <sound/pcm_params.h> 30#include <sound/initval.h> 31#include <linux/interrupt.h> 32 33#include "saa7134.h" 34#include "saa7134-reg.h" 35 36static unsigned int debug = 0; 37module_param(debug, int, 0644); 38MODULE_PARM_DESC(debug,"enable debug messages [alsa]"); 39 40/* 41 * Configuration macros 42 */ 43 44/* defaults */ 45#define MIXER_ADDR_TVTUNER 0 46#define MIXER_ADDR_LINE1 1 47#define MIXER_ADDR_LINE2 2 48#define MIXER_ADDR_LAST 2 49 50 51static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */ 52static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR; /* ID for this card */ 53static int enable[SNDRV_CARDS] = {1, [1 ... (SNDRV_CARDS - 1)] = 1}; 54 55module_param_array(index, int, NULL, 0444); 56module_param_array(enable, int, NULL, 0444); 57MODULE_PARM_DESC(index, "Index value for SAA7134 capture interface(s)."); 58MODULE_PARM_DESC(enable, "Enable (or not) the SAA7134 capture interface(s)."); 59 60#define dprintk(fmt, arg...) if (debug) \ 61 printk(KERN_DEBUG "%s/alsa: " fmt, dev->name , ##arg) 62 63 64 65/* 66 * Main chip structure 67 */ 68 69typedef struct snd_card_saa7134 { 70 struct snd_card *card; 71 spinlock_t mixer_lock; 72 int mixer_volume[MIXER_ADDR_LAST+1][2]; 73 int capture_source[MIXER_ADDR_LAST+1][2]; 74 struct pci_dev *pci; 75 struct saa7134_dev *dev; 76 77 unsigned long iobase; 78 int irq; 79 80 spinlock_t lock; 81} snd_card_saa7134_t; 82 83 84 85/* 86 * PCM structure 87 */ 88 89typedef struct snd_card_saa7134_pcm { 90 struct saa7134_dev *dev; 91 92 spinlock_t lock; 93 94 struct snd_pcm_substream *substream; 95} snd_card_saa7134_pcm_t; 96 97static struct snd_card *snd_saa7134_cards[SNDRV_CARDS]; 98 99 100/* 101 * saa7134 DMA audio stop 102 * 103 * Called when the capture device is released or the buffer overflows 104 * 105 * - Copied verbatim from saa7134-oss's dsp_dma_stop. 106 * 107 */ 108 109static void saa7134_dma_stop(struct saa7134_dev *dev) 110{ 111 dev->dmasound.dma_blk = -1; 112 dev->dmasound.dma_running = 0; 113 saa7134_set_dmabits(dev); 114} 115 116/* 117 * saa7134 DMA audio start 118 * 119 * Called when preparing the capture device for use 120 * 121 * - Copied verbatim from saa7134-oss's dsp_dma_start. 122 * 123 */ 124 125static void saa7134_dma_start(struct saa7134_dev *dev) 126{ 127 dev->dmasound.dma_blk = 0; 128 dev->dmasound.dma_running = 1; 129 saa7134_set_dmabits(dev); 130} 131 132/* 133 * saa7134 audio DMA IRQ handler 134 * 135 * Called whenever we get an SAA7134_IRQ_REPORT_DONE_RA3 interrupt 136 * Handles shifting between the 2 buffers, manages the read counters, 137 * and notifies ALSA when periods elapse 138 * 139 * - Mostly copied from saa7134-oss's saa7134_irq_oss_done. 140 * 141 */ 142 143static void saa7134_irq_alsa_done(struct saa7134_dev *dev, 144 unsigned long status) 145{ 146 int next_blk, reg = 0; 147 148 spin_lock(&dev->slock); 149 if (UNSET == dev->dmasound.dma_blk) { 150 dprintk("irq: recording stopped\n"); 151 goto done; 152 } 153 if (0 != (status & 0x0f000000)) 154 dprintk("irq: lost %ld\n", (status >> 24) & 0x0f); 155 if (0 == (status & 0x10000000)) { 156 /* odd */ 157 if (0 == (dev->dmasound.dma_blk & 0x01)) 158 reg = SAA7134_RS_BA1(6); 159 } else { 160 /* even */ 161 if (1 == (dev->dmasound.dma_blk & 0x01)) 162 reg = SAA7134_RS_BA2(6); 163 } 164 if (0 == reg) { 165 dprintk("irq: field oops [%s]\n", 166 (status & 0x10000000) ? "even" : "odd"); 167 goto done; 168 } 169 170 if (dev->dmasound.read_count >= dev->dmasound.blksize * (dev->dmasound.blocks-2)) { 171 dprintk("irq: overrun [full=%d/%d] - Blocks in %d\n",dev->dmasound.read_count, 172 dev->dmasound.bufsize, dev->dmasound.blocks); 173 spin_unlock(&dev->slock); 174 snd_pcm_stop(dev->dmasound.substream,SNDRV_PCM_STATE_XRUN); 175 return; 176 } 177 178 /* next block addr */ 179 next_blk = (dev->dmasound.dma_blk + 2) % dev->dmasound.blocks; 180 saa_writel(reg,next_blk * dev->dmasound.blksize); 181 if (debug > 2) 182 dprintk("irq: ok, %s, next_blk=%d, addr=%x, blocks=%u, size=%u, read=%u\n", 183 (status & 0x10000000) ? "even" : "odd ", next_blk, 184 next_blk * dev->dmasound.blksize, dev->dmasound.blocks, dev->dmasound.blksize, dev->dmasound.read_count); 185 186 /* update status & wake waiting readers */ 187 dev->dmasound.dma_blk = (dev->dmasound.dma_blk + 1) % dev->dmasound.blocks; 188 dev->dmasound.read_count += dev->dmasound.blksize; 189 190 dev->dmasound.recording_on = reg; 191 192 if (dev->dmasound.read_count >= snd_pcm_lib_period_bytes(dev->dmasound.substream)) { 193 spin_unlock(&dev->slock); 194 snd_pcm_period_elapsed(dev->dmasound.substream); 195 spin_lock(&dev->slock); 196 } 197 198 done: 199 spin_unlock(&dev->slock); 200 201} 202 203/* 204 * IRQ request handler 205 * 206 * Runs along with saa7134's IRQ handler, discards anything that isn't 207 * DMA sound 208 * 209 */ 210 211static irqreturn_t saa7134_alsa_irq(int irq, void *dev_id) 212{ 213 struct saa7134_dmasound *dmasound = dev_id; 214 struct saa7134_dev *dev = dmasound->priv_data; 215 216 unsigned long report, status; 217 int loop, handled = 0; 218 219 for (loop = 0; loop < 10; loop++) { 220 report = saa_readl(SAA7134_IRQ_REPORT); 221 status = saa_readl(SAA7134_IRQ_STATUS); 222 223 if (report & SAA7134_IRQ_REPORT_DONE_RA3) { 224 handled = 1; 225 saa_writel(SAA7134_IRQ_REPORT,report); 226 saa7134_irq_alsa_done(dev, status); 227 } else { 228 goto out; 229 } 230 } 231 232 if (loop == 10) { 233 dprintk("error! looping IRQ!"); 234 } 235 236out: 237 return IRQ_RETVAL(handled); 238} 239 240/* 241 * ALSA capture trigger 242 * 243 * - One of the ALSA capture callbacks. 244 * 245 * Called whenever a capture is started or stopped. Must be defined, 246 * but there's nothing we want to do here 247 * 248 */ 249 250static int snd_card_saa7134_capture_trigger(struct snd_pcm_substream * substream, 251 int cmd) 252{ 253 struct snd_pcm_runtime *runtime = substream->runtime; 254 snd_card_saa7134_pcm_t *pcm = runtime->private_data; 255 struct saa7134_dev *dev=pcm->dev; 256 int err = 0; 257 258 spin_lock(&dev->slock); 259 if (cmd == SNDRV_PCM_TRIGGER_START) { 260 /* start dma */ 261 saa7134_dma_start(dev); 262 } else if (cmd == SNDRV_PCM_TRIGGER_STOP) { 263 /* stop dma */ 264 saa7134_dma_stop(dev); 265 } else { 266 err = -EINVAL; 267 } 268 spin_unlock(&dev->slock); 269 270 return err; 271} 272 273/* 274 * DMA buffer initialization 275 * 276 * Uses V4L functions to initialize the DMA. Shouldn't be necessary in 277 * ALSA, but I was unable to use ALSA's own DMA, and had to force the 278 * usage of V4L's 279 * 280 * - Copied verbatim from saa7134-oss. 281 * 282 */ 283 284static int dsp_buffer_init(struct saa7134_dev *dev) 285{ 286 int err; 287 288 BUG_ON(!dev->dmasound.bufsize); 289 290 videobuf_dma_init(&dev->dmasound.dma); 291 err = videobuf_dma_init_kernel(&dev->dmasound.dma, PCI_DMA_FROMDEVICE, 292 (dev->dmasound.bufsize + PAGE_SIZE) >> PAGE_SHIFT); 293 if (0 != err) 294 return err; 295 return 0; 296} 297 298/* 299 * DMA buffer release 300 * 301 * Called after closing the device, during snd_card_saa7134_capture_close 302 * 303 */ 304 305static int dsp_buffer_free(struct saa7134_dev *dev) 306{ 307 BUG_ON(!dev->dmasound.blksize); 308 309 videobuf_dma_free(&dev->dmasound.dma); 310 311 dev->dmasound.blocks = 0; 312 dev->dmasound.blksize = 0; 313 dev->dmasound.bufsize = 0; 314 315 return 0; 316} 317 318 319/* 320 * ALSA PCM preparation 321 * 322 * - One of the ALSA capture callbacks. 323 * 324 * Called right after the capture device is opened, this function configures 325 * the buffer using the previously defined functions, allocates the memory, 326 * sets up the hardware registers, and then starts the DMA. When this function 327 * returns, the audio should be flowing. 328 * 329 */ 330 331static int snd_card_saa7134_capture_prepare(struct snd_pcm_substream * substream) 332{ 333 struct snd_pcm_runtime *runtime = substream->runtime; 334 int bswap, sign; 335 u32 fmt, control; 336 snd_card_saa7134_t *saa7134 = snd_pcm_substream_chip(substream); 337 struct saa7134_dev *dev; 338 snd_card_saa7134_pcm_t *pcm = runtime->private_data; 339 340 pcm->dev->dmasound.substream = substream; 341 342 dev = saa7134->dev; 343 344 if (snd_pcm_format_width(runtime->format) == 8) 345 fmt = 0x00; 346 else 347 fmt = 0x01; 348 349 if (snd_pcm_format_signed(runtime->format)) 350 sign = 1; 351 else 352 sign = 0; 353 354 if (snd_pcm_format_big_endian(runtime->format)) 355 bswap = 1; 356 else 357 bswap = 0; 358 359 switch (dev->pci->device) { 360 case PCI_DEVICE_ID_PHILIPS_SAA7134: 361 if (1 == runtime->channels) 362 fmt |= (1 << 3); 363 if (2 == runtime->channels) 364 fmt |= (3 << 3); 365 if (sign) 366 fmt |= 0x04; 367 368 fmt |= (MIXER_ADDR_TVTUNER == dev->dmasound.input) ? 0xc0 : 0x80; 369 saa_writeb(SAA7134_NUM_SAMPLES0, ((dev->dmasound.blksize - 1) & 0x0000ff)); 370 saa_writeb(SAA7134_NUM_SAMPLES1, ((dev->dmasound.blksize - 1) & 0x00ff00) >> 8); 371 saa_writeb(SAA7134_NUM_SAMPLES2, ((dev->dmasound.blksize - 1) & 0xff0000) >> 16); 372 saa_writeb(SAA7134_AUDIO_FORMAT_CTRL, fmt); 373 374 break; 375 case PCI_DEVICE_ID_PHILIPS_SAA7133: 376 case PCI_DEVICE_ID_PHILIPS_SAA7135: 377 if (1 == runtime->channels) 378 fmt |= (1 << 4); 379 if (2 == runtime->channels) 380 fmt |= (2 << 4); 381 if (!sign) 382 fmt |= 0x04; 383 saa_writel(SAA7133_NUM_SAMPLES, dev->dmasound.blksize -1); 384 saa_writel(SAA7133_AUDIO_CHANNEL, 0x543210 | (fmt << 24)); 385 break; 386 } 387 388 dprintk("rec_start: afmt=%d ch=%d => fmt=0x%x swap=%c\n", 389 runtime->format, runtime->channels, fmt, 390 bswap ? 'b' : '-'); 391 /* dma: setup channel 6 (= AUDIO) */ 392 control = SAA7134_RS_CONTROL_BURST_16 | 393 SAA7134_RS_CONTROL_ME | 394 (dev->dmasound.pt.dma >> 12); 395 if (bswap) 396 control |= SAA7134_RS_CONTROL_BSWAP; 397 398 saa_writel(SAA7134_RS_BA1(6),0); 399 saa_writel(SAA7134_RS_BA2(6),dev->dmasound.blksize); 400 saa_writel(SAA7134_RS_PITCH(6),0); 401 saa_writel(SAA7134_RS_CONTROL(6),control); 402 403 dev->dmasound.rate = runtime->rate; 404 405 return 0; 406 407} 408 409/* 410 * ALSA pointer fetching 411 * 412 * - One of the ALSA capture callbacks. 413 * 414 * Called whenever a period elapses, it must return the current hardware 415 * position of the buffer. 416 * Also resets the read counter used to prevent overruns 417 * 418 */ 419 420static snd_pcm_uframes_t 421snd_card_saa7134_capture_pointer(struct snd_pcm_substream * substream) 422{ 423 struct snd_pcm_runtime *runtime = substream->runtime; 424 snd_card_saa7134_pcm_t *pcm = runtime->private_data; 425 struct saa7134_dev *dev=pcm->dev; 426 427 if (dev->dmasound.read_count) { 428 dev->dmasound.read_count -= snd_pcm_lib_period_bytes(substream); 429 dev->dmasound.read_offset += snd_pcm_lib_period_bytes(substream); 430 if (dev->dmasound.read_offset == dev->dmasound.bufsize) 431 dev->dmasound.read_offset = 0; 432 } 433 434 return bytes_to_frames(runtime, dev->dmasound.read_offset); 435} 436 437/* 438 * ALSA hardware capabilities definition 439 */ 440 441static struct snd_pcm_hardware snd_card_saa7134_capture = 442{ 443 .info = (SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_INTERLEAVED | 444 SNDRV_PCM_INFO_BLOCK_TRANSFER | 445 SNDRV_PCM_INFO_MMAP_VALID), 446 .formats = SNDRV_PCM_FMTBIT_S16_LE | \ 447 SNDRV_PCM_FMTBIT_S16_BE | \ 448 SNDRV_PCM_FMTBIT_S8 | \ 449 SNDRV_PCM_FMTBIT_U8 | \ 450 SNDRV_PCM_FMTBIT_U16_LE | \ 451 SNDRV_PCM_FMTBIT_U16_BE, 452 .rates = SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_48000, 453 .rate_min = 32000, 454 .rate_max = 48000, 455 .channels_min = 1, 456 .channels_max = 2, 457 .buffer_bytes_max = (256*1024), 458 .period_bytes_min = 64, 459 .period_bytes_max = (256*1024), 460 .periods_min = 2, 461 .periods_max = 1024, 462}; 463 464static void snd_card_saa7134_runtime_free(struct snd_pcm_runtime *runtime) 465{ 466 snd_card_saa7134_pcm_t *pcm = runtime->private_data; 467 468 kfree(pcm); 469} 470 471 472/* 473 * ALSA hardware params 474 * 475 * - One of the ALSA capture callbacks. 476 * 477 * Called on initialization, right before the PCM preparation 478 * 479 */ 480 481static int snd_card_saa7134_hw_params(struct snd_pcm_substream * substream, 482 struct snd_pcm_hw_params * hw_params) 483{ 484 snd_card_saa7134_t *saa7134 = snd_pcm_substream_chip(substream); 485 struct saa7134_dev *dev; 486 unsigned int period_size, periods; 487 int err; 488 489 period_size = params_period_bytes(hw_params); 490 periods = params_periods(hw_params); 491 492 snd_assert(period_size >= 0x100 && period_size <= 0x10000, 493 return -EINVAL); 494 snd_assert(periods >= 2, return -EINVAL); 495 snd_assert(period_size * periods <= 1024 * 1024, return -EINVAL); 496 497 dev = saa7134->dev; 498 499 if (dev->dmasound.blocks == periods && 500 dev->dmasound.blksize == period_size) 501 return 0; 502 503 /* release the old buffer */ 504 if (substream->runtime->dma_area) { 505 saa7134_pgtable_free(dev->pci, &dev->dmasound.pt); 506 videobuf_pci_dma_unmap(dev->pci, &dev->dmasound.dma); 507 dsp_buffer_free(dev); 508 substream->runtime->dma_area = NULL; 509 } 510 dev->dmasound.blocks = periods; 511 dev->dmasound.blksize = period_size; 512 dev->dmasound.bufsize = period_size * periods; 513 514 err = dsp_buffer_init(dev); 515 if (0 != err) { 516 dev->dmasound.blocks = 0; 517 dev->dmasound.blksize = 0; 518 dev->dmasound.bufsize = 0; 519 return err; 520 } 521 522 if (0 != (err = videobuf_pci_dma_map(dev->pci, &dev->dmasound.dma))) { 523 dsp_buffer_free(dev); 524 return err; 525 } 526 if (0 != (err = saa7134_pgtable_alloc(dev->pci,&dev->dmasound.pt))) { 527 videobuf_pci_dma_unmap(dev->pci, &dev->dmasound.dma); 528 dsp_buffer_free(dev); 529 return err; 530 } 531 if (0 != (err = saa7134_pgtable_build(dev->pci,&dev->dmasound.pt, 532 dev->dmasound.dma.sglist, 533 dev->dmasound.dma.sglen, 534 0))) { 535 saa7134_pgtable_free(dev->pci, &dev->dmasound.pt); 536 videobuf_pci_dma_unmap(dev->pci, &dev->dmasound.dma); 537 dsp_buffer_free(dev); 538 return err; 539 } 540 541 /* I should be able to use runtime->dma_addr in the control 542 byte, but it doesn't work. So I allocate the DMA using the 543 V4L functions, and force ALSA to use that as the DMA area */ 544 545 substream->runtime->dma_area = dev->dmasound.dma.vmalloc; 546 547 return 1; 548 549} 550 551/* 552 * ALSA hardware release 553 * 554 * - One of the ALSA capture callbacks. 555 * 556 * Called after closing the device, but before snd_card_saa7134_capture_close 557 * It stops the DMA audio and releases the buffers. 558 * 559 */ 560 561static int snd_card_saa7134_hw_free(struct snd_pcm_substream * substream) 562{ 563 snd_card_saa7134_t *saa7134 = snd_pcm_substream_chip(substream); 564 struct saa7134_dev *dev; 565 566 dev = saa7134->dev; 567 568 if (substream->runtime->dma_area) { 569 saa7134_pgtable_free(dev->pci, &dev->dmasound.pt); 570 videobuf_pci_dma_unmap(dev->pci, &dev->dmasound.dma); 571 dsp_buffer_free(dev); 572 substream->runtime->dma_area = NULL; 573 } 574 575 return 0; 576} 577 578/* 579 * ALSA capture finish 580 * 581 * - One of the ALSA capture callbacks. 582 * 583 * Called after closing the device. 584 * 585 */ 586 587static int snd_card_saa7134_capture_close(struct snd_pcm_substream * substream) 588{ 589 snd_card_saa7134_t *saa7134 = snd_pcm_substream_chip(substream); 590 struct saa7134_dev *dev = saa7134->dev; 591 592 dev->ctl_mute = 1; 593 saa7134_tvaudio_setmute(dev); 594 return 0; 595} 596 597/* 598 * ALSA capture start 599 * 600 * - One of the ALSA capture callbacks. 601 * 602 * Called when opening the device. It creates and populates the PCM 603 * structure 604 * 605 */ 606 607static int snd_card_saa7134_capture_open(struct snd_pcm_substream * substream) 608{ 609 struct snd_pcm_runtime *runtime = substream->runtime; 610 snd_card_saa7134_pcm_t *pcm; 611 snd_card_saa7134_t *saa7134 = snd_pcm_substream_chip(substream); 612 struct saa7134_dev *dev = saa7134->dev; 613 int amux, err; 614 615 mutex_lock(&dev->dmasound.lock); 616 617 dev->dmasound.read_count = 0; 618 dev->dmasound.read_offset = 0; 619 620 amux = dev->input->amux; 621 if ((amux < 1) || (amux > 3)) 622 amux = 1; 623 dev->dmasound.input = amux - 1; 624 625 mutex_unlock(&dev->dmasound.lock); 626 627 pcm = kzalloc(sizeof(*pcm), GFP_KERNEL); 628 if (pcm == NULL) 629 return -ENOMEM; 630 631 pcm->dev=saa7134->dev; 632 633 spin_lock_init(&pcm->lock); 634 635 pcm->substream = substream; 636 runtime->private_data = pcm; 637 runtime->private_free = snd_card_saa7134_runtime_free; 638 runtime->hw = snd_card_saa7134_capture; 639 640 dev->ctl_mute = 0; 641 saa7134_tvaudio_setmute(dev); 642 643 if ((err = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS)) < 0) 644 return err; 645 646 return 0; 647} 648 649/* 650 * ALSA capture callbacks definition 651 */ 652 653static struct snd_pcm_ops snd_card_saa7134_capture_ops = { 654 .open = snd_card_saa7134_capture_open, 655 .close = snd_card_saa7134_capture_close, 656 .ioctl = snd_pcm_lib_ioctl, 657 .hw_params = snd_card_saa7134_hw_params, 658 .hw_free = snd_card_saa7134_hw_free, 659 .prepare = snd_card_saa7134_capture_prepare, 660 .trigger = snd_card_saa7134_capture_trigger, 661 .pointer = snd_card_saa7134_capture_pointer, 662}; 663 664/* 665 * ALSA PCM setup 666 * 667 * Called when initializing the board. Sets up the name and hooks up 668 * the callbacks 669 * 670 */ 671 672static int snd_card_saa7134_pcm(snd_card_saa7134_t *saa7134, int device) 673{ 674 struct snd_pcm *pcm; 675 int err; 676 677 if ((err = snd_pcm_new(saa7134->card, "SAA7134 PCM", device, 0, 1, &pcm)) < 0) 678 return err; 679 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_card_saa7134_capture_ops); 680 pcm->private_data = saa7134; 681 pcm->info_flags = 0; 682 strcpy(pcm->name, "SAA7134 PCM"); 683 return 0; 684} 685 686#define SAA713x_VOLUME(xname, xindex, addr) \ 687{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \ 688 .info = snd_saa7134_volume_info, \ 689 .get = snd_saa7134_volume_get, .put = snd_saa7134_volume_put, \ 690 .private_value = addr } 691 692static int snd_saa7134_volume_info(struct snd_kcontrol * kcontrol, 693 struct snd_ctl_elem_info * uinfo) 694{ 695 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 696 uinfo->count = 2; 697 uinfo->value.integer.min = 0; 698 uinfo->value.integer.max = 20; 699 return 0; 700} 701 702static int snd_saa7134_volume_get(struct snd_kcontrol * kcontrol, 703 struct snd_ctl_elem_value * ucontrol) 704{ 705 snd_card_saa7134_t *chip = snd_kcontrol_chip(kcontrol); 706 int addr = kcontrol->private_value; 707 708 ucontrol->value.integer.value[0] = chip->mixer_volume[addr][0]; 709 ucontrol->value.integer.value[1] = chip->mixer_volume[addr][1]; 710 return 0; 711} 712 713static int snd_saa7134_volume_put(struct snd_kcontrol * kcontrol, 714 struct snd_ctl_elem_value * ucontrol) 715{ 716 snd_card_saa7134_t *chip = snd_kcontrol_chip(kcontrol); 717 struct saa7134_dev *dev = chip->dev; 718 719 int change, addr = kcontrol->private_value; 720 int left, right; 721 722 left = ucontrol->value.integer.value[0]; 723 if (left < 0) 724 left = 0; 725 if (left > 20) 726 left = 20; 727 right = ucontrol->value.integer.value[1]; 728 if (right < 0) 729 right = 0; 730 if (right > 20) 731 right = 20; 732 spin_lock_irq(&chip->mixer_lock); 733 change = 0; 734 if (chip->mixer_volume[addr][0] != left) { 735 change = 1; 736 right = left; 737 } 738 if (chip->mixer_volume[addr][1] != right) { 739 change = 1; 740 left = right; 741 } 742 if (change) { 743 switch (dev->pci->device) { 744 case PCI_DEVICE_ID_PHILIPS_SAA7134: 745 switch (addr) { 746 case MIXER_ADDR_TVTUNER: 747 left = 20; 748 break; 749 case MIXER_ADDR_LINE1: 750 saa_andorb(SAA7134_ANALOG_IO_SELECT, 0x10, 751 (left > 10) ? 0x00 : 0x10); 752 break; 753 case MIXER_ADDR_LINE2: 754 saa_andorb(SAA7134_ANALOG_IO_SELECT, 0x20, 755 (left > 10) ? 0x00 : 0x20); 756 break; 757 } 758 break; 759 case PCI_DEVICE_ID_PHILIPS_SAA7133: 760 case PCI_DEVICE_ID_PHILIPS_SAA7135: 761 switch (addr) { 762 case MIXER_ADDR_TVTUNER: 763 left = 20; 764 break; 765 case MIXER_ADDR_LINE1: 766 saa_andorb(0x0594, 0x10, 767 (left > 10) ? 0x00 : 0x10); 768 break; 769 case MIXER_ADDR_LINE2: 770 saa_andorb(0x0594, 0x20, 771 (left > 10) ? 0x00 : 0x20); 772 break; 773 } 774 break; 775 } 776 chip->mixer_volume[addr][0] = left; 777 chip->mixer_volume[addr][1] = right; 778 } 779 spin_unlock_irq(&chip->mixer_lock); 780 return change; 781} 782 783#define SAA713x_CAPSRC(xname, xindex, addr) \ 784{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = xindex, \ 785 .info = snd_saa7134_capsrc_info, \ 786 .get = snd_saa7134_capsrc_get, .put = snd_saa7134_capsrc_put, \ 787 .private_value = addr } 788 789static int snd_saa7134_capsrc_info(struct snd_kcontrol * kcontrol, 790 struct snd_ctl_elem_info * uinfo) 791{ 792 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; 793 uinfo->count = 2; 794 uinfo->value.integer.min = 0; 795 uinfo->value.integer.max = 1; 796 return 0; 797} 798 799static int snd_saa7134_capsrc_get(struct snd_kcontrol * kcontrol, 800 struct snd_ctl_elem_value * ucontrol) 801{ 802 snd_card_saa7134_t *chip = snd_kcontrol_chip(kcontrol); 803 int addr = kcontrol->private_value; 804 805 spin_lock_irq(&chip->mixer_lock); 806 ucontrol->value.integer.value[0] = chip->capture_source[addr][0]; 807 ucontrol->value.integer.value[1] = chip->capture_source[addr][1]; 808 spin_unlock_irq(&chip->mixer_lock); 809 810 return 0; 811} 812 813static int snd_saa7134_capsrc_put(struct snd_kcontrol * kcontrol, 814 struct snd_ctl_elem_value * ucontrol) 815{ 816 snd_card_saa7134_t *chip = snd_kcontrol_chip(kcontrol); 817 int change, addr = kcontrol->private_value; 818 int left, right; 819 u32 anabar, xbarin; 820 int analog_io, rate; 821 struct saa7134_dev *dev; 822 823 dev = chip->dev; 824 825 left = ucontrol->value.integer.value[0] & 1; 826 right = ucontrol->value.integer.value[1] & 1; 827 spin_lock_irq(&chip->mixer_lock); 828 829 change = chip->capture_source[addr][0] != left || 830 chip->capture_source[addr][1] != right; 831 chip->capture_source[addr][0] = left; 832 chip->capture_source[addr][1] = right; 833 dev->dmasound.input=addr; 834 spin_unlock_irq(&chip->mixer_lock); 835 836 837 if (change) { 838 switch (dev->pci->device) { 839 840 case PCI_DEVICE_ID_PHILIPS_SAA7134: 841 switch (addr) { 842 case MIXER_ADDR_TVTUNER: 843 saa_andorb(SAA7134_AUDIO_FORMAT_CTRL, 0xc0, 0xc0); 844 saa_andorb(SAA7134_SIF_SAMPLE_FREQ, 0x03, 0x00); 845 break; 846 case MIXER_ADDR_LINE1: 847 case MIXER_ADDR_LINE2: 848 analog_io = (MIXER_ADDR_LINE1 == addr) ? 0x00 : 0x08; 849 rate = (32000 == dev->dmasound.rate) ? 0x01 : 0x03; 850 saa_andorb(SAA7134_ANALOG_IO_SELECT, 0x08, analog_io); 851 saa_andorb(SAA7134_AUDIO_FORMAT_CTRL, 0xc0, 0x80); 852 saa_andorb(SAA7134_SIF_SAMPLE_FREQ, 0x03, rate); 853 break; 854 } 855 856 break; 857 case PCI_DEVICE_ID_PHILIPS_SAA7133: 858 case PCI_DEVICE_ID_PHILIPS_SAA7135: 859 xbarin = 0x03; // adc 860 anabar = 0; 861 switch (addr) { 862 case MIXER_ADDR_TVTUNER: 863 xbarin = 0; // Demodulator 864 anabar = 2; // DACs 865 break; 866 case MIXER_ADDR_LINE1: 867 anabar = 0; // aux1, aux1 868 break; 869 case MIXER_ADDR_LINE2: 870 anabar = 9; // aux2, aux2 871 break; 872 } 873 874 /* output xbar always main channel */ 875 saa_dsp_writel(dev, SAA7133_DIGITAL_OUTPUT_SEL1, 0xbbbb10); 876 877 if (left || right) { // We've got data, turn the input on 878 saa_dsp_writel(dev, SAA7133_DIGITAL_INPUT_XBAR1, xbarin); 879 saa_writel(SAA7133_ANALOG_IO_SELECT, anabar); 880 } else { 881 saa_dsp_writel(dev, SAA7133_DIGITAL_INPUT_XBAR1, 0); 882 saa_writel(SAA7133_ANALOG_IO_SELECT, 0); 883 } 884 break; 885 } 886 } 887 888 return change; 889} 890 891static struct snd_kcontrol_new snd_saa7134_controls[] = { 892SAA713x_VOLUME("Video Volume", 0, MIXER_ADDR_TVTUNER), 893SAA713x_CAPSRC("Video Capture Switch", 0, MIXER_ADDR_TVTUNER), 894SAA713x_VOLUME("Line Volume", 1, MIXER_ADDR_LINE1), 895SAA713x_CAPSRC("Line Capture Switch", 1, MIXER_ADDR_LINE1), 896SAA713x_VOLUME("Line Volume", 2, MIXER_ADDR_LINE2), 897SAA713x_CAPSRC("Line Capture Switch", 2, MIXER_ADDR_LINE2), 898}; 899 900/* 901 * ALSA mixer setup 902 * 903 * Called when initializing the board. Sets up the name and hooks up 904 * the callbacks 905 * 906 */ 907 908static int snd_card_saa7134_new_mixer(snd_card_saa7134_t * chip) 909{ 910 struct snd_card *card = chip->card; 911 unsigned int idx; 912 int err; 913 914 snd_assert(chip != NULL, return -EINVAL); 915 strcpy(card->mixername, "SAA7134 Mixer"); 916 917 for (idx = 0; idx < ARRAY_SIZE(snd_saa7134_controls); idx++) { 918 if ((err = snd_ctl_add(card, snd_ctl_new1(&snd_saa7134_controls[idx], chip))) < 0) 919 return err; 920 } 921 return 0; 922} 923 924static void snd_saa7134_free(struct snd_card * card) 925{ 926 snd_card_saa7134_t *chip = card->private_data; 927 928 if (chip->dev->dmasound.priv_data == NULL) 929 return; 930 931 if (chip->irq >= 0) { 932 synchronize_irq(chip->irq); 933 free_irq(chip->irq, &chip->dev->dmasound); 934 } 935 936 chip->dev->dmasound.priv_data = NULL; 937 938} 939 940/* 941 * ALSA initialization 942 * 943 * Called by the init routine, once for each saa7134 device present, 944 * it creates the basic structures and registers the ALSA devices 945 * 946 */ 947 948static int alsa_card_saa7134_create(struct saa7134_dev *dev, int devnum) 949{ 950 951 struct snd_card *card; 952 snd_card_saa7134_t *chip; 953 int err; 954 955 956 if (devnum >= SNDRV_CARDS) 957 return -ENODEV; 958 if (!enable[devnum]) 959 return -ENODEV; 960 961 card = snd_card_new(index[devnum], id[devnum], THIS_MODULE, sizeof(snd_card_saa7134_t)); 962 963 if (card == NULL) 964 return -ENOMEM; 965 966 strcpy(card->driver, "SAA7134"); 967 968 /* Card "creation" */ 969 970 card->private_free = snd_saa7134_free; 971 chip = (snd_card_saa7134_t *) card->private_data; 972 973 spin_lock_init(&chip->lock); 974 spin_lock_init(&chip->mixer_lock); 975 976 chip->dev = dev; 977 978 chip->card = card; 979 980 chip->pci = dev->pci; 981 chip->iobase = pci_resource_start(dev->pci, 0); 982 983 984 err = request_irq(dev->pci->irq, saa7134_alsa_irq, 985 IRQF_SHARED | IRQF_DISABLED, dev->name, 986 (void*) &dev->dmasound); 987 988 if (err < 0) { 989 printk(KERN_ERR "%s: can't get IRQ %d for ALSA\n", 990 dev->name, dev->pci->irq); 991 goto __nodev; 992 } 993 994 chip->irq = dev->pci->irq; 995 996 mutex_init(&dev->dmasound.lock); 997 998 if ((err = snd_card_saa7134_new_mixer(chip)) < 0) 999 goto __nodev; 1000 1001 if ((err = snd_card_saa7134_pcm(chip, 0)) < 0) 1002 goto __nodev; 1003 1004 snd_card_set_dev(card, &chip->pci->dev); 1005 1006 /* End of "creation" */ 1007 1008 strcpy(card->shortname, "SAA7134"); 1009 sprintf(card->longname, "%s at 0x%lx irq %d", 1010 chip->dev->name, chip->iobase, chip->irq); 1011 1012 printk(KERN_INFO "%s/alsa: %s registered as card %d\n",dev->name,card->longname,index[devnum]); 1013 1014 if ((err = snd_card_register(card)) == 0) { 1015 snd_saa7134_cards[devnum] = card; 1016 return 0; 1017 } 1018 1019__nodev: 1020 snd_card_free(card); 1021 return err; 1022} 1023 1024 1025static int alsa_device_init(struct saa7134_dev *dev) 1026{ 1027 dev->dmasound.priv_data = dev; 1028 alsa_card_saa7134_create(dev,dev->nr); 1029 return 1; 1030} 1031 1032static int alsa_device_exit(struct saa7134_dev *dev) 1033{ 1034 1035 snd_card_free(snd_saa7134_cards[dev->nr]); 1036 snd_saa7134_cards[dev->nr] = NULL; 1037 return 1; 1038} 1039 1040/* 1041 * Module initializer 1042 * 1043 * Loops through present saa7134 cards, and assigns an ALSA device 1044 * to each one 1045 * 1046 */ 1047 1048static int saa7134_alsa_init(void) 1049{ 1050 struct saa7134_dev *dev = NULL; 1051 struct list_head *list; 1052 1053 if (!saa7134_dmasound_init && !saa7134_dmasound_exit) { 1054 saa7134_dmasound_init = alsa_device_init; 1055 saa7134_dmasound_exit = alsa_device_exit; 1056 } else { 1057 printk(KERN_WARNING "saa7134 ALSA: can't load, DMA sound handler already assigned (probably to OSS)\n"); 1058 return -EBUSY; 1059 } 1060 1061 printk(KERN_INFO "saa7134 ALSA driver for DMA sound loaded\n"); 1062 1063 list_for_each(list,&saa7134_devlist) { 1064 dev = list_entry(list, struct saa7134_dev, devlist); 1065 if (dev->dmasound.priv_data == NULL) { 1066 alsa_device_init(dev); 1067 } else { 1068 printk(KERN_ERR "saa7134 ALSA: DMA sound is being handled by OSS. ignoring %s\n",dev->name); 1069 return -EBUSY; 1070 } 1071 } 1072 1073 if (dev == NULL) 1074 printk(KERN_INFO "saa7134 ALSA: no saa7134 cards found\n"); 1075 1076 return 0; 1077 1078} 1079 1080/* 1081 * Module destructor 1082 */ 1083 1084static void saa7134_alsa_exit(void) 1085{ 1086 int idx; 1087 1088 for (idx = 0; idx < SNDRV_CARDS; idx++) { 1089 snd_card_free(snd_saa7134_cards[idx]); 1090 } 1091 1092 saa7134_dmasound_init = NULL; 1093 saa7134_dmasound_exit = NULL; 1094 printk(KERN_INFO "saa7134 ALSA driver for DMA sound unloaded\n"); 1095 1096 return; 1097} 1098 1099/* We initialize this late, to make sure the sound system is up and running */ 1100late_initcall(saa7134_alsa_init); 1101module_exit(saa7134_alsa_exit); 1102MODULE_LICENSE("GPL"); 1103MODULE_AUTHOR("Ricardo Cerqueira"); 1104