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

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