git.oblomov.eu Git - linux-2.6/blob - drivers/media/video/saa7134/saa7134-alsa.c

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