[PATCH] V4L: 926: Saa7134 alsa can only be autoloaded after saa7134 is active

- Saa7134-alsa can only be autoloaded after saa7134 is active
- Applied pertinent changes proposed by the ALSA team
- dsp_nr replaced by ALSA's index[]

Signed-off-by: Ricardo Cerqueira <v4l@cerqueira.org>
Signed-off-by: Mauro Carvalho Chehab <mchehab@brturbo.com.br>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

1 files changed, 154 insertions, 154 deletions

diff --git a/drivers/media/video/saa7134/saa7134-oss.c b/drivers/media/video/saa7134/saa7134-oss.c
index f1b0e0d93d7b..fd53dfcc1644 100644
--- a/drivers/media/video/saa7134/saa7134-oss.c
+++ b/drivers/media/video/saa7134/saa7134-oss.c
@@ -59,9 +59,9 @@ static int dsp_buffer_conf(struct saa7134_dev *dev, int blksize, int blocks)
         if ((blksize * blocks) > 1024*1024)
                 blocks = 1024*1024 / blksize;
 
-        dev->oss.blocks  = blocks;
-        dev->oss.blksize = blksize;
-        dev->oss.bufsize = blksize * blocks;
+        dev->dmasound.blocks  = blocks;
+        dev->dmasound.blksize = blksize;
+        dev->dmasound.bufsize = blksize * blocks;
 
         dprintk("buffer config: %d blocks / %d bytes, %d kB total\n",
                 blocks,blksize,blksize * blocks / 1024);
@@ -72,11 +72,11 @@ static int dsp_buffer_init(struct saa7134_dev *dev)
 {
         int err;
 
-        if (!dev->oss.bufsize)
+        if (!dev->dmasound.bufsize)
                 BUG();
-        videobuf_dma_init(&dev->oss.dma);
-        err = videobuf_dma_init_kernel(&dev->oss.dma, PCI_DMA_FROMDEVICE,
-                                       (dev->oss.bufsize + PAGE_SIZE) >> PAGE_SHIFT);
+        videobuf_dma_init(&dev->dmasound.dma);
+        err = videobuf_dma_init_kernel(&dev->dmasound.dma, PCI_DMA_FROMDEVICE,
+                                       (dev->dmasound.bufsize + PAGE_SIZE) >> PAGE_SHIFT);
         if (0 != err)
                 return err;
         return 0;
@@ -84,26 +84,26 @@ static int dsp_buffer_init(struct saa7134_dev *dev)
 
 static int dsp_buffer_free(struct saa7134_dev *dev)
 {
-        if (!dev->oss.blksize)
+        if (!dev->dmasound.blksize)
                 BUG();
-        videobuf_dma_free(&dev->oss.dma);
-        dev->oss.blocks  = 0;
-        dev->oss.blksize = 0;
-        dev->oss.bufsize = 0;
+        videobuf_dma_free(&dev->dmasound.dma);
+        dev->dmasound.blocks  = 0;
+        dev->dmasound.blksize = 0;
+        dev->dmasound.bufsize = 0;
         return 0;
 }
 
 static void dsp_dma_start(struct saa7134_dev *dev)
 {
-        dev->oss.dma_blk     = 0;
-        dev->oss.dma_running = 1;
+        dev->dmasound.dma_blk     = 0;
+        dev->dmasound.dma_running = 1;
         saa7134_set_dmabits(dev);
 }
 
 static void dsp_dma_stop(struct saa7134_dev *dev)
 {
-        dev->oss.dma_blk     = -1;
-        dev->oss.dma_running = 0;
+        dev->dmasound.dma_blk     = -1;
+        dev->dmasound.dma_running = 0;
         saa7134_set_dmabits(dev);
 }
 
@@ -114,18 +114,18 @@ static int dsp_rec_start(struct saa7134_dev *dev)
         unsigned long flags;
 
         /* prepare buffer */
-        if (0 != (err = videobuf_dma_pci_map(dev->pci,&dev->oss.dma)))
+        if (0 != (err = videobuf_dma_pci_map(dev->pci,&dev->dmasound.dma)))
                 return err;
-        if (0 != (err = saa7134_pgtable_alloc(dev->pci,&dev->oss.pt)))
+        if (0 != (err = saa7134_pgtable_alloc(dev->pci,&dev->dmasound.pt)))
                 goto fail1;
-        if (0 != (err = saa7134_pgtable_build(dev->pci,&dev->oss.pt,
-                                              dev->oss.dma.sglist,
-                                              dev->oss.dma.sglen,
+        if (0 != (err = saa7134_pgtable_build(dev->pci,&dev->dmasound.pt,
+                                              dev->dmasound.dma.sglist,
+                                              dev->dmasound.dma.sglen,
                                               0)))
                 goto fail2;
 
         /* sample format */
-        switch (dev->oss.afmt) {
+        switch (dev->dmasound.afmt) {
         case AFMT_U8:
         case AFMT_S8:     fmt = 0x00;  break;
         case AFMT_U16_LE:
@@ -137,14 +137,14 @@ static int dsp_rec_start(struct saa7134_dev *dev)
                 goto fail2;
         }
 
-        switch (dev->oss.afmt) {
+        switch (dev->dmasound.afmt) {
         case AFMT_S8:
         case AFMT_S16_LE:
         case AFMT_S16_BE: sign = 1; break;
         default:          sign = 0; break;
         }
 
-        switch (dev->oss.afmt) {
+        switch (dev->dmasound.afmt) {
         case AFMT_U16_BE:
         case AFMT_S16_BE: bswap = 1; break;
         default:          bswap = 0; break;
@@ -152,58 +152,58 @@ static int dsp_rec_start(struct saa7134_dev *dev)
 
         switch (dev->pci->device) {
         case PCI_DEVICE_ID_PHILIPS_SAA7134:
-                if (1 == dev->oss.channels)
+                if (1 == dev->dmasound.channels)
                         fmt |= (1 << 3);
-                if (2 == dev->oss.channels)
+                if (2 == dev->dmasound.channels)
                         fmt |= (3 << 3);
                 if (sign)
                         fmt |= 0x04;
-                fmt |= (TV == dev->oss.input) ? 0xc0 : 0x80;
+                fmt |= (TV == dev->dmasound.input) ? 0xc0 : 0x80;
 
-                saa_writeb(SAA7134_NUM_SAMPLES0, ((dev->oss.blksize - 1) & 0x0000ff));
-                saa_writeb(SAA7134_NUM_SAMPLES1, ((dev->oss.blksize - 1) & 0x00ff00) >>  8);
-                saa_writeb(SAA7134_NUM_SAMPLES2, ((dev->oss.blksize - 1) & 0xff0000) >> 16);
+                saa_writeb(SAA7134_NUM_SAMPLES0, ((dev->dmasound.blksize - 1) & 0x0000ff));
+                saa_writeb(SAA7134_NUM_SAMPLES1, ((dev->dmasound.blksize - 1) & 0x00ff00) >>  8);
+                saa_writeb(SAA7134_NUM_SAMPLES2, ((dev->dmasound.blksize - 1) & 0xff0000) >> 16);
                 saa_writeb(SAA7134_AUDIO_FORMAT_CTRL, fmt);
 
                 break;
         case PCI_DEVICE_ID_PHILIPS_SAA7133:
         case PCI_DEVICE_ID_PHILIPS_SAA7135:
-                if (1 == dev->oss.channels)
+                if (1 == dev->dmasound.channels)
                         fmt |= (1 << 4);
-                if (2 == dev->oss.channels)
+                if (2 == dev->dmasound.channels)
                         fmt |= (2 << 4);
                 if (!sign)
                         fmt |= 0x04;
-                saa_writel(SAA7133_NUM_SAMPLES, dev->oss.blksize -4);
+                saa_writel(SAA7133_NUM_SAMPLES, dev->dmasound.blksize -4);
                 saa_writel(SAA7133_AUDIO_CHANNEL, 0x543210 | (fmt << 24));
                 break;
         }
         dprintk("rec_start: afmt=%d ch=%d  =>  fmt=0x%x swap=%c\n",
-                dev->oss.afmt, dev->oss.channels, fmt,
+                dev->dmasound.afmt, dev->dmasound.channels, fmt,
                 bswap ? 'b' : '-');
 
         /* dma: setup channel 6 (= AUDIO) */
         control = SAA7134_RS_CONTROL_BURST_16 |
                 SAA7134_RS_CONTROL_ME |
-                (dev->oss.pt.dma >> 12);
+                (dev->dmasound.pt.dma >> 12);
         if (bswap)
                 control |= SAA7134_RS_CONTROL_BSWAP;
         saa_writel(SAA7134_RS_BA1(6),0);
-        saa_writel(SAA7134_RS_BA2(6),dev->oss.blksize);
+        saa_writel(SAA7134_RS_BA2(6),dev->dmasound.blksize);
         saa_writel(SAA7134_RS_PITCH(6),0);
         saa_writel(SAA7134_RS_CONTROL(6),control);
 
         /* start dma */
-        dev->oss.recording_on = 1;
+        dev->dmasound.recording_on = 1;
         spin_lock_irqsave(&dev->slock,flags);
         dsp_dma_start(dev);
         spin_unlock_irqrestore(&dev->slock,flags);
         return 0;
 
  fail2:
-        saa7134_pgtable_free(dev->pci,&dev->oss.pt);
+        saa7134_pgtable_free(dev->pci,&dev->dmasound.pt);
  fail1:
-        videobuf_dma_pci_unmap(dev->pci,&dev->oss.dma);
+        videobuf_dma_pci_unmap(dev->pci,&dev->dmasound.dma);
         return err;
 }
 
@@ -211,17 +211,17 @@ static int dsp_rec_stop(struct saa7134_dev *dev)
 {
         unsigned long flags;
 
-        dprintk("rec_stop dma_blk=%d\n",dev->oss.dma_blk);
+        dprintk("rec_stop dma_blk=%d\n",dev->dmasound.dma_blk);
 
         /* stop dma */
-        dev->oss.recording_on = 0;
+        dev->dmasound.recording_on = 0;
         spin_lock_irqsave(&dev->slock,flags);
         dsp_dma_stop(dev);
         spin_unlock_irqrestore(&dev->slock,flags);
 
         /* unlock buffer */
-        saa7134_pgtable_free(dev->pci,&dev->oss.pt);
-        videobuf_dma_pci_unmap(dev->pci,&dev->oss.dma);
+        saa7134_pgtable_free(dev->pci,&dev->dmasound.pt);
+        videobuf_dma_pci_unmap(dev->pci,&dev->dmasound.dma);
         return 0;
 }
 
@@ -236,35 +236,35 @@ static int dsp_open(struct inode *inode, struct file *file)
 
         list_for_each(list,&saa7134_devlist) {
                 h = list_entry(list, struct saa7134_dev, devlist);
-                if (h->oss.minor_dsp == minor)
+                if (h->dmasound.minor_dsp == minor)
                         dev = h;
         }
         if (NULL == dev)
                 return -ENODEV;
 
-        down(&dev->oss.lock);
+        down(&dev->dmasound.lock);
         err = -EBUSY;
-        if (dev->oss.users_dsp)
+        if (dev->dmasound.users_dsp)
                 goto fail1;
-        dev->oss.users_dsp++;
+        dev->dmasound.users_dsp++;
         file->private_data = dev;
 
-        dev->oss.afmt        = AFMT_U8;
-        dev->oss.channels    = 1;
-        dev->oss.read_count  = 0;
-        dev->oss.read_offset = 0;
+        dev->dmasound.afmt        = AFMT_U8;
+        dev->dmasound.channels    = 1;
+        dev->dmasound.read_count  = 0;
+        dev->dmasound.read_offset = 0;
         dsp_buffer_conf(dev,PAGE_SIZE,64);
         err = dsp_buffer_init(dev);
         if (0 != err)
                 goto fail2;
 
-        up(&dev->oss.lock);
+        up(&dev->dmasound.lock);
         return 0;
 
  fail2:
-        dev->oss.users_dsp--;
+        dev->dmasound.users_dsp--;
  fail1:
-        up(&dev->oss.lock);
+        up(&dev->dmasound.lock);
         return err;
 }
 
@@ -272,13 +272,13 @@ static int dsp_release(struct inode *inode, struct file *file)
 {
         struct saa7134_dev *dev = file->private_data;
 
-        down(&dev->oss.lock);
-        if (dev->oss.recording_on)
+        down(&dev->dmasound.lock);
+        if (dev->dmasound.recording_on)
                 dsp_rec_stop(dev);
         dsp_buffer_free(dev);
-        dev->oss.users_dsp--;
+        dev->dmasound.users_dsp--;
         file->private_data = NULL;
-        up(&dev->oss.lock);
+        up(&dev->dmasound.lock);
         return 0;
 }
 
@@ -291,12 +291,12 @@ static ssize_t dsp_read(struct file *file, char __user *buffer,
         unsigned long flags;
         int err,ret = 0;
 
-        add_wait_queue(&dev->oss.wq, &wait);
-        down(&dev->oss.lock);
+        add_wait_queue(&dev->dmasound.wq, &wait);
+        down(&dev->dmasound.lock);
         while (count > 0) {
                 /* wait for data if needed */
-                if (0 == dev->oss.read_count) {
-                        if (!dev->oss.recording_on) {
+                if (0 == dev->dmasound.read_count) {
+                        if (!dev->dmasound.recording_on) {
                                 err = dsp_rec_start(dev);
                                 if (err < 0) {
                                         if (0 == ret)
@@ -304,8 +304,8 @@ static ssize_t dsp_read(struct file *file, char __user *buffer,
                                         break;
                                 }
                         }
-                        if (dev->oss.recording_on &&
-                            !dev->oss.dma_running) {
+                        if (dev->dmasound.recording_on &&
+                            !dev->dmasound.dma_running) {
                                 /* recover from overruns */
                                 spin_lock_irqsave(&dev->slock,flags);
                                 dsp_dma_start(dev);
@@ -316,12 +316,12 @@ static ssize_t dsp_read(struct file *file, char __user *buffer,
                                         ret = -EAGAIN;
                                 break;
                         }
-                        up(&dev->oss.lock);
+                        up(&dev->dmasound.lock);
                         set_current_state(TASK_INTERRUPTIBLE);
-                        if (0 == dev->oss.read_count)
+                        if (0 == dev->dmasound.read_count)
                                 schedule();
                         set_current_state(TASK_RUNNING);
-                        down(&dev->oss.lock);
+                        down(&dev->dmasound.lock);
                         if (signal_pending(current)) {
                                 if (0 == ret)
                                         ret = -EINTR;
@@ -331,12 +331,12 @@ static ssize_t dsp_read(struct file *file, char __user *buffer,
 
                 /* copy data to userspace */
                 bytes = count;
-                if (bytes > dev->oss.read_count)
-                        bytes = dev->oss.read_count;
-                if (bytes > dev->oss.bufsize - dev->oss.read_offset)
-                        bytes = dev->oss.bufsize - dev->oss.read_offset;
+                if (bytes > dev->dmasound.read_count)
+                        bytes = dev->dmasound.read_count;
+                if (bytes > dev->dmasound.bufsize - dev->dmasound.read_offset)
+                        bytes = dev->dmasound.bufsize - dev->dmasound.read_offset;
                 if (copy_to_user(buffer + ret,
-                                 dev->oss.dma.vmalloc + dev->oss.read_offset,
+                                 dev->dmasound.dma.vmalloc + dev->dmasound.read_offset,
                                  bytes)) {
                         if (0 == ret)
                                 ret = -EFAULT;
@@ -345,13 +345,13 @@ static ssize_t dsp_read(struct file *file, char __user *buffer,
 
                 ret   += bytes;
                 count -= bytes;
-                dev->oss.read_count  -= bytes;
-                dev->oss.read_offset += bytes;
-                if (dev->oss.read_offset == dev->oss.bufsize)
-                        dev->oss.read_offset = 0;
+                dev->dmasound.read_count  -= bytes;
+                dev->dmasound.read_offset += bytes;
+                if (dev->dmasound.read_offset == dev->dmasound.bufsize)
+                        dev->dmasound.read_offset = 0;
         }
-        up(&dev->oss.lock);
-        remove_wait_queue(&dev->oss.wq, &wait);
+        up(&dev->dmasound.lock);
+        remove_wait_queue(&dev->dmasound.wq, &wait);
         return ret;
 }
 
@@ -382,35 +382,35 @@ static int dsp_ioctl(struct inode *inode, struct file *file,
                         return -EFAULT;
                 /* fall through */
         case SOUND_PCM_READ_RATE:
-                return put_user(dev->oss.rate, p);
+                return put_user(dev->dmasound.rate, p);
 
         case SNDCTL_DSP_STEREO:
                 if (get_user(val, p))
                         return -EFAULT;
-                down(&dev->oss.lock);
-                dev->oss.channels = val ? 2 : 1;
-                if (dev->oss.recording_on) {
+                down(&dev->dmasound.lock);
+                dev->dmasound.channels = val ? 2 : 1;
+                if (dev->dmasound.recording_on) {
                         dsp_rec_stop(dev);
                         dsp_rec_start(dev);
                 }
-                up(&dev->oss.lock);
-                return put_user(dev->oss.channels-1, p);
+                up(&dev->dmasound.lock);
+                return put_user(dev->dmasound.channels-1, p);
 
         case SNDCTL_DSP_CHANNELS:
                 if (get_user(val, p))
                         return -EFAULT;
                 if (val != 1 && val != 2)
                         return -EINVAL;
-                down(&dev->oss.lock);
-                dev->oss.channels = val;
-                if (dev->oss.recording_on) {
+                down(&dev->dmasound.lock);
+                dev->dmasound.channels = val;
+                if (dev->dmasound.recording_on) {
                         dsp_rec_stop(dev);
                         dsp_rec_start(dev);
                 }
-                up(&dev->oss.lock);
+                up(&dev->dmasound.lock);
                 /* fall through */
         case SOUND_PCM_READ_CHANNELS:
-                return put_user(dev->oss.channels, p);
+                return put_user(dev->dmasound.channels, p);
 
         case SNDCTL_DSP_GETFMTS: /* Returns a mask */
                 return put_user(AFMT_U8     | AFMT_S8     |
@@ -430,20 +430,20 @@ static int dsp_ioctl(struct inode *inode, struct file *file,
                 case AFMT_U16_BE:
                 case AFMT_S16_LE:
                 case AFMT_S16_BE:
-                        down(&dev->oss.lock);
-                        dev->oss.afmt = val;
-                        if (dev->oss.recording_on) {
+                        down(&dev->dmasound.lock);
+                        dev->dmasound.afmt = val;
+                        if (dev->dmasound.recording_on) {
                                 dsp_rec_stop(dev);
                                 dsp_rec_start(dev);
                         }
-                        up(&dev->oss.lock);
-                        return put_user(dev->oss.afmt, p);
+                        up(&dev->dmasound.lock);
+                        return put_user(dev->dmasound.afmt, p);
                 default:
                         return -EINVAL;
                 }
 
         case SOUND_PCM_READ_BITS:
-                switch (dev->oss.afmt) {
+                switch (dev->dmasound.afmt) {
                 case AFMT_U8:
                 case AFMT_S8:
                         return put_user(8, p);
@@ -461,18 +461,18 @@ static int dsp_ioctl(struct inode *inode, struct file *file,
                 return 0;
 
         case SNDCTL_DSP_RESET:
-                down(&dev->oss.lock);
-                if (dev->oss.recording_on)
+                down(&dev->dmasound.lock);
+                if (dev->dmasound.recording_on)
                         dsp_rec_stop(dev);
-                up(&dev->oss.lock);
+                up(&dev->dmasound.lock);
                 return 0;
         case SNDCTL_DSP_GETBLKSIZE:
-                return put_user(dev->oss.blksize, p);
+                return put_user(dev->dmasound.blksize, p);
 
         case SNDCTL_DSP_SETFRAGMENT:
                 if (get_user(val, p))
                         return -EFAULT;
-                if (dev->oss.recording_on)
+                if (dev->dmasound.recording_on)
                         return -EBUSY;
                 dsp_buffer_free(dev);
                 /* used to be arg >> 16 instead of val >> 16; fixed */
@@ -487,9 +487,9 @@ static int dsp_ioctl(struct inode *inode, struct file *file,
         case SNDCTL_DSP_GETISPACE:
         {
                 audio_buf_info info;
-                info.fragsize   = dev->oss.blksize;
-                info.fragstotal = dev->oss.blocks;
-                info.bytes      = dev->oss.read_count;
+                info.fragsize   = dev->dmasound.blksize;
+                info.fragstotal = dev->dmasound.blocks;
+                info.bytes      = dev->dmasound.read_count;
                 info.fragments  = info.bytes / info.fragsize;
                 if (copy_to_user(argp, &info, sizeof(info)))
                         return -EFAULT;
@@ -505,13 +505,13 @@ static unsigned int dsp_poll(struct file *file, struct poll_table_struct *wait)
         struct saa7134_dev *dev = file->private_data;
         unsigned int mask = 0;
 
-        poll_wait(file, &dev->oss.wq, wait);
+        poll_wait(file, &dev->dmasound.wq, wait);
 
-        if (0 == dev->oss.read_count) {
-                down(&dev->oss.lock);
-                if (!dev->oss.recording_on)
+        if (0 == dev->dmasound.read_count) {
+                down(&dev->dmasound.lock);
+                if (!dev->dmasound.recording_on)
                         dsp_rec_start(dev);
-                up(&dev->oss.lock);
+                up(&dev->dmasound.lock);
         } else
                 mask |= (POLLIN | POLLRDNORM);
         return mask;
@@ -535,7 +535,7 @@ mixer_recsrc_7134(struct saa7134_dev *dev)
 {
         int analog_io,rate;
 
-        switch (dev->oss.input) {
+        switch (dev->dmasound.input) {
         case TV:
                 saa_andorb(SAA7134_AUDIO_FORMAT_CTRL, 0xc0, 0xc0);
                 saa_andorb(SAA7134_SIF_SAMPLE_FREQ,   0x03, 0x00);
@@ -543,8 +543,8 @@ mixer_recsrc_7134(struct saa7134_dev *dev)
         case LINE1:
         case LINE2:
         case LINE2_LEFT:
-                analog_io = (LINE1 == dev->oss.input) ? 0x00 : 0x08;
-                rate = (32000 == dev->oss.rate) ? 0x01 : 0x03;
+                analog_io = (LINE1 == dev->dmasound.input) ? 0x00 : 0x08;
+                rate = (32000 == dev->dmasound.rate) ? 0x01 : 0x03;
                 saa_andorb(SAA7134_ANALOG_IO_SELECT,  0x08, analog_io);
                 saa_andorb(SAA7134_AUDIO_FORMAT_CTRL, 0xc0, 0x80);
                 saa_andorb(SAA7134_SIF_SAMPLE_FREQ,   0x03, rate);
@@ -560,7 +560,7 @@ mixer_recsrc_7133(struct saa7134_dev *dev)
 
         xbarin = 0x03; // adc
     anabar = 0;
-        switch (dev->oss.input) {
+        switch (dev->dmasound.input) {
         case TV:
                 xbarin = 0; // Demodulator
         anabar = 2; // DACs
@@ -586,9 +586,9 @@ mixer_recsrc(struct saa7134_dev *dev, enum saa7134_audio_in src)
 {
         static const char *iname[] = { "Oops", "TV", "LINE1", "LINE2" };
 
-        dev->oss.count++;
-        dev->oss.input = src;
-        dprintk("mixer input = %s\n",iname[dev->oss.input]);
+        dev->dmasound.count++;
+        dev->dmasound.input = src;
+        dprintk("mixer input = %s\n",iname[dev->dmasound.input]);
 
         switch (dev->pci->device) {
         case PCI_DEVICE_ID_PHILIPS_SAA7134:
@@ -640,7 +640,7 @@ static int mixer_open(struct inode *inode, struct file *file)
 
         list_for_each(list,&saa7134_devlist) {
                 h = list_entry(list, struct saa7134_dev, devlist);
-                if (h->oss.minor_mixer == minor)
+                if (h->dmasound.minor_mixer == minor)
                         dev = h;
         }
         if (NULL == dev)
@@ -676,7 +676,7 @@ static int mixer_ioctl(struct inode *inode, struct file *file,
                 memset(&info,0,sizeof(info));
                 strlcpy(info.id,   "TV audio", sizeof(info.id));
                 strlcpy(info.name, dev->name,  sizeof(info.name));
-                info.modify_counter = dev->oss.count;
+                info.modify_counter = dev->dmasound.count;
                 if (copy_to_user(argp, &info, sizeof(info)))
                         return -EFAULT;
                 return 0;
@@ -698,26 +698,26 @@ static int mixer_ioctl(struct inode *inode, struct file *file,
         case MIXER_READ(SOUND_MIXER_RECMASK):
         case MIXER_READ(SOUND_MIXER_DEVMASK):
                 val = SOUND_MASK_LINE1 | SOUND_MASK_LINE2;
-                if (32000 == dev->oss.rate)
+                if (32000 == dev->dmasound.rate)
                         val |= SOUND_MASK_VIDEO;
                 return put_user(val, p);
 
         case MIXER_WRITE(SOUND_MIXER_RECSRC):
                 if (get_user(val, p))
                         return -EFAULT;
-                input = dev->oss.input;
-                if (32000 == dev->oss.rate  &&
-                    val & SOUND_MASK_VIDEO  &&  dev->oss.input != TV)
+                input = dev->dmasound.input;
+                if (32000 == dev->dmasound.rate  &&
+                    val & SOUND_MASK_VIDEO  &&  dev->dmasound.input != TV)
                         input = TV;
-                if (val & SOUND_MASK_LINE1  &&  dev->oss.input != LINE1)
+                if (val & SOUND_MASK_LINE1  &&  dev->dmasound.input != LINE1)
                         input = LINE1;
-                if (val & SOUND_MASK_LINE2  &&  dev->oss.input != LINE2)
+                if (val & SOUND_MASK_LINE2  &&  dev->dmasound.input != LINE2)
                         input = LINE2;
-                if (input != dev->oss.input)
+                if (input != dev->dmasound.input)
                         mixer_recsrc(dev,input);
                 /* fall throuth */
         case MIXER_READ(SOUND_MIXER_RECSRC):
-                switch (dev->oss.input) {
+                switch (dev->dmasound.input) {
                 case TV:    ret = SOUND_MASK_VIDEO; break;
                 case LINE1: ret = SOUND_MASK_LINE1; break;
                 case LINE2: ret = SOUND_MASK_LINE2; break;
@@ -727,7 +727,7 @@ static int mixer_ioctl(struct inode *inode, struct file *file,
 
         case MIXER_WRITE(SOUND_MIXER_VIDEO):
         case MIXER_READ(SOUND_MIXER_VIDEO):
-                if (32000 != dev->oss.rate)
+                if (32000 != dev->dmasound.rate)
                         return -EINVAL;
                 return put_user(100 | 100 << 8, p);
 
@@ -736,22 +736,22 @@ static int mixer_ioctl(struct inode *inode, struct file *file,
                         return -EFAULT;
                 val &= 0xff;
                 val = (val <= 50) ? 50 : 100;
-                dev->oss.line1 = val;
-                mixer_level(dev,LINE1,dev->oss.line1);
+                dev->dmasound.line1 = val;
+                mixer_level(dev,LINE1,dev->dmasound.line1);
                 /* fall throuth */
         case MIXER_READ(SOUND_MIXER_LINE1):
-                return put_user(dev->oss.line1 | dev->oss.line1 << 8, p);
+                return put_user(dev->dmasound.line1 | dev->dmasound.line1 << 8, p);
 
         case MIXER_WRITE(SOUND_MIXER_LINE2):
                 if (get_user(val, p))
                         return -EFAULT;
                 val &= 0xff;
                 val = (val <= 50) ? 50 : 100;
-                dev->oss.line2 = val;
-                mixer_level(dev,LINE2,dev->oss.line2);
+                dev->dmasound.line2 = val;
+                mixer_level(dev,LINE2,dev->dmasound.line2);
                 /* fall throuth */
         case MIXER_READ(SOUND_MIXER_LINE2):
-                return put_user(dev->oss.line2 | dev->oss.line2 << 8, p);
+                return put_user(dev->dmasound.line2 | dev->dmasound.line2 << 8, p);
 
         default:
                 return -EINVAL;
@@ -771,8 +771,8 @@ struct file_operations saa7134_mixer_fops = {
 int saa7134_oss_init1(struct saa7134_dev *dev)
 {
         /* general */
-        init_MUTEX(&dev->oss.lock);
-        init_waitqueue_head(&dev->oss.wq);
+        init_MUTEX(&dev->dmasound.lock);
+        init_waitqueue_head(&dev->dmasound.wq);
 
         switch (dev->pci->device) {
         case PCI_DEVICE_ID_PHILIPS_SAA7133:
@@ -784,17 +784,17 @@ int saa7134_oss_init1(struct saa7134_dev *dev)
         }
 
         /* dsp */
-        dev->oss.rate = 32000;
+        dev->dmasound.rate = 32000;
         if (oss_rate)
-                dev->oss.rate = oss_rate;
-        dev->oss.rate = (dev->oss.rate > 40000) ? 48000 : 32000;
+                dev->dmasound.rate = oss_rate;
+        dev->dmasound.rate = (dev->dmasound.rate > 40000) ? 48000 : 32000;
 
         /* mixer */
-        dev->oss.line1 = 50;
-        dev->oss.line2 = 50;
-        mixer_level(dev,LINE1,dev->oss.line1);
-        mixer_level(dev,LINE2,dev->oss.line2);
-        mixer_recsrc(dev, (dev->oss.rate == 32000) ? TV : LINE2);
+        dev->dmasound.line1 = 50;
+        dev->dmasound.line2 = 50;
+        mixer_level(dev,LINE1,dev->dmasound.line1);
+        mixer_level(dev,LINE2,dev->dmasound.line2);
+        mixer_recsrc(dev, (dev->dmasound.rate == 32000) ? TV : LINE2);
 
         return 0;
 }
@@ -810,7 +810,7 @@ void saa7134_irq_oss_done(struct saa7134_dev *dev, unsigned long status)
         int next_blk, reg = 0;
 
         spin_lock(&dev->slock);
-        if (UNSET == dev->oss.dma_blk) {
+        if (UNSET == dev->dmasound.dma_blk) {
                 dprintk("irq: recording stopped\n");
                 goto done;
         }
@@ -818,11 +818,11 @@ void saa7134_irq_oss_done(struct saa7134_dev *dev, unsigned long status)
                 dprintk("irq: lost %ld\n", (status >> 24) & 0x0f);
         if (0 == (status & 0x10000000)) {
                 /* odd */
-                if (0 == (dev->oss.dma_blk & 0x01))
+                if (0 == (dev->dmasound.dma_blk & 0x01))
                         reg = SAA7134_RS_BA1(6);
         } else {
                 /* even */
-                if (1 == (dev->oss.dma_blk & 0x01))
+                if (1 == (dev->dmasound.dma_blk & 0x01))
                         reg = SAA7134_RS_BA2(6);
         }
         if (0 == reg) {
@@ -830,25 +830,25 @@ void saa7134_irq_oss_done(struct saa7134_dev *dev, unsigned long status)
                         (status & 0x10000000) ? "even" : "odd");
                 goto done;
         }
-        if (dev->oss.read_count >= dev->oss.blksize * (dev->oss.blocks-2)) {
-                dprintk("irq: overrun [full=%d/%d]\n",dev->oss.read_count,
-                        dev->oss.bufsize);
+        if (dev->dmasound.read_count >= dev->dmasound.blksize * (dev->dmasound.blocks-2)) {
+                dprintk("irq: overrun [full=%d/%d]\n",dev->dmasound.read_count,
+                        dev->dmasound.bufsize);
                 dsp_dma_stop(dev);
                 goto done;
         }
 
         /* next block addr */
-        next_blk = (dev->oss.dma_blk + 2) % dev->oss.blocks;
-        saa_writel(reg,next_blk * dev->oss.blksize);
+        next_blk = (dev->dmasound.dma_blk + 2) % dev->dmasound.blocks;
+        saa_writel(reg,next_blk * dev->dmasound.blksize);
         if (oss_debug > 2)
                 dprintk("irq: ok, %s, next_blk=%d, addr=%x\n",
                         (status & 0x10000000) ? "even" : "odd ", next_blk,
-                        next_blk * dev->oss.blksize);
+                        next_blk * dev->dmasound.blksize);
 
         /* update status & wake waiting readers */
-        dev->oss.dma_blk = (dev->oss.dma_blk + 1) % dev->oss.blocks;
-        dev->oss.read_count += dev->oss.blksize;
-        wake_up(&dev->oss.wq);
+        dev->dmasound.dma_blk = (dev->dmasound.dma_blk + 1) % dev->dmasound.blocks;
+        dev->dmasound.read_count += dev->dmasound.blksize;
+        wake_up(&dev->dmasound.wq);
 
  done:
         spin_unlock(&dev->slock);