3 * device driver for philips saa7134 based TV cards
6 * (c) 2001,02 Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]
7 * 2005 conversion to standalone module:
8 * Ricardo Cerqueira <v4l@cerqueira.org>
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 #include <linux/init.h>
26 #include <linux/list.h>
27 #include <linux/module.h>
28 #include <linux/kernel.h>
29 #include <linux/interrupt.h>
30 #include <linux/slab.h>
31 #include <linux/sound.h>
32 #include <linux/soundcard.h>
34 #include "saa7134-reg.h"
37 /* ------------------------------------------------------------------ */
39 static unsigned int debug = 0;
40 module_param(debug, int, 0644);
41 MODULE_PARM_DESC(debug,"enable debug messages [oss]");
43 static unsigned int rate = 0;
44 module_param(rate, int, 0444);
45 MODULE_PARM_DESC(rate,"sample rate (valid are: 32000,48000)");
47 static unsigned int dsp_nr[] = {[0 ... (SAA7134_MAXBOARDS - 1)] = UNSET };
48 MODULE_PARM_DESC(dsp_nr, "device numbers for SAA7134 capture interface(s).");
49 module_param_array(dsp_nr, int, NULL, 0444);
51 static unsigned int mixer_nr[] = {[0 ... (SAA7134_MAXBOARDS - 1)] = UNSET };
52 MODULE_PARM_DESC(mixer_nr, "mixer numbers for SAA7134 capture interface(s).");
53 module_param_array(mixer_nr, int, NULL, 0444);
55 #define dprintk(fmt, arg...) if (debug) \
56 printk(KERN_DEBUG "%s/oss: " fmt, dev->name , ## arg)
59 /* ------------------------------------------------------------------ */
61 static int dsp_buffer_conf(struct saa7134_dev *dev, int blksize, int blocks)
65 if (blksize > 0x10000)
70 if ((blksize * blocks) > 1024*1024)
71 blocks = 1024*1024 / blksize;
73 dev->dmasound.blocks = blocks;
74 dev->dmasound.blksize = blksize;
75 dev->dmasound.bufsize = blksize * blocks;
77 dprintk("buffer config: %d blocks / %d bytes, %d kB total\n",
78 blocks,blksize,blksize * blocks / 1024);
82 static int dsp_buffer_init(struct saa7134_dev *dev)
86 BUG_ON(!dev->dmasound.bufsize);
87 videobuf_dma_init(&dev->dmasound.dma);
88 err = videobuf_dma_init_kernel(&dev->dmasound.dma, PCI_DMA_FROMDEVICE,
89 (dev->dmasound.bufsize + PAGE_SIZE) >> PAGE_SHIFT);
95 static int dsp_buffer_free(struct saa7134_dev *dev)
97 BUG_ON(!dev->dmasound.blksize);
98 videobuf_dma_free(&dev->dmasound.dma);
99 dev->dmasound.blocks = 0;
100 dev->dmasound.blksize = 0;
101 dev->dmasound.bufsize = 0;
105 static void dsp_dma_start(struct saa7134_dev *dev)
107 dev->dmasound.dma_blk = 0;
108 dev->dmasound.dma_running = 1;
109 saa7134_set_dmabits(dev);
112 static void dsp_dma_stop(struct saa7134_dev *dev)
114 dev->dmasound.dma_blk = -1;
115 dev->dmasound.dma_running = 0;
116 saa7134_set_dmabits(dev);
119 static int dsp_rec_start(struct saa7134_dev *dev)
121 int err, bswap, sign;
126 if (0 != (err = videobuf_pci_dma_map(dev->pci,&dev->dmasound.dma)))
128 if (0 != (err = saa7134_pgtable_alloc(dev->pci,&dev->dmasound.pt)))
130 if (0 != (err = saa7134_pgtable_build(dev->pci,&dev->dmasound.pt,
131 dev->dmasound.dma.sglist,
132 dev->dmasound.dma.sglen,
137 switch (dev->dmasound.afmt) {
139 case AFMT_S8: fmt = 0x00; break;
143 case AFMT_S16_BE: fmt = 0x01; break;
149 switch (dev->dmasound.afmt) {
152 case AFMT_S16_BE: sign = 1; break;
153 default: sign = 0; break;
156 switch (dev->dmasound.afmt) {
158 case AFMT_S16_BE: bswap = 1; break;
159 default: bswap = 0; break;
162 switch (dev->pci->device) {
163 case PCI_DEVICE_ID_PHILIPS_SAA7134:
164 if (1 == dev->dmasound.channels)
166 if (2 == dev->dmasound.channels)
170 fmt |= (TV == dev->dmasound.input) ? 0xc0 : 0x80;
172 saa_writeb(SAA7134_NUM_SAMPLES0, ((dev->dmasound.blksize - 1) & 0x0000ff));
173 saa_writeb(SAA7134_NUM_SAMPLES1, ((dev->dmasound.blksize - 1) & 0x00ff00) >> 8);
174 saa_writeb(SAA7134_NUM_SAMPLES2, ((dev->dmasound.blksize - 1) & 0xff0000) >> 16);
175 saa_writeb(SAA7134_AUDIO_FORMAT_CTRL, fmt);
178 case PCI_DEVICE_ID_PHILIPS_SAA7133:
179 case PCI_DEVICE_ID_PHILIPS_SAA7135:
180 if (1 == dev->dmasound.channels)
182 if (2 == dev->dmasound.channels)
186 saa_writel(SAA7133_NUM_SAMPLES, dev->dmasound.blksize -4);
187 saa_writel(SAA7133_AUDIO_CHANNEL, 0x543210 | (fmt << 24));
190 dprintk("rec_start: afmt=%d ch=%d => fmt=0x%x swap=%c\n",
191 dev->dmasound.afmt, dev->dmasound.channels, fmt,
194 /* dma: setup channel 6 (= AUDIO) */
195 control = SAA7134_RS_CONTROL_BURST_16 |
196 SAA7134_RS_CONTROL_ME |
197 (dev->dmasound.pt.dma >> 12);
199 control |= SAA7134_RS_CONTROL_BSWAP;
200 saa_writel(SAA7134_RS_BA1(6),0);
201 saa_writel(SAA7134_RS_BA2(6),dev->dmasound.blksize);
202 saa_writel(SAA7134_RS_PITCH(6),0);
203 saa_writel(SAA7134_RS_CONTROL(6),control);
206 dev->dmasound.recording_on = 1;
207 spin_lock_irqsave(&dev->slock,flags);
209 spin_unlock_irqrestore(&dev->slock,flags);
213 saa7134_pgtable_free(dev->pci,&dev->dmasound.pt);
215 videobuf_pci_dma_unmap(dev->pci,&dev->dmasound.dma);
219 static int dsp_rec_stop(struct saa7134_dev *dev)
223 dprintk("rec_stop dma_blk=%d\n",dev->dmasound.dma_blk);
226 dev->dmasound.recording_on = 0;
227 spin_lock_irqsave(&dev->slock,flags);
229 spin_unlock_irqrestore(&dev->slock,flags);
232 saa7134_pgtable_free(dev->pci,&dev->dmasound.pt);
233 videobuf_pci_dma_unmap(dev->pci,&dev->dmasound.dma);
237 /* ------------------------------------------------------------------ */
239 static int dsp_open(struct inode *inode, struct file *file)
241 int minor = iminor(inode);
242 struct saa7134_dev *h,*dev = NULL;
243 struct list_head *list;
246 list_for_each(list,&saa7134_devlist) {
247 h = list_entry(list, struct saa7134_dev, devlist);
248 if (h->dmasound.minor_dsp == minor)
254 mutex_lock(&dev->dmasound.lock);
256 if (dev->dmasound.users_dsp)
258 dev->dmasound.users_dsp++;
259 file->private_data = dev;
261 dev->dmasound.afmt = AFMT_U8;
262 dev->dmasound.channels = 1;
263 dev->dmasound.read_count = 0;
264 dev->dmasound.read_offset = 0;
265 dsp_buffer_conf(dev,PAGE_SIZE,64);
266 err = dsp_buffer_init(dev);
270 mutex_unlock(&dev->dmasound.lock);
274 dev->dmasound.users_dsp--;
276 mutex_unlock(&dev->dmasound.lock);
280 static int dsp_release(struct inode *inode, struct file *file)
282 struct saa7134_dev *dev = file->private_data;
284 mutex_lock(&dev->dmasound.lock);
285 if (dev->dmasound.recording_on)
287 dsp_buffer_free(dev);
288 dev->dmasound.users_dsp--;
289 file->private_data = NULL;
290 mutex_unlock(&dev->dmasound.lock);
294 static ssize_t dsp_read(struct file *file, char __user *buffer,
295 size_t count, loff_t *ppos)
297 struct saa7134_dev *dev = file->private_data;
298 DECLARE_WAITQUEUE(wait, current);
303 add_wait_queue(&dev->dmasound.wq, &wait);
304 mutex_lock(&dev->dmasound.lock);
306 /* wait for data if needed */
307 if (0 == dev->dmasound.read_count) {
308 if (!dev->dmasound.recording_on) {
309 err = dsp_rec_start(dev);
316 if (dev->dmasound.recording_on &&
317 !dev->dmasound.dma_running) {
318 /* recover from overruns */
319 spin_lock_irqsave(&dev->slock,flags);
321 spin_unlock_irqrestore(&dev->slock,flags);
323 if (file->f_flags & O_NONBLOCK) {
328 mutex_unlock(&dev->dmasound.lock);
329 set_current_state(TASK_INTERRUPTIBLE);
330 if (0 == dev->dmasound.read_count)
332 set_current_state(TASK_RUNNING);
333 mutex_lock(&dev->dmasound.lock);
334 if (signal_pending(current)) {
341 /* copy data to userspace */
343 if (bytes > dev->dmasound.read_count)
344 bytes = dev->dmasound.read_count;
345 if (bytes > dev->dmasound.bufsize - dev->dmasound.read_offset)
346 bytes = dev->dmasound.bufsize - dev->dmasound.read_offset;
347 if (copy_to_user(buffer + ret,
348 dev->dmasound.dma.vmalloc + dev->dmasound.read_offset,
357 dev->dmasound.read_count -= bytes;
358 dev->dmasound.read_offset += bytes;
359 if (dev->dmasound.read_offset == dev->dmasound.bufsize)
360 dev->dmasound.read_offset = 0;
362 mutex_unlock(&dev->dmasound.lock);
363 remove_wait_queue(&dev->dmasound.wq, &wait);
367 static ssize_t dsp_write(struct file *file, const char __user *buffer,
368 size_t count, loff_t *ppos)
373 static const char *osspcm_ioctls[] = {
374 "RESET", "SYNC", "SPEED", "STEREO", "GETBLKSIZE", "SETFMT",
375 "CHANNELS", "?", "POST", "SUBDIVIDE", "SETFRAGMENT", "GETFMTS",
376 "GETOSPACE", "GETISPACE", "NONBLOCK", "GETCAPS", "GET/SETTRIGGER",
377 "GETIPTR", "GETOPTR", "MAPINBUF", "MAPOUTBUF", "SETSYNCRO",
378 "SETDUPLEX", "GETODELAY"
380 #define OSSPCM_IOCTLS ARRAY_SIZE(osspcm_ioctls)
382 static void saa7134_oss_print_ioctl(char *name, unsigned int cmd)
386 switch (_IOC_DIR(cmd)) {
387 case _IOC_NONE: dir = "--"; break;
388 case _IOC_READ: dir = "r-"; break;
389 case _IOC_WRITE: dir = "-w"; break;
390 case _IOC_READ | _IOC_WRITE: dir = "rw"; break;
391 default: dir = "??"; break;
393 switch (_IOC_TYPE(cmd)) {
395 printk(KERN_DEBUG "%s: ioctl 0x%08x (oss dsp, %s, SNDCTL_DSP_%s)\n",
396 name, cmd, dir, (_IOC_NR(cmd) < OSSPCM_IOCTLS) ?
397 osspcm_ioctls[_IOC_NR(cmd)] : "???");
400 printk(KERN_DEBUG "%s: ioctl 0x%08x (oss mixer, %s, #%d)\n",
401 name, cmd, dir, _IOC_NR(cmd));
404 printk(KERN_DEBUG "%s: ioctl 0x%08x (???, %s, #%d)\n",
405 name, cmd, dir, _IOC_NR(cmd));
409 static int dsp_ioctl(struct inode *inode, struct file *file,
410 unsigned int cmd, unsigned long arg)
412 struct saa7134_dev *dev = file->private_data;
413 void __user *argp = (void __user *) arg;
414 int __user *p = argp;
418 saa7134_oss_print_ioctl(dev->name,cmd);
421 return put_user(SOUND_VERSION, p);
422 case SNDCTL_DSP_GETCAPS:
425 case SNDCTL_DSP_SPEED:
426 if (get_user(val, p))
429 case SOUND_PCM_READ_RATE:
430 return put_user(dev->dmasound.rate, p);
432 case SNDCTL_DSP_STEREO:
433 if (get_user(val, p))
435 mutex_lock(&dev->dmasound.lock);
436 dev->dmasound.channels = val ? 2 : 1;
437 if (dev->dmasound.recording_on) {
441 mutex_unlock(&dev->dmasound.lock);
442 return put_user(dev->dmasound.channels-1, p);
444 case SNDCTL_DSP_CHANNELS:
445 if (get_user(val, p))
447 if (val != 1 && val != 2)
449 mutex_lock(&dev->dmasound.lock);
450 dev->dmasound.channels = val;
451 if (dev->dmasound.recording_on) {
455 mutex_unlock(&dev->dmasound.lock);
457 case SOUND_PCM_READ_CHANNELS:
458 return put_user(dev->dmasound.channels, p);
460 case SNDCTL_DSP_GETFMTS: /* Returns a mask */
461 return put_user(AFMT_U8 | AFMT_S8 |
462 AFMT_U16_LE | AFMT_U16_BE |
463 AFMT_S16_LE | AFMT_S16_BE, p);
465 case SNDCTL_DSP_SETFMT: /* Selects ONE fmt */
466 if (get_user(val, p))
478 mutex_lock(&dev->dmasound.lock);
479 dev->dmasound.afmt = val;
480 if (dev->dmasound.recording_on) {
484 mutex_unlock(&dev->dmasound.lock);
485 return put_user(dev->dmasound.afmt, p);
490 case SOUND_PCM_READ_BITS:
491 switch (dev->dmasound.afmt) {
494 return put_user(8, p);
499 return put_user(16, p);
504 case SNDCTL_DSP_NONBLOCK:
505 file->f_flags |= O_NONBLOCK;
508 case SNDCTL_DSP_RESET:
509 mutex_lock(&dev->dmasound.lock);
510 if (dev->dmasound.recording_on)
512 mutex_unlock(&dev->dmasound.lock);
514 case SNDCTL_DSP_GETBLKSIZE:
515 return put_user(dev->dmasound.blksize, p);
517 case SNDCTL_DSP_SETFRAGMENT:
518 if (get_user(val, p))
520 if (dev->dmasound.recording_on)
522 dsp_buffer_free(dev);
523 /* used to be arg >> 16 instead of val >> 16; fixed */
524 dsp_buffer_conf(dev,1 << (val & 0xffff), (val >> 16) & 0xffff);
525 dsp_buffer_init(dev);
528 case SNDCTL_DSP_SYNC:
532 case SNDCTL_DSP_GETISPACE:
535 info.fragsize = dev->dmasound.blksize;
536 info.fragstotal = dev->dmasound.blocks;
537 info.bytes = dev->dmasound.read_count;
538 info.fragments = info.bytes / info.fragsize;
539 if (copy_to_user(argp, &info, sizeof(info)))
548 static unsigned int dsp_poll(struct file *file, struct poll_table_struct *wait)
550 struct saa7134_dev *dev = file->private_data;
551 unsigned int mask = 0;
553 poll_wait(file, &dev->dmasound.wq, wait);
555 if (0 == dev->dmasound.read_count) {
556 mutex_lock(&dev->dmasound.lock);
557 if (!dev->dmasound.recording_on)
559 mutex_unlock(&dev->dmasound.lock);
561 mask |= (POLLIN | POLLRDNORM);
565 const struct file_operations saa7134_dsp_fops = {
566 .owner = THIS_MODULE,
568 .release = dsp_release,
576 /* ------------------------------------------------------------------ */
579 mixer_recsrc_7134(struct saa7134_dev *dev)
583 switch (dev->dmasound.input) {
585 saa_andorb(SAA7134_AUDIO_FORMAT_CTRL, 0xc0, 0xc0);
586 saa_andorb(SAA7134_SIF_SAMPLE_FREQ, 0x03, 0x00);
591 analog_io = (LINE1 == dev->dmasound.input) ? 0x00 : 0x08;
592 rate = (32000 == dev->dmasound.rate) ? 0x01 : 0x03;
593 saa_andorb(SAA7134_ANALOG_IO_SELECT, 0x08, analog_io);
594 saa_andorb(SAA7134_AUDIO_FORMAT_CTRL, 0xc0, 0x80);
595 saa_andorb(SAA7134_SIF_SAMPLE_FREQ, 0x03, rate);
602 mixer_recsrc_7133(struct saa7134_dev *dev)
606 xbarin = 0x03; // adc
608 switch (dev->dmasound.input) {
610 xbarin = 0; // Demodulator
614 anabar = 0; // aux1, aux1
618 anabar = 9; // aux2, aux2
621 /* output xbar always main channel */
622 saa_dsp_writel(dev, 0x46c >> 2, 0xbbbb10);
623 saa_dsp_writel(dev, 0x464 >> 2, xbarin);
624 saa_writel(0x594 >> 2, anabar);
630 mixer_recsrc(struct saa7134_dev *dev, enum saa7134_audio_in src)
632 static const char *iname[] = { "Oops", "TV", "LINE1", "LINE2" };
634 dev->dmasound.count++;
635 dev->dmasound.input = src;
636 dprintk("mixer input = %s\n",iname[dev->dmasound.input]);
638 switch (dev->pci->device) {
639 case PCI_DEVICE_ID_PHILIPS_SAA7134:
640 mixer_recsrc_7134(dev);
642 case PCI_DEVICE_ID_PHILIPS_SAA7133:
643 case PCI_DEVICE_ID_PHILIPS_SAA7135:
644 mixer_recsrc_7133(dev);
651 mixer_level(struct saa7134_dev *dev, enum saa7134_audio_in src, int level)
653 switch (dev->pci->device) {
654 case PCI_DEVICE_ID_PHILIPS_SAA7134:
660 saa_andorb(SAA7134_ANALOG_IO_SELECT, 0x10,
661 (100 == level) ? 0x00 : 0x10);
665 saa_andorb(SAA7134_ANALOG_IO_SELECT, 0x20,
666 (100 == level) ? 0x00 : 0x20);
670 case PCI_DEVICE_ID_PHILIPS_SAA7133:
671 case PCI_DEVICE_ID_PHILIPS_SAA7135:
678 /* ------------------------------------------------------------------ */
680 static int mixer_open(struct inode *inode, struct file *file)
682 int minor = iminor(inode);
683 struct saa7134_dev *h,*dev = NULL;
684 struct list_head *list;
686 list_for_each(list,&saa7134_devlist) {
687 h = list_entry(list, struct saa7134_dev, devlist);
688 if (h->dmasound.minor_mixer == minor)
694 file->private_data = dev;
698 static int mixer_release(struct inode *inode, struct file *file)
700 file->private_data = NULL;
704 static int mixer_ioctl(struct inode *inode, struct file *file,
705 unsigned int cmd, unsigned long arg)
707 struct saa7134_dev *dev = file->private_data;
708 enum saa7134_audio_in input;
710 void __user *argp = (void __user *) arg;
711 int __user *p = argp;
714 saa7134_oss_print_ioctl(dev->name,cmd);
717 return put_user(SOUND_VERSION, p);
718 case SOUND_MIXER_INFO:
721 memset(&info,0,sizeof(info));
722 strlcpy(info.id, "TV audio", sizeof(info.id));
723 strlcpy(info.name, dev->name, sizeof(info.name));
724 info.modify_counter = dev->dmasound.count;
725 if (copy_to_user(argp, &info, sizeof(info)))
729 case SOUND_OLD_MIXER_INFO:
731 _old_mixer_info info;
732 memset(&info,0,sizeof(info));
733 strlcpy(info.id, "TV audio", sizeof(info.id));
734 strlcpy(info.name, dev->name, sizeof(info.name));
735 if (copy_to_user(argp, &info, sizeof(info)))
739 case MIXER_READ(SOUND_MIXER_CAPS):
740 return put_user(SOUND_CAP_EXCL_INPUT, p);
741 case MIXER_READ(SOUND_MIXER_STEREODEVS):
742 return put_user(0, p);
743 case MIXER_READ(SOUND_MIXER_RECMASK):
744 case MIXER_READ(SOUND_MIXER_DEVMASK):
745 val = SOUND_MASK_LINE1 | SOUND_MASK_LINE2;
746 if (32000 == dev->dmasound.rate)
747 val |= SOUND_MASK_VIDEO;
748 return put_user(val, p);
750 case MIXER_WRITE(SOUND_MIXER_RECSRC):
751 if (get_user(val, p))
753 input = dev->dmasound.input;
754 if (32000 == dev->dmasound.rate &&
755 val & SOUND_MASK_VIDEO && dev->dmasound.input != TV)
757 if (val & SOUND_MASK_LINE1 && dev->dmasound.input != LINE1)
759 if (val & SOUND_MASK_LINE2 && dev->dmasound.input != LINE2)
761 if (input != dev->dmasound.input)
762 mixer_recsrc(dev,input);
764 case MIXER_READ(SOUND_MIXER_RECSRC):
765 switch (dev->dmasound.input) {
766 case TV: ret = SOUND_MASK_VIDEO; break;
767 case LINE1: ret = SOUND_MASK_LINE1; break;
768 case LINE2: ret = SOUND_MASK_LINE2; break;
771 return put_user(ret, p);
773 case MIXER_WRITE(SOUND_MIXER_VIDEO):
774 case MIXER_READ(SOUND_MIXER_VIDEO):
775 if (32000 != dev->dmasound.rate)
777 return put_user(100 | 100 << 8, p);
779 case MIXER_WRITE(SOUND_MIXER_LINE1):
780 if (get_user(val, p))
783 val = (val <= 50) ? 50 : 100;
784 dev->dmasound.line1 = val;
785 mixer_level(dev,LINE1,dev->dmasound.line1);
787 case MIXER_READ(SOUND_MIXER_LINE1):
788 return put_user(dev->dmasound.line1 | dev->dmasound.line1 << 8, p);
790 case MIXER_WRITE(SOUND_MIXER_LINE2):
791 if (get_user(val, p))
794 val = (val <= 50) ? 50 : 100;
795 dev->dmasound.line2 = val;
796 mixer_level(dev,LINE2,dev->dmasound.line2);
798 case MIXER_READ(SOUND_MIXER_LINE2):
799 return put_user(dev->dmasound.line2 | dev->dmasound.line2 << 8, p);
806 const struct file_operations saa7134_mixer_fops = {
807 .owner = THIS_MODULE,
809 .release = mixer_release,
810 .ioctl = mixer_ioctl,
814 /* ------------------------------------------------------------------ */
816 static irqreturn_t saa7134_oss_irq(int irq, void *dev_id)
818 struct saa7134_dmasound *dmasound = dev_id;
819 struct saa7134_dev *dev = dmasound->priv_data;
820 unsigned long report, status;
821 int loop, handled = 0;
823 for (loop = 0; loop < 10; loop++) {
824 report = saa_readl(SAA7134_IRQ_REPORT);
825 status = saa_readl(SAA7134_IRQ_STATUS);
827 if (report & SAA7134_IRQ_REPORT_DONE_RA3) {
829 saa_writel(SAA7134_IRQ_REPORT,report);
830 saa7134_irq_oss_done(dev, status);
837 dprintk("error! looping IRQ!");
840 return IRQ_RETVAL(handled);
843 int saa7134_oss_init1(struct saa7134_dev *dev)
846 if ((request_irq(dev->pci->irq, saa7134_oss_irq,
847 IRQF_SHARED | IRQF_DISABLED, dev->name,
848 (void*) &dev->dmasound)) < 0)
852 mutex_init(&dev->dmasound.lock);
853 init_waitqueue_head(&dev->dmasound.wq);
855 switch (dev->pci->device) {
856 case PCI_DEVICE_ID_PHILIPS_SAA7133:
857 case PCI_DEVICE_ID_PHILIPS_SAA7135:
858 saa_writel(0x588 >> 2, 0x00000fff);
859 saa_writel(0x58c >> 2, 0x00543210);
860 saa_dsp_writel(dev, 0x46c >> 2, 0xbbbbbb);
865 dev->dmasound.rate = 32000;
867 dev->dmasound.rate = rate;
868 dev->dmasound.rate = (dev->dmasound.rate > 40000) ? 48000 : 32000;
871 dev->dmasound.line1 = 50;
872 dev->dmasound.line2 = 50;
873 mixer_level(dev,LINE1,dev->dmasound.line1);
874 mixer_level(dev,LINE2,dev->dmasound.line2);
875 mixer_recsrc(dev, (dev->dmasound.rate == 32000) ? TV : LINE2);
880 int saa7134_oss_fini(struct saa7134_dev *dev)
886 void saa7134_irq_oss_done(struct saa7134_dev *dev, unsigned long status)
888 int next_blk, reg = 0;
890 spin_lock(&dev->slock);
891 if (UNSET == dev->dmasound.dma_blk) {
892 dprintk("irq: recording stopped\n");
895 if (0 != (status & 0x0f000000))
896 dprintk("irq: lost %ld\n", (status >> 24) & 0x0f);
897 if (0 == (status & 0x10000000)) {
899 if (0 == (dev->dmasound.dma_blk & 0x01))
900 reg = SAA7134_RS_BA1(6);
903 if (1 == (dev->dmasound.dma_blk & 0x01))
904 reg = SAA7134_RS_BA2(6);
907 dprintk("irq: field oops [%s]\n",
908 (status & 0x10000000) ? "even" : "odd");
911 if (dev->dmasound.read_count >= dev->dmasound.blksize * (dev->dmasound.blocks-2)) {
912 dprintk("irq: overrun [full=%d/%d]\n",dev->dmasound.read_count,
913 dev->dmasound.bufsize);
918 /* next block addr */
919 next_blk = (dev->dmasound.dma_blk + 2) % dev->dmasound.blocks;
920 saa_writel(reg,next_blk * dev->dmasound.blksize);
922 dprintk("irq: ok, %s, next_blk=%d, addr=%x\n",
923 (status & 0x10000000) ? "even" : "odd ", next_blk,
924 next_blk * dev->dmasound.blksize);
926 /* update status & wake waiting readers */
927 dev->dmasound.dma_blk = (dev->dmasound.dma_blk + 1) % dev->dmasound.blocks;
928 dev->dmasound.read_count += dev->dmasound.blksize;
929 wake_up(&dev->dmasound.wq);
932 spin_unlock(&dev->slock);
935 static int saa7134_dsp_create(struct saa7134_dev *dev)
939 err = dev->dmasound.minor_dsp =
940 register_sound_dsp(&saa7134_dsp_fops,
945 printk(KERN_INFO "%s: registered device dsp%d\n",
946 dev->name,dev->dmasound.minor_dsp >> 4);
948 err = dev->dmasound.minor_mixer =
949 register_sound_mixer(&saa7134_mixer_fops,
953 printk(KERN_INFO "%s: registered device mixer%d\n",
954 dev->name,dev->dmasound.minor_mixer >> 4);
959 unregister_sound_dsp(dev->dmasound.minor_dsp);
965 static int oss_device_init(struct saa7134_dev *dev)
967 dev->dmasound.priv_data = dev;
968 saa7134_oss_init1(dev);
969 saa7134_dsp_create(dev);
973 static int oss_device_exit(struct saa7134_dev *dev)
976 unregister_sound_mixer(dev->dmasound.minor_mixer);
977 unregister_sound_dsp(dev->dmasound.minor_dsp);
979 saa7134_oss_fini(dev);
981 if (dev->pci->irq > 0) {
982 synchronize_irq(dev->pci->irq);
983 free_irq(dev->pci->irq,&dev->dmasound);
986 dev->dmasound.priv_data = NULL;
990 static int saa7134_oss_init(void)
992 struct saa7134_dev *dev = NULL;
993 struct list_head *list;
995 if (!saa7134_dmasound_init && !saa7134_dmasound_exit) {
996 saa7134_dmasound_init = oss_device_init;
997 saa7134_dmasound_exit = oss_device_exit;
999 printk(KERN_WARNING "saa7134 OSS: can't load, DMA sound handler already assigned (probably to ALSA)\n");
1003 printk(KERN_INFO "saa7134 OSS driver for DMA sound loaded\n");
1006 list_for_each(list,&saa7134_devlist) {
1007 dev = list_entry(list, struct saa7134_dev, devlist);
1008 if (dev->dmasound.priv_data == NULL) {
1009 oss_device_init(dev);
1011 printk(KERN_ERR "saa7134 OSS: DMA sound is being handled by ALSA, ignoring %s\n",dev->name);
1017 printk(KERN_INFO "saa7134 OSS: no saa7134 cards found\n");
1023 static void saa7134_oss_exit(void)
1025 struct saa7134_dev *dev = NULL;
1026 struct list_head *list;
1028 list_for_each(list,&saa7134_devlist) {
1029 dev = list_entry(list, struct saa7134_dev, devlist);
1031 /* Device isn't registered by OSS, probably ALSA's */
1032 if (!dev->dmasound.minor_dsp)
1035 oss_device_exit(dev);
1039 saa7134_dmasound_init = NULL;
1040 saa7134_dmasound_exit = NULL;
1042 printk(KERN_INFO "saa7134 OSS driver for DMA sound unloaded\n");
1047 /* We initialize this late, to make sure the sound system is up and running */
1048 late_initcall(saa7134_oss_init);
1049 module_exit(saa7134_oss_exit);
1050 MODULE_LICENSE("GPL");
1051 MODULE_AUTHOR("Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]");
1053 /* ----------------------------------------------------------- */