kernel/drivers/media/pci/saa7134/saa7134-alsa.c

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