drivers/media/video/saa7134/saa7134-oss.c

   1 /*
   2  *
   3  * device driver for philips saa7134 based TV cards
   4  * oss dsp interface
   5  *
   6  * (c) 2001,02 Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]
   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; either version 2 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, write to the Free Software
  20  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21  */
  22
  23 #include <linux/init.h>
  24 #include <linux/list.h>
  25 #include <linux/module.h>
  26 #include <linux/moduleparam.h>
  27 #include <linux/kernel.h>
  28 #include <linux/slab.h>
  29 #include <linux/soundcard.h>
  30
  31 #include "saa7134-reg.h"
  32 #include "saa7134.h"
  33
  34 /* ------------------------------------------------------------------ */
  35
  36 static unsigned int oss_debug  = 0;
  37 module_param(oss_debug, int, 0644);
  38 MODULE_PARM_DESC(oss_debug,"enable debug messages [oss]");
  39
  40 static unsigned int oss_rate  = 0;
  41 module_param(oss_rate, int, 0444);
  42 MODULE_PARM_DESC(oss_rate,"sample rate (valid are: 32000,48000)");
  43
  44 #define dprintk(fmt, arg...)    if (oss_debug) \
  45         printk(KERN_DEBUG "%s/oss: " fmt, dev->name , ## arg)
  46
  47
  48 /* ------------------------------------------------------------------ */
  49
  50 static int dsp_buffer_conf(struct saa7134_dev *dev, int blksize, int blocks)
  51 {
  52         if (blksize < 0x100)
  53                 blksize = 0x100;
  54         if (blksize > 0x10000)
  55                 blksize = 0x10000;
  56
  57         if (blocks < 2)
  58                 blocks = 2;
  59         if ((blksize * blocks) > 1024*1024)
  60                 blocks = 1024*1024 / blksize;
  61
  62         dev->dmasound.blocks  = blocks;
  63         dev->dmasound.blksize = blksize;
  64         dev->dmasound.bufsize = blksize * blocks;
  65
  66         dprintk("buffer config: %d blocks / %d bytes, %d kB total\n",
  67                 blocks,blksize,blksize * blocks / 1024);
  68         return 0;
  69 }
  70
  71 static int dsp_buffer_init(struct saa7134_dev *dev)
  72 {
  73         int err;
  74
  75         if (!dev->dmasound.bufsize)
  76                 BUG();
  77         videobuf_dma_init(&dev->dmasound.dma);
  78         err = videobuf_dma_init_kernel(&dev->dmasound.dma, PCI_DMA_FROMDEVICE,
  79                                        (dev->dmasound.bufsize + PAGE_SIZE) >> PAGE_SHIFT);
  80         if (0 != err)
  81                 return err;
  82         return 0;
  83 }
  84
  85 static int dsp_buffer_free(struct saa7134_dev *dev)
  86 {
  87         if (!dev->dmasound.blksize)
  88                 BUG();
  89         videobuf_dma_free(&dev->dmasound.dma);
  90         dev->dmasound.blocks  = 0;
  91         dev->dmasound.blksize = 0;
  92         dev->dmasound.bufsize = 0;
  93         return 0;
  94 }
  95
  96 static void dsp_dma_start(struct saa7134_dev *dev)
  97 {
  98         dev->dmasound.dma_blk     = 0;
  99         dev->dmasound.dma_running = 1;
 100         saa7134_set_dmabits(dev);
 101 }
 102
 103 static void dsp_dma_stop(struct saa7134_dev *dev)
 104 {
 105         dev->dmasound.dma_blk     = -1;
 106         dev->dmasound.dma_running = 0;
 107         saa7134_set_dmabits(dev);
 108 }
 109
 110 static int dsp_rec_start(struct saa7134_dev *dev)
 111 {
 112         int err, bswap, sign;
 113         u32 fmt, control;
 114         unsigned long flags;
 115
 116         /* prepare buffer */
 117         if (0 != (err = videobuf_dma_pci_map(dev->pci,&dev->dmasound.dma)))
 118                 return err;
 119         if (0 != (err = saa7134_pgtable_alloc(dev->pci,&dev->dmasound.pt)))
 120                 goto fail1;
 121         if (0 != (err = saa7134_pgtable_build(dev->pci,&dev->dmasound.pt,
 122                                               dev->dmasound.dma.sglist,
 123                                               dev->dmasound.dma.sglen,
 124                                               0)))
 125                 goto fail2;
 126
 127         /* sample format */
 128         switch (dev->dmasound.afmt) {
 129         case AFMT_U8:
 130         case AFMT_S8:     fmt = 0x00;  break;
 131         case AFMT_U16_LE:
 132         case AFMT_U16_BE:
 133         case AFMT_S16_LE:
 134         case AFMT_S16_BE: fmt = 0x01;  break;
 135         default:
 136                 err = -EINVAL;
 137                 goto fail2;
 138         }
 139
 140         switch (dev->dmasound.afmt) {
 141         case AFMT_S8:
 142         case AFMT_S16_LE:
 143         case AFMT_S16_BE: sign = 1; break;
 144         default:          sign = 0; break;
 145         }
 146
 147         switch (dev->dmasound.afmt) {
 148         case AFMT_U16_BE:
 149         case AFMT_S16_BE: bswap = 1; break;
 150         default:          bswap = 0; break;
 151         }
 152
 153         switch (dev->pci->device) {
 154         case PCI_DEVICE_ID_PHILIPS_SAA7134:
 155                 if (1 == dev->dmasound.channels)
 156                         fmt |= (1 << 3);
 157                 if (2 == dev->dmasound.channels)
 158                         fmt |= (3 << 3);
 159                 if (sign)
 160                         fmt |= 0x04;
 161                 fmt |= (TV == dev->dmasound.input) ? 0xc0 : 0x80;
 162
 163                 saa_writeb(SAA7134_NUM_SAMPLES0, ((dev->dmasound.blksize - 1) & 0x0000ff));
 164                 saa_writeb(SAA7134_NUM_SAMPLES1, ((dev->dmasound.blksize - 1) & 0x00ff00) >>  8);
 165                 saa_writeb(SAA7134_NUM_SAMPLES2, ((dev->dmasound.blksize - 1) & 0xff0000) >> 16);
 166                 saa_writeb(SAA7134_AUDIO_FORMAT_CTRL, fmt);
 167
 168                 break;
 169         case PCI_DEVICE_ID_PHILIPS_SAA7133:
 170         case PCI_DEVICE_ID_PHILIPS_SAA7135:
 171                 if (1 == dev->dmasound.channels)
 172                         fmt |= (1 << 4);
 173                 if (2 == dev->dmasound.channels)
 174                         fmt |= (2 << 4);
 175                 if (!sign)
 176                         fmt |= 0x04;
 177                 saa_writel(SAA7133_NUM_SAMPLES, dev->dmasound.blksize -4);
 178                 saa_writel(SAA7133_AUDIO_CHANNEL, 0x543210 | (fmt << 24));
 179                 break;
 180         }
 181         dprintk("rec_start: afmt=%d ch=%d  =>  fmt=0x%x swap=%c\n",
 182                 dev->dmasound.afmt, dev->dmasound.channels, fmt,
 183                 bswap ? 'b' : '-');
 184
 185         /* dma: setup channel 6 (= AUDIO) */
 186         control = SAA7134_RS_CONTROL_BURST_16 |
 187                 SAA7134_RS_CONTROL_ME |
 188                 (dev->dmasound.pt.dma >> 12);
 189         if (bswap)
 190                 control |= SAA7134_RS_CONTROL_BSWAP;
 191         saa_writel(SAA7134_RS_BA1(6),0);
 192         saa_writel(SAA7134_RS_BA2(6),dev->dmasound.blksize);
 193         saa_writel(SAA7134_RS_PITCH(6),0);
 194         saa_writel(SAA7134_RS_CONTROL(6),control);
 195
 196         /* start dma */
 197         dev->dmasound.recording_on = 1;
 198         spin_lock_irqsave(&dev->slock,flags);
 199         dsp_dma_start(dev);
 200         spin_unlock_irqrestore(&dev->slock,flags);
 201         return 0;
 202
 203  fail2:
 204         saa7134_pgtable_free(dev->pci,&dev->dmasound.pt);
 205  fail1:
 206         videobuf_dma_pci_unmap(dev->pci,&dev->dmasound.dma);
 207         return err;
 208 }
 209
 210 static int dsp_rec_stop(struct saa7134_dev *dev)
 211 {
 212         unsigned long flags;
 213
 214         dprintk("rec_stop dma_blk=%d\n",dev->dmasound.dma_blk);
 215
 216         /* stop dma */
 217         dev->dmasound.recording_on = 0;
 218         spin_lock_irqsave(&dev->slock,flags);
 219         dsp_dma_stop(dev);
 220         spin_unlock_irqrestore(&dev->slock,flags);
 221
 222         /* unlock buffer */
 223         saa7134_pgtable_free(dev->pci,&dev->dmasound.pt);
 224         videobuf_dma_pci_unmap(dev->pci,&dev->dmasound.dma);
 225         return 0;
 226 }
 227
 228 /* ------------------------------------------------------------------ */
 229
 230 static int dsp_open(struct inode *inode, struct file *file)
 231 {
 232         int minor = iminor(inode);
 233         struct saa7134_dev *h,*dev = NULL;
 234         struct list_head *list;
 235         int err;
 236
 237         list_for_each(list,&saa7134_devlist) {
 238                 h = list_entry(list, struct saa7134_dev, devlist);
 239                 if (h->dmasound.minor_dsp == minor)
 240                         dev = h;
 241         }
 242         if (NULL == dev)
 243                 return -ENODEV;
 244
 245         down(&dev->dmasound.lock);
 246         err = -EBUSY;
 247         if (dev->dmasound.users_dsp)
 248                 goto fail1;
 249         dev->dmasound.users_dsp++;
 250         file->private_data = dev;
 251
 252         dev->dmasound.afmt        = AFMT_U8;
 253         dev->dmasound.channels    = 1;
 254         dev->dmasound.read_count  = 0;
 255         dev->dmasound.read_offset = 0;
 256         dsp_buffer_conf(dev,PAGE_SIZE,64);
 257         err = dsp_buffer_init(dev);
 258         if (0 != err)
 259                 goto fail2;
 260
 261         up(&dev->dmasound.lock);
 262         return 0;
 263
 264  fail2:
 265         dev->dmasound.users_dsp--;
 266  fail1:
 267         up(&dev->dmasound.lock);
 268         return err;
 269 }
 270
 271 static int dsp_release(struct inode *inode, struct file *file)
 272 {
 273         struct saa7134_dev *dev = file->private_data;
 274
 275         down(&dev->dmasound.lock);
 276         if (dev->dmasound.recording_on)
 277                 dsp_rec_stop(dev);
 278         dsp_buffer_free(dev);
 279         dev->dmasound.users_dsp--;
 280         file->private_data = NULL;
 281         up(&dev->dmasound.lock);
 282         return 0;
 283 }
 284
 285 static ssize_t dsp_read(struct file *file, char __user *buffer,
 286                         size_t count, loff_t *ppos)
 287 {
 288         struct saa7134_dev *dev = file->private_data;
 289         DECLARE_WAITQUEUE(wait, current);
 290         unsigned int bytes;
 291         unsigned long flags;
 292         int err,ret = 0;
 293
 294         add_wait_queue(&dev->dmasound.wq, &wait);
 295         down(&dev->dmasound.lock);
 296         while (count > 0) {
 297                 /* wait for data if needed */
 298                 if (0 == dev->dmasound.read_count) {
 299                         if (!dev->dmasound.recording_on) {
 300                                 err = dsp_rec_start(dev);
 301                                 if (err < 0) {
 302                                         if (0 == ret)
 303                                                 ret = err;
 304                                         break;
 305                                 }
 306                         }
 307                         if (dev->dmasound.recording_on &&
 308                             !dev->dmasound.dma_running) {
 309                                 /* recover from overruns */
 310                                 spin_lock_irqsave(&dev->slock,flags);
 311                                 dsp_dma_start(dev);
 312                                 spin_unlock_irqrestore(&dev->slock,flags);
 313                         }
 314                         if (file->f_flags & O_NONBLOCK) {
 315                                 if (0 == ret)
 316                                         ret = -EAGAIN;
 317                                 break;
 318                         }
 319                         up(&dev->dmasound.lock);
 320                         set_current_state(TASK_INTERRUPTIBLE);
 321                         if (0 == dev->dmasound.read_count)
 322                                 schedule();
 323                         set_current_state(TASK_RUNNING);
 324                         down(&dev->dmasound.lock);
 325                         if (signal_pending(current)) {
 326                                 if (0 == ret)
 327                                         ret = -EINTR;
 328                                 break;
 329                         }
 330                 }
 331
 332                 /* copy data to userspace */
 333                 bytes = count;
 334                 if (bytes > dev->dmasound.read_count)
 335                         bytes = dev->dmasound.read_count;
 336                 if (bytes > dev->dmasound.bufsize - dev->dmasound.read_offset)
 337                         bytes = dev->dmasound.bufsize - dev->dmasound.read_offset;
 338                 if (copy_to_user(buffer + ret,
 339                                  dev->dmasound.dma.vmalloc + dev->dmasound.read_offset,
 340                                  bytes)) {
 341                         if (0 == ret)
 342                                 ret = -EFAULT;
 343                         break;
 344                 }
 345
 346                 ret   += bytes;
 347                 count -= bytes;
 348                 dev->dmasound.read_count  -= bytes;
 349                 dev->dmasound.read_offset += bytes;
 350                 if (dev->dmasound.read_offset == dev->dmasound.bufsize)
 351                         dev->dmasound.read_offset = 0;
 352         }
 353         up(&dev->dmasound.lock);
 354         remove_wait_queue(&dev->dmasound.wq, &wait);
 355         return ret;
 356 }
 357
 358 static ssize_t dsp_write(struct file *file, const char __user *buffer,
 359                          size_t count, loff_t *ppos)
 360 {
 361         return -EINVAL;
 362 }
 363
 364 static int dsp_ioctl(struct inode *inode, struct file *file,
 365                      unsigned int cmd, unsigned long arg)
 366 {
 367         struct saa7134_dev *dev = file->private_data;
 368         void __user *argp = (void __user *) arg;
 369         int __user *p = argp;
 370         int val = 0;
 371
 372         if (oss_debug > 1)
 373                 saa7134_print_ioctl(dev->name,cmd);
 374         switch (cmd) {
 375         case OSS_GETVERSION:
 376                 return put_user(SOUND_VERSION, p);
 377         case SNDCTL_DSP_GETCAPS:
 378                 return 0;
 379
 380         case SNDCTL_DSP_SPEED:
 381                 if (get_user(val, p))
 382                         return -EFAULT;
 383                 /* fall through */
 384         case SOUND_PCM_READ_RATE:
 385                 return put_user(dev->dmasound.rate, p);
 386
 387         case SNDCTL_DSP_STEREO:
 388                 if (get_user(val, p))
 389                         return -EFAULT;
 390                 down(&dev->dmasound.lock);
 391                 dev->dmasound.channels = val ? 2 : 1;
 392                 if (dev->dmasound.recording_on) {
 393                         dsp_rec_stop(dev);
 394                         dsp_rec_start(dev);
 395                 }
 396                 up(&dev->dmasound.lock);
 397                 return put_user(dev->dmasound.channels-1, p);
 398
 399         case SNDCTL_DSP_CHANNELS:
 400                 if (get_user(val, p))
 401                         return -EFAULT;
 402                 if (val != 1 && val != 2)
 403                         return -EINVAL;
 404                 down(&dev->dmasound.lock);
 405                 dev->dmasound.channels = val;
 406                 if (dev->dmasound.recording_on) {
 407                         dsp_rec_stop(dev);
 408                         dsp_rec_start(dev);
 409                 }
 410                 up(&dev->dmasound.lock);
 411                 /* fall through */
 412         case SOUND_PCM_READ_CHANNELS:
 413                 return put_user(dev->dmasound.channels, p);
 414
 415         case SNDCTL_DSP_GETFMTS: /* Returns a mask */
 416                 return put_user(AFMT_U8     | AFMT_S8     |
 417                                 AFMT_U16_LE | AFMT_U16_BE |
 418                                 AFMT_S16_LE | AFMT_S16_BE, p);
 419
 420         case SNDCTL_DSP_SETFMT: /* Selects ONE fmt */
 421                 if (get_user(val, p))
 422                         return -EFAULT;
 423                 switch (val) {
 424                 case AFMT_QUERY:
 425                         /* nothing to do */
 426                         break;
 427                 case AFMT_U8:
 428                 case AFMT_S8:
 429                 case AFMT_U16_LE:
 430                 case AFMT_U16_BE:
 431                 case AFMT_S16_LE:
 432                 case AFMT_S16_BE:
 433                         down(&dev->dmasound.lock);
 434                         dev->dmasound.afmt = val;
 435                         if (dev->dmasound.recording_on) {
 436                                 dsp_rec_stop(dev);
 437                                 dsp_rec_start(dev);
 438                         }
 439                         up(&dev->dmasound.lock);
 440                         return put_user(dev->dmasound.afmt, p);
 441                 default:
 442                         return -EINVAL;
 443                 }
 444
 445         case SOUND_PCM_READ_BITS:
 446                 switch (dev->dmasound.afmt) {
 447                 case AFMT_U8:
 448                 case AFMT_S8:
 449                         return put_user(8, p);
 450                 case AFMT_U16_LE:
 451                 case AFMT_U16_BE:
 452                 case AFMT_S16_LE:
 453                 case AFMT_S16_BE:
 454                         return put_user(16, p);
 455                 default:
 456                         return -EINVAL;
 457                 }
 458
 459         case SNDCTL_DSP_NONBLOCK:
 460                 file->f_flags |= O_NONBLOCK;
 461                 return 0;
 462
 463         case SNDCTL_DSP_RESET:
 464                 down(&dev->dmasound.lock);
 465                 if (dev->dmasound.recording_on)
 466                         dsp_rec_stop(dev);
 467                 up(&dev->dmasound.lock);
 468                 return 0;
 469         case SNDCTL_DSP_GETBLKSIZE:
 470                 return put_user(dev->dmasound.blksize, p);
 471
 472         case SNDCTL_DSP_SETFRAGMENT:
 473                 if (get_user(val, p))
 474                         return -EFAULT;
 475                 if (dev->dmasound.recording_on)
 476                         return -EBUSY;
 477                 dsp_buffer_free(dev);
 478                 /* used to be arg >> 16 instead of val >> 16; fixed */
 479                 dsp_buffer_conf(dev,1 << (val & 0xffff), (val >> 16) & 0xffff);
 480                 dsp_buffer_init(dev);
 481                 return 0;
 482
 483         case SNDCTL_DSP_SYNC:
 484                 /* NOP */
 485                 return 0;
 486
 487         case SNDCTL_DSP_GETISPACE:
 488         {
 489                 audio_buf_info info;
 490                 info.fragsize   = dev->dmasound.blksize;
 491                 info.fragstotal = dev->dmasound.blocks;
 492                 info.bytes      = dev->dmasound.read_count;
 493                 info.fragments  = info.bytes / info.fragsize;
 494                 if (copy_to_user(argp, &info, sizeof(info)))
 495                         return -EFAULT;
 496                 return 0;
 497         }
 498         default:
 499                 return -EINVAL;
 500         }
 501 }
 502
 503 static unsigned int dsp_poll(struct file *file, struct poll_table_struct *wait)
 504 {
 505         struct saa7134_dev *dev = file->private_data;
 506         unsigned int mask = 0;
 507
 508         poll_wait(file, &dev->dmasound.wq, wait);
 509
 510         if (0 == dev->dmasound.read_count) {
 511                 down(&dev->dmasound.lock);
 512                 if (!dev->dmasound.recording_on)
 513                         dsp_rec_start(dev);
 514                 up(&dev->dmasound.lock);
 515         } else
 516                 mask |= (POLLIN | POLLRDNORM);
 517         return mask;
 518 }
 519
 520 struct file_operations saa7134_dsp_fops = {
 521         .owner   = THIS_MODULE,
 522         .open    = dsp_open,
 523         .release = dsp_release,
 524         .read    = dsp_read,
 525         .write   = dsp_write,
 526         .ioctl   = dsp_ioctl,
 527         .poll    = dsp_poll,
 528         .llseek  = no_llseek,
 529 };
 530
 531 /* ------------------------------------------------------------------ */
 532
 533 static int
 534 mixer_recsrc_7134(struct saa7134_dev *dev)
 535 {
 536         int analog_io,rate;
 537
 538         switch (dev->dmasound.input) {
 539         case TV:
 540                 saa_andorb(SAA7134_AUDIO_FORMAT_CTRL, 0xc0, 0xc0);
 541                 saa_andorb(SAA7134_SIF_SAMPLE_FREQ,   0x03, 0x00);
 542                 break;
 543         case LINE1:
 544         case LINE2:
 545         case LINE2_LEFT:
 546                 analog_io = (LINE1 == dev->dmasound.input) ? 0x00 : 0x08;
 547                 rate = (32000 == dev->dmasound.rate) ? 0x01 : 0x03;
 548                 saa_andorb(SAA7134_ANALOG_IO_SELECT,  0x08, analog_io);
 549                 saa_andorb(SAA7134_AUDIO_FORMAT_CTRL, 0xc0, 0x80);
 550                 saa_andorb(SAA7134_SIF_SAMPLE_FREQ,   0x03, rate);
 551                 break;
 552         }
 553         return 0;
 554 }
 555
 556 static int
 557 mixer_recsrc_7133(struct saa7134_dev *dev)
 558 {
 559         u32 anabar, xbarin;
 560
 561         xbarin = 0x03; // adc
 562     anabar = 0;
 563         switch (dev->dmasound.input) {
 564         case TV:
 565                 xbarin = 0; // Demodulator
 566         anabar = 2; // DACs
 567                 break;
 568         case LINE1:
 569                 anabar = 0;  // aux1, aux1
 570                 break;
 571         case LINE2:
 572         case LINE2_LEFT:
 573                 anabar = 9;  // aux2, aux2
 574                 break;
 575         }
 576     /* output xbar always main channel */
 577         saa_dsp_writel(dev, 0x46c >> 2, 0xbbbb10);
 578         saa_dsp_writel(dev, 0x464 >> 2, xbarin);
 579         saa_writel(0x594 >> 2, anabar);
 580
 581         return 0;
 582 }
 583
 584 static int
 585 mixer_recsrc(struct saa7134_dev *dev, enum saa7134_audio_in src)
 586 {
 587         static const char *iname[] = { "Oops", "TV", "LINE1", "LINE2" };
 588
 589         dev->dmasound.count++;
 590         dev->dmasound.input = src;
 591         dprintk("mixer input = %s\n",iname[dev->dmasound.input]);
 592
 593         switch (dev->pci->device) {
 594         case PCI_DEVICE_ID_PHILIPS_SAA7134:
 595                 mixer_recsrc_7134(dev);
 596                 break;
 597         case PCI_DEVICE_ID_PHILIPS_SAA7133:
 598         case PCI_DEVICE_ID_PHILIPS_SAA7135:
 599                 mixer_recsrc_7133(dev);
 600                 break;
 601         }
 602         return 0;
 603 }
 604
 605 static int
 606 mixer_level(struct saa7134_dev *dev, enum saa7134_audio_in src, int level)
 607 {
 608         switch (dev->pci->device) {
 609         case PCI_DEVICE_ID_PHILIPS_SAA7134:
 610                 switch (src) {
 611                 case TV:
 612                         /* nothing */
 613                         break;
 614                 case LINE1:
 615                         saa_andorb(SAA7134_ANALOG_IO_SELECT,  0x10,
 616                                    (100 == level) ? 0x00 : 0x10);
 617                         break;
 618                 case LINE2:
 619                 case LINE2_LEFT:
 620                         saa_andorb(SAA7134_ANALOG_IO_SELECT,  0x20,
 621                                    (100 == level) ? 0x00 : 0x20);
 622                         break;
 623                 }
 624                 break;
 625         case PCI_DEVICE_ID_PHILIPS_SAA7133:
 626         case PCI_DEVICE_ID_PHILIPS_SAA7135:
 627                 /* nothing */
 628                 break;
 629         }
 630         return 0;
 631 }
 632
 633 /* ------------------------------------------------------------------ */
 634
 635 static int mixer_open(struct inode *inode, struct file *file)
 636 {
 637         int minor = iminor(inode);
 638         struct saa7134_dev *h,*dev = NULL;
 639         struct list_head *list;
 640
 641         list_for_each(list,&saa7134_devlist) {
 642                 h = list_entry(list, struct saa7134_dev, devlist);
 643                 if (h->dmasound.minor_mixer == minor)
 644                         dev = h;
 645         }
 646         if (NULL == dev)
 647                 return -ENODEV;
 648
 649         file->private_data = dev;
 650         return 0;
 651 }
 652
 653 static int mixer_release(struct inode *inode, struct file *file)
 654 {
 655         file->private_data = NULL;
 656         return 0;
 657 }
 658
 659 static int mixer_ioctl(struct inode *inode, struct file *file,
 660                      unsigned int cmd, unsigned long arg)
 661 {
 662         struct saa7134_dev *dev = file->private_data;
 663         enum saa7134_audio_in input;
 664         int val,ret;
 665         void __user *argp = (void __user *) arg;
 666         int __user *p = argp;
 667
 668         if (oss_debug > 1)
 669                 saa7134_print_ioctl(dev->name,cmd);
 670         switch (cmd) {
 671         case OSS_GETVERSION:
 672                 return put_user(SOUND_VERSION, p);
 673         case SOUND_MIXER_INFO:
 674         {
 675                 mixer_info info;
 676                 memset(&info,0,sizeof(info));
 677                 strlcpy(info.id,   "TV audio", sizeof(info.id));
 678                 strlcpy(info.name, dev->name,  sizeof(info.name));
 679                 info.modify_counter = dev->dmasound.count;
 680                 if (copy_to_user(argp, &info, sizeof(info)))
 681                         return -EFAULT;
 682                 return 0;
 683         }
 684         case SOUND_OLD_MIXER_INFO:
 685         {
 686                 _old_mixer_info info;
 687                 memset(&info,0,sizeof(info));
 688                 strlcpy(info.id,   "TV audio", sizeof(info.id));
 689                 strlcpy(info.name, dev->name,  sizeof(info.name));
 690                 if (copy_to_user(argp, &info, sizeof(info)))
 691                         return -EFAULT;
 692                 return 0;
 693         }
 694         case MIXER_READ(SOUND_MIXER_CAPS):
 695                 return put_user(SOUND_CAP_EXCL_INPUT, p);
 696         case MIXER_READ(SOUND_MIXER_STEREODEVS):
 697                 return put_user(0, p);
 698         case MIXER_READ(SOUND_MIXER_RECMASK):
 699         case MIXER_READ(SOUND_MIXER_DEVMASK):
 700                 val = SOUND_MASK_LINE1 | SOUND_MASK_LINE2;
 701                 if (32000 == dev->dmasound.rate)
 702                         val |= SOUND_MASK_VIDEO;
 703                 return put_user(val, p);
 704
 705         case MIXER_WRITE(SOUND_MIXER_RECSRC):
 706                 if (get_user(val, p))
 707                         return -EFAULT;
 708                 input = dev->dmasound.input;
 709                 if (32000 == dev->dmasound.rate  &&
 710                     val & SOUND_MASK_VIDEO  &&  dev->dmasound.input != TV)
 711                         input = TV;
 712                 if (val & SOUND_MASK_LINE1  &&  dev->dmasound.input != LINE1)
 713                         input = LINE1;
 714                 if (val & SOUND_MASK_LINE2  &&  dev->dmasound.input != LINE2)
 715                         input = LINE2;
 716                 if (input != dev->dmasound.input)
 717                         mixer_recsrc(dev,input);
 718                 /* fall throuth */
 719         case MIXER_READ(SOUND_MIXER_RECSRC):
 720                 switch (dev->dmasound.input) {
 721                 case TV:    ret = SOUND_MASK_VIDEO; break;
 722                 case LINE1: ret = SOUND_MASK_LINE1; break;
 723                 case LINE2: ret = SOUND_MASK_LINE2; break;
 724                 default:    ret = 0;
 725                 }
 726                 return put_user(ret, p);
 727
 728         case MIXER_WRITE(SOUND_MIXER_VIDEO):
 729         case MIXER_READ(SOUND_MIXER_VIDEO):
 730                 if (32000 != dev->dmasound.rate)
 731                         return -EINVAL;
 732                 return put_user(100 | 100 << 8, p);
 733
 734         case MIXER_WRITE(SOUND_MIXER_LINE1):
 735                 if (get_user(val, p))
 736                         return -EFAULT;
 737                 val &= 0xff;
 738                 val = (val <= 50) ? 50 : 100;
 739                 dev->dmasound.line1 = val;
 740                 mixer_level(dev,LINE1,dev->dmasound.line1);
 741                 /* fall throuth */
 742         case MIXER_READ(SOUND_MIXER_LINE1):
 743                 return put_user(dev->dmasound.line1 | dev->dmasound.line1 << 8, p);
 744
 745         case MIXER_WRITE(SOUND_MIXER_LINE2):
 746                 if (get_user(val, p))
 747                         return -EFAULT;
 748                 val &= 0xff;
 749                 val = (val <= 50) ? 50 : 100;
 750                 dev->dmasound.line2 = val;
 751                 mixer_level(dev,LINE2,dev->dmasound.line2);
 752                 /* fall throuth */
 753         case MIXER_READ(SOUND_MIXER_LINE2):
 754                 return put_user(dev->dmasound.line2 | dev->dmasound.line2 << 8, p);
 755
 756         default:
 757                 return -EINVAL;
 758         }
 759 }
 760
 761 struct file_operations saa7134_mixer_fops = {
 762         .owner   = THIS_MODULE,
 763         .open    = mixer_open,
 764         .release = mixer_release,
 765         .ioctl   = mixer_ioctl,
 766         .llseek  = no_llseek,
 767 };
 768
 769 /* ------------------------------------------------------------------ */
 770
 771 int saa7134_oss_init1(struct saa7134_dev *dev)
 772 {
 773         /* general */
 774         init_MUTEX(&dev->dmasound.lock);
 775         init_waitqueue_head(&dev->dmasound.wq);
 776
 777         switch (dev->pci->device) {
 778         case PCI_DEVICE_ID_PHILIPS_SAA7133:
 779         case PCI_DEVICE_ID_PHILIPS_SAA7135:
 780                 saa_writel(0x588 >> 2, 0x00000fff);
 781                 saa_writel(0x58c >> 2, 0x00543210);
 782                 saa_dsp_writel(dev, 0x46c >> 2, 0xbbbbbb);
 783                 break;
 784         }
 785
 786         /* dsp */
 787         dev->dmasound.rate = 32000;
 788         if (oss_rate)
 789                 dev->dmasound.rate = oss_rate;
 790         dev->dmasound.rate = (dev->dmasound.rate > 40000) ? 48000 : 32000;
 791
 792         /* mixer */
 793         dev->dmasound.line1 = 50;
 794         dev->dmasound.line2 = 50;
 795         mixer_level(dev,LINE1,dev->dmasound.line1);
 796         mixer_level(dev,LINE2,dev->dmasound.line2);
 797         mixer_recsrc(dev, (dev->dmasound.rate == 32000) ? TV : LINE2);
 798
 799         return 0;
 800 }
 801
 802 int saa7134_oss_fini(struct saa7134_dev *dev)
 803 {
 804         /* nothing */
 805         return 0;
 806 }
 807
 808 void saa7134_irq_oss_done(struct saa7134_dev *dev, unsigned long status)
 809 {
 810         int next_blk, reg = 0;
 811
 812         spin_lock(&dev->slock);
 813         if (UNSET == dev->dmasound.dma_blk) {
 814                 dprintk("irq: recording stopped\n");
 815                 goto done;
 816         }
 817         if (0 != (status & 0x0f000000))
 818                 dprintk("irq: lost %ld\n", (status >> 24) & 0x0f);
 819         if (0 == (status & 0x10000000)) {
 820                 /* odd */
 821                 if (0 == (dev->dmasound.dma_blk & 0x01))
 822                         reg = SAA7134_RS_BA1(6);
 823         } else {
 824                 /* even */
 825                 if (1 == (dev->dmasound.dma_blk & 0x01))
 826                         reg = SAA7134_RS_BA2(6);
 827         }
 828         if (0 == reg) {
 829                 dprintk("irq: field oops [%s]\n",
 830                         (status & 0x10000000) ? "even" : "odd");
 831                 goto done;
 832         }
 833         if (dev->dmasound.read_count >= dev->dmasound.blksize * (dev->dmasound.blocks-2)) {
 834                 dprintk("irq: overrun [full=%d/%d]\n",dev->dmasound.read_count,
 835                         dev->dmasound.bufsize);
 836                 dsp_dma_stop(dev);
 837                 goto done;
 838         }
 839
 840         /* next block addr */
 841         next_blk = (dev->dmasound.dma_blk + 2) % dev->dmasound.blocks;
 842         saa_writel(reg,next_blk * dev->dmasound.blksize);
 843         if (oss_debug > 2)
 844                 dprintk("irq: ok, %s, next_blk=%d, addr=%x\n",
 845                         (status & 0x10000000) ? "even" : "odd ", next_blk,
 846                         next_blk * dev->dmasound.blksize);
 847
 848         /* update status & wake waiting readers */
 849         dev->dmasound.dma_blk = (dev->dmasound.dma_blk + 1) % dev->dmasound.blocks;
 850         dev->dmasound.read_count += dev->dmasound.blksize;
 851         wake_up(&dev->dmasound.wq);
 852
 853  done:
 854         spin_unlock(&dev->slock);
 855 }
 856
 857 /* ----------------------------------------------------------- */
 858 /*
 859  * Local variables:
 860  * c-basic-offset: 8
 861  * End:
 862  */