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