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