V4L/DVB (3318b): sem2mutex: drivers/media/, #2
Ingo Molnar [Tue, 7 Feb 2006 08:49:14 +0000 (06:49 -0200)]
Semaphore to mutex conversion.

The conversion was generated via scripts, and the result was validated
automatically via a script as well.

Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Mauro Carvalho Chehab <mchehab@infradead.org>

79 files changed:
drivers/media/common/saa7146_core.c
drivers/media/common/saa7146_fops.c
drivers/media/common/saa7146_i2c.c
drivers/media/common/saa7146_vbi.c
drivers/media/common/saa7146_video.c
drivers/media/dvb/b2c2/flexcop-common.h
drivers/media/dvb/b2c2/flexcop-i2c.c
drivers/media/dvb/bt8xx/bt878.c
drivers/media/dvb/bt8xx/bt878.h
drivers/media/dvb/bt8xx/dst.c
drivers/media/dvb/bt8xx/dst_ca.c
drivers/media/dvb/bt8xx/dst_common.h
drivers/media/dvb/bt8xx/dvb-bt8xx.c
drivers/media/dvb/bt8xx/dvb-bt8xx.h
drivers/media/dvb/cinergyT2/cinergyT2.c
drivers/media/dvb/dvb-core/dmxdev.c
drivers/media/dvb/dvb-core/dmxdev.h
drivers/media/dvb/dvb-core/dvb_demux.c
drivers/media/dvb/dvb-core/dvb_demux.h
drivers/media/dvb/dvb-core/dvb_frontend.c
drivers/media/dvb/dvb-core/dvb_net.c
drivers/media/dvb/dvb-usb/cxusb.c
drivers/media/dvb/dvb-usb/dibusb-common.c
drivers/media/dvb/dvb-usb/digitv.c
drivers/media/dvb/dvb-usb/dvb-usb-init.c
drivers/media/dvb/dvb-usb/dvb-usb-urb.c
drivers/media/dvb/dvb-usb/dvb-usb.h
drivers/media/dvb/dvb-usb/vp702x.c
drivers/media/dvb/dvb-usb/vp7045.c
drivers/media/dvb/frontends/bcm3510.c
drivers/media/dvb/ttpci/av7110.c
drivers/media/dvb/ttpci/av7110.h
drivers/media/dvb/ttpci/av7110_hw.c
drivers/media/dvb/ttpci/budget.h
drivers/media/dvb/ttusb-budget/dvb-ttusb-budget.c
drivers/media/dvb/ttusb-dec/ttusb_dec.c
drivers/media/radio/miropcm20-rds-core.c
drivers/media/radio/radio-aimslab.c
drivers/media/radio/radio-aztech.c
drivers/media/radio/radio-maestro.c
drivers/media/radio/radio-maxiradio.c
drivers/media/radio/radio-sf16fmi.c
drivers/media/radio/radio-sf16fmr2.c
drivers/media/radio/radio-typhoon.c
drivers/media/radio/radio-zoltrix.c
drivers/media/video/arv.c
drivers/media/video/bttv-driver.c
drivers/media/video/bw-qcam.c
drivers/media/video/bw-qcam.h
drivers/media/video/c-qcam.c
drivers/media/video/cpia.c
drivers/media/video/cpia.h
drivers/media/video/cx88/cx88-core.c
drivers/media/video/cx88/cx88-video.c
drivers/media/video/cx88/cx88.h
drivers/media/video/em28xx/em28xx-video.c
drivers/media/video/em28xx/em28xx.h
drivers/media/video/meye.c
drivers/media/video/meye.h
drivers/media/video/mxb.c
drivers/media/video/planb.c
drivers/media/video/planb.h
drivers/media/video/pms.c
drivers/media/video/saa5246a.c
drivers/media/video/saa5249.c
drivers/media/video/saa7134/saa7134-alsa.c
drivers/media/video/saa7134/saa7134-core.c
drivers/media/video/saa7134/saa7134-empress.c
drivers/media/video/saa7134/saa7134-oss.c
drivers/media/video/saa7134/saa7134-video.c
drivers/media/video/saa7134/saa7134.h
drivers/media/video/video-buf-dvb.c
drivers/media/video/video-buf.c
drivers/media/video/videodev.c
drivers/media/video/vino.c
include/linux/videodev2.h
include/media/saa7146.h
include/media/video-buf-dvb.h
include/media/video-buf.h

index 04c1938..ee16c04 100644 (file)
@@ -21,7 +21,7 @@
 #include <media/saa7146.h>
 
 LIST_HEAD(saa7146_devices);
-DECLARE_MUTEX(saa7146_devices_lock);
+DEFINE_MUTEX(saa7146_devices_lock);
 
 static int saa7146_num;
 
@@ -402,11 +402,11 @@ static int saa7146_init_one(struct pci_dev *pci, const struct pci_device_id *ent
 
        pci_set_drvdata(pci, dev);
 
-       init_MUTEX(&dev->lock);
+       mutex_init(&dev->lock);
        spin_lock_init(&dev->int_slock);
        spin_lock_init(&dev->slock);
 
-       init_MUTEX(&dev->i2c_lock);
+       mutex_init(&dev->i2c_lock);
 
        dev->module = THIS_MODULE;
        init_waitqueue_head(&dev->i2c_wq);
index f8cf73e..dc7fb20 100644 (file)
@@ -17,18 +17,18 @@ int saa7146_res_get(struct saa7146_fh *fh, unsigned int bit)
        }
 
        /* is it free? */
-       down(&dev->lock);
+       mutex_lock(&dev->lock);
        if (vv->resources & bit) {
                DEB_D(("locked! vv->resources:0x%02x, we want:0x%02x\n",vv->resources,bit));
                /* no, someone else uses it */
-               up(&dev->lock);
+               mutex_unlock(&dev->lock);
                return 0;
        }
        /* it's free, grab it */
        fh->resources  |= bit;
        vv->resources |= bit;
        DEB_D(("res: get 0x%02x, cur:0x%02x\n",bit,vv->resources));
-       up(&dev->lock);
+       mutex_unlock(&dev->lock);
        return 1;
 }
 
@@ -40,11 +40,11 @@ void saa7146_res_free(struct saa7146_fh *fh, unsigned int bits)
        if ((fh->resources & bits) != bits)
                BUG();
 
-       down(&dev->lock);
+       mutex_lock(&dev->lock);
        fh->resources  &= ~bits;
        vv->resources &= ~bits;
        DEB_D(("res: put 0x%02x, cur:0x%02x\n",bits,vv->resources));
-       up(&dev->lock);
+       mutex_unlock(&dev->lock);
 }
 
 
@@ -204,7 +204,7 @@ static int fops_open(struct inode *inode, struct file *file)
 
        DEB_EE(("inode:%p, file:%p, minor:%d\n",inode,file,minor));
 
-       if (down_interruptible(&saa7146_devices_lock))
+       if (mutex_lock_interruptible(&saa7146_devices_lock))
                return -ERESTARTSYS;
 
        list_for_each(list,&saa7146_devices) {
@@ -276,7 +276,7 @@ out:
                kfree(fh);
                file->private_data = NULL;
        }
-       up(&saa7146_devices_lock);
+       mutex_unlock(&saa7146_devices_lock);
        return result;
 }
 
@@ -287,7 +287,7 @@ static int fops_release(struct inode *inode, struct file *file)
 
        DEB_EE(("inode:%p, file:%p\n",inode,file));
 
-       if (down_interruptible(&saa7146_devices_lock))
+       if (mutex_lock_interruptible(&saa7146_devices_lock))
                return -ERESTARTSYS;
 
        if( fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
@@ -303,7 +303,7 @@ static int fops_release(struct inode *inode, struct file *file)
        file->private_data = NULL;
        kfree(fh);
 
-       up(&saa7146_devices_lock);
+       mutex_unlock(&saa7146_devices_lock);
 
        return 0;
 }
index 8aabdd8..d9953f7 100644 (file)
@@ -279,7 +279,7 @@ int saa7146_i2c_transfer(struct saa7146_dev *dev, const struct i2c_msg *msgs, in
        int address_err = 0;
        int short_delay = 0;
 
-       if (down_interruptible (&dev->i2c_lock))
+       if (mutex_lock_interruptible(&dev->i2c_lock))
                return -ERESTARTSYS;
 
        for(i=0;i<num;i++) {
@@ -366,7 +366,7 @@ out:
                }
        }
 
-       up(&dev->i2c_lock);
+       mutex_unlock(&dev->i2c_lock);
        return err;
 }
 
index 468d3c9..500bd3f 100644 (file)
@@ -410,7 +410,7 @@ static int vbi_open(struct saa7146_dev *dev, struct file *file)
                            V4L2_FIELD_SEQ_TB, // FIXME: does this really work?
                            sizeof(struct saa7146_buf),
                            file);
-       init_MUTEX(&fh->vbi_q.lock);
+       mutex_init(&fh->vbi_q.lock);
 
        init_timer(&fh->vbi_read_timeout);
        fh->vbi_read_timeout.function = vbi_read_timeout;
index 7ebac79..6b42713 100644 (file)
@@ -378,20 +378,20 @@ static int s_fmt(struct saa7146_fh *fh, struct v4l2_format *f)
                err = try_win(dev,&f->fmt.win);
                if (0 != err)
                        return err;
-               down(&dev->lock);
+               mutex_lock(&dev->lock);
                fh->ov.win    = f->fmt.win;
                fh->ov.nclips = f->fmt.win.clipcount;
                if (fh->ov.nclips > 16)
                        fh->ov.nclips = 16;
                if (copy_from_user(fh->ov.clips,f->fmt.win.clips,sizeof(struct v4l2_clip)*fh->ov.nclips)) {
-                       up(&dev->lock);
+                       mutex_unlock(&dev->lock);
                        return -EFAULT;
                }
 
                /* fh->ov.fh is used to indicate that we have valid overlay informations, too */
                fh->ov.fh = fh;
 
-               up(&dev->lock);
+               mutex_unlock(&dev->lock);
 
                /* check if our current overlay is active */
                if (IS_OVERLAY_ACTIVE(fh) != 0) {
@@ -516,7 +516,7 @@ static int set_control(struct saa7146_fh *fh, struct v4l2_control *c)
                return -EINVAL;
        }
 
-       down(&dev->lock);
+       mutex_lock(&dev->lock);
 
        switch (ctrl->type) {
        case V4L2_CTRL_TYPE_BOOLEAN:
@@ -560,7 +560,7 @@ static int set_control(struct saa7146_fh *fh, struct v4l2_control *c)
                /* fixme: we can support changing VFLIP and HFLIP here... */
                if (IS_CAPTURE_ACTIVE(fh) != 0) {
                        DEB_D(("V4L2_CID_HFLIP while active capture.\n"));
-                       up(&dev->lock);
+                       mutex_unlock(&dev->lock);
                        return -EINVAL;
                }
                vv->hflip = c->value;
@@ -568,7 +568,7 @@ static int set_control(struct saa7146_fh *fh, struct v4l2_control *c)
        case V4L2_CID_VFLIP:
                if (IS_CAPTURE_ACTIVE(fh) != 0) {
                        DEB_D(("V4L2_CID_VFLIP while active capture.\n"));
-                       up(&dev->lock);
+                       mutex_unlock(&dev->lock);
                        return -EINVAL;
                }
                vv->vflip = c->value;
@@ -577,7 +577,7 @@ static int set_control(struct saa7146_fh *fh, struct v4l2_control *c)
                return -EINVAL;
        }
        }
-       up(&dev->lock);
+       mutex_unlock(&dev->lock);
 
        if (IS_OVERLAY_ACTIVE(fh) != 0) {
                saa7146_stop_preview(fh);
@@ -939,7 +939,7 @@ int saa7146_video_do_ioctl(struct inode *inode, struct file *file, unsigned int
                        }
                }
 
-               down(&dev->lock);
+               mutex_lock(&dev->lock);
 
                /* ok, accept it */
                vv->ov_fb = *fb;
@@ -948,7 +948,7 @@ int saa7146_video_do_ioctl(struct inode *inode, struct file *file, unsigned int
                        vv->ov_fb.fmt.bytesperline =
                                vv->ov_fb.fmt.width*fmt->depth/8;
 
-               up(&dev->lock);
+               mutex_unlock(&dev->lock);
 
                return 0;
        }
@@ -1086,7 +1086,7 @@ int saa7146_video_do_ioctl(struct inode *inode, struct file *file, unsigned int
                        }
                }
 
-               down(&dev->lock);
+               mutex_lock(&dev->lock);
 
                for(i = 0; i < dev->ext_vv_data->num_stds; i++)
                        if (*id & dev->ext_vv_data->stds[i].id)
@@ -1098,7 +1098,7 @@ int saa7146_video_do_ioctl(struct inode *inode, struct file *file, unsigned int
                        found = 1;
                }
 
-               up(&dev->lock);
+               mutex_unlock(&dev->lock);
 
                if (vv->ov_suspend != NULL) {
                        saa7146_start_preview(vv->ov_suspend);
@@ -1201,11 +1201,11 @@ int saa7146_video_do_ioctl(struct inode *inode, struct file *file, unsigned int
                DEB_D(("VIDIOCGMBUF \n"));
 
                q = &fh->video_q;
-               down(&q->lock);
+               mutex_lock(&q->lock);
                err = videobuf_mmap_setup(q,gbuffers,gbufsize,
                                          V4L2_MEMORY_MMAP);
                if (err < 0) {
-                       up(&q->lock);
+                       mutex_unlock(&q->lock);
                        return err;
                }
                memset(mbuf,0,sizeof(*mbuf));
@@ -1213,7 +1213,7 @@ int saa7146_video_do_ioctl(struct inode *inode, struct file *file, unsigned int
                mbuf->size   = gbuffers * gbufsize;
                for (i = 0; i < gbuffers; i++)
                        mbuf->offsets[i] = i * gbufsize;
-               up(&q->lock);
+               mutex_unlock(&q->lock);
                return 0;
        }
        default:
@@ -1414,7 +1414,7 @@ static int video_open(struct saa7146_dev *dev, struct file *file)
                            sizeof(struct saa7146_buf),
                            file);
 
-       init_MUTEX(&fh->video_q.lock);
+       mutex_init(&fh->video_q.lock);
 
        return 0;
 }
index 7d7e161..b3dd060 100644 (file)
@@ -10,6 +10,7 @@
 
 #include <linux/config.h>
 #include <linux/pci.h>
+#include <linux/mutex.h>
 
 #include "flexcop-reg.h"
 
@@ -73,8 +74,7 @@ struct flexcop_device {
        int (*fe_sleep) (struct dvb_frontend *);
 
        struct i2c_adapter i2c_adap;
-       struct semaphore i2c_sem;
-
+       struct mutex i2c_mutex;
        struct module *owner;
 
        /* options and status */
index 56495cb..e0bd2d8 100644 (file)
@@ -135,7 +135,7 @@ static int flexcop_master_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg msgs
        struct flexcop_device *fc = i2c_get_adapdata(i2c_adap);
        int i, ret = 0;
 
-       if (down_interruptible(&fc->i2c_sem))
+       if (mutex_lock_interruptible(&fc->i2c_mutex))
                return -ERESTARTSYS;
 
        /* reading */
@@ -161,7 +161,7 @@ static int flexcop_master_xfer(struct i2c_adapter *i2c_adap, struct i2c_msg msgs
        else
                ret = num;
 
-       up(&fc->i2c_sem);
+       mutex_unlock(&fc->i2c_mutex);
 
        return ret;
 }
@@ -180,7 +180,7 @@ int flexcop_i2c_init(struct flexcop_device *fc)
 {
        int ret;
 
-       sema_init(&fc->i2c_sem,1);
+       mutex_init(&fc->i2c_mutex);
 
        memset(&fc->i2c_adap, 0, sizeof(struct i2c_adapter));
        strncpy(fc->i2c_adap.name, "B2C2 FlexCop device",I2C_NAME_SIZE);
index 34c3189..d276ce6 100644 (file)
@@ -344,7 +344,7 @@ bt878_device_control(struct bt878 *bt, unsigned int cmd, union dst_gpio_packet *
        int retval;
 
        retval = 0;
-       if (down_interruptible (&bt->gpio_lock))
+       if (mutex_lock_interruptible(&bt->gpio_lock))
                return -ERESTARTSYS;
        /* special gpio signal */
        switch (cmd) {
@@ -375,7 +375,7 @@ bt878_device_control(struct bt878 *bt, unsigned int cmd, union dst_gpio_packet *
                retval = -EINVAL;
                break;
        }
-       up(&bt->gpio_lock);
+       mutex_unlock(&bt->gpio_lock);
        return retval;
 }
 
index 9faf937..f685bc1 100644 (file)
@@ -25,6 +25,8 @@
 #include <linux/pci.h>
 #include <linux/sched.h>
 #include <linux/spinlock.h>
+#include <linux/mutex.h>
+
 #include "bt848.h"
 #include "bttv.h"
 
@@ -108,7 +110,7 @@ struct cards {
 extern int bt878_num;
 
 struct bt878 {
-       struct semaphore  gpio_lock;
+       struct mutex gpio_lock;
        unsigned int nr;
        unsigned int bttv_nr;
        struct i2c_adapter *adapter;
index 3a2ff1c..d800df1 100644 (file)
@@ -910,7 +910,7 @@ static int dst_get_device_id(struct dst_state *state)
 
 static int dst_probe(struct dst_state *state)
 {
-       sema_init(&state->dst_mutex, 1);
+       mutex_init(&state->dst_mutex);
        if ((rdc_8820_reset(state)) < 0) {
                dprintk(verbose, DST_ERROR, 1, "RDC 8820 RESET Failed.");
                return -1;
@@ -962,7 +962,7 @@ int dst_command(struct dst_state *state, u8 *data, u8 len)
 {
        u8 reply;
 
-       down(&state->dst_mutex);
+       mutex_lock(&state->dst_mutex);
        if ((dst_comm_init(state)) < 0) {
                dprintk(verbose, DST_NOTICE, 1, "DST Communication Initialization Failed.");
                goto error;
@@ -1013,11 +1013,11 @@ int dst_command(struct dst_state *state, u8 *data, u8 len)
                dprintk(verbose, DST_INFO, 1, "checksum failure");
                goto error;
        }
-       up(&state->dst_mutex);
+       mutex_unlock(&state->dst_mutex);
        return 0;
 
 error:
-       up(&state->dst_mutex);
+       mutex_unlock(&state->dst_mutex);
        return -EIO;
 
 }
@@ -1128,7 +1128,7 @@ static int dst_write_tuna(struct dvb_frontend *fe)
                        dst_set_voltage(fe, SEC_VOLTAGE_13);
        }
        state->diseq_flags &= ~(HAS_LOCK | ATTEMPT_TUNE);
-       down(&state->dst_mutex);
+       mutex_lock(&state->dst_mutex);
        if ((dst_comm_init(state)) < 0) {
                dprintk(verbose, DST_DEBUG, 1, "DST Communication initialization failed.");
                goto error;
@@ -1160,11 +1160,11 @@ static int dst_write_tuna(struct dvb_frontend *fe)
        state->diseq_flags |= ATTEMPT_TUNE;
        retval = dst_get_tuna(state);
 werr:
-       up(&state->dst_mutex);
+       mutex_unlock(&state->dst_mutex);
        return retval;
 
 error:
-       up(&state->dst_mutex);
+       mutex_unlock(&state->dst_mutex);
        return -EIO;
 }
 
index c650b4b..f6b49a8 100644 (file)
@@ -81,7 +81,7 @@ static int dst_ci_command(struct dst_state* state, u8 * data, u8 *ca_string, u8
 {
        u8 reply;
 
-       down(&state->dst_mutex);
+       mutex_lock(&state->dst_mutex);
        dst_comm_init(state);
        msleep(65);
 
@@ -110,11 +110,11 @@ static int dst_ci_command(struct dst_state* state, u8 * data, u8 *ca_string, u8
                        goto error;
                }
        }
-       up(&state->dst_mutex);
+       mutex_unlock(&state->dst_mutex);
        return 0;
 
 error:
-       up(&state->dst_mutex);
+       mutex_unlock(&state->dst_mutex);
        return -EIO;
 }
 
index 81557f3..51d4e04 100644 (file)
@@ -25,6 +25,7 @@
 #include <linux/smp_lock.h>
 #include <linux/dvb/frontend.h>
 #include <linux/device.h>
+#include <linux/mutex.h>
 #include "bt878.h"
 
 #include "dst_ca.h"
@@ -121,7 +122,7 @@ struct dst_state {
        u8 vendor[8];
        u8 board_info[8];
 
-       struct semaphore dst_mutex;
+       struct mutex dst_mutex;
 };
 
 struct dst_types {
index ea27b15..1649846 100644 (file)
@@ -76,13 +76,13 @@ static int dvb_bt8xx_start_feed(struct dvb_demux_feed *dvbdmxfeed)
        if (!dvbdmx->dmx.frontend)
                return -EINVAL;
 
-       down(&card->lock);
+       mutex_lock(&card->lock);
        card->nfeeds++;
        rc = card->nfeeds;
        if (card->nfeeds == 1)
                bt878_start(card->bt, card->gpio_mode,
                            card->op_sync_orin, card->irq_err_ignore);
-       up(&card->lock);
+       mutex_unlock(&card->lock);
        return rc;
 }
 
@@ -96,11 +96,11 @@ static int dvb_bt8xx_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
        if (!dvbdmx->dmx.frontend)
                return -EINVAL;
 
-       down(&card->lock);
+       mutex_lock(&card->lock);
        card->nfeeds--;
        if (card->nfeeds == 0)
                bt878_stop(card->bt);
-       up(&card->lock);
+       mutex_unlock(&card->lock);
 
        return 0;
 }
@@ -788,7 +788,7 @@ static int dvb_bt8xx_probe(struct bttv_sub_device *sub)
        if (!(card = kzalloc(sizeof(struct dvb_bt8xx_card), GFP_KERNEL)))
                return -ENOMEM;
 
-       init_MUTEX(&card->lock);
+       mutex_init(&card->lock);
        card->bttv_nr = sub->core->nr;
        strncpy(card->card_name, sub->core->name, sizeof(sub->core->name));
        card->i2c_adapter = &sub->core->i2c_adap;
@@ -881,7 +881,7 @@ static int dvb_bt8xx_probe(struct bttv_sub_device *sub)
                return -EFAULT;
        }
 
-       init_MUTEX(&card->bt->gpio_lock);
+       mutex_init(&card->bt->gpio_lock);
        card->bt->bttv_nr = sub->core->nr;
 
        if ( (ret = dvb_bt8xx_load_card(card, sub->core->type)) ) {
index cf035a8..00dd9fa 100644 (file)
@@ -26,6 +26,7 @@
 #define DVB_BT8XX_H
 
 #include <linux/i2c.h>
+#include <linux/mutex.h>
 #include "dvbdev.h"
 #include "dvb_net.h"
 #include "bttv.h"
@@ -38,7 +39,7 @@
 #include "lgdt330x.h"
 
 struct dvb_bt8xx_card {
-       struct semaphore lock;
+       struct mutex lock;
        int nfeeds;
        char card_name[32];
        struct dvb_adapter dvb_adapter;
index c4b4c5b..29b7be5 100644 (file)
@@ -30,6 +30,7 @@
 #include <linux/pci.h>
 #include <linux/input.h>
 #include <linux/dvb/frontend.h>
+#include <linux/mutex.h>
 
 #include "dmxdev.h"
 #include "dvb_demux.h"
@@ -116,7 +117,7 @@ static struct dvb_frontend_info cinergyt2_fe_info = {
 struct cinergyt2 {
        struct dvb_demux demux;
        struct usb_device *udev;
-       struct semaphore sem;
+       struct mutex sem;
        struct dvb_adapter adapter;
        struct dvb_device *fedev;
        struct dmxdev dmxdev;
@@ -345,14 +346,14 @@ static int cinergyt2_start_feed(struct dvb_demux_feed *dvbdmxfeed)
        struct dvb_demux *demux = dvbdmxfeed->demux;
        struct cinergyt2 *cinergyt2 = demux->priv;
 
-       if (cinergyt2->disconnect_pending || down_interruptible(&cinergyt2->sem))
+       if (cinergyt2->disconnect_pending || mutex_lock_interruptible(&cinergyt2->sem))
                return -ERESTARTSYS;
 
        if (cinergyt2->streaming == 0)
                cinergyt2_start_stream_xfer(cinergyt2);
 
        cinergyt2->streaming++;
-       up(&cinergyt2->sem);
+       mutex_unlock(&cinergyt2->sem);
        return 0;
 }
 
@@ -361,13 +362,13 @@ static int cinergyt2_stop_feed(struct dvb_demux_feed *dvbdmxfeed)
        struct dvb_demux *demux = dvbdmxfeed->demux;
        struct cinergyt2 *cinergyt2 = demux->priv;
 
-       if (cinergyt2->disconnect_pending || down_interruptible(&cinergyt2->sem))
+       if (cinergyt2->disconnect_pending || mutex_lock_interruptible(&cinergyt2->sem))
                return -ERESTARTSYS;
 
        if (--cinergyt2->streaming == 0)
                cinergyt2_stop_stream_xfer(cinergyt2);
 
-       up(&cinergyt2->sem);
+       mutex_unlock(&cinergyt2->sem);
        return 0;
 }
 
@@ -483,11 +484,11 @@ static int cinergyt2_open (struct inode *inode, struct file *file)
        struct cinergyt2 *cinergyt2 = dvbdev->priv;
        int err = -ERESTARTSYS;
 
-       if (cinergyt2->disconnect_pending || down_interruptible(&cinergyt2->sem))
+       if (cinergyt2->disconnect_pending || mutex_lock_interruptible(&cinergyt2->sem))
                return -ERESTARTSYS;
 
        if ((err = dvb_generic_open(inode, file))) {
-               up(&cinergyt2->sem);
+               mutex_unlock(&cinergyt2->sem);
                return err;
        }
 
@@ -499,7 +500,7 @@ static int cinergyt2_open (struct inode *inode, struct file *file)
 
        atomic_inc(&cinergyt2->inuse);
 
-       up(&cinergyt2->sem);
+       mutex_unlock(&cinergyt2->sem);
        return 0;
 }
 
@@ -517,7 +518,7 @@ static int cinergyt2_release (struct inode *inode, struct file *file)
        struct dvb_device *dvbdev = file->private_data;
        struct cinergyt2 *cinergyt2 = dvbdev->priv;
 
-       if (down_interruptible(&cinergyt2->sem))
+       if (mutex_lock_interruptible(&cinergyt2->sem))
                return -ERESTARTSYS;
 
        if (!cinergyt2->disconnect_pending && (file->f_flags & O_ACCMODE) != O_RDONLY) {
@@ -526,7 +527,7 @@ static int cinergyt2_release (struct inode *inode, struct file *file)
                cinergyt2_sleep(cinergyt2, 1);
        }
 
-       up(&cinergyt2->sem);
+       mutex_unlock(&cinergyt2->sem);
 
        if (atomic_dec_and_test(&cinergyt2->inuse) && cinergyt2->disconnect_pending) {
                warn("delayed unregister in release");
@@ -541,12 +542,12 @@ static unsigned int cinergyt2_poll (struct file *file, struct poll_table_struct
        struct dvb_device *dvbdev = file->private_data;
        struct cinergyt2 *cinergyt2 = dvbdev->priv;
 
-       if (cinergyt2->disconnect_pending || down_interruptible(&cinergyt2->sem))
+       if (cinergyt2->disconnect_pending || mutex_lock_interruptible(&cinergyt2->sem))
                return -ERESTARTSYS;
 
        poll_wait(file, &cinergyt2->poll_wq, wait);
 
-       up(&cinergyt2->sem);
+       mutex_unlock(&cinergyt2->sem);
 
        return (POLLIN | POLLRDNORM | POLLPRI);
 }
@@ -613,7 +614,7 @@ static int cinergyt2_ioctl (struct inode *inode, struct file *file,
                if (copy_from_user(&p, (void  __user*) arg, sizeof(p)))
                        return -EFAULT;
 
-               if (cinergyt2->disconnect_pending || down_interruptible(&cinergyt2->sem))
+               if (cinergyt2->disconnect_pending || mutex_lock_interruptible(&cinergyt2->sem))
                        return -ERESTARTSYS;
 
                param->cmd = CINERGYT2_EP1_SET_TUNER_PARAMETERS;
@@ -629,7 +630,7 @@ static int cinergyt2_ioctl (struct inode *inode, struct file *file,
                                        (char *) param, sizeof(*param),
                                        NULL, 0);
 
-               up(&cinergyt2->sem);
+               mutex_unlock(&cinergyt2->sem);
 
                return (err < 0) ? err : 0;
        }
@@ -724,7 +725,7 @@ static void cinergyt2_query_rc (void *data)
        struct cinergyt2_rc_event rc_events[12];
        int n, len, i;
 
-       if (cinergyt2->disconnect_pending || down_interruptible(&cinergyt2->sem))
+       if (cinergyt2->disconnect_pending || mutex_lock_interruptible(&cinergyt2->sem))
                return;
 
        len = cinergyt2_command(cinergyt2, buf, sizeof(buf),
@@ -784,7 +785,7 @@ out:
        schedule_delayed_work(&cinergyt2->rc_query_work,
                              msecs_to_jiffies(RC_QUERY_INTERVAL));
 
-       up(&cinergyt2->sem);
+       mutex_unlock(&cinergyt2->sem);
 }
 
 static int cinergyt2_register_rc(struct cinergyt2 *cinergyt2)
@@ -849,7 +850,7 @@ static void cinergyt2_query (void *data)
        uint8_t lock_bits;
        uint32_t unc;
 
-       if (cinergyt2->disconnect_pending || down_interruptible(&cinergyt2->sem))
+       if (cinergyt2->disconnect_pending || mutex_lock_interruptible(&cinergyt2->sem))
                return;
 
        unc = s->uncorrected_block_count;
@@ -868,7 +869,7 @@ static void cinergyt2_query (void *data)
        schedule_delayed_work(&cinergyt2->query_work,
                              msecs_to_jiffies(QUERY_INTERVAL));
 
-       up(&cinergyt2->sem);
+       mutex_unlock(&cinergyt2->sem);
 }
 
 static int cinergyt2_probe (struct usb_interface *intf,
@@ -885,7 +886,7 @@ static int cinergyt2_probe (struct usb_interface *intf,
        memset (cinergyt2, 0, sizeof (struct cinergyt2));
        usb_set_intfdata (intf, (void *) cinergyt2);
 
-       init_MUTEX(&cinergyt2->sem);
+       mutex_init(&cinergyt2->sem);
        init_waitqueue_head (&cinergyt2->poll_wq);
        INIT_WORK(&cinergyt2->query_work, cinergyt2_query, cinergyt2);
 
@@ -967,7 +968,7 @@ static int cinergyt2_suspend (struct usb_interface *intf, pm_message_t state)
 {
        struct cinergyt2 *cinergyt2 = usb_get_intfdata (intf);
 
-       if (cinergyt2->disconnect_pending || down_interruptible(&cinergyt2->sem))
+       if (cinergyt2->disconnect_pending || mutex_lock_interruptible(&cinergyt2->sem))
                return -ERESTARTSYS;
 
        if (state.event > PM_EVENT_ON) {
@@ -981,7 +982,7 @@ static int cinergyt2_suspend (struct usb_interface *intf, pm_message_t state)
                cinergyt2_sleep(cinergyt2, 1);
        }
 
-       up(&cinergyt2->sem);
+       mutex_unlock(&cinergyt2->sem);
        return 0;
 }
 
@@ -990,7 +991,7 @@ static int cinergyt2_resume (struct usb_interface *intf)
        struct cinergyt2 *cinergyt2 = usb_get_intfdata (intf);
        struct dvbt_set_parameters_msg *param = &cinergyt2->param;
 
-       if (cinergyt2->disconnect_pending || down_interruptible(&cinergyt2->sem))
+       if (cinergyt2->disconnect_pending || mutex_lock_interruptible(&cinergyt2->sem))
                return -ERESTARTSYS;
 
        if (!cinergyt2->sleeping) {
@@ -1003,7 +1004,7 @@ static int cinergyt2_resume (struct usb_interface *intf)
 
        cinergyt2_resume_rc(cinergyt2);
 
-       up(&cinergyt2->sem);
+       mutex_unlock(&cinergyt2->sem);
        return 0;
 }
 
index 7b8373a..ead5343 100644 (file)
@@ -175,12 +175,12 @@ static int dvb_dvr_open(struct inode *inode, struct file *file)
 
        dprintk ("function : %s\n", __FUNCTION__);
 
-       if (down_interruptible (&dmxdev->mutex))
+       if (mutex_lock_interruptible(&dmxdev->mutex))
                return -ERESTARTSYS;
 
        if ((file->f_flags&O_ACCMODE)==O_RDWR) {
                if (!(dmxdev->capabilities&DMXDEV_CAP_DUPLEX)) {
-                       up(&dmxdev->mutex);
+                       mutex_unlock(&dmxdev->mutex);
                        return -EOPNOTSUPP;
                }
        }
@@ -190,7 +190,7 @@ static int dvb_dvr_open(struct inode *inode, struct file *file)
              dmxdev->dvr_buffer.size=DVR_BUFFER_SIZE;
              dmxdev->dvr_buffer.data=vmalloc(DVR_BUFFER_SIZE);
              if (!dmxdev->dvr_buffer.data) {
-                     up(&dmxdev->mutex);
+                     mutex_unlock(&dmxdev->mutex);
                      return -ENOMEM;
              }
        }
@@ -199,20 +199,20 @@ static int dvb_dvr_open(struct inode *inode, struct file *file)
                dmxdev->dvr_orig_fe=dmxdev->demux->frontend;
 
                if (!dmxdev->demux->write) {
-                       up(&dmxdev->mutex);
+                       mutex_unlock(&dmxdev->mutex);
                        return -EOPNOTSUPP;
                }
 
                front=get_fe(dmxdev->demux, DMX_MEMORY_FE);
 
                if (!front) {
-                       up(&dmxdev->mutex);
+                       mutex_unlock(&dmxdev->mutex);
                        return -EINVAL;
                }
                dmxdev->demux->disconnect_frontend(dmxdev->demux);
                dmxdev->demux->connect_frontend(dmxdev->demux, front);
        }
-       up(&dmxdev->mutex);
+       mutex_unlock(&dmxdev->mutex);
        return 0;
 }
 
@@ -221,7 +221,7 @@ static int dvb_dvr_release(struct inode *inode, struct file *file)
        struct dvb_device *dvbdev = file->private_data;
        struct dmxdev *dmxdev = dvbdev->priv;
 
-       if (down_interruptible (&dmxdev->mutex))
+       if (mutex_lock_interruptible(&dmxdev->mutex))
                return -ERESTARTSYS;
 
        if ((file->f_flags&O_ACCMODE)==O_WRONLY) {
@@ -239,7 +239,7 @@ static int dvb_dvr_release(struct inode *inode, struct file *file)
                        vfree(mem);
                }
        }
-       up(&dmxdev->mutex);
+       mutex_unlock(&dmxdev->mutex);
        return 0;
 }
 
@@ -254,10 +254,10 @@ static ssize_t dvb_dvr_write(struct file *file, const char __user *buf,
                return -EOPNOTSUPP;
        if ((file->f_flags&O_ACCMODE)!=O_WRONLY)
                return -EINVAL;
-       if (down_interruptible (&dmxdev->mutex))
+       if (mutex_lock_interruptible(&dmxdev->mutex))
                return -ERESTARTSYS;
        ret=dmxdev->demux->write(dmxdev->demux, buf, count);
-       up(&dmxdev->mutex);
+       mutex_unlock(&dmxdev->mutex);
        return ret;
 }
 
@@ -268,11 +268,11 @@ static ssize_t dvb_dvr_read(struct file *file, char __user *buf, size_t count,
        struct dmxdev *dmxdev = dvbdev->priv;
        int ret;
 
-       //down(&dmxdev->mutex);
+       //mutex_lock(&dmxdev->mutex);
        ret= dvb_dmxdev_buffer_read(&dmxdev->dvr_buffer,
                              file->f_flags&O_NONBLOCK,
                              buf, count, ppos);
-       //up(&dmxdev->mutex);
+       //mutex_unlock(&dmxdev->mutex);
        return ret;
 }
 
@@ -688,7 +688,7 @@ static int dvb_demux_open(struct inode *inode, struct file *file)
        if (!dmxdev->filter)
                return -EINVAL;
 
-       if (down_interruptible(&dmxdev->mutex))
+       if (mutex_lock_interruptible(&dmxdev->mutex))
                return -ERESTARTSYS;
 
        for (i=0; i<dmxdev->filternum; i++)
@@ -696,12 +696,12 @@ static int dvb_demux_open(struct inode *inode, struct file *file)
                        break;
 
        if (i==dmxdev->filternum) {
-               up(&dmxdev->mutex);
+               mutex_unlock(&dmxdev->mutex);
                return -EMFILE;
        }
 
        dmxdevfilter=&dmxdev->filter[i];
-       sema_init(&dmxdevfilter->mutex, 1);
+       mutex_init(&dmxdevfilter->mutex);
        dmxdevfilter->dvbdev=dmxdev->dvbdev;
        file->private_data=dmxdevfilter;
 
@@ -711,18 +711,18 @@ static int dvb_demux_open(struct inode *inode, struct file *file)
        dmxdevfilter->feed.ts=NULL;
        init_timer(&dmxdevfilter->timer);
 
-       up(&dmxdev->mutex);
+       mutex_unlock(&dmxdev->mutex);
        return 0;
 }
 
 
 static int dvb_dmxdev_filter_free(struct dmxdev *dmxdev, struct dmxdev_filter *dmxdevfilter)
 {
-       if (down_interruptible(&dmxdev->mutex))
+       if (mutex_lock_interruptible(&dmxdev->mutex))
                return -ERESTARTSYS;
 
-       if (down_interruptible(&dmxdevfilter->mutex)) {
-               up(&dmxdev->mutex);
+       if (mutex_lock_interruptible(&dmxdevfilter->mutex)) {
+               mutex_unlock(&dmxdev->mutex);
                return -ERESTARTSYS;
        }
 
@@ -740,8 +740,8 @@ static int dvb_dmxdev_filter_free(struct dmxdev *dmxdev, struct dmxdev_filter *d
 
        dvb_dmxdev_filter_state_set(dmxdevfilter, DMXDEV_STATE_FREE);
        wake_up(&dmxdevfilter->buffer.queue);
-       up(&dmxdevfilter->mutex);
-       up(&dmxdev->mutex);
+       mutex_unlock(&dmxdevfilter->mutex);
+       mutex_unlock(&dmxdev->mutex);
        return 0;
 }
 
@@ -841,7 +841,7 @@ dvb_demux_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
        struct dmxdev_filter *dmxdevfilter= file->private_data;
        int ret=0;
 
-       if (down_interruptible(&dmxdevfilter->mutex))
+       if (mutex_lock_interruptible(&dmxdevfilter->mutex))
                return -ERESTARTSYS;
 
        if (dmxdevfilter->type==DMXDEV_TYPE_SEC)
@@ -851,7 +851,7 @@ dvb_demux_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
                                     file->f_flags&O_NONBLOCK,
                                     buf, count, ppos);
 
-       up(&dmxdevfilter->mutex);
+       mutex_unlock(&dmxdevfilter->mutex);
        return ret;
 }
 
@@ -864,58 +864,58 @@ static int dvb_demux_do_ioctl(struct inode *inode, struct file *file,
        unsigned long arg=(unsigned long) parg;
        int ret=0;
 
-       if (down_interruptible (&dmxdev->mutex))
+       if (mutex_lock_interruptible(&dmxdev->mutex))
                return -ERESTARTSYS;
 
        switch (cmd) {
        case DMX_START:
-               if (down_interruptible(&dmxdevfilter->mutex)) {
-                       up(&dmxdev->mutex);
+               if (mutex_lock_interruptible(&dmxdevfilter->mutex)) {
+                       mutex_unlock(&dmxdev->mutex);
                        return -ERESTARTSYS;
                }
                if (dmxdevfilter->state<DMXDEV_STATE_SET)
                        ret = -EINVAL;
                else
                        ret = dvb_dmxdev_filter_start(dmxdevfilter);
-               up(&dmxdevfilter->mutex);
+               mutex_unlock(&dmxdevfilter->mutex);
                break;
 
        case DMX_STOP:
-               if (down_interruptible(&dmxdevfilter->mutex)) {
-                       up(&dmxdev->mutex);
+               if (mutex_lock_interruptible(&dmxdevfilter->mutex)) {
+                       mutex_unlock(&dmxdev->mutex);
                        return -ERESTARTSYS;
                }
                ret=dvb_dmxdev_filter_stop(dmxdevfilter);
-               up(&dmxdevfilter->mutex);
+               mutex_unlock(&dmxdevfilter->mutex);
                break;
 
        case DMX_SET_FILTER:
-               if (down_interruptible(&dmxdevfilter->mutex)) {
-                       up(&dmxdev->mutex);
+               if (mutex_lock_interruptible(&dmxdevfilter->mutex)) {
+                       mutex_unlock(&dmxdev->mutex);
                        return -ERESTARTSYS;
                }
                ret = dvb_dmxdev_filter_set(dmxdev, dmxdevfilter,
                                    (struct dmx_sct_filter_params *)parg);
-               up(&dmxdevfilter->mutex);
+               mutex_unlock(&dmxdevfilter->mutex);
                break;
 
        case DMX_SET_PES_FILTER:
-               if (down_interruptible(&dmxdevfilter->mutex)) {
-                       up(&dmxdev->mutex);
+               if (mutex_lock_interruptible(&dmxdevfilter->mutex)) {
+                       mutex_unlock(&dmxdev->mutex);
                        return -ERESTARTSYS;
                }
                ret=dvb_dmxdev_pes_filter_set(dmxdev, dmxdevfilter,
                                               (struct dmx_pes_filter_params *)parg);
-               up(&dmxdevfilter->mutex);
+               mutex_unlock(&dmxdevfilter->mutex);
                break;
 
        case DMX_SET_BUFFER_SIZE:
-               if (down_interruptible(&dmxdevfilter->mutex)) {
-                       up(&dmxdev->mutex);
+               if (mutex_lock_interruptible(&dmxdevfilter->mutex)) {
+                       mutex_unlock(&dmxdev->mutex);
                        return -ERESTARTSYS;
                }
                ret=dvb_dmxdev_set_buffer_size(dmxdevfilter, arg);
-               up(&dmxdevfilter->mutex);
+               mutex_unlock(&dmxdevfilter->mutex);
                break;
 
        case DMX_GET_EVENT:
@@ -959,7 +959,7 @@ static int dvb_demux_do_ioctl(struct inode *inode, struct file *file,
        default:
                ret=-EINVAL;
        }
-       up(&dmxdev->mutex);
+       mutex_unlock(&dmxdev->mutex);
        return ret;
 }
 
@@ -1030,7 +1030,7 @@ static int dvb_dvr_do_ioctl(struct inode *inode, struct file *file,
 
        int ret=0;
 
-       if (down_interruptible (&dmxdev->mutex))
+       if (mutex_lock_interruptible(&dmxdev->mutex))
                return -ERESTARTSYS;
 
        switch (cmd) {
@@ -1042,7 +1042,7 @@ static int dvb_dvr_do_ioctl(struct inode *inode, struct file *file,
        default:
                ret=-EINVAL;
        }
-       up(&dmxdev->mutex);
+       mutex_unlock(&dmxdev->mutex);
        return ret;
 }
 
@@ -1113,7 +1113,7 @@ dvb_dmxdev_init(struct dmxdev *dmxdev, struct dvb_adapter *dvb_adapter)
                return -ENOMEM;
        }
 
-       sema_init(&dmxdev->mutex, 1);
+       mutex_init(&dmxdev->mutex);
        spin_lock_init(&dmxdev->lock);
        for (i=0; i<dmxdev->filternum; i++) {
                dmxdev->filter[i].dev=dmxdev;
index fd72920..ec2a7a4 100644 (file)
@@ -30,7 +30,7 @@
 #include <linux/wait.h>
 #include <linux/fs.h>
 #include <linux/string.h>
-#include <asm/semaphore.h>
+#include <linux/mutex.h>
 
 #include <linux/dvb/dmx.h>
 
@@ -83,7 +83,7 @@ struct dmxdev_filter {
        struct dmxdev *dev;
        struct dmxdev_buffer buffer;
 
-       struct semaphore mutex;
+       struct mutex mutex;
 
        /* only for sections */
        struct timer_list timer;
@@ -117,7 +117,7 @@ struct dmxdev {
        struct dmxdev_buffer dvr_buffer;
 #define DVR_BUFFER_SIZE (10*188*1024)
 
-       struct semaphore mutex;
+       struct mutex mutex;
        spinlock_t lock;
 };
 
index b4c899b..83ec5e0 100644 (file)
@@ -589,18 +589,18 @@ static int dmx_ts_feed_set(struct dmx_ts_feed *ts_feed, u16 pid, int ts_type,
        if (pid > DMX_MAX_PID)
                return -EINVAL;
 
-       if (down_interruptible(&demux->mutex))
+       if (mutex_lock_interruptible(&demux->mutex))
                return -ERESTARTSYS;
 
        if (ts_type & TS_DECODER) {
                if (pes_type >= DMX_TS_PES_OTHER) {
-                       up(&demux->mutex);
+                       mutex_unlock(&demux->mutex);
                        return -EINVAL;
                }
 
                if (demux->pesfilter[pes_type] &&
                    demux->pesfilter[pes_type] != feed) {
-                       up(&demux->mutex);
+                       mutex_unlock(&demux->mutex);
                        return -EINVAL;
                }
 
@@ -622,14 +622,14 @@ static int dmx_ts_feed_set(struct dmx_ts_feed *ts_feed, u16 pid, int ts_type,
 #else
                feed->buffer = vmalloc(feed->buffer_size);
                if (!feed->buffer) {
-                       up(&demux->mutex);
+                       mutex_unlock(&demux->mutex);
                        return -ENOMEM;
                }
 #endif
        }
 
        feed->state = DMX_STATE_READY;
-       up(&demux->mutex);
+       mutex_unlock(&demux->mutex);
 
        return 0;
 }
@@ -640,21 +640,21 @@ static int dmx_ts_feed_start_filtering(struct dmx_ts_feed *ts_feed)
        struct dvb_demux *demux = feed->demux;
        int ret;
 
-       if (down_interruptible(&demux->mutex))
+       if (mutex_lock_interruptible(&demux->mutex))
                return -ERESTARTSYS;
 
        if (feed->state != DMX_STATE_READY || feed->type != DMX_TYPE_TS) {
-               up(&demux->mutex);
+               mutex_unlock(&demux->mutex);
                return -EINVAL;
        }
 
        if (!demux->start_feed) {
-               up(&demux->mutex);
+               mutex_unlock(&demux->mutex);
                return -ENODEV;
        }
 
        if ((ret = demux->start_feed(feed)) < 0) {
-               up(&demux->mutex);
+               mutex_unlock(&demux->mutex);
                return ret;
        }
 
@@ -662,7 +662,7 @@ static int dmx_ts_feed_start_filtering(struct dmx_ts_feed *ts_feed)
        ts_feed->is_filtering = 1;
        feed->state = DMX_STATE_GO;
        spin_unlock_irq(&demux->lock);
-       up(&demux->mutex);
+       mutex_unlock(&demux->mutex);
 
        return 0;
 }
@@ -673,16 +673,16 @@ static int dmx_ts_feed_stop_filtering(struct dmx_ts_feed *ts_feed)
        struct dvb_demux *demux = feed->demux;
        int ret;
 
-       if (down_interruptible(&demux->mutex))
+       if (mutex_lock_interruptible(&demux->mutex))
                return -ERESTARTSYS;
 
        if (feed->state < DMX_STATE_GO) {
-               up(&demux->mutex);
+               mutex_unlock(&demux->mutex);
                return -EINVAL;
        }
 
        if (!demux->stop_feed) {
-               up(&demux->mutex);
+               mutex_unlock(&demux->mutex);
                return -ENODEV;
        }
 
@@ -692,7 +692,7 @@ static int dmx_ts_feed_stop_filtering(struct dmx_ts_feed *ts_feed)
        ts_feed->is_filtering = 0;
        feed->state = DMX_STATE_ALLOCATED;
        spin_unlock_irq(&demux->lock);
-       up(&demux->mutex);
+       mutex_unlock(&demux->mutex);
 
        return ret;
 }
@@ -704,11 +704,11 @@ static int dvbdmx_allocate_ts_feed(struct dmx_demux *dmx,
        struct dvb_demux *demux = (struct dvb_demux *)dmx;
        struct dvb_demux_feed *feed;
 
-       if (down_interruptible(&demux->mutex))
+       if (mutex_lock_interruptible(&demux->mutex))
                return -ERESTARTSYS;
 
        if (!(feed = dvb_dmx_feed_alloc(demux))) {
-               up(&demux->mutex);
+               mutex_unlock(&demux->mutex);
                return -EBUSY;
        }
 
@@ -729,7 +729,7 @@ static int dvbdmx_allocate_ts_feed(struct dmx_demux *dmx,
 
        if (!(feed->filter = dvb_dmx_filter_alloc(demux))) {
                feed->state = DMX_STATE_FREE;
-               up(&demux->mutex);
+               mutex_unlock(&demux->mutex);
                return -EBUSY;
        }
 
@@ -737,7 +737,7 @@ static int dvbdmx_allocate_ts_feed(struct dmx_demux *dmx,
        feed->filter->feed = feed;
        feed->filter->state = DMX_STATE_READY;
 
-       up(&demux->mutex);
+       mutex_unlock(&demux->mutex);
 
        return 0;
 }
@@ -748,11 +748,11 @@ static int dvbdmx_release_ts_feed(struct dmx_demux *dmx,
        struct dvb_demux *demux = (struct dvb_demux *)dmx;
        struct dvb_demux_feed *feed = (struct dvb_demux_feed *)ts_feed;
 
-       if (down_interruptible(&demux->mutex))
+       if (mutex_lock_interruptible(&demux->mutex))
                return -ERESTARTSYS;
 
        if (feed->state == DMX_STATE_FREE) {
-               up(&demux->mutex);
+               mutex_unlock(&demux->mutex);
                return -EINVAL;
        }
 #ifndef NOBUFS
@@ -770,7 +770,7 @@ static int dvbdmx_release_ts_feed(struct dmx_demux *dmx,
        if (feed->ts_type & TS_DECODER && feed->pes_type < DMX_TS_PES_OTHER)
                demux->pesfilter[feed->pes_type] = NULL;
 
-       up(&demux->mutex);
+       mutex_unlock(&demux->mutex);
        return 0;
 }
 
@@ -785,12 +785,12 @@ static int dmx_section_feed_allocate_filter(struct dmx_section_feed *feed,
        struct dvb_demux *dvbdemux = dvbdmxfeed->demux;
        struct dvb_demux_filter *dvbdmxfilter;
 
-       if (down_interruptible(&dvbdemux->mutex))
+       if (mutex_lock_interruptible(&dvbdemux->mutex))
                return -ERESTARTSYS;
 
        dvbdmxfilter = dvb_dmx_filter_alloc(dvbdemux);
        if (!dvbdmxfilter) {
-               up(&dvbdemux->mutex);
+               mutex_unlock(&dvbdemux->mutex);
                return -EBUSY;
        }
 
@@ -805,7 +805,7 @@ static int dmx_section_feed_allocate_filter(struct dmx_section_feed *feed,
        dvbdmxfeed->filter = dvbdmxfilter;
        spin_unlock_irq(&dvbdemux->lock);
 
-       up(&dvbdemux->mutex);
+       mutex_unlock(&dvbdemux->mutex);
        return 0;
 }
 
@@ -819,7 +819,7 @@ static int dmx_section_feed_set(struct dmx_section_feed *feed,
        if (pid > 0x1fff)
                return -EINVAL;
 
-       if (down_interruptible(&dvbdmx->mutex))
+       if (mutex_lock_interruptible(&dvbdmx->mutex))
                return -ERESTARTSYS;
 
        dvb_demux_feed_add(dvbdmxfeed);
@@ -833,13 +833,13 @@ static int dmx_section_feed_set(struct dmx_section_feed *feed,
 #else
        dvbdmxfeed->buffer = vmalloc(dvbdmxfeed->buffer_size);
        if (!dvbdmxfeed->buffer) {
-               up(&dvbdmx->mutex);
+               mutex_unlock(&dvbdmx->mutex);
                return -ENOMEM;
        }
 #endif
 
        dvbdmxfeed->state = DMX_STATE_READY;
-       up(&dvbdmx->mutex);
+       mutex_unlock(&dvbdmx->mutex);
        return 0;
 }
 
@@ -871,16 +871,16 @@ static int dmx_section_feed_start_filtering(struct dmx_section_feed *feed)
        struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
        int ret;
 
-       if (down_interruptible(&dvbdmx->mutex))
+       if (mutex_lock_interruptible(&dvbdmx->mutex))
                return -ERESTARTSYS;
 
        if (feed->is_filtering) {
-               up(&dvbdmx->mutex);
+               mutex_unlock(&dvbdmx->mutex);
                return -EBUSY;
        }
 
        if (!dvbdmxfeed->filter) {
-               up(&dvbdmx->mutex);
+               mutex_unlock(&dvbdmx->mutex);
                return -EINVAL;
        }
 
@@ -890,14 +890,14 @@ static int dmx_section_feed_start_filtering(struct dmx_section_feed *feed)
        dvbdmxfeed->feed.sec.seclen = 0;
 
        if (!dvbdmx->start_feed) {
-               up(&dvbdmx->mutex);
+               mutex_unlock(&dvbdmx->mutex);
                return -ENODEV;
        }
 
        prepare_secfilters(dvbdmxfeed);
 
        if ((ret = dvbdmx->start_feed(dvbdmxfeed)) < 0) {
-               up(&dvbdmx->mutex);
+               mutex_unlock(&dvbdmx->mutex);
                return ret;
        }
 
@@ -906,7 +906,7 @@ static int dmx_section_feed_start_filtering(struct dmx_section_feed *feed)
        dvbdmxfeed->state = DMX_STATE_GO;
        spin_unlock_irq(&dvbdmx->lock);
 
-       up(&dvbdmx->mutex);
+       mutex_unlock(&dvbdmx->mutex);
        return 0;
 }
 
@@ -916,11 +916,11 @@ static int dmx_section_feed_stop_filtering(struct dmx_section_feed *feed)
        struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
        int ret;
 
-       if (down_interruptible(&dvbdmx->mutex))
+       if (mutex_lock_interruptible(&dvbdmx->mutex))
                return -ERESTARTSYS;
 
        if (!dvbdmx->stop_feed) {
-               up(&dvbdmx->mutex);
+               mutex_unlock(&dvbdmx->mutex);
                return -ENODEV;
        }
 
@@ -931,7 +931,7 @@ static int dmx_section_feed_stop_filtering(struct dmx_section_feed *feed)
        feed->is_filtering = 0;
        spin_unlock_irq(&dvbdmx->lock);
 
-       up(&dvbdmx->mutex);
+       mutex_unlock(&dvbdmx->mutex);
        return ret;
 }
 
@@ -942,11 +942,11 @@ static int dmx_section_feed_release_filter(struct dmx_section_feed *feed,
        struct dvb_demux_feed *dvbdmxfeed = (struct dvb_demux_feed *)feed;
        struct dvb_demux *dvbdmx = dvbdmxfeed->demux;
 
-       if (down_interruptible(&dvbdmx->mutex))
+       if (mutex_lock_interruptible(&dvbdmx->mutex))
                return -ERESTARTSYS;
 
        if (dvbdmxfilter->feed != dvbdmxfeed) {
-               up(&dvbdmx->mutex);
+               mutex_unlock(&dvbdmx->mutex);
                return -EINVAL;
        }
 
@@ -966,7 +966,7 @@ static int dmx_section_feed_release_filter(struct dmx_section_feed *feed,
 
        dvbdmxfilter->state = DMX_STATE_FREE;
        spin_unlock_irq(&dvbdmx->lock);
-       up(&dvbdmx->mutex);
+       mutex_unlock(&dvbdmx->mutex);
        return 0;
 }
 
@@ -977,11 +977,11 @@ static int dvbdmx_allocate_section_feed(struct dmx_demux *demux,
        struct dvb_demux *dvbdmx = (struct dvb_demux *)demux;
        struct dvb_demux_feed *dvbdmxfeed;
 
-       if (down_interruptible(&dvbdmx->mutex))
+       if (mutex_lock_interruptible(&dvbdmx->mutex))
                return -ERESTARTSYS;
 
        if (!(dvbdmxfeed = dvb_dmx_feed_alloc(dvbdmx))) {
-               up(&dvbdmx->mutex);
+               mutex_unlock(&dvbdmx->mutex);
                return -EBUSY;
        }
 
@@ -1006,7 +1006,7 @@ static int dvbdmx_allocate_section_feed(struct dmx_demux *demux,
        (*feed)->stop_filtering = dmx_section_feed_stop_filtering;
        (*feed)->release_filter = dmx_section_feed_release_filter;
 
-       up(&dvbdmx->mutex);
+       mutex_unlock(&dvbdmx->mutex);
        return 0;
 }
 
@@ -1016,11 +1016,11 @@ static int dvbdmx_release_section_feed(struct dmx_demux *demux,
        struct dvb_demux_feed *dvbdmxfeed = (struct dvb_demux_feed *)feed;
        struct dvb_demux *dvbdmx = (struct dvb_demux *)demux;
 
-       if (down_interruptible(&dvbdmx->mutex))
+       if (mutex_lock_interruptible(&dvbdmx->mutex))
                return -ERESTARTSYS;
 
        if (dvbdmxfeed->state == DMX_STATE_FREE) {
-               up(&dvbdmx->mutex);
+               mutex_unlock(&dvbdmx->mutex);
                return -EINVAL;
        }
 #ifndef NOBUFS
@@ -1033,7 +1033,7 @@ static int dvbdmx_release_section_feed(struct dmx_demux *demux,
 
        dvbdmxfeed->pid = 0xffff;
 
-       up(&dvbdmx->mutex);
+       mutex_unlock(&dvbdmx->mutex);
        return 0;
 }
 
@@ -1071,10 +1071,10 @@ static int dvbdmx_write(struct dmx_demux *demux, const char *buf, size_t count)
        if ((!demux->frontend) || (demux->frontend->source != DMX_MEMORY_FE))
                return -EINVAL;
 
-       if (down_interruptible(&dvbdemux->mutex))
+       if (mutex_lock_interruptible(&dvbdemux->mutex))
                return -ERESTARTSYS;
        dvb_dmx_swfilter(dvbdemux, buf, count);
-       up(&dvbdemux->mutex);
+       mutex_unlock(&dvbdemux->mutex);
 
        if (signal_pending(current))
                return -EINTR;
@@ -1126,11 +1126,11 @@ static int dvbdmx_connect_frontend(struct dmx_demux *demux,
        if (demux->frontend)
                return -EINVAL;
 
-       if (down_interruptible(&dvbdemux->mutex))
+       if (mutex_lock_interruptible(&dvbdemux->mutex))
                return -ERESTARTSYS;
 
        demux->frontend = frontend;
-       up(&dvbdemux->mutex);
+       mutex_unlock(&dvbdemux->mutex);
        return 0;
 }
 
@@ -1138,11 +1138,11 @@ static int dvbdmx_disconnect_frontend(struct dmx_demux *demux)
 {
        struct dvb_demux *dvbdemux = (struct dvb_demux *)demux;
 
-       if (down_interruptible(&dvbdemux->mutex))
+       if (mutex_lock_interruptible(&dvbdemux->mutex))
                return -ERESTARTSYS;
 
        demux->frontend = NULL;
-       up(&dvbdemux->mutex);
+       mutex_unlock(&dvbdemux->mutex);
        return 0;
 }
 
@@ -1215,7 +1215,7 @@ int dvb_dmx_init(struct dvb_demux *dvbdemux)
        dmx->disconnect_frontend = dvbdmx_disconnect_frontend;
        dmx->get_pes_pids = dvbdmx_get_pes_pids;
 
-       sema_init(&dvbdemux->mutex, 1);
+       mutex_init(&dvbdemux->mutex);
        spin_lock_init(&dvbdemux->lock);
 
        return 0;
index 0cc8883..2c5f915 100644 (file)
@@ -26,7 +26,7 @@
 #include <linux/time.h>
 #include <linux/timer.h>
 #include <linux/spinlock.h>
-#include <asm/semaphore.h>
+#include <linux/mutex.h>
 
 #include "demux.h"
 
@@ -125,7 +125,7 @@ struct dvb_demux {
        u8 tsbuf[204];
        int tsbufp;
 
-       struct semaphore mutex;
+       struct mutex mutex;
        spinlock_t lock;
 };
 
index 771f32d..22e96cf 100644 (file)
@@ -37,7 +37,6 @@
 #include <linux/suspend.h>
 #include <linux/jiffies.h>
 #include <asm/processor.h>
-#include <asm/semaphore.h>
 
 #include "dvb_frontend.h"
 #include "dvbdev.h"
@@ -88,7 +87,7 @@ MODULE_PARM_DESC(dvb_powerdown_on_sleep, "0: do not power down, 1: turn LNB vola
  * FESTATE_LOSTLOCK. When the lock has been lost, and we're searching it again.
  */
 
-static DECLARE_MUTEX(frontend_mutex);
+static DEFINE_MUTEX(frontend_mutex);
 
 struct dvb_frontend_private {
 
@@ -1021,12 +1020,12 @@ int dvb_register_frontend(struct dvb_adapter* dvb,
 
        dprintk ("%s\n", __FUNCTION__);
 
-       if (down_interruptible (&frontend_mutex))
+       if (mutex_lock_interruptible(&frontend_mutex))
                return -ERESTARTSYS;
 
        fe->frontend_priv = kzalloc(sizeof(struct dvb_frontend_private), GFP_KERNEL);
        if (fe->frontend_priv == NULL) {
-               up(&frontend_mutex);
+               mutex_unlock(&frontend_mutex);
                return -ENOMEM;
        }
        fepriv = fe->frontend_priv;
@@ -1045,7 +1044,7 @@ int dvb_register_frontend(struct dvb_adapter* dvb,
        dvb_register_device (fe->dvb, &fepriv->dvbdev, &dvbdev_template,
                             fe, DVB_DEVICE_FRONTEND);
 
-       up (&frontend_mutex);
+       mutex_unlock(&frontend_mutex);
        return 0;
 }
 EXPORT_SYMBOL(dvb_register_frontend);
@@ -1055,7 +1054,7 @@ int dvb_unregister_frontend(struct dvb_frontend* fe)
        struct dvb_frontend_private *fepriv = fe->frontend_priv;
        dprintk ("%s\n", __FUNCTION__);
 
-       down (&frontend_mutex);
+       mutex_lock(&frontend_mutex);
        dvb_unregister_device (fepriv->dvbdev);
        dvb_frontend_stop (fe);
        if (fe->ops->release)
@@ -1064,7 +1063,7 @@ int dvb_unregister_frontend(struct dvb_frontend* fe)
                printk("dvb_frontend: Demodulator (%s) does not have a release callback!\n", fe->ops->info.name);
        /* fe is invalid now */
        kfree(fepriv);
-       up (&frontend_mutex);
+       mutex_unlock(&frontend_mutex);
        return 0;
 }
 EXPORT_SYMBOL(dvb_unregister_frontend);
index 6711eb6..2f0f358 100644 (file)
@@ -62,6 +62,7 @@
 #include <linux/uio.h>
 #include <asm/uaccess.h>
 #include <linux/crc32.h>
+#include <linux/mutex.h>
 
 #include "dvb_demux.h"
 #include "dvb_net.h"
@@ -151,8 +152,7 @@ struct dvb_net_priv {
        unsigned char ule_bridged;              /* Whether the ULE_BRIDGED extension header was found. */
        int ule_sndu_remain;                    /* Nr. of bytes still required for current ULE SNDU. */
        unsigned long ts_count;                 /* Current ts cell counter. */
-
-       struct semaphore mutex;
+       struct mutex mutex;
 };
 
 
@@ -889,7 +889,7 @@ static int dvb_net_feed_start(struct net_device *dev)
        unsigned char *mac = (unsigned char *) dev->dev_addr;
 
        dprintk("%s: rx_mode %i\n", __FUNCTION__, priv->rx_mode);
-       down(&priv->mutex);
+       mutex_lock(&priv->mutex);
        if (priv->tsfeed || priv->secfeed || priv->secfilter || priv->multi_secfilter[0])
                printk("%s: BUG %d\n", __FUNCTION__, __LINE__);
 
@@ -974,7 +974,7 @@ static int dvb_net_feed_start(struct net_device *dev)
                ret = -EINVAL;
 
 error:
-       up(&priv->mutex);
+       mutex_unlock(&priv->mutex);
        return ret;
 }
 
@@ -984,7 +984,7 @@ static int dvb_net_feed_stop(struct net_device *dev)
        int i, ret = 0;
 
        dprintk("%s\n", __FUNCTION__);
-       down(&priv->mutex);
+       mutex_lock(&priv->mutex);
        if (priv->feedtype == DVB_NET_FEEDTYPE_MPE) {
                if (priv->secfeed) {
                        if (priv->secfeed->is_filtering) {
@@ -1026,7 +1026,7 @@ static int dvb_net_feed_stop(struct net_device *dev)
                        printk("%s: no ts feed to stop\n", dev->name);
        } else
                ret = -EINVAL;
-       up(&priv->mutex);
+       mutex_unlock(&priv->mutex);
        return ret;
 }
 
@@ -1208,7 +1208,7 @@ static int dvb_net_add_if(struct dvb_net *dvbnet, u16 pid, u8 feedtype)
 
        INIT_WORK(&priv->set_multicast_list_wq, wq_set_multicast_list, net);
        INIT_WORK(&priv->restart_net_feed_wq, wq_restart_net_feed, net);
-       init_MUTEX(&priv->mutex);
+       mutex_init(&priv->mutex);
 
        net->base_addr = pid;
 
index f327fac..e62a293 100644 (file)
@@ -77,7 +77,7 @@ static int cxusb_i2c_xfer(struct i2c_adapter *adap,struct i2c_msg msg[],int num)
        struct dvb_usb_device *d = i2c_get_adapdata(adap);
        int i;
 
-       if (down_interruptible(&d->i2c_sem) < 0)
+       if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
                return -EAGAIN;
 
        if (num > 2)
@@ -126,7 +126,7 @@ static int cxusb_i2c_xfer(struct i2c_adapter *adap,struct i2c_msg msg[],int num)
                }
        }
 
-       up(&d->i2c_sem);
+       mutex_unlock(&d->i2c_mutex);
        return i;
 }
 
index 269d899..2d52b76 100644 (file)
@@ -128,7 +128,7 @@ static int dibusb_i2c_xfer(struct i2c_adapter *adap,struct i2c_msg msg[],int num
        struct dvb_usb_device *d = i2c_get_adapdata(adap);
        int i;
 
-       if (down_interruptible(&d->i2c_sem) < 0)
+       if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
                return -EAGAIN;
 
        if (num > 2)
@@ -146,7 +146,7 @@ static int dibusb_i2c_xfer(struct i2c_adapter *adap,struct i2c_msg msg[],int num
                                break;
        }
 
-       up(&d->i2c_sem);
+       mutex_unlock(&d->i2c_mutex);
        return i;
 }
 
index caa1346..91136c0 100644 (file)
@@ -48,7 +48,7 @@ static int digitv_i2c_xfer(struct i2c_adapter *adap,struct i2c_msg msg[],int num
        struct dvb_usb_device *d = i2c_get_adapdata(adap);
        int i;
 
-       if (down_interruptible(&d->i2c_sem) < 0)
+       if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
                return -EAGAIN;
 
        if (num > 2)
@@ -67,7 +67,7 @@ static int digitv_i2c_xfer(struct i2c_adapter *adap,struct i2c_msg msg[],int num
                                break;
        }
 
-       up(&d->i2c_sem);
+       mutex_unlock(&d->i2c_mutex);
        return i;
 }
 
index 716f8bf..4258a99 100644 (file)
@@ -42,8 +42,8 @@ static int dvb_usb_init(struct dvb_usb_device *d)
 {
        int ret = 0;
 
-       sema_init(&d->usb_sem, 1);
-       sema_init(&d->i2c_sem, 1);
+       mutex_init(&d->usb_mutex);
+       mutex_init(&d->i2c_mutex);
 
        d->state = DVB_USB_STATE_INIT;
 
index ee82197..9002f35 100644 (file)
@@ -21,7 +21,7 @@ int dvb_usb_generic_rw(struct dvb_usb_device *d, u8 *wbuf, u16 wlen, u8 *rbuf,
        if (wbuf == NULL || wlen == 0)
                return -EINVAL;
 
-       if ((ret = down_interruptible(&d->usb_sem)))
+       if ((ret = mutex_lock_interruptible(&d->usb_mutex)))
                return ret;
 
        deb_xfer(">>> ");
@@ -53,7 +53,7 @@ int dvb_usb_generic_rw(struct dvb_usb_device *d, u8 *wbuf, u16 wlen, u8 *rbuf,
                }
        }
 
-       up(&d->usb_sem);
+       mutex_unlock(&d->usb_mutex);
        return ret;
 }
 EXPORT_SYMBOL(dvb_usb_generic_rw);
index 5e5d21a..d2be37c 100644 (file)
@@ -12,6 +12,7 @@
 #include <linux/input.h>
 #include <linux/usb.h>
 #include <linux/firmware.h>
+#include <linux/mutex.h>
 
 #include "dvb_frontend.h"
 #include "dvb_demux.h"
@@ -227,8 +228,8 @@ struct dvb_usb_properties {
  * @feedcount: number of reqested feeds (used for streaming-activation)
  * @pid_filtering: is hardware pid_filtering used or not.
  *
- * @usb_sem: semaphore of USB control messages (reading needs two messages)
- * @i2c_sem: semaphore for i2c-transfers
+ * @usb_mutex: semaphore of USB control messages (reading needs two messages)
+ * @i2c_mutex: semaphore for i2c-transfers
  *
  * @i2c_adap: device's i2c_adapter if it uses I2CoverUSB
  * @pll_addr: I2C address of the tuner for programming
@@ -283,10 +284,10 @@ struct dvb_usb_device {
        int pid_filtering;
 
        /* locking */
-       struct semaphore usb_sem;
+       struct mutex usb_mutex;
 
        /* i2c */
-       struct semaphore i2c_sem;
+       struct mutex i2c_mutex;
        struct i2c_adapter i2c_adap;
 
        /* tuner programming information */
index 4a95eca..b2f098a 100644 (file)
@@ -75,7 +75,7 @@ int vp702x_usb_inout_op(struct dvb_usb_device *d, u8 *o, int olen, u8 *i, int il
 {
        int ret;
 
-       if ((ret = down_interruptible(&d->usb_sem)))
+       if ((ret = mutex_lock_interruptible(&d->usb_mutex)))
                return ret;
 
        if ((ret = vp702x_usb_out_op(d,REQUEST_OUT,0,0,o,olen)) < 0)
@@ -84,7 +84,7 @@ int vp702x_usb_inout_op(struct dvb_usb_device *d, u8 *o, int olen, u8 *i, int il
        ret = vp702x_usb_in_op(d,REQUEST_IN,0,0,i,ilen);
 
 unlock:
-       up(&d->usb_sem);
+       mutex_unlock(&d->usb_mutex);
 
        return ret;
 }
index 0282049..7fa656b 100644 (file)
@@ -38,7 +38,7 @@ int vp7045_usb_op(struct dvb_usb_device *d, u8 cmd, u8 *out, int outlen, u8 *in,
        deb_xfer("out buffer: ");
        debug_dump(outbuf,outlen+1,deb_xfer);
 
-       if ((ret = down_interruptible(&d->usb_sem)))
+       if ((ret = mutex_lock_interruptible(&d->usb_mutex)))
                return ret;
 
        if (usb_control_msg(d->udev,
@@ -68,7 +68,7 @@ int vp7045_usb_op(struct dvb_usb_device *d, u8 cmd, u8 *out, int outlen, u8 *in,
                memcpy(in,&inbuf[1],inlen);
 
 unlock:
-       up(&d->usb_sem);
+       mutex_unlock(&d->usb_mutex);
 
        return ret;
 }
index caaee89..1708a1d 100644 (file)
@@ -39,6 +39,7 @@
 #include <linux/jiffies.h>
 #include <linux/string.h>
 #include <linux/slab.h>
+#include <linux/mutex.h>
 
 #include "dvb_frontend.h"
 #include "bcm3510.h"
@@ -52,7 +53,7 @@ struct bcm3510_state {
        struct dvb_frontend frontend;
 
        /* demodulator private data */
-       struct semaphore hab_sem;
+       struct mutex hab_mutex;
        u8 firmware_loaded:1;
 
        unsigned long next_status_check;
@@ -213,7 +214,7 @@ static int bcm3510_do_hab_cmd(struct bcm3510_state *st, u8 cmd, u8 msgid, u8 *ob
        dbufout(ob,olen+2,deb_hab);
        deb_hab("\n");
 
-       if (down_interruptible(&st->hab_sem) < 0)
+       if (mutex_lock_interruptible(&st->hab_mutex) < 0)
                return -EAGAIN;
 
        if ((ret = bcm3510_hab_send_request(st, ob, olen+2)) < 0 ||
@@ -226,7 +227,7 @@ static int bcm3510_do_hab_cmd(struct bcm3510_state *st, u8 cmd, u8 msgid, u8 *ob
 
        memcpy(ibuf,&ib[2],ilen);
 error:
-       up(&st->hab_sem);
+       mutex_unlock(&st->hab_mutex);
        return ret;
 }
 
@@ -796,7 +797,7 @@ struct dvb_frontend* bcm3510_attach(const struct bcm3510_config *config,
        state->frontend.ops = &state->ops;
        state->frontend.demodulator_priv = state;
 
-       sema_init(&state->hab_sem, 1);
+       mutex_init(&state->hab_mutex);
 
        if ((ret = bcm3510_readB(state,0xe0,&v)) < 0)
                goto error;
index d36369e..1aa61bf 100644 (file)
@@ -54,7 +54,6 @@
 #include <linux/i2c.h>
 
 #include <asm/system.h>
-#include <asm/semaphore.h>
 
 #include <linux/dvb/frontend.h>
 
@@ -242,10 +241,10 @@ static int arm_thread(void *data)
                if (!av7110->arm_ready)
                        continue;
 
-               if (down_interruptible(&av7110->dcomlock))
+               if (mutex_lock_interruptible(&av7110->dcomlock))
                        break;
                newloops = rdebi(av7110, DEBINOSWAP, STATUS_LOOPS, 0, 2);
-               up(&av7110->dcomlock);
+               mutex_unlock(&av7110->dcomlock);
 
                if (newloops == av7110->arm_loops || av7110->arm_errors > 3) {
                        printk(KERN_ERR "dvb-ttpci: ARM crashed @ card %d\n",
@@ -253,10 +252,10 @@ static int arm_thread(void *data)
 
                        recover_arm(av7110);
 
-                       if (down_interruptible(&av7110->dcomlock))
+                       if (mutex_lock_interruptible(&av7110->dcomlock))
                                break;
                        newloops = rdebi(av7110, DEBINOSWAP, STATUS_LOOPS, 0, 2) - 1;
-                       up(&av7110->dcomlock);
+                       mutex_unlock(&av7110->dcomlock);
                }
                av7110->arm_loops = newloops;
                av7110->arm_errors = 0;
@@ -741,7 +740,7 @@ int ChangePIDs(struct av7110 *av7110, u16 vpid, u16 apid, u16 ttpid,
        int ret = 0;
        dprintk(4, "%p\n", av7110);
 
-       if (down_interruptible(&av7110->pid_mutex))
+       if (mutex_lock_interruptible(&av7110->pid_mutex))
                return -ERESTARTSYS;
 
        if (!(vpid & 0x8000))
@@ -760,7 +759,7 @@ int ChangePIDs(struct av7110 *av7110, u16 vpid, u16 apid, u16 ttpid,
                ret = SetPIDs(av7110, vpid, apid, ttpid, subpid, pcrpid);
        }
 
-       up(&av7110->pid_mutex);
+       mutex_unlock(&av7110->pid_mutex);
        return ret;
 }
 
@@ -2096,7 +2095,7 @@ static int av7110_fe_lock_fix(struct av7110* av7110, fe_status_t status)
        if (av7110->playing)
                return 0;
 
-       if (down_interruptible(&av7110->pid_mutex))
+       if (mutex_lock_interruptible(&av7110->pid_mutex))
                return -ERESTARTSYS;
 
        if (synced) {
@@ -2118,7 +2117,7 @@ static int av7110_fe_lock_fix(struct av7110* av7110, fe_status_t status)
        if (!ret)
                av7110->fe_synced = synced;
 
-       up(&av7110->pid_mutex);
+       mutex_unlock(&av7110->pid_mutex);
        return ret;
 }
 
@@ -2713,16 +2712,16 @@ static int av7110_attach(struct saa7146_dev* dev, struct saa7146_pci_extension_d
        tasklet_init (&av7110->debi_tasklet, debiirq, (unsigned long) av7110);
        tasklet_init (&av7110->gpio_tasklet, gpioirq, (unsigned long) av7110);
 
-       sema_init(&av7110->pid_mutex, 1);
+       mutex_init(&av7110->pid_mutex);
 
        /* locks for data transfers from/to AV7110 */
        spin_lock_init(&av7110->debilock);
-       sema_init(&av7110->dcomlock, 1);
+       mutex_init(&av7110->dcomlock);
        av7110->debitype = -1;
 
        /* default OSD window */
        av7110->osdwin = 1;
-       sema_init(&av7110->osd_sema, 1);
+       mutex_init(&av7110->osd_mutex);
 
        /* ARM "watchdog" */
        init_waitqueue_head(&av7110->arm_wait);
index fafd25f..3e2e121 100644 (file)
@@ -16,6 +16,7 @@
 #include <linux/dvb/ca.h>
 #include <linux/dvb/osd.h>
 #include <linux/dvb/net.h>
+#include <linux/mutex.h>
 
 #include "dvbdev.h"
 #include "demux.h"
@@ -127,7 +128,7 @@ struct av7110 {
        /* DEBI and polled command interface */
 
        spinlock_t              debilock;
-       struct semaphore        dcomlock;
+       struct mutex            dcomlock;
        volatile int            debitype;
        volatile int            debilen;
 
@@ -146,7 +147,7 @@ struct av7110 {
 
        int                     osdwin;      /* currently active window */
        u16                     osdbpp[8];
-       struct semaphore        osd_sema;
+       struct mutex            osd_mutex;
 
        /* CA */
 
@@ -172,7 +173,7 @@ struct av7110 {
        struct tasklet_struct   vpe_tasklet;
 
        int                     fe_synced;
-       struct semaphore        pid_mutex;
+       struct mutex            pid_mutex;
 
        int                     video_blank;
        struct video_status     videostate;
index b2e63e9..3c5366d 100644 (file)
@@ -324,10 +324,10 @@ int av7110_wait_msgstate(struct av7110 *av7110, u16 flags)
        start = jiffies;
        for (;;) {
                err = time_after(jiffies, start + ARM_WAIT_FREE);
-               if (down_interruptible(&av7110->dcomlock))
+               if (mutex_lock_interruptible(&av7110->dcomlock))
                        return -ERESTARTSYS;
                stat = rdebi(av7110, DEBINOSWAP, MSGSTATE, 0, 2);
-               up(&av7110->dcomlock);
+               mutex_unlock(&av7110->dcomlock);
                if ((stat & flags) == 0)
                        break;
                if (err) {
@@ -484,11 +484,11 @@ static int av7110_send_fw_cmd(struct av7110 *av7110, u16* buf, int length)
                dprintk(1, "arm not ready.\n");
                return -1;
        }
-       if (down_interruptible(&av7110->dcomlock))
+       if (mutex_lock_interruptible(&av7110->dcomlock))
                return -ERESTARTSYS;
 
        ret = __av7110_send_fw_cmd(av7110, buf, length);
-       up(&av7110->dcomlock);
+       mutex_unlock(&av7110->dcomlock);
        if (ret && ret!=-ERESTARTSYS)
                printk(KERN_ERR "dvb-ttpci: %s(): av7110_send_fw_cmd error %d\n",
                       __FUNCTION__, ret);
@@ -560,11 +560,11 @@ int av7110_fw_request(struct av7110 *av7110, u16 *request_buf,
                return -1;
        }
 
-       if (down_interruptible(&av7110->dcomlock))
+       if (mutex_lock_interruptible(&av7110->dcomlock))
                return -ERESTARTSYS;
 
        if ((err = __av7110_send_fw_cmd(av7110, request_buf, request_buf_len)) < 0) {
-               up(&av7110->dcomlock);
+               mutex_unlock(&av7110->dcomlock);
                printk(KERN_ERR "dvb-ttpci: av7110_fw_request error %d\n", err);
                return err;
        }
@@ -576,7 +576,7 @@ int av7110_fw_request(struct av7110 *av7110, u16 *request_buf,
                        break;
                if (err) {
                        printk(KERN_ERR "%s: timeout waiting for COMMAND to complete\n", __FUNCTION__);
-                       up(&av7110->dcomlock);
+                       mutex_unlock(&av7110->dcomlock);
                        return -ETIMEDOUT;
                }
 #ifdef _NOHANDSHAKE
@@ -592,7 +592,7 @@ int av7110_fw_request(struct av7110 *av7110, u16 *request_buf,
                        break;
                if (err) {
                        printk(KERN_ERR "%s: timeout waiting for HANDSHAKE_REG\n", __FUNCTION__);
-                       up(&av7110->dcomlock);
+                       mutex_unlock(&av7110->dcomlock);
                        return -ETIMEDOUT;
                }
                msleep(1);
@@ -603,12 +603,12 @@ int av7110_fw_request(struct av7110 *av7110, u16 *request_buf,
        stat = rdebi(av7110, DEBINOSWAP, MSGSTATE, 0, 2);
        if (stat & GPMQOver) {
                printk(KERN_ERR "%s: GPMQOver\n", __FUNCTION__);
-               up(&av7110->dcomlock);
+               mutex_unlock(&av7110->dcomlock);
                return -1;
        }
        else if (stat & OSDQOver) {
                printk(KERN_ERR "%s: OSDQOver\n", __FUNCTION__);
-               up(&av7110->dcomlock);
+               mutex_unlock(&av7110->dcomlock);
                return -1;
        }
 #endif
@@ -616,7 +616,7 @@ int av7110_fw_request(struct av7110 *av7110, u16 *request_buf,
        for (i = 0; i < reply_buf_len; i++)
                reply_buf[i] = rdebi(av7110, DEBINOSWAP, COM_BUFF + 2 * i, 0, 2);
 
-       up(&av7110->dcomlock);
+       mutex_unlock(&av7110->dcomlock);
        return 0;
 }
 
@@ -732,7 +732,7 @@ static int FlushText(struct av7110 *av7110)
        unsigned long start;
        int err;
 
-       if (down_interruptible(&av7110->dcomlock))
+       if (mutex_lock_interruptible(&av7110->dcomlock))
                return -ERESTARTSYS;
        start = jiffies;
        while (1) {
@@ -742,12 +742,12 @@ static int FlushText(struct av7110 *av7110)
                if (err) {
                        printk(KERN_ERR "dvb-ttpci: %s(): timeout waiting for BUFF1_BASE == 0\n",
                               __FUNCTION__);
-                       up(&av7110->dcomlock);
+                       mutex_unlock(&av7110->dcomlock);
                        return -ETIMEDOUT;
                }
                msleep(1);
        }
-       up(&av7110->dcomlock);
+       mutex_unlock(&av7110->dcomlock);
        return 0;
 }
 
@@ -758,7 +758,7 @@ static int WriteText(struct av7110 *av7110, u8 win, u16 x, u16 y, u8* buf)
        int length = strlen(buf) + 1;
        u16 cbuf[5] = { (COMTYPE_OSD << 8) + DText, 3, win, x, y };
 
-       if (down_interruptible(&av7110->dcomlock))
+       if (mutex_lock_interruptible(&av7110->dcomlock))
                return -ERESTARTSYS;
 
        start = jiffies;
@@ -769,7 +769,7 @@ static int WriteText(struct av7110 *av7110, u8 win, u16 x, u16 y, u8* buf)
                if (ret) {
                        printk(KERN_ERR "dvb-ttpci: %s: timeout waiting for BUFF1_BASE == 0\n",
                               __FUNCTION__);
-                       up(&av7110->dcomlock);
+                       mutex_unlock(&av7110->dcomlock);
                        return -ETIMEDOUT;
                }
                msleep(1);
@@ -783,7 +783,7 @@ static int WriteText(struct av7110 *av7110, u8 win, u16 x, u16 y, u8* buf)
                if (ret) {
                        printk(KERN_ERR "dvb-ttpci: %s: timeout waiting for HANDSHAKE_REG\n",
                               __FUNCTION__);
-                       up(&av7110->dcomlock);
+                       mutex_unlock(&av7110->dcomlock);
                        return -ETIMEDOUT;
                }
                msleep(1);
@@ -795,7 +795,7 @@ static int WriteText(struct av7110 *av7110, u8 win, u16 x, u16 y, u8* buf)
        if (length & 1)
                wdebi(av7110, DEBINOSWAP, BUFF1_BASE + i * 2, 0, 2);
        ret = __av7110_send_fw_cmd(av7110, cbuf, 5);
-       up(&av7110->dcomlock);
+       mutex_unlock(&av7110->dcomlock);
        if (ret && ret!=-ERESTARTSYS)
                printk(KERN_ERR "dvb-ttpci: WriteText error %d\n", ret);
        return ret;
@@ -1059,7 +1059,7 @@ int av7110_osd_cmd(struct av7110 *av7110, osd_cmd_t *dc)
 {
        int ret;
 
-       if (down_interruptible(&av7110->osd_sema))
+       if (mutex_lock_interruptible(&av7110->osd_mutex))
                return -ERESTARTSYS;
 
        switch (dc->cmd) {
@@ -1195,7 +1195,7 @@ int av7110_osd_cmd(struct av7110 *av7110, osd_cmd_t *dc)
                break;
        }
 
-       up(&av7110->osd_sema);
+       mutex_unlock(&av7110->osd_mutex);
        if (ret==-ERESTARTSYS)
                dprintk(1, "av7110_osd_cmd(%d) returns with -ERESTARTSYS\n",dc->cmd);
        else if (ret)
index c7bb63c..4ac0f4d 100644 (file)
@@ -10,6 +10,8 @@
 #include "dvb_net.h"
 
 #include <linux/module.h>
+#include <linux/mutex.h>
+
 #include <media/saa7146.h>
 
 extern int budget_debug;
@@ -51,7 +53,7 @@ struct budget {
        struct dmx_frontend mem_frontend;
 
        int fe_synced;
-       struct semaphore pid_mutex;
+       struct mutex pid_mutex;
 
        int ci_present;
        int video_port;
index 5a13c47..ecb15d4 100644 (file)
@@ -19,7 +19,7 @@
 #include <linux/time.h>
 #include <linux/errno.h>
 #include <linux/jiffies.h>
-#include <asm/semaphore.h>
+#include <linux/mutex.h>
 
 #include "dvb_frontend.h"
 #include "dmxdev.h"
@@ -35,7 +35,6 @@
 #include <linux/dvb/dmx.h>
 #include <linux/pci.h>
 
-
 /*
   TTUSB_HWSECTIONS:
     the DSP supports filtering in hardware, however, since the "muxstream"
@@ -83,8 +82,8 @@ struct ttusb {
        struct dvb_net dvbnet;
 
        /* and one for USB access. */
-       struct semaphore semi2c;
-       struct semaphore semusb;
+       struct mutex semi2c;
+       struct mutex semusb;
 
        struct dvb_adapter adapter;
        struct usb_device *dev;
@@ -150,7 +149,7 @@ static int ttusb_cmd(struct ttusb *ttusb,
        printk("\n");
 #endif
 
-       if (down_interruptible(&ttusb->semusb) < 0)
+       if (mutex_lock_interruptible(&ttusb->semusb) < 0)
                return -EAGAIN;
 
        err = usb_bulk_msg(ttusb->dev, ttusb->bulk_out_pipe,
@@ -158,13 +157,13 @@ static int ttusb_cmd(struct ttusb *ttusb,
        if (err != 0) {
                dprintk("%s: usb_bulk_msg(send) failed, err == %i!\n",
                        __FUNCTION__, err);
-               up(&ttusb->semusb);
+               mutex_unlock(&ttusb->semusb);
                return err;
        }
        if (actual_len != len) {
                dprintk("%s: only wrote %d of %d bytes\n", __FUNCTION__,
                        actual_len, len);
-               up(&ttusb->semusb);
+               mutex_unlock(&ttusb->semusb);
                return -1;
        }
 
@@ -174,7 +173,7 @@ static int ttusb_cmd(struct ttusb *ttusb,
        if (err != 0) {
                printk("%s: failed, receive error %d\n", __FUNCTION__,
                       err);
-               up(&ttusb->semusb);
+               mutex_unlock(&ttusb->semusb);
                return err;
        }
 #if DEBUG >= 3
@@ -185,14 +184,14 @@ static int ttusb_cmd(struct ttusb *ttusb,
        printk("\n");
 #endif
        if (!needresult)
-               up(&ttusb->semusb);
+               mutex_unlock(&ttusb->semusb);
        return 0;
 }
 
 static int ttusb_result(struct ttusb *ttusb, u8 * data, int len)
 {
        memcpy(data, ttusb->last_result, len);
-       up(&ttusb->semusb);
+       mutex_unlock(&ttusb->semusb);
        return 0;
 }
 
@@ -250,7 +249,7 @@ static int master_xfer(struct i2c_adapter* adapter, struct i2c_msg *msg, int num
        int i = 0;
        int inc;
 
-       if (down_interruptible(&ttusb->semi2c) < 0)
+       if (mutex_lock_interruptible(&ttusb->semi2c) < 0)
                return -EAGAIN;
 
        while (i < num) {
@@ -284,7 +283,7 @@ static int master_xfer(struct i2c_adapter* adapter, struct i2c_msg *msg, int num
                i += inc;
        }
 
-       up(&ttusb->semi2c);
+       mutex_unlock(&ttusb->semi2c);
        return i;
 }
 
@@ -1495,8 +1494,11 @@ static int ttusb_probe(struct usb_interface *intf, const struct usb_device_id *i
        ttusb->dev = udev;
        ttusb->c = 0;
        ttusb->mux_state = 0;
-       sema_init(&ttusb->semi2c, 0);
-       sema_init(&ttusb->semusb, 1);
+       mutex_init(&ttusb->semi2c);
+
+       mutex_lock(&ttusb->semi2c);
+
+       mutex_init(&ttusb->semusb);
 
        ttusb_setup_interfaces(ttusb);
 
@@ -1504,7 +1506,7 @@ static int ttusb_probe(struct usb_interface *intf, const struct usb_device_id *i
        if (ttusb_init_controller(ttusb))
                printk("ttusb_init_controller: error\n");
 
-       up(&ttusb->semi2c);
+       mutex_unlock(&ttusb->semi2c);
 
        dvb_register_adapter(&ttusb->adapter, "Technotrend/Hauppauge Nova-USB", THIS_MODULE);
        ttusb->adapter.priv = ttusb;
index df83117..44dea32 100644 (file)
@@ -20,7 +20,8 @@
  *
  */
 
-#include <asm/semaphore.h>
+#include <linux/mutex.h>
+
 #include <linux/list.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
@@ -115,7 +116,7 @@ struct ttusb_dec {
        unsigned int                    out_pipe;
        unsigned int                    irq_pipe;
        enum ttusb_dec_interface        interface;
-       struct semaphore                usb_sem;
+       struct mutex                    usb_mutex;
 
        void                    *irq_buffer;
        struct urb              *irq_urb;
@@ -124,7 +125,7 @@ struct ttusb_dec {
        dma_addr_t              iso_dma_handle;
        struct urb              *iso_urb[ISO_BUF_COUNT];
        int                     iso_stream_count;
-       struct semaphore        iso_sem;
+       struct mutex            iso_mutex;
 
        u8                              packet[MAX_PVA_LENGTH + 4];
        enum ttusb_dec_packet_type      packet_type;
@@ -273,9 +274,9 @@ static int ttusb_dec_send_command(struct ttusb_dec *dec, const u8 command,
        if (!b)
                return -ENOMEM;
 
-       if ((result = down_interruptible(&dec->usb_sem))) {
+       if ((result = mutex_lock_interruptible(&dec->usb_mutex))) {
                kfree(b);
-               printk("%s: Failed to down usb semaphore.\n", __FUNCTION__);
+               printk("%s: Failed to lock usb mutex.\n", __FUNCTION__);
                return result;
        }
 
@@ -300,7 +301,7 @@ static int ttusb_dec_send_command(struct ttusb_dec *dec, const u8 command,
        if (result) {
                printk("%s: command bulk message failed: error %d\n",
                       __FUNCTION__, result);
-               up(&dec->usb_sem);
+               mutex_unlock(&dec->usb_mutex);
                kfree(b);
                return result;
        }
@@ -311,7 +312,7 @@ static int ttusb_dec_send_command(struct ttusb_dec *dec, const u8 command,
        if (result) {
                printk("%s: result bulk message failed: error %d\n",
                       __FUNCTION__, result);
-               up(&dec->usb_sem);
+               mutex_unlock(&dec->usb_mutex);
                kfree(b);
                return result;
        } else {
@@ -327,7 +328,7 @@ static int ttusb_dec_send_command(struct ttusb_dec *dec, const u8 command,
                if (cmd_result && b[3] > 0)
                        memcpy(cmd_result, &b[4], b[3]);
 
-               up(&dec->usb_sem);
+               mutex_unlock(&dec->usb_mutex);
 
                kfree(b);
                return 0;
@@ -835,7 +836,7 @@ static void ttusb_dec_stop_iso_xfer(struct ttusb_dec *dec)
 
        dprintk("%s\n", __FUNCTION__);
 
-       if (down_interruptible(&dec->iso_sem))
+       if (mutex_lock_interruptible(&dec->iso_mutex))
                return;
 
        dec->iso_stream_count--;
@@ -845,7 +846,7 @@ static void ttusb_dec_stop_iso_xfer(struct ttusb_dec *dec)
                        usb_kill_urb(dec->iso_urb[i]);
        }
 
-       up(&dec->iso_sem);
+       mutex_unlock(&dec->iso_mutex);
 }
 
 /* Setting the interface of the DEC tends to take down the USB communications
@@ -890,7 +891,7 @@ static int ttusb_dec_start_iso_xfer(struct ttusb_dec *dec)
 
        dprintk("%s\n", __FUNCTION__);
 
-       if (down_interruptible(&dec->iso_sem))
+       if (mutex_lock_interruptible(&dec->iso_mutex))
                return -EAGAIN;
 
        if (!dec->iso_stream_count) {
@@ -911,7 +912,7 @@ static int ttusb_dec_start_iso_xfer(struct ttusb_dec *dec)
                                        i--;
                                }
 
-                               up(&dec->iso_sem);
+                               mutex_unlock(&dec->iso_mutex);
                                return result;
                        }
                }
@@ -919,7 +920,7 @@ static int ttusb_dec_start_iso_xfer(struct ttusb_dec *dec)
 
        dec->iso_stream_count++;
 
-       up(&dec->iso_sem);
+       mutex_unlock(&dec->iso_mutex);
 
        return 0;
 }
@@ -1229,8 +1230,8 @@ static int ttusb_dec_init_usb(struct ttusb_dec *dec)
 {
        dprintk("%s\n", __FUNCTION__);
 
-       sema_init(&dec->usb_sem, 1);
-       sema_init(&dec->iso_sem, 1);
+       mutex_init(&dec->usb_mutex);
+       mutex_init(&dec->iso_mutex);
 
        dec->command_pipe = usb_sndbulkpipe(dec->udev, COMMAND_PIPE);
        dec->result_pipe = usb_rcvbulkpipe(dec->udev, RESULT_PIPE);
index a917a90..b602c73 100644 (file)
 #include <linux/string.h>
 #include <linux/init.h>
 #include <linux/slab.h>
-#include <asm/semaphore.h>
+#include <linux/mutex.h>
+
 #include <asm/io.h>
 #include "../../../sound/oss/aci.h"
 #include "miropcm20-rds-core.h"
 
 #define DEBUG 0
 
-static struct semaphore aci_rds_sem;
+static struct mutex aci_rds_mutex;
 
 #define RDS_DATASHIFT          2   /* Bit 2 */
 #define RDS_DATAMASK        (1 << RDS_DATASHIFT)
@@ -181,7 +182,7 @@ int aci_rds_cmd(unsigned char cmd, unsigned char databuffer[], int datasize)
 {
        int ret;
 
-       if (down_interruptible(&aci_rds_sem))
+       if (mutex_lock_interruptible(&aci_rds_mutex))
                return -EINTR;
 
        rds_write(cmd);
@@ -192,7 +193,7 @@ int aci_rds_cmd(unsigned char cmd, unsigned char databuffer[], int datasize)
        else
                ret = 0;
 
-       up(&aci_rds_sem);
+       mutex_unlock(&aci_rds_mutex);
        
        return ret;
 }
@@ -200,7 +201,7 @@ EXPORT_SYMBOL(aci_rds_cmd);
 
 int __init attach_aci_rds(void)
 {
-       init_MUTEX(&aci_rds_sem);
+       mutex_init(&aci_rds_mutex);
        return 0;
 }
 
index 914deab..557fb5c 100644 (file)
@@ -43,7 +43,7 @@
 
 static int io = CONFIG_RADIO_RTRACK_PORT; 
 static int radio_nr = -1;
-static struct semaphore lock;
+static struct mutex lock;
 
 struct rt_device
 {
@@ -83,23 +83,23 @@ static void rt_incvol(void)
 static void rt_mute(struct rt_device *dev)
 {
        dev->muted = 1;
-       down(&lock);
+       mutex_lock(&lock);
        outb(0xd0, io);                 /* volume steady, off           */
-       up(&lock);
+       mutex_unlock(&lock);
 }
 
 static int rt_setvol(struct rt_device *dev, int vol)
 {
        int i;
 
-       down(&lock);
+       mutex_lock(&lock);
        
        if(vol == dev->curvol) {        /* requested volume = current */
                if (dev->muted) {       /* user is unmuting the card  */
                        dev->muted = 0;
                        outb (0xd8, io);        /* enable card */
                }       
-               up(&lock);
+               mutex_unlock(&lock);
                return 0;
        }
 
@@ -108,7 +108,7 @@ static int rt_setvol(struct rt_device *dev, int vol)
                sleep_delay(2000000);   /* make sure it's totally down  */
                outb(0xd0, io);         /* volume steady, off           */
                dev->curvol = 0;        /* track the volume state!      */
-               up(&lock);
+               mutex_unlock(&lock);
                return 0;
        }
 
@@ -121,7 +121,7 @@ static int rt_setvol(struct rt_device *dev, int vol)
                        rt_decvol();
 
        dev->curvol = vol;
-       up(&lock);
+       mutex_unlock(&lock);
        return 0;
 }
 
@@ -168,7 +168,7 @@ static int rt_setfreq(struct rt_device *dev, unsigned long freq)
        freq += 171200;                 /* Add 10.7 MHz IF              */
        freq /= 800;                    /* Convert to 50 kHz units      */
        
-       down(&lock);                    /* Stop other ops interfering */
+       mutex_lock(&lock);                      /* Stop other ops interfering */
         
        send_0_byte (io, dev);          /*  0: LSB of frequency         */
 
@@ -196,7 +196,7 @@ static int rt_setfreq(struct rt_device *dev, unsigned long freq)
        else
                outb (0xd8, io);        /* volume steady + sigstr + on */
                
-       up(&lock);
+       mutex_unlock(&lock);
 
        return 0;
 }
@@ -337,7 +337,7 @@ static int __init rtrack_init(void)
 
        /* Set up the I/O locking */
        
-       init_MUTEX(&lock);
+       mutex_init(&lock);
        
        /* mute card - prevents noisy bootups */
 
index 523be82..83bdae2 100644 (file)
@@ -42,7 +42,7 @@
 static int io = CONFIG_RADIO_AZTECH_PORT; 
 static int radio_nr = -1;
 static int radio_wait_time = 1000;
-static struct semaphore lock;
+static struct mutex lock;
 
 struct az_device
 {
@@ -87,9 +87,9 @@ static void send_1_byte (struct az_device *dev)
 
 static int az_setvol(struct az_device *dev, int vol)
 {
-       down(&lock);
+       mutex_lock(&lock);
        outb (volconvert(vol), io);
-       up(&lock);
+       mutex_unlock(&lock);
        return 0;
 }
 
@@ -122,7 +122,7 @@ static int az_setfreq(struct az_device *dev, unsigned long frequency)
        frequency += 171200;            /* Add 10.7 MHz IF              */
        frequency /= 800;               /* Convert to 50 kHz units      */
                                        
-       down(&lock);
+       mutex_lock(&lock);
        
        send_0_byte (dev);              /*  0: LSB of frequency       */
 
@@ -152,7 +152,7 @@ static int az_setfreq(struct az_device *dev, unsigned long frequency)
        udelay (radio_wait_time);
        outb_p(128+64+volconvert(dev->curvol), io);
        
-       up(&lock);
+       mutex_unlock(&lock);
 
        return 0;
 }
@@ -283,7 +283,7 @@ static int __init aztech_init(void)
                return -EBUSY;
        }
 
-       init_MUTEX(&lock);
+       mutex_init(&lock);
        aztech_radio.priv=&aztech_unit;
        
        if(video_register_device(&aztech_radio, VFL_TYPE_RADIO, radio_nr)==-1)
index 36c9f5b..39c1d91 100644 (file)
 #include <linux/sched.h>
 #include <asm/io.h>
 #include <asm/uaccess.h>
-#include <asm/semaphore.h>
+#include <linux/mutex.h>
 #include <linux/pci.h>
 #include <linux/videodev.h>
 
+
 #define DRIVER_VERSION "0.05"
 
 #define GPIO_DATA      0x60   /* port offset from ESS_IO_BASE */
@@ -104,7 +105,7 @@ struct radio_device {
                muted,  /* VIDEO_AUDIO_MUTE */
                stereo, /* VIDEO_TUNER_STEREO_ON */     
                tuned;  /* signal strength (0 or 0xffff) */
-       struct  semaphore lock;
+       struct mutex lock;
 };
 
 static u32 radio_bits_get(struct radio_device *dev)
@@ -258,9 +259,9 @@ static int radio_ioctl(struct inode *inode, struct file *file,
        struct radio_device *card = video_get_drvdata(dev);
        int ret;
 
-       down(&card->lock);
+       mutex_lock(&card->lock);
        ret = video_usercopy(inode, file, cmd, arg, radio_function);
-       up(&card->lock);
+       mutex_unlock(&card->lock);
 
        return ret;
 }
@@ -311,7 +312,7 @@ static int __devinit maestro_probe(struct pci_dev *pdev,
        }
 
        radio_unit->io = pci_resource_start(pdev, 0) + GPIO_DATA;
-       init_MUTEX(&radio_unit->lock);
+       mutex_init(&radio_unit->lock);
 
        maestro_radio_inst = video_device_alloc();
        if (maestro_radio_inst == NULL) {
index c975ddd..f0bf47b 100644 (file)
@@ -37,7 +37,8 @@
 #include <linux/sched.h>
 #include <asm/io.h>
 #include <asm/uaccess.h>
-#include <asm/semaphore.h>
+#include <linux/mutex.h>
+
 #include <linux/pci.h>
 #include <linux/videodev.h>
 
@@ -101,7 +102,7 @@ static struct radio_device
                
        unsigned long freq;
        
-       struct  semaphore lock;
+       struct mutex lock;
 } radio_unit = {0, 0, 0, 0, };
 
 
@@ -267,9 +268,9 @@ static int radio_ioctl(struct inode *inode, struct file *file,
        struct radio_device *card=dev->priv;
        int ret;
        
-       down(&card->lock);
+       mutex_lock(&card->lock);
        ret = video_usercopy(inode, file, cmd, arg, radio_function);
-       up(&card->lock);
+       mutex_unlock(&card->lock);
        return ret;
 }
 
@@ -290,7 +291,7 @@ static int __devinit maxiradio_init_one(struct pci_dev *pdev, const struct pci_d
                goto err_out_free_region;
 
        radio_unit.io = pci_resource_start(pdev, 0);
-       init_MUTEX(&radio_unit.lock);
+       mutex_init(&radio_unit.lock);
        maxiradio_radio.priv = &radio_unit;
 
        if(video_register_device(&maxiradio_radio, VFL_TYPE_RADIO, radio_nr)==-1) {
index 0229f79..53073b4 100644 (file)
@@ -24,7 +24,7 @@
 #include <linux/isapnp.h>
 #include <asm/io.h>            /* outb, outb_p                 */
 #include <asm/uaccess.h>       /* copy to/from user            */
-#include <asm/semaphore.h>
+#include <linux/mutex.h>
 
 struct fmi_device
 {
@@ -37,7 +37,7 @@ struct fmi_device
 static int io = -1; 
 static int radio_nr = -1;
 static struct pnp_dev *dev = NULL;
-static struct semaphore lock;
+static struct mutex lock;
 
 /* freq is in 1/16 kHz to internal number, hw precision is 50 kHz */
 /* It is only useful to give freq in intervall of 800 (=0.05Mhz),
@@ -68,16 +68,16 @@ static void outbits(int bits, unsigned int data, int port)
 
 static inline void fmi_mute(int port)
 {
-       down(&lock);
+       mutex_lock(&lock);
        outb(0x00, port);
-       up(&lock);
+       mutex_unlock(&lock);
 }
 
 static inline void fmi_unmute(int port)
 {
-       down(&lock);
+       mutex_lock(&lock);
        outb(0x08, port);
-       up(&lock);
+       mutex_unlock(&lock);
 }
 
 static inline int fmi_setfreq(struct fmi_device *dev)
@@ -85,12 +85,12 @@ static inline int fmi_setfreq(struct fmi_device *dev)
        int myport = dev->port;
        unsigned long freq = dev->curfreq;
 
-       down(&lock);
+       mutex_lock(&lock);
 
        outbits(16, RSF16_ENCODE(freq), myport);
        outbits(8, 0xC0, myport);
        msleep(143);            /* was schedule_timeout(HZ/7) */
-       up(&lock);
+       mutex_unlock(&lock);
        if (dev->curvol) fmi_unmute(myport);
        return 0;
 }
@@ -102,7 +102,7 @@ static inline int fmi_getsigstr(struct fmi_device *dev)
        int myport = dev->port;
 
        
-       down(&lock);
+       mutex_lock(&lock);
        val = dev->curvol ? 0x08 : 0x00;        /* unmute/mute */
        outb(val, myport);
        outb(val | 0x10, myport);
@@ -110,7 +110,7 @@ static inline int fmi_getsigstr(struct fmi_device *dev)
        res = (int)inb(myport+1);
        outb(val, myport);
        
-       up(&lock);
+       mutex_unlock(&lock);
        return (res & 2) ? 0 : 0xFFFF;
 }
 
@@ -296,7 +296,7 @@ static int __init fmi_init(void)
        fmi_unit.flags = VIDEO_TUNER_LOW;
        fmi_radio.priv = &fmi_unit;
        
-       init_MUTEX(&lock);
+       mutex_init(&lock);
        
        if (video_register_device(&fmi_radio, VFL_TYPE_RADIO, radio_nr) == -1) {
                release_region(io, 2);
index 099ffb3..bcebd8c 100644 (file)
@@ -19,9 +19,9 @@
 #include <asm/io.h>            /* outb, outb_p                 */
 #include <asm/uaccess.h>       /* copy to/from user            */
 #include <linux/videodev.h>    /* kernel radio structs         */
-#include <asm/semaphore.h>
+#include <linux/mutex.h>
 
-static struct semaphore lock;
+static struct mutex lock;
 
 #undef DEBUG
 //#define DEBUG 1
@@ -238,9 +238,9 @@ static int fmr2_do_ioctl(struct inode *inode, struct file *file,
                        if (fmr2->mute)
                                v->flags |= VIDEO_AUDIO_MUTE;
                        v->mode=VIDEO_MODE_AUTO;
-                       down(&lock);
+                       mutex_lock(&lock);
                        v->signal = fmr2_getsigstr(fmr2);
-                       up(&lock);
+                       mutex_unlock(&lock);
                        return 0;
                }
                case VIDIOCSTUNER:
@@ -274,9 +274,9 @@ static int fmr2_do_ioctl(struct inode *inode, struct file *file,
                        /* set card freq (if not muted) */
                        if (fmr2->curvol && !fmr2->mute)
                        {
-                               down(&lock);
+                               mutex_lock(&lock);
                                fmr2_setfreq(fmr2);
-                               up(&lock);
+                               mutex_unlock(&lock);
                        }
                        return 0;
                }
@@ -318,14 +318,14 @@ static int fmr2_do_ioctl(struct inode *inode, struct file *file,
                        else
                                printk(KERN_DEBUG "mute\n");
 #endif
-                       down(&lock);
+                       mutex_lock(&lock);
                        if (fmr2->curvol && !fmr2->mute)
                        {
                                fmr2_setvolume(fmr2);
                                fmr2_setfreq(fmr2);
                        }
                        else fmr2_mute(fmr2->port);
-                       up(&lock);
+                       mutex_unlock(&lock);
                        return 0;
                }
                case VIDIOCGUNIT:
@@ -380,7 +380,7 @@ static int __init fmr2_init(void)
        fmr2_unit.card_type = 0;
        fmr2_radio.priv = &fmr2_unit;
 
-       init_MUTEX(&lock);
+       mutex_init(&lock);
 
        if (request_region(io, 2, "sf16fmr2"))
        {
@@ -397,10 +397,10 @@ static int __init fmr2_init(void)
        printk(KERN_INFO "SF16FMR2 radio card driver at 0x%x.\n", io);
        debug_print((KERN_DEBUG "Mute %d Low %d\n",VIDEO_AUDIO_MUTE,VIDEO_TUNER_LOW));
        /* mute card - prevents noisy bootups */
-       down(&lock);
+       mutex_lock(&lock);
        fmr2_mute(io);
        fmr2_product_info(&fmr2_unit);
-       up(&lock);
+       mutex_unlock(&lock);
        debug_print((KERN_DEBUG "card_type %d\n", fmr2_unit.card_type));
        return 0;
 }
index 8ac9a8e..e509558 100644 (file)
@@ -59,7 +59,7 @@ struct typhoon_device {
        int muted;
        unsigned long curfreq;
        unsigned long mutefreq;
-       struct semaphore lock;
+       struct mutex lock;
 };
 
 static void typhoon_setvol_generic(struct typhoon_device *dev, int vol);
@@ -77,12 +77,12 @@ static int typhoon_get_info(char *buf, char **start, off_t offset, int len);
 
 static void typhoon_setvol_generic(struct typhoon_device *dev, int vol)
 {
-       down(&dev->lock);
+       mutex_lock(&dev->lock);
        vol >>= 14;                             /* Map 16 bit to 2 bit */
        vol &= 3;
        outb_p(vol / 2, dev->iobase);           /* Set the volume, high bit. */
        outb_p(vol % 2, dev->iobase + 2);       /* Set the volume, low bit. */
-       up(&dev->lock);
+       mutex_unlock(&dev->lock);
 }
 
 static int typhoon_setfreq_generic(struct typhoon_device *dev,
@@ -102,7 +102,7 @@ static int typhoon_setfreq_generic(struct typhoon_device *dev,
         *
         */
 
-       down(&dev->lock);
+       mutex_lock(&dev->lock);
        x = frequency / 160;
        outval = (x * x + 2500) / 5000;
        outval = (outval * x + 5000) / 10000;
@@ -112,7 +112,7 @@ static int typhoon_setfreq_generic(struct typhoon_device *dev,
        outb_p((outval >> 8) & 0x01, dev->iobase + 4);
        outb_p(outval >> 9, dev->iobase + 6);
        outb_p(outval & 0xff, dev->iobase + 8);
-       up(&dev->lock);
+       mutex_unlock(&dev->lock);
 
        return 0;
 }
@@ -337,7 +337,7 @@ static int __init typhoon_init(void)
 #endif /* MODULE */
 
        printk(KERN_INFO BANNER);
-       init_MUTEX(&typhoon_unit.lock);
+       mutex_init(&typhoon_unit.lock);
        io = typhoon_unit.iobase;
        if (!request_region(io, 8, "typhoon")) {
                printk(KERN_ERR "radio-typhoon: port 0x%x already in use\n",
index d590e80..7bf1a42 100644 (file)
@@ -48,7 +48,7 @@ struct zol_device {
        unsigned long curfreq;
        int muted;
        unsigned int stereo;
-       struct semaphore lock;
+       struct mutex lock;
 };
 
 static int zol_setvol(struct zol_device *dev, int vol)
@@ -57,30 +57,30 @@ static int zol_setvol(struct zol_device *dev, int vol)
        if (dev->muted)
                return 0;
 
-       down(&dev->lock);
+       mutex_lock(&dev->lock);
        if (vol == 0) {
                outb(0, io);
                outb(0, io);
                inb(io + 3);    /* Zoltrix needs to be read to confirm */
-               up(&dev->lock);
+               mutex_unlock(&dev->lock);
                return 0;
        }
 
        outb(dev->curvol-1, io);
        msleep(10);
        inb(io + 2);
-       up(&dev->lock);
+       mutex_unlock(&dev->lock);
        return 0;
 }
 
 static void zol_mute(struct zol_device *dev)
 {
        dev->muted = 1;
-       down(&dev->lock);
+       mutex_lock(&dev->lock);
        outb(0, io);
        outb(0, io);
        inb(io + 3);            /* Zoltrix needs to be read to confirm */
-       up(&dev->lock);
+       mutex_unlock(&dev->lock);
 }
 
 static void zol_unmute(struct zol_device *dev)
@@ -104,7 +104,7 @@ static int zol_setfreq(struct zol_device *dev, unsigned long freq)
        bitmask = 0xc480402c10080000ull;
        i = 45;
 
-       down(&dev->lock);
+       mutex_lock(&dev->lock);
        
        outb(0, io);
        outb(0, io);
@@ -149,7 +149,7 @@ static int zol_setfreq(struct zol_device *dev, unsigned long freq)
                udelay(1000);
        }
        
-       up(&dev->lock);
+       mutex_unlock(&dev->lock);
        
        if(!dev->muted)
        {
@@ -164,7 +164,7 @@ static int zol_getsigstr(struct zol_device *dev)
 {
        int a, b;
 
-       down(&dev->lock);
+       mutex_lock(&dev->lock);
        outb(0x00, io);         /* This stuff I found to do nothing */
        outb(dev->curvol, io);
        msleep(20);
@@ -173,7 +173,7 @@ static int zol_getsigstr(struct zol_device *dev)
        msleep(10);
        b = inb(io);
 
-       up(&dev->lock);
+       mutex_unlock(&dev->lock);
        
        if (a != b)
                return (0);
@@ -188,7 +188,7 @@ static int zol_is_stereo (struct zol_device *dev)
 {
        int x1, x2;
 
-       down(&dev->lock);
+       mutex_lock(&dev->lock);
        
        outb(0x00, io);
        outb(dev->curvol, io);
@@ -198,7 +198,7 @@ static int zol_is_stereo (struct zol_device *dev)
        msleep(10);
        x2 = inb(io);
 
-       up(&dev->lock);
+       mutex_unlock(&dev->lock);
        
        if ((x1 == x2) && (x1 == 0xcf))
                return 1;
@@ -350,7 +350,7 @@ static int __init zoltrix_init(void)
        }
        printk(KERN_INFO "Zoltrix Radio Plus card driver.\n");
 
-       init_MUTEX(&zoltrix_unit.lock);
+       mutex_init(&zoltrix_unit.lock);
        
        /* mute card - prevents noisy bootups */
 
index 994b75f..c586f64 100644 (file)
@@ -31,8 +31,8 @@
 #include <linux/mm.h>
 #include <linux/sched.h>
 #include <linux/videodev.h>
+#include <linux/mutex.h>
 
-#include <asm/semaphore.h>
 #include <asm/uaccess.h>
 #include <asm/m32r.h>
 #include <asm/io.h>
@@ -117,7 +117,7 @@ struct ar_device {
        int width, height;
        int frame_bytes, line_bytes;
        wait_queue_head_t wait;
-       struct semaphore lock;
+       struct mutex lock;
 };
 
 static int video_nr = -1;      /* video device number (first free) */
@@ -288,7 +288,7 @@ static ssize_t ar_read(struct file *file, char *buf, size_t count, loff_t *ppos)
        if (ar->mode == AR_MODE_NORMAL)
                arvcr1 |= ARVCR1_NORMAL;
 
-       down(&ar->lock);
+       mutex_lock(&ar->lock);
 
 #if USE_INT
        local_irq_save(flags);
@@ -392,7 +392,7 @@ static ssize_t ar_read(struct file *file, char *buf, size_t count, loff_t *ppos)
        }
        DEBUG(1, "ret = %d\n", ret);
 out_up:
-       up(&ar->lock);
+       mutex_unlock(&ar->lock);
        return ret;
 }
 
@@ -456,7 +456,7 @@ static int ar_do_ioctl(struct inode *inode, struct file *file,
                    (w->width != AR_WIDTH_QVGA || w->height != AR_HEIGHT_QVGA))
                                return -EINVAL;
 
-               down(&ar->lock);
+               mutex_lock(&ar->lock);
                ar->width = w->width;
                ar->height = w->height;
                if (ar->width == AR_WIDTH_VGA) {
@@ -473,7 +473,7 @@ static int ar_do_ioctl(struct inode *inode, struct file *file,
                        ar->line_bytes = AR_LINE_BYTES_QVGA;
                        ar->mode = AR_MODE_INTERLACE;
                }
-               up(&ar->lock);
+               mutex_unlock(&ar->lock);
                return 0;
        }
        case VIDIOCGFBUF:
@@ -734,7 +734,7 @@ static int ar_initialize(struct video_device *dev)
 void ar_release(struct video_device *vfd)
 {
        struct ar_device *ar = vfd->priv;
-       down(&ar->lock);
+       mutex_lock(&ar->lock);
        video_device_release(vfd);
 }
 
@@ -824,7 +824,7 @@ static int __init ar_init(void)
                ar->line_bytes  = AR_LINE_BYTES_QVGA;
                ar->mode        = AR_MODE_INTERLACE;
        }
-       init_MUTEX(&ar->lock);
+       mutex_init(&ar->lock);
        init_waitqueue_head(&ar->wait);
 
 #if USE_INT
index 578b200..c0415d6 100644 (file)
@@ -1965,7 +1965,7 @@ static int setup_window(struct bttv_fh *fh, struct bttv *btv,
                BUG();
        }
 
-       down(&fh->cap.lock);
+       mutex_lock(&fh->cap.lock);
                kfree(fh->ov.clips);
        fh->ov.clips    = clips;
        fh->ov.nclips   = n;
@@ -1986,7 +1986,7 @@ static int setup_window(struct bttv_fh *fh, struct bttv *btv,
                bttv_overlay_risc(btv, &fh->ov, fh->ovfmt, new);
                retval = bttv_switch_overlay(btv,fh,new);
        }
-       up(&fh->cap.lock);
+       mutex_unlock(&fh->cap.lock);
        return retval;
 }
 
@@ -2166,7 +2166,7 @@ static int bttv_s_fmt(struct bttv_fh *fh, struct bttv *btv,
                fmt = format_by_fourcc(f->fmt.pix.pixelformat);
 
                /* update our state informations */
-               down(&fh->cap.lock);
+               mutex_lock(&fh->cap.lock);
                fh->fmt              = fmt;
                fh->cap.field        = f->fmt.pix.field;
                fh->cap.last         = V4L2_FIELD_NONE;
@@ -2175,7 +2175,7 @@ static int bttv_s_fmt(struct bttv_fh *fh, struct bttv *btv,
                btv->init.fmt        = fmt;
                btv->init.width      = f->fmt.pix.width;
                btv->init.height     = f->fmt.pix.height;
-               up(&fh->cap.lock);
+               mutex_unlock(&fh->cap.lock);
 
                return 0;
        }
@@ -2282,7 +2282,7 @@ static int bttv_do_ioctl(struct inode *inode, struct file *file,
                fmt = format_by_palette(pic->palette);
                if (NULL == fmt)
                        return -EINVAL;
-               down(&fh->cap.lock);
+               mutex_lock(&fh->cap.lock);
                if (fmt->depth != pic->depth) {
                        retval = -EINVAL;
                        goto fh_unlock_and_return;
@@ -2313,7 +2313,7 @@ static int bttv_do_ioctl(struct inode *inode, struct file *file,
                bt848_contrast(btv,pic->contrast);
                bt848_hue(btv,pic->hue);
                bt848_sat(btv,pic->colour);
-               up(&fh->cap.lock);
+               mutex_unlock(&fh->cap.lock);
                return 0;
        }
 
@@ -2379,7 +2379,7 @@ static int bttv_do_ioctl(struct inode *inode, struct file *file,
                        return -EPERM;
                end = (unsigned long)fbuf->base +
                        fbuf->height * fbuf->bytesperline;
-               down(&fh->cap.lock);
+               mutex_lock(&fh->cap.lock);
                retval = -EINVAL;
 
                switch (fbuf->depth) {
@@ -2417,7 +2417,7 @@ static int bttv_do_ioctl(struct inode *inode, struct file *file,
                        btv->fbuf.fmt.bytesperline = fbuf->bytesperline;
                else
                        btv->fbuf.fmt.bytesperline = btv->fbuf.fmt.width*fbuf->depth/8;
-               up(&fh->cap.lock);
+               mutex_unlock(&fh->cap.lock);
                return 0;
        }
 
@@ -2440,7 +2440,7 @@ static int bttv_do_ioctl(struct inode *inode, struct file *file,
                if (!check_alloc_btres(btv,fh,RESOURCE_OVERLAY))
                        return -EBUSY;
 
-               down(&fh->cap.lock);
+               mutex_lock(&fh->cap.lock);
                if (*on) {
                        fh->ov.tvnorm = btv->tvnorm;
                        new = videobuf_alloc(sizeof(*new));
@@ -2451,7 +2451,7 @@ static int bttv_do_ioctl(struct inode *inode, struct file *file,
 
                /* switch over */
                retval = bttv_switch_overlay(btv,fh,new);
-               up(&fh->cap.lock);
+               mutex_unlock(&fh->cap.lock);
                return retval;
        }
 
@@ -2460,7 +2460,7 @@ static int bttv_do_ioctl(struct inode *inode, struct file *file,
                struct video_mbuf *mbuf = arg;
                unsigned int i;
 
-               down(&fh->cap.lock);
+               mutex_lock(&fh->cap.lock);
                retval = videobuf_mmap_setup(&fh->cap,gbuffers,gbufsize,
                                             V4L2_MEMORY_MMAP);
                if (retval < 0)
@@ -2470,7 +2470,7 @@ static int bttv_do_ioctl(struct inode *inode, struct file *file,
                mbuf->size   = gbuffers * gbufsize;
                for (i = 0; i < gbuffers; i++)
                        mbuf->offsets[i] = i * gbufsize;
-               up(&fh->cap.lock);
+               mutex_unlock(&fh->cap.lock);
                return 0;
        }
        case VIDIOCMCAPTURE:
@@ -2482,7 +2482,7 @@ static int bttv_do_ioctl(struct inode *inode, struct file *file,
                if (vm->frame >= VIDEO_MAX_FRAME)
                        return -EINVAL;
 
-               down(&fh->cap.lock);
+               mutex_lock(&fh->cap.lock);
                retval = -EINVAL;
                buf = (struct bttv_buffer *)fh->cap.bufs[vm->frame];
                if (NULL == buf)
@@ -2504,7 +2504,7 @@ static int bttv_do_ioctl(struct inode *inode, struct file *file,
                spin_lock_irqsave(&btv->s_lock,flags);
                buffer_queue(&fh->cap,&buf->vb);
                spin_unlock_irqrestore(&btv->s_lock,flags);
-               up(&fh->cap.lock);
+               mutex_unlock(&fh->cap.lock);
                return 0;
        }
        case VIDIOCSYNC:
@@ -2515,7 +2515,7 @@ static int bttv_do_ioctl(struct inode *inode, struct file *file,
                if (*frame >= VIDEO_MAX_FRAME)
                        return -EINVAL;
 
-               down(&fh->cap.lock);
+               mutex_lock(&fh->cap.lock);
                retval = -EINVAL;
                buf = (struct bttv_buffer *)fh->cap.bufs[*frame];
                if (NULL == buf)
@@ -2535,7 +2535,7 @@ static int bttv_do_ioctl(struct inode *inode, struct file *file,
                        retval = -EINVAL;
                        break;
                }
-               up(&fh->cap.lock);
+               mutex_unlock(&fh->cap.lock);
                return retval;
        }
 
@@ -2719,7 +2719,7 @@ static int bttv_do_ioctl(struct inode *inode, struct file *file,
                if (0 == (fmt->flags & FORMAT_FLAGS_PACKED))
                        return -EINVAL;
 
-               down(&fh->cap.lock);
+               mutex_lock(&fh->cap.lock);
                retval = -EINVAL;
                if (fb->flags & V4L2_FBUF_FLAG_OVERLAY) {
                        if (fb->fmt.width > bttv_tvnorms[btv->tvnorm].swidth)
@@ -2759,7 +2759,7 @@ static int bttv_do_ioctl(struct inode *inode, struct file *file,
                                retval = bttv_switch_overlay(btv,fh,new);
                        }
                }
-               up(&fh->cap.lock);
+               mutex_unlock(&fh->cap.lock);
                return retval;
        }
 
@@ -2890,7 +2890,7 @@ static int bttv_do_ioctl(struct inode *inode, struct file *file,
        return 0;
 
  fh_unlock_and_return:
-       up(&fh->cap.lock);
+       mutex_unlock(&fh->cap.lock);
        return retval;
 }
 
@@ -2957,16 +2957,16 @@ static unsigned int bttv_poll(struct file *file, poll_table *wait)
                buf = list_entry(fh->cap.stream.next,struct bttv_buffer,vb.stream);
        } else {
                /* read() capture */
-               down(&fh->cap.lock);
+               mutex_lock(&fh->cap.lock);
                if (NULL == fh->cap.read_buf) {
                        /* need to capture a new frame */
                        if (locked_btres(fh->btv,RESOURCE_VIDEO)) {
-                               up(&fh->cap.lock);
+                               mutex_unlock(&fh->cap.lock);
                                return POLLERR;
                        }
                        fh->cap.read_buf = videobuf_alloc(fh->cap.msize);
                        if (NULL == fh->cap.read_buf) {
-                               up(&fh->cap.lock);
+                               mutex_unlock(&fh->cap.lock);
                                return POLLERR;
                        }
                        fh->cap.read_buf->memory = V4L2_MEMORY_USERPTR;
@@ -2974,13 +2974,13 @@ static unsigned int bttv_poll(struct file *file, poll_table *wait)
                        if (0 != fh->cap.ops->buf_prepare(&fh->cap,fh->cap.read_buf,field)) {
                                kfree (fh->cap.read_buf);
                                fh->cap.read_buf = NULL;
-                               up(&fh->cap.lock);
+                               mutex_unlock(&fh->cap.lock);
                                return POLLERR;
                        }
                        fh->cap.ops->buf_queue(&fh->cap,fh->cap.read_buf);
                        fh->cap.read_off = 0;
                }
-               up(&fh->cap.lock);
+               mutex_unlock(&fh->cap.lock);
                buf = (struct bttv_buffer*)fh->cap.read_buf;
        }
 
index 6bad93e..d97b7d8 100644 (file)
@@ -73,7 +73,7 @@ OTHER DEALINGS IN THE SOFTWARE.
 #include <linux/parport.h>
 #include <linux/sched.h>
 #include <linux/videodev.h>
-#include <asm/semaphore.h>
+#include <linux/mutex.h>
 #include <asm/uaccess.h>
 
 #include "bw-qcam.h"
@@ -168,7 +168,7 @@ static struct qcam_device *qcam_init(struct parport *port)
        
        memcpy(&q->vdev, &qcam_template, sizeof(qcam_template));
        
-       init_MUTEX(&q->lock);
+       mutex_init(&q->lock);
 
        q->port_mode = (QC_ANY | QC_NOTSET);
        q->width = 320;
@@ -772,9 +772,9 @@ static int qcam_do_ioctl(struct inode *inode, struct file *file,
                        qcam->whitebal = p->whiteness>>8;
                        qcam->bpp = p->depth;
 
-                       down(&qcam->lock);                      
+                       mutex_lock(&qcam->lock);
                        qc_setscanmode(qcam);
-                       up(&qcam->lock);
+                       mutex_unlock(&qcam->lock);
                        qcam->status |= QC_PARAM_CHANGE;
 
                        return 0;
@@ -805,9 +805,9 @@ static int qcam_do_ioctl(struct inode *inode, struct file *file,
                                qcam->height = 240;
                                qcam->transfer_scale = 1;
                        }
-                       down(&qcam->lock);
+                       mutex_lock(&qcam->lock);
                        qc_setscanmode(qcam);
-                       up(&qcam->lock);
+                       mutex_unlock(&qcam->lock);
                        
                        /* We must update the camera before we grab. We could
                           just have changed the grab size */
@@ -854,7 +854,7 @@ static ssize_t qcam_read(struct file *file, char __user *buf,
        int len;
        parport_claim_or_block(qcam->pdev);
        
-       down(&qcam->lock);
+       mutex_lock(&qcam->lock);
        
        qc_reset(qcam);
 
@@ -864,7 +864,7 @@ static ssize_t qcam_read(struct file *file, char __user *buf,
 
        len=qc_capture(qcam, buf,count);
        
-       up(&qcam->lock);
+       mutex_unlock(&qcam->lock);
        
        parport_release(qcam->pdev);
        return len;
index 723e8ad..6701daf 100644 (file)
@@ -55,7 +55,7 @@ struct qcam_device {
        struct video_device vdev;
        struct pardevice *pdev;
        struct parport *pport;
-       struct semaphore lock;
+       struct mutex lock;
        int width, height;
        int bpp;
        int mode;
index 9976db4..8211fd8 100644 (file)
@@ -34,7 +34,8 @@
 #include <linux/parport.h>
 #include <linux/sched.h>
 #include <linux/videodev.h>
-#include <asm/semaphore.h>
+#include <linux/mutex.h>
+
 #include <asm/uaccess.h>
 
 struct qcam_device {
@@ -47,7 +48,7 @@ struct qcam_device {
        int contrast, brightness, whitebal;
        int top, left;
        unsigned int bidirectional;
-       struct semaphore lock;
+       struct mutex lock;
 };
 
 /* cameras maximum */
@@ -581,11 +582,11 @@ static int qcam_do_ioctl(struct inode *inode, struct file *file,
                        qcam->contrast = p->contrast>>8;
                        qcam->whitebal = p->whiteness>>8;
 
-                       down(&qcam->lock);                      
+                       mutex_lock(&qcam->lock);
                        parport_claim_or_block(qcam->pdev);
                        qc_setup(qcam); 
                        parport_release(qcam->pdev);
-                       up(&qcam->lock);
+                       mutex_unlock(&qcam->lock);
                        return 0;
                }
                case VIDIOCSWIN:
@@ -628,11 +629,11 @@ static int qcam_do_ioctl(struct inode *inode, struct file *file,
 #endif
                        /* Ok we figured out what to use from our 
                           wide choice */
-                       down(&qcam->lock);
+                       mutex_lock(&qcam->lock);
                        parport_claim_or_block(qcam->pdev);
                        qc_setup(qcam);
                        parport_release(qcam->pdev);
-                       up(&qcam->lock);
+                       mutex_unlock(&qcam->lock);
                        return 0;
                }
                case VIDIOCGWIN:
@@ -672,12 +673,12 @@ static ssize_t qcam_read(struct file *file, char __user *buf,
        struct qcam_device *qcam=(struct qcam_device *)v;
        int len;
 
-       down(&qcam->lock);
+       mutex_lock(&qcam->lock);
        parport_claim_or_block(qcam->pdev);
        /* Probably should have a semaphore against multiple users */
        len = qc_capture(qcam, buf,count); 
        parport_release(qcam->pdev);
-       up(&qcam->lock);
+       mutex_unlock(&qcam->lock);
        return len;
 }
 
@@ -727,7 +728,7 @@ static struct qcam_device *qcam_init(struct parport *port)
        
        memcpy(&q->vdev, &qcam_template, sizeof(qcam_template));
 
-       init_MUTEX(&q->lock);
+       mutex_init(&q->lock);
        q->width = q->ccd_width = 320;
        q->height = q->ccd_height = 240;
        q->mode = QC_MILLIONS | QC_DECIMATION_1;
index 9f59541..c240502 100644 (file)
@@ -39,7 +39,7 @@
 #include <linux/pagemap.h>
 #include <linux/delay.h>
 #include <asm/io.h>
-#include <asm/semaphore.h>
+#include <linux/mutex.h>
 
 #ifdef CONFIG_KMOD
 #include <linux/kmod.h>
@@ -622,7 +622,7 @@ static int cpia_write_proc(struct file *file, const char __user *buf,
        
        buffer = page;
        
-       if (down_interruptible(&cam->param_lock))
+       if (mutex_lock_interruptible(&cam->param_lock))
                return -ERESTARTSYS;
        
        /*
@@ -1350,7 +1350,7 @@ static int cpia_write_proc(struct file *file, const char __user *buf,
        } else
                DBG("error: %d\n", retval);
        
-       up(&cam->param_lock);
+       mutex_unlock(&cam->param_lock);
        
 out:
        free_page((unsigned long)page);
@@ -1664,7 +1664,7 @@ static int do_command(struct cam_data *cam, u16 command, u8 a, u8 b, u8 c, u8 d)
        case CPIA_COMMAND_GetColourParams:
        case CPIA_COMMAND_GetColourBalance:
        case CPIA_COMMAND_GetExposure:
-               down(&cam->param_lock);
+               mutex_lock(&cam->param_lock);
                datasize=8;
                break;
        case CPIA_COMMAND_ReadMCPorts: 
@@ -1691,7 +1691,7 @@ static int do_command(struct cam_data *cam, u16 command, u8 a, u8 b, u8 c, u8 d)
                if (command == CPIA_COMMAND_GetColourParams ||
                    command == CPIA_COMMAND_GetColourBalance ||
                    command == CPIA_COMMAND_GetExposure)
-                       up(&cam->param_lock);
+                       mutex_unlock(&cam->param_lock);
        } else {
                switch(command) {
                case CPIA_COMMAND_GetCPIAVersion:
@@ -1726,13 +1726,13 @@ static int do_command(struct cam_data *cam, u16 command, u8 a, u8 b, u8 c, u8 d)
                        cam->params.colourParams.brightness = data[0];
                        cam->params.colourParams.contrast = data[1];
                        cam->params.colourParams.saturation = data[2];
-                       up(&cam->param_lock);
+                       mutex_unlock(&cam->param_lock);
                        break;
                case CPIA_COMMAND_GetColourBalance:
                        cam->params.colourBalance.redGain = data[0];
                        cam->params.colourBalance.greenGain = data[1];
                        cam->params.colourBalance.blueGain = data[2];
-                       up(&cam->param_lock);
+                       mutex_unlock(&cam->param_lock);
                        break;
                case CPIA_COMMAND_GetExposure:
                        cam->params.exposure.gain = data[0];
@@ -1743,7 +1743,7 @@ static int do_command(struct cam_data *cam, u16 command, u8 a, u8 b, u8 c, u8 d)
                        cam->params.exposure.green1Comp = data[5];
                        cam->params.exposure.green2Comp = data[6];
                        cam->params.exposure.blueComp = data[7];
-                       up(&cam->param_lock);
+                       mutex_unlock(&cam->param_lock);
                        break;
 
                case CPIA_COMMAND_ReadMCPorts: 
@@ -2059,7 +2059,7 @@ static int parse_picture(struct cam_data *cam, int size)
        int rows, cols, linesize, subsample_422;
 
        /* make sure params don't change while we are decoding */
-       down(&cam->param_lock);
+       mutex_lock(&cam->param_lock);
 
        obuf = cam->decompressed_frame.data;
        end_obuf = obuf+CPIA_MAX_FRAME_SIZE;
@@ -2069,26 +2069,26 @@ static int parse_picture(struct cam_data *cam, int size)
 
        if ((ibuf[0] != MAGIC_0) || (ibuf[1] != MAGIC_1)) {
                LOG("header not found\n");
-               up(&cam->param_lock);
+               mutex_unlock(&cam->param_lock);
                return -1;
        }
 
        if ((ibuf[16] != VIDEOSIZE_QCIF) && (ibuf[16] != VIDEOSIZE_CIF)) {
                LOG("wrong video size\n");
-               up(&cam->param_lock);
+               mutex_unlock(&cam->param_lock);
                return -1;
        }
        
        if (ibuf[17] != SUBSAMPLE_420 && ibuf[17] != SUBSAMPLE_422) {
                LOG("illegal subtype %d\n",ibuf[17]);
-               up(&cam->param_lock);
+               mutex_unlock(&cam->param_lock);
                return -1;
        }
        subsample_422 = ibuf[17] == SUBSAMPLE_422;
        
        if (ibuf[18] != YUVORDER_YUYV && ibuf[18] != YUVORDER_UYVY) {
                LOG("illegal yuvorder %d\n",ibuf[18]);
-               up(&cam->param_lock);
+               mutex_unlock(&cam->param_lock);
                return -1;
        }
        in_uyvy = ibuf[18] == YUVORDER_UYVY;
@@ -2098,7 +2098,7 @@ static int parse_picture(struct cam_data *cam, int size)
            (ibuf[26] != cam->params.roi.rowStart) ||
            (ibuf[27] != cam->params.roi.rowEnd)) {
                LOG("ROI mismatch\n");
-               up(&cam->param_lock);
+               mutex_unlock(&cam->param_lock);
                return -1;
        }
        cols = 8*(ibuf[25] - ibuf[24]);
@@ -2107,14 +2107,14 @@ static int parse_picture(struct cam_data *cam, int size)
        
        if ((ibuf[28] != NOT_COMPRESSED) && (ibuf[28] != COMPRESSED)) {
                LOG("illegal compression %d\n",ibuf[28]);
-               up(&cam->param_lock);
+               mutex_unlock(&cam->param_lock);
                return -1;
        }
        compressed = (ibuf[28] == COMPRESSED);
        
        if (ibuf[29] != NO_DECIMATION && ibuf[29] != DECIMATION_ENAB) {
                LOG("illegal decimation %d\n",ibuf[29]);
-               up(&cam->param_lock);
+               mutex_unlock(&cam->param_lock);
                return -1;
        }
        decimation = (ibuf[29] == DECIMATION_ENAB);     
@@ -2130,7 +2130,7 @@ static int parse_picture(struct cam_data *cam, int size)
        cam->params.status.vpStatus = ibuf[38];
        cam->params.status.errorCode = ibuf[39];
        cam->fps = ibuf[41];
-       up(&cam->param_lock);
+       mutex_unlock(&cam->param_lock);
        
        linesize = skipcount(cols, out_fmt);
        ibuf += FRAME_HEADER_SIZE;
@@ -2271,9 +2271,9 @@ static int find_over_exposure(int brightness)
 /* update various camera modes and settings */
 static void dispatch_commands(struct cam_data *cam)
 {
-       down(&cam->param_lock);
+       mutex_lock(&cam->param_lock);
        if (cam->cmd_queue==COMMAND_NONE) {
-               up(&cam->param_lock);
+               mutex_unlock(&cam->param_lock);
                return;
        }
        DEB_BYTE(cam->cmd_queue);
@@ -2415,7 +2415,7 @@ static void dispatch_commands(struct cam_data *cam)
          }
 
        cam->cmd_queue = COMMAND_NONE;
-       up(&cam->param_lock);
+       mutex_unlock(&cam->param_lock);
        return;
 }
 
@@ -2562,7 +2562,7 @@ static void monitor_exposure(struct cam_data *cam)
        gain = data[2];
        coarseL = data[3];
 
-       down(&cam->param_lock);
+       mutex_lock(&cam->param_lock);
        light_exp = cam->params.colourParams.brightness +
                    TC - 50 + EXP_ACC_LIGHT;
        if(light_exp > 255)
@@ -2762,7 +2762,7 @@ static void monitor_exposure(struct cam_data *cam)
                        LOG("Automatically increasing sensor_fps\n");
                }
        }
-       up(&cam->param_lock);
+       mutex_unlock(&cam->param_lock);
 }
 
 /*-----------------------------------------------------------------*/
@@ -2778,10 +2778,10 @@ static void restart_flicker(struct cam_data *cam)
        int cam_exposure, old_exp;
        if(!FIRMWARE_VERSION(1,2))
                return;
-       down(&cam->param_lock);
+       mutex_lock(&cam->param_lock);
        if(cam->params.flickerControl.flickerMode == 0 ||
           cam->raw_image[39] == 0) {
-               up(&cam->param_lock);
+               mutex_unlock(&cam->param_lock);
                return;
        }
        cam_exposure = cam->raw_image[39]*2;
@@ -2810,7 +2810,7 @@ static void restart_flicker(struct cam_data *cam)
                        cam->exposure_status = EXPOSURE_NORMAL;
 
        }
-       up(&cam->param_lock);
+       mutex_unlock(&cam->param_lock);
 }
 #undef FIRMWARE_VERSION
 
@@ -3186,7 +3186,7 @@ static int cpia_open(struct inode *inode, struct file *file)
        if (!try_module_get(cam->ops->owner))
                return -ENODEV;
 
-       down(&cam->busy_lock);
+       mutex_lock(&cam->busy_lock);
        err = -ENOMEM;
        if (!cam->raw_image) {
                cam->raw_image = rvmalloc(CPIA_MAX_IMAGE_SIZE);
@@ -3227,7 +3227,7 @@ static int cpia_open(struct inode *inode, struct file *file)
        
        ++cam->open_count;
        file->private_data = dev;
-       up(&cam->busy_lock);
+       mutex_unlock(&cam->busy_lock);
        return 0;
 
  oops:
@@ -3239,7 +3239,7 @@ static int cpia_open(struct inode *inode, struct file *file)
                rvfree(cam->raw_image, CPIA_MAX_IMAGE_SIZE);
                cam->raw_image = NULL;
        }
-       up(&cam->busy_lock);
+       mutex_unlock(&cam->busy_lock);
        put_cam(cam->ops);
        return err;
 }
@@ -3303,24 +3303,24 @@ static ssize_t cpia_read(struct file *file, char __user *buf,
        int err;
 
        /* make this _really_ smp and multithread-safe */
-       if (down_interruptible(&cam->busy_lock))
+       if (mutex_lock_interruptible(&cam->busy_lock))
                return -EINTR;
 
        if (!buf) {
                DBG("buf NULL\n");
-               up(&cam->busy_lock);
+               mutex_unlock(&cam->busy_lock);
                return -EINVAL;
        }
 
        if (!count) {
                DBG("count 0\n");
-               up(&cam->busy_lock);
+               mutex_unlock(&cam->busy_lock);
                return 0;
        }
 
        if (!cam->ops) {
                DBG("ops NULL\n");
-               up(&cam->busy_lock);
+               mutex_unlock(&cam->busy_lock);
                return -ENODEV;
        }
 
@@ -3329,7 +3329,7 @@ static ssize_t cpia_read(struct file *file, char __user *buf,
        cam->mmap_kludge=0;
        if((err = fetch_frame(cam)) != 0) {
                DBG("ERROR from fetch_frame: %d\n", err);
-               up(&cam->busy_lock);
+               mutex_unlock(&cam->busy_lock);
                return err;
        }
        cam->decompressed_frame.state = FRAME_UNUSED;
@@ -3338,17 +3338,17 @@ static ssize_t cpia_read(struct file *file, char __user *buf,
        if (cam->decompressed_frame.count > count) {
                DBG("count wrong: %d, %lu\n", cam->decompressed_frame.count,
                    (unsigned long) count);
-               up(&cam->busy_lock);
+               mutex_unlock(&cam->busy_lock);
                return -EFAULT;
        }
        if (copy_to_user(buf, cam->decompressed_frame.data,
                        cam->decompressed_frame.count)) {
                DBG("copy_to_user failed\n");
-               up(&cam->busy_lock);
+               mutex_unlock(&cam->busy_lock);
                return -EFAULT;
        }
 
-       up(&cam->busy_lock);
+       mutex_unlock(&cam->busy_lock);
        return cam->decompressed_frame.count;
 }
 
@@ -3363,7 +3363,7 @@ static int cpia_do_ioctl(struct inode *inode, struct file *file,
                return -ENODEV;
        
        /* make this _really_ smp-safe */
-       if (down_interruptible(&cam->busy_lock))
+       if (mutex_lock_interruptible(&cam->busy_lock))
                return -EINTR;
 
        //DBG("cpia_ioctl: %u\n", ioctlnr);
@@ -3439,7 +3439,7 @@ static int cpia_do_ioctl(struct inode *inode, struct file *file,
                        break;
                }
 
-               down(&cam->param_lock);
+               mutex_lock(&cam->param_lock);
                /* brightness, colour, contrast need no check 0-65535 */
                cam->vp = *vp;
                /* update cam->params.colourParams */
@@ -3466,7 +3466,7 @@ static int cpia_do_ioctl(struct inode *inode, struct file *file,
 
                /* queue command to update camera */
                cam->cmd_queue |= COMMAND_SETCOLOURPARAMS;
-               up(&cam->param_lock);
+               mutex_unlock(&cam->param_lock);
                DBG("VIDIOCSPICT: %d / %d // %d / %d / %d / %d\n",
                    vp->depth, vp->palette, vp->brightness, vp->hue, vp->colour,
                    vp->contrast);
@@ -3501,13 +3501,13 @@ static int cpia_do_ioctl(struct inode *inode, struct file *file,
                /* we set the video window to something smaller or equal to what
                * is requested by the user???
                */
-               down(&cam->param_lock);
+               mutex_lock(&cam->param_lock);
                if (vw->width != cam->vw.width || vw->height != cam->vw.height) {
                        int video_size = match_videosize(vw->width, vw->height);
 
                        if (video_size < 0) {
                                retval = -EINVAL;
-                               up(&cam->param_lock);
+                               mutex_unlock(&cam->param_lock);
                                break;
                        }
                        cam->video_size = video_size;
@@ -3520,7 +3520,7 @@ static int cpia_do_ioctl(struct inode *inode, struct file *file,
                        cam->cmd_queue |= COMMAND_SETFORMAT;
                }
 
-               up(&cam->param_lock);
+               mutex_unlock(&cam->param_lock);
 
                /* setformat ignored by camera during streaming,
                 * so stop/dispatch/start */
@@ -3682,7 +3682,7 @@ static int cpia_do_ioctl(struct inode *inode, struct file *file,
 
                DBG("%d,%d/%dx%d\n", vc->x,vc->y,vc->width, vc->height);
                
-               down(&cam->param_lock);
+               mutex_lock(&cam->param_lock);
                
                cam->vc.x      = vc->x;
                cam->vc.y      = vc->y;
@@ -3692,7 +3692,7 @@ static int cpia_do_ioctl(struct inode *inode, struct file *file,
                set_vw_size(cam);
                cam->cmd_queue |= COMMAND_SETFORMAT;
 
-               up(&cam->param_lock);
+               mutex_unlock(&cam->param_lock);
 
                /* setformat ignored by camera during streaming,
                 * so stop/dispatch/start */
@@ -3736,7 +3736,7 @@ static int cpia_do_ioctl(struct inode *inode, struct file *file,
                break;
        }
 
-       up(&cam->busy_lock);
+       mutex_unlock(&cam->busy_lock);
        return retval;
 } 
 
@@ -3769,12 +3769,12 @@ static int cpia_mmap(struct file *file, struct vm_area_struct *vma)
                return -ENODEV;
        
        /* make this _really_ smp-safe */
-       if (down_interruptible(&cam->busy_lock))
+       if (mutex_lock_interruptible(&cam->busy_lock))
                return -EINTR;
 
        if (!cam->frame_buf) {  /* we do lazy allocation */
                if ((retval = allocate_frame_buf(cam))) {
-                       up(&cam->busy_lock);
+                       mutex_unlock(&cam->busy_lock);
                        return retval;
                }
        }
@@ -3783,7 +3783,7 @@ static int cpia_mmap(struct file *file, struct vm_area_struct *vma)
        while (size > 0) {
                page = vmalloc_to_pfn((void *)pos);
                if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED)) {
-                       up(&cam->busy_lock);
+                       mutex_unlock(&cam->busy_lock);
                        return -EAGAIN;
                }
                start += PAGE_SIZE;
@@ -3795,7 +3795,7 @@ static int cpia_mmap(struct file *file, struct vm_area_struct *vma)
        }
 
        DBG("cpia_mmap: %ld\n", size);
-       up(&cam->busy_lock);
+       mutex_unlock(&cam->busy_lock);
 
        return 0;
 }
@@ -3936,8 +3936,8 @@ static void init_camera_struct(struct cam_data *cam,
        memset(cam, 0, sizeof(struct cam_data));
 
        cam->ops = ops;
-       init_MUTEX(&cam->param_lock);
-       init_MUTEX(&cam->busy_lock);
+       mutex_init(&cam->param_lock);
+       mutex_init(&cam->busy_lock);
 
        reset_camera_struct(cam);
 
index f629b69..de66782 100644 (file)
@@ -47,6 +47,7 @@
 #include <linux/videodev.h>
 #include <linux/list.h>
 #include <linux/smp_lock.h>
+#include <linux/mutex.h>
 
 struct cpia_camera_ops
 {
@@ -246,7 +247,7 @@ enum v4l_camstates {
 struct cam_data {
        struct list_head cam_data_list;
 
-        struct semaphore busy_lock;     /* guard against SMP multithreading */
+        struct mutex busy_lock;     /* guard against SMP multithreading */
        struct cpia_camera_ops *ops;    /* lowlevel driver operations */
        void *lowlevel_data;            /* private data for lowlevel driver */
        u8 *raw_image;                  /* buffer for raw image data */
@@ -261,7 +262,7 @@ struct cam_data {
        u8 mainsFreq;                   /* for flicker control */
 
                                /* proc interface */
-       struct semaphore param_lock;    /* params lock for this camera */
+       struct mutex param_lock;        /* params lock for this camera */
        struct cam_params params;       /* camera settings */
        struct proc_dir_entry *proc_entry;      /* /proc/cpia/videoX */
        
index 3720f24..eda7cd8 100644 (file)
@@ -1061,7 +1061,7 @@ struct cx88_core* cx88_core_get(struct pci_dev *pci)
        core->pci_bus  = pci->bus->number;
        core->pci_slot = PCI_SLOT(pci->devfn);
        core->pci_irqmask = 0x00fc00;
-       init_MUTEX(&core->lock);
+       mutex_init(&core->lock);
 
        core->nr = cx88_devcount++;
        sprintf(core->name,"cx88[%d]",core->nr);
index 073494c..d15ef15 100644 (file)
@@ -336,17 +336,17 @@ static int res_get(struct cx8800_dev *dev, struct cx8800_fh *fh, unsigned int bi
                return 1;
 
        /* is it free? */
-       down(&core->lock);
+       mutex_lock(&core->lock);
        if (dev->resources & bit) {
                /* no, someone else uses it */
-               up(&core->lock);
+               mutex_unlock(&core->lock);
                return 0;
        }
        /* it's free, grab it */
        fh->resources  |= bit;
        dev->resources |= bit;
        dprintk(1,"res: get %d\n",bit);
-       up(&core->lock);
+       mutex_unlock(&core->lock);
        return 1;
 }
 
@@ -369,11 +369,11 @@ void res_free(struct cx8800_dev *dev, struct cx8800_fh *fh, unsigned int bits)
        if ((fh->resources & bits) != bits)
                BUG();
 
-       down(&core->lock);
+       mutex_lock(&core->lock);
        fh->resources  &= ~bits;
        dev->resources &= ~bits;
        dprintk(1,"res: put %d\n",bits);
-       up(&core->lock);
+       mutex_unlock(&core->lock);
 }
 
 /* ------------------------------------------------------------------ */
@@ -1291,9 +1291,9 @@ int cx88_do_ioctl(struct inode *inode, struct file *file, int radio,
                if (i == ARRAY_SIZE(tvnorms))
                        return -EINVAL;
 
-               down(&core->lock);
+               mutex_lock(&core->lock);
                cx88_set_tvnorm(core,&tvnorms[i]);
-               up(&core->lock);
+               mutex_unlock(&core->lock);
                return 0;
        }
 
@@ -1343,10 +1343,10 @@ int cx88_do_ioctl(struct inode *inode, struct file *file, int radio,
 
                if (*i >= 4)
                        return -EINVAL;
-               down(&core->lock);
+               mutex_lock(&core->lock);
                cx88_newstation(core);
                video_mux(core,*i);
-               up(&core->lock);
+               mutex_unlock(&core->lock);
                return 0;
        }
 
@@ -1438,7 +1438,7 @@ int cx88_do_ioctl(struct inode *inode, struct file *file, int radio,
                        return -EINVAL;
                if (1 == radio && f->type != V4L2_TUNER_RADIO)
                        return -EINVAL;
-               down(&core->lock);
+               mutex_lock(&core->lock);
                core->freq = f->frequency;
                cx88_newstation(core);
                cx88_call_i2c_clients(core,VIDIOC_S_FREQUENCY,f);
@@ -1447,7 +1447,7 @@ int cx88_do_ioctl(struct inode *inode, struct file *file, int radio,
                msleep (10);
                cx88_set_tvaudio(core);
 
-               up(&core->lock);
+               mutex_unlock(&core->lock);
                return 0;
        }
 
@@ -1921,11 +1921,11 @@ static int __devinit cx8800_initdev(struct pci_dev *pci_dev,
        pci_set_drvdata(pci_dev,dev);
 
        /* initial device configuration */
-       down(&core->lock);
+       mutex_lock(&core->lock);
        cx88_set_tvnorm(core,tvnorms);
        init_controls(core);
        video_mux(core,0);
-       up(&core->lock);
+       mutex_unlock(&core->lock);
 
        /* start tvaudio thread */
        if (core->tuner_type != TUNER_ABSENT)
index 31a688a..a4cf247 100644 (file)
@@ -35,6 +35,7 @@
 #include "cx88-reg.h"
 
 #include <linux/version.h>
+#include <linux/mutex.h>
 #define CX88_VERSION_CODE KERNEL_VERSION(0,0,5)
 
 #ifndef TRUE
@@ -309,8 +310,7 @@ struct cx88_core {
        /* IR remote control state */
        struct cx88_IR             *ir;
 
-       struct semaphore           lock;
-
+       struct mutex               lock;
        /* various v4l controls */
        u32                        freq;
 
index 1c1557d..671fc52 100644 (file)
@@ -362,12 +362,12 @@ static int em28xx_v4l2_open(struct inode *inode, struct file *filp)
                return -EBUSY;
        }
 
-       init_MUTEX(&dev->fileop_lock);  /* to 1 == available */
+       mutex_init(&dev->fileop_lock);  /* to 1 == available */
        spin_lock_init(&dev->queue_lock);
        init_waitqueue_head(&dev->wait_frame);
        init_waitqueue_head(&dev->wait_stream);
 
-       down(&dev->lock);
+       mutex_lock(&dev->lock);
 
        if (dev->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
                em28xx_set_alternate(dev);
@@ -404,8 +404,8 @@ static int em28xx_v4l2_open(struct inode *inode, struct file *filp)
 
        dev->state |= DEV_INITIALIZED;
 
-      err:
-       up(&dev->lock);
+err:
+       mutex_unlock(&dev->lock);
        up_read(&em28xx_disconnect);
        return errCode;
 }
@@ -447,7 +447,7 @@ static int em28xx_v4l2_close(struct inode *inode, struct file *filp)
 
        em28xx_videodbg("users=%d\n", dev->users);
 
-       down(&dev->lock);
+       mutex_lock(&dev->lock);
 
        em28xx_uninit_isoc(dev);
 
@@ -456,7 +456,7 @@ static int em28xx_v4l2_close(struct inode *inode, struct file *filp)
        /* the device is already disconnect, free the remaining resources */
        if (dev->state & DEV_DISCONNECTED) {
                em28xx_release_resources(dev);
-               up(&dev->lock);
+               mutex_unlock(&dev->lock);
                kfree(dev);
                return 0;
        }
@@ -472,7 +472,7 @@ static int em28xx_v4l2_close(struct inode *inode, struct file *filp)
 
        dev->users--;
        wake_up_interruptible_nr(&dev->open, 1);
-       up(&dev->lock);
+       mutex_unlock(&dev->lock);
        return 0;
 }
 
@@ -496,7 +496,7 @@ em28xx_v4l2_read(struct file *filp, char __user * buf, size_t count,
                em28xx_videodbg("V4L2_BUF_TYPE_VBI_CAPTURE is set\n");
                em28xx_videodbg("not supported yet! ...\n");
                if (copy_to_user(buf, "", 1)) {
-                       up(&dev->fileop_lock);
+                       mutex_unlock(&dev->fileop_lock);
                        return -EFAULT;
                }
                return (1);
@@ -505,38 +505,38 @@ em28xx_v4l2_read(struct file *filp, char __user * buf, size_t count,
                em28xx_videodbg("V4L2_BUF_TYPE_SLICED_VBI_CAPTURE is set\n");
                em28xx_videodbg("not supported yet! ...\n");
                if (copy_to_user(buf, "", 1)) {
-                       up(&dev->fileop_lock);
+                       mutex_unlock(&dev->fileop_lock);
                        return -EFAULT;
                }
                return (1);
        }
 
-       if (down_interruptible(&dev->fileop_lock))
+       if (mutex_lock_interruptible(&dev->fileop_lock))
                return -ERESTARTSYS;
 
        if (dev->state & DEV_DISCONNECTED) {
                em28xx_videodbg("device not present\n");
-               up(&dev->fileop_lock);
+               mutex_unlock(&dev->fileop_lock);
                return -ENODEV;
        }
 
        if (dev->state & DEV_MISCONFIGURED) {
                em28xx_videodbg("device misconfigured; close and open it again\n");
-               up(&dev->fileop_lock);
+               mutex_unlock(&dev->fileop_lock);
                return -EIO;
        }
 
        if (dev->io == IO_MMAP) {
                em28xx_videodbg ("IO method is set to mmap; close and open"
                                " the device again to choose the read method\n");
-               up(&dev->fileop_lock);
+               mutex_unlock(&dev->fileop_lock);
                return -EINVAL;
        }
 
        if (dev->io == IO_NONE) {
                if (!em28xx_request_buffers(dev, EM28XX_NUM_READ_FRAMES)) {
                        em28xx_errdev("read failed, not enough memory\n");
-                       up(&dev->fileop_lock);
+                       mutex_unlock(&dev->fileop_lock);
                        return -ENOMEM;
                }
                dev->io = IO_READ;
@@ -545,13 +545,13 @@ em28xx_v4l2_read(struct file *filp, char __user * buf, size_t count,
        }
 
        if (!count) {
-               up(&dev->fileop_lock);
+               mutex_unlock(&dev->fileop_lock);
                return 0;
        }
 
        if (list_empty(&dev->outqueue)) {
                if (filp->f_flags & O_NONBLOCK) {
-                       up(&dev->fileop_lock);
+                       mutex_unlock(&dev->fileop_lock);
                        return -EAGAIN;
                }
                ret = wait_event_interruptible
@@ -559,11 +559,11 @@ em28xx_v4l2_read(struct file *filp, char __user * buf, size_t count,
                     (!list_empty(&dev->outqueue)) ||
                     (dev->state & DEV_DISCONNECTED));
                if (ret) {
-                       up(&dev->fileop_lock);
+                       mutex_unlock(&dev->fileop_lock);
                        return ret;
                }
                if (dev->state & DEV_DISCONNECTED) {
-                       up(&dev->fileop_lock);
+                       mutex_unlock(&dev->fileop_lock);
                        return -ENODEV;
                }
        }
@@ -582,12 +582,12 @@ em28xx_v4l2_read(struct file *filp, char __user * buf, size_t count,
                count = f->buf.length;
 
        if (copy_to_user(buf, f->bufmem, count)) {
-               up(&dev->fileop_lock);
+               mutex_unlock(&dev->fileop_lock);
                return -EFAULT;
        }
        *f_pos += count;
 
-       up(&dev->fileop_lock);
+       mutex_unlock(&dev->fileop_lock);
 
        return count;
 }
@@ -601,7 +601,7 @@ static unsigned int em28xx_v4l2_poll(struct file *filp, poll_table * wait)
        unsigned int mask = 0;
        struct em28xx *dev = filp->private_data;
 
-       if (down_interruptible(&dev->fileop_lock))
+       if (mutex_lock_interruptible(&dev->fileop_lock))
                return POLLERR;
 
        if (dev->state & DEV_DISCONNECTED) {
@@ -627,13 +627,13 @@ static unsigned int em28xx_v4l2_poll(struct file *filp, poll_table * wait)
                        if (!list_empty(&dev->outqueue))
                                mask |= POLLIN | POLLRDNORM;
 
-                       up(&dev->fileop_lock);
+                       mutex_unlock(&dev->fileop_lock);
 
                        return mask;
                }
        }
 
-       up(&dev->fileop_lock);
+       mutex_unlock(&dev->fileop_lock);
        return POLLERR;
 }
 
@@ -673,25 +673,25 @@ static int em28xx_v4l2_mmap(struct file *filp, struct vm_area_struct *vma)
 
        struct em28xx *dev = filp->private_data;
 
-       if (down_interruptible(&dev->fileop_lock))
+       if (mutex_lock_interruptible(&dev->fileop_lock))
                return -ERESTARTSYS;
 
        if (dev->state & DEV_DISCONNECTED) {
                em28xx_videodbg("mmap: device not present\n");
-               up(&dev->fileop_lock);
+               mutex_unlock(&dev->fileop_lock);
                return -ENODEV;
        }
 
        if (dev->state & DEV_MISCONFIGURED) {
                em28xx_videodbg ("mmap: Device is misconfigured; close and "
                                                "open it again\n");
-               up(&dev->fileop_lock);
+               mutex_unlock(&dev->fileop_lock);
                return -EIO;
        }
 
        if (dev->io != IO_MMAP || !(vma->vm_flags & VM_WRITE) ||
            size != PAGE_ALIGN(dev->frame[0].buf.length)) {
-               up(&dev->fileop_lock);
+               mutex_unlock(&dev->fileop_lock);
                return -EINVAL;
        }
 
@@ -701,7 +701,7 @@ static int em28xx_v4l2_mmap(struct file *filp, struct vm_area_struct *vma)
        }
        if (i == dev->num_frames) {
                em28xx_videodbg("mmap: user supplied mapping address is out of range\n");
-               up(&dev->fileop_lock);
+               mutex_unlock(&dev->fileop_lock);
                return -EINVAL;
        }
 
@@ -713,7 +713,7 @@ static int em28xx_v4l2_mmap(struct file *filp, struct vm_area_struct *vma)
        while (size > 0) {      /* size is page-aligned */
                if (vm_insert_page(vma, start, vmalloc_to_page(pos))) {
                        em28xx_videodbg("mmap: vm_insert_page failed\n");
-                       up(&dev->fileop_lock);
+                       mutex_unlock(&dev->fileop_lock);
                        return -EAGAIN;
                }
                start += PAGE_SIZE;
@@ -725,7 +725,7 @@ static int em28xx_v4l2_mmap(struct file *filp, struct vm_area_struct *vma)
        vma->vm_private_data = &dev->frame[i];
 
        em28xx_vm_open(vma);
-       up(&dev->fileop_lock);
+       mutex_unlock(&dev->fileop_lock);
        return 0;
 }
 
@@ -1125,7 +1125,7 @@ static int em28xx_do_ioctl(struct inode *inode, struct file *filp,
                if (i == TVNORMS)
                        return -EINVAL;
 
-               down(&dev->lock);
+               mutex_lock(&dev->lock);
                dev->tvnorm = &tvnorms[i];
 
                em28xx_set_norm(dev, dev->width, dev->height);
@@ -1135,7 +1135,7 @@ static int em28xx_do_ioctl(struct inode *inode, struct file *filp,
                em28xx_i2c_call_clients(dev, VIDIOC_S_STD,
                                        &dev->tvnorm->id);
 
-               up(&dev->lock);
+               mutex_unlock(&dev->lock);
 
                return 0;
        }
@@ -1189,9 +1189,9 @@ static int em28xx_do_ioctl(struct inode *inode, struct file *filp,
                if (0 == INPUT(*index)->type)
                        return -EINVAL;
 
-               down(&dev->lock);
+               mutex_lock(&dev->lock);
                video_mux(dev, *index);
-               up(&dev->lock);
+               mutex_unlock(&dev->lock);
 
                return 0;
        }
@@ -1338,10 +1338,10 @@ static int em28xx_do_ioctl(struct inode *inode, struct file *filp,
 /*             t->signal = 0xffff;*/
 /*             em28xx_i2c_call_clients(dev,VIDIOC_G_TUNER,t);*/
                /* No way to get signal strength? */
-               down(&dev->lock);
+               mutex_lock(&dev->lock);
                em28xx_i2c_call_clients(dev, DECODER_GET_STATUS,
                                        &status);
-               up(&dev->lock);
+               mutex_unlock(&dev->lock);
                t->signal =
                        (status & DECODER_STATUS_GOOD) != 0 ? 0xffff : 0;
 
@@ -1363,10 +1363,10 @@ static int em28xx_do_ioctl(struct inode *inode, struct file *filp,
                t->rangehigh = 0xffffffffUL;    /* FIXME: set correct range */
 /*             t->signal = 0xffff; */
                /* No way to get signal strength? */
-               down(&dev->lock);
+               mutex_lock(&dev->lock);
                em28xx_i2c_call_clients(dev, DECODER_GET_STATUS,
                                        &status);
-               up(&dev->lock);
+               mutex_unlock(&dev->lock);
                t->signal =
                        (status & DECODER_STATUS_GOOD) != 0 ? 0xffff : 0;
 
@@ -1394,10 +1394,10 @@ static int em28xx_do_ioctl(struct inode *inode, struct file *filp,
                if (V4L2_TUNER_ANALOG_TV != f->type)
                        return -EINVAL;
 
-               down(&dev->lock);
+               mutex_lock(&dev->lock);
                dev->ctl_freq = f->frequency;
                em28xx_i2c_call_clients(dev, VIDIOC_S_FREQUENCY, f);
-               up(&dev->lock);
+               mutex_unlock(&dev->lock);
                return 0;
        }
        case VIDIOC_CROPCAP:
@@ -1660,25 +1660,25 @@ static int em28xx_v4l2_ioctl(struct inode *inode, struct file *filp,
        int ret = 0;
        struct em28xx *dev = filp->private_data;
 
-       if (down_interruptible(&dev->fileop_lock))
+       if (mutex_lock_interruptible(&dev->fileop_lock))
                return -ERESTARTSYS;
 
        if (dev->state & DEV_DISCONNECTED) {
                em28xx_errdev("v4l2 ioctl: device not present\n");
-               up(&dev->fileop_lock);
+               mutex_unlock(&dev->fileop_lock);
                return -ENODEV;
        }
 
        if (dev->state & DEV_MISCONFIGURED) {
                em28xx_errdev
                    ("v4l2 ioctl: device is misconfigured; close and open it again\n");
-               up(&dev->fileop_lock);
+               mutex_unlock(&dev->fileop_lock);
                return -EIO;
        }
 
        ret = video_usercopy(inode, filp, cmd, arg, em28xx_video_do_ioctl);
 
-       up(&dev->fileop_lock);
+       mutex_unlock(&dev->fileop_lock);
 
        return ret;
 }
@@ -1712,7 +1712,7 @@ static int em28xx_init_dev(struct em28xx **devhandle, struct usb_device *udev,
 
        dev->udev = udev;
        dev->model = model;
-       init_MUTEX(&dev->lock);
+       mutex_init(&dev->lock);
        init_waitqueue_head(&dev->open);
 
        dev->em28xx_write_regs = em28xx_write_regs;
@@ -1788,7 +1788,7 @@ static int em28xx_init_dev(struct em28xx **devhandle, struct usb_device *udev,
                return -ENOMEM;
        }
 
-       down(&dev->lock);
+       mutex_lock(&dev->lock);
        /* register i2c bus */
        em28xx_i2c_register(dev);
 
@@ -1798,7 +1798,7 @@ static int em28xx_init_dev(struct em28xx **devhandle, struct usb_device *udev,
        /* configure the device */
        em28xx_config_i2c(dev);
 
-       up(&dev->lock);
+       mutex_unlock(&dev->lock);
 
        errCode = em28xx_config(dev);
 
@@ -1849,12 +1849,12 @@ static int em28xx_init_dev(struct em28xx **devhandle, struct usb_device *udev,
        list_add_tail(&dev->devlist,&em28xx_devlist);
 
        /* register v4l2 device */
-       down(&dev->lock);
+       mutex_lock(&dev->lock);
        if ((retval = video_register_device(dev->vdev, VFL_TYPE_GRABBER,
                                         video_nr[dev->devno]))) {
                em28xx_errdev("unable to register video device (error=%i).\n",
                              retval);
-               up(&dev->lock);
+               mutex_unlock(&dev->lock);
                list_del(&dev->devlist);
                video_device_release(dev->vdev);
                kfree(dev);
@@ -1865,7 +1865,7 @@ static int em28xx_init_dev(struct em28xx **devhandle, struct usb_device *udev,
        if (video_register_device(dev->vbi_dev, VFL_TYPE_VBI,
                                        vbi_nr[dev->devno]) < 0) {
                printk("unable to register vbi device\n");
-               up(&dev->lock);
+               mutex_unlock(&dev->lock);
                list_del(&dev->devlist);
                video_device_release(dev->vbi_dev);
                video_device_release(dev->vdev);
@@ -1886,7 +1886,7 @@ static int em28xx_init_dev(struct em28xx **devhandle, struct usb_device *udev,
        }
        video_mux(dev, 0);
 
-       up(&dev->lock);
+       mutex_unlock(&dev->lock);
 
        em28xx_info("V4L2 device registered as /dev/video%d and /dev/vbi%d\n",
                                dev->vdev->minor-MINOR_VFL_TYPE_GRABBER_MIN,
@@ -2035,7 +2035,7 @@ static void em28xx_usb_disconnect(struct usb_interface *interface)
 
        down_write(&em28xx_disconnect);
 
-       down(&dev->lock);
+       mutex_lock(&dev->lock);
 
        em28xx_info("disconnecting %s\n", dev->vdev->name);
 
@@ -2057,7 +2057,7 @@ static void em28xx_usb_disconnect(struct usb_interface *interface)
                em28xx_release_resources(dev);
        }
 
-       up(&dev->lock);
+       mutex_unlock(&dev->lock);
 
        if (!dev->users) {
                kfree(dev->alt_max_pkt_size);
index ddf06c5..4e2fe62 100644 (file)
@@ -27,6 +27,7 @@
 
 #include <linux/videodev.h>
 #include <linux/i2c.h>
+#include <linux/mutex.h>
 #include <media/ir-kbd-i2c.h>
 
 /* Boards supported by driver */
@@ -260,7 +261,7 @@ struct em28xx {
        enum em28xx_stream_state stream;
        enum em28xx_io_method io;
        /* locks */
-       struct semaphore lock, fileop_lock;
+       struct mutex lock, fileop_lock;
        spinlock_t queue_lock;
        struct list_head inqueue, outqueue;
        wait_queue_head_t open, wait_frame, wait_stream;
index 2869464..850bee9 100644 (file)
@@ -925,7 +925,7 @@ static int meye_do_ioctl(struct inode *inode, struct file *file,
                        return -EINVAL;
                if (p->palette != VIDEO_PALETTE_YUV422)
                        return -EINVAL;
-               down(&meye.lock);
+               mutex_lock(&meye.lock);
                sonypi_camera_command(SONYPI_COMMAND_SETCAMERABRIGHTNESS,
                                      p->brightness >> 10);
                sonypi_camera_command(SONYPI_COMMAND_SETCAMERAHUE,
@@ -935,7 +935,7 @@ static int meye_do_ioctl(struct inode *inode, struct file *file,
                sonypi_camera_command(SONYPI_COMMAND_SETCAMERACONTRAST,
                                      p->contrast >> 10);
                meye.picture = *p;
-               up(&meye.lock);
+               mutex_unlock(&meye.lock);
                break;
        }
 
@@ -946,21 +946,21 @@ static int meye_do_ioctl(struct inode *inode, struct file *file,
                if (*i < 0 || *i >= gbuffers)
                        return -EINVAL;
 
-               down(&meye.lock);
+               mutex_lock(&meye.lock);
 
                switch (meye.grab_buffer[*i].state) {
 
                case MEYE_BUF_UNUSED:
-                       up(&meye.lock);
+                       mutex_unlock(&meye.lock);
                        return -EINVAL;
                case MEYE_BUF_USING:
                        if (file->f_flags & O_NONBLOCK) {
-                               up(&meye.lock);
+                               mutex_unlock(&meye.lock);
                                return -EAGAIN;
                        }
                        if (wait_event_interruptible(meye.proc_list,
                                                     (meye.grab_buffer[*i].state != MEYE_BUF_USING))) {
-                               up(&meye.lock);
+                               mutex_unlock(&meye.lock);
                                return -EINTR;
                        }
                        /* fall through */
@@ -968,7 +968,7 @@ static int meye_do_ioctl(struct inode *inode, struct file *file,
                        meye.grab_buffer[*i].state = MEYE_BUF_UNUSED;
                        kfifo_get(meye.doneq, (unsigned char *)&unused, sizeof(int));
                }
-               up(&meye.lock);
+               mutex_unlock(&meye.lock);
                break;
        }
 
@@ -987,7 +987,7 @@ static int meye_do_ioctl(struct inode *inode, struct file *file,
                if (meye.grab_buffer[vm->frame].state != MEYE_BUF_UNUSED)
                        return -EBUSY;
 
-               down(&meye.lock);
+               mutex_lock(&meye.lock);
                if (vm->width == 640 && vm->height == 480) {
                        if (meye.params.subsample) {
                                meye.params.subsample = 0;
@@ -999,7 +999,7 @@ static int meye_do_ioctl(struct inode *inode, struct file *file,
                                restart = 1;
                        }
                } else {
-                       up(&meye.lock);
+                       mutex_unlock(&meye.lock);
                        return -EINVAL;
                }
 
@@ -1007,7 +1007,7 @@ static int meye_do_ioctl(struct inode *inode, struct file *file,
                        mchip_continuous_start();
                meye.grab_buffer[vm->frame].state = MEYE_BUF_USING;
                kfifo_put(meye.grabq, (unsigned char *)&vm->frame, sizeof(int));
-               up(&meye.lock);
+               mutex_unlock(&meye.lock);
                break;
        }
 
@@ -1039,7 +1039,7 @@ static int meye_do_ioctl(struct inode *inode, struct file *file,
                        return -EINVAL;
                if (jp->framerate > 31)
                        return -EINVAL;
-               down(&meye.lock);
+               mutex_lock(&meye.lock);
                if (meye.params.subsample != jp->subsample ||
                    meye.params.quality != jp->quality)
                        mchip_hic_stop();       /* need restart */
@@ -1050,7 +1050,7 @@ static int meye_do_ioctl(struct inode *inode, struct file *file,
                                      meye.params.agc);
                sonypi_camera_command(SONYPI_COMMAND_SETCAMERAPICTURE,
                                      meye.params.picture);
-               up(&meye.lock);
+               mutex_unlock(&meye.lock);
                break;
        }
 
@@ -1068,12 +1068,12 @@ static int meye_do_ioctl(struct inode *inode, struct file *file,
                }
                if (meye.grab_buffer[*nb].state != MEYE_BUF_UNUSED)
                        return -EBUSY;
-               down(&meye.lock);
+               mutex_lock(&meye.lock);
                if (meye.mchip_mode != MCHIP_HIC_MODE_CONT_COMP)
                        mchip_cont_compression_start();
                meye.grab_buffer[*nb].state = MEYE_BUF_USING;
                kfifo_put(meye.grabq, (unsigned char *)nb, sizeof(int));
-               up(&meye.lock);
+               mutex_unlock(&meye.lock);
                break;
        }
 
@@ -1084,20 +1084,20 @@ static int meye_do_ioctl(struct inode *inode, struct file *file,
                if (*i < 0 || *i >= gbuffers)
                        return -EINVAL;
 
-               down(&meye.lock);
+               mutex_lock(&meye.lock);
                switch (meye.grab_buffer[*i].state) {
 
                case MEYE_BUF_UNUSED:
-                       up(&meye.lock);
+                       mutex_unlock(&meye.lock);
                        return -EINVAL;
                case MEYE_BUF_USING:
                        if (file->f_flags & O_NONBLOCK) {
-                               up(&meye.lock);
+                               mutex_unlock(&meye.lock);
                                return -EAGAIN;
                        }
                        if (wait_event_interruptible(meye.proc_list,
                                                     (meye.grab_buffer[*i].state != MEYE_BUF_USING))) {
-                               up(&meye.lock);
+                               mutex_unlock(&meye.lock);
                                return -EINTR;
                        }
                        /* fall through */
@@ -1106,7 +1106,7 @@ static int meye_do_ioctl(struct inode *inode, struct file *file,
                        kfifo_get(meye.doneq, (unsigned char *)&unused, sizeof(int));
                }
                *i = meye.grab_buffer[*i].size;
-               up(&meye.lock);
+               mutex_unlock(&meye.lock);
                break;
        }
 
@@ -1116,14 +1116,14 @@ static int meye_do_ioctl(struct inode *inode, struct file *file,
                        return -EINVAL;
                if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED)
                        return -EBUSY;
-               down(&meye.lock);
+               mutex_lock(&meye.lock);
                meye.grab_buffer[0].state = MEYE_BUF_USING;
                mchip_take_picture();
                mchip_get_picture(
                        meye.grab_fbuffer,
                        mchip_hsize() * mchip_vsize() * 2);
                meye.grab_buffer[0].state = MEYE_BUF_DONE;
-               up(&meye.lock);
+               mutex_unlock(&meye.lock);
                break;
        }
 
@@ -1134,7 +1134,7 @@ static int meye_do_ioctl(struct inode *inode, struct file *file,
                        return -EINVAL;
                if (meye.grab_buffer[0].state != MEYE_BUF_UNUSED)
                        return -EBUSY;
-               down(&meye.lock);
+               mutex_lock(&meye.lock);
                meye.grab_buffer[0].state = MEYE_BUF_USING;
                *len = -1;
                while (*len == -1) {
@@ -1142,7 +1142,7 @@ static int meye_do_ioctl(struct inode *inode, struct file *file,
                        *len = mchip_compress_frame(meye.grab_fbuffer, gbufsize);
                }
                meye.grab_buffer[0].state = MEYE_BUF_DONE;
-               up(&meye.lock);
+               mutex_unlock(&meye.lock);
                break;
        }
 
@@ -1285,7 +1285,7 @@ static int meye_do_ioctl(struct inode *inode, struct file *file,
        case VIDIOC_S_CTRL: {
                struct v4l2_control *c = arg;
 
-               down(&meye.lock);
+               mutex_lock(&meye.lock);
                switch (c->id) {
                case V4L2_CID_BRIGHTNESS:
                        sonypi_camera_command(
@@ -1329,17 +1329,17 @@ static int meye_do_ioctl(struct inode *inode, struct file *file,
                        meye.params.framerate = c->value;
                        break;
                default:
-                       up(&meye.lock);
+                       mutex_unlock(&meye.lock);
                        return -EINVAL;
                }
-               up(&meye.lock);
+               mutex_unlock(&meye.lock);
                break;
        }
 
        case VIDIOC_G_CTRL: {
                struct v4l2_control *c = arg;
 
-               down(&meye.lock);
+               mutex_lock(&meye.lock);
                switch (c->id) {
                case V4L2_CID_BRIGHTNESS:
                        c->value = meye.picture.brightness >> 10;
@@ -1369,10 +1369,10 @@ static int meye_do_ioctl(struct inode *inode, struct file *file,
                        c->value = meye.params.framerate;
                        break;
                default:
-                       up(&meye.lock);
+                       mutex_unlock(&meye.lock);
                        return -EINVAL;
                }
-               up(&meye.lock);
+               mutex_unlock(&meye.lock);
                break;
        }
 
@@ -1469,7 +1469,7 @@ static int meye_do_ioctl(struct inode *inode, struct file *file,
                    f->fmt.pix.field != V4L2_FIELD_NONE)
                        return -EINVAL;
                f->fmt.pix.field = V4L2_FIELD_NONE;
-               down(&meye.lock);
+               mutex_lock(&meye.lock);
                if (f->fmt.pix.width <= 320) {
                        f->fmt.pix.width = 320;
                        f->fmt.pix.height = 240;
@@ -1487,7 +1487,7 @@ static int meye_do_ioctl(struct inode *inode, struct file *file,
                        meye.mchip_mode = MCHIP_HIC_MODE_CONT_COMP;
                        break;
                }
-               up(&meye.lock);
+               mutex_unlock(&meye.lock);
                f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
                f->fmt.pix.sizeimage = f->fmt.pix.height *
                                       f->fmt.pix.bytesperline;
@@ -1509,11 +1509,11 @@ static int meye_do_ioctl(struct inode *inode, struct file *file,
                        /* already allocated, no modifications */
                        break;
                }
-               down(&meye.lock);
+               mutex_lock(&meye.lock);
                if (meye.grab_fbuffer) {
                        for (i = 0; i < gbuffers; i++)
                                if (meye.vma_use_count[i]) {
-                                       up(&meye.lock);
+                                       mutex_unlock(&meye.lock);
                                        return -EINVAL;
                                }
                        rvfree(meye.grab_fbuffer, gbuffers * gbufsize);
@@ -1525,12 +1525,12 @@ static int meye_do_ioctl(struct inode *inode, struct file *file,
                if (!meye.grab_fbuffer) {
                        printk(KERN_ERR "meye: v4l framebuffer allocation"
                                        " failed\n");
-                       up(&meye.lock);
+                       mutex_unlock(&meye.lock);
                        return -ENOMEM;
                }
                for (i = 0; i < gbuffers; i++)
                        meye.vma_use_count[i] = 0;
-               up(&meye.lock);
+               mutex_unlock(&meye.lock);
                break;
        }
 
@@ -1569,12 +1569,12 @@ static int meye_do_ioctl(struct inode *inode, struct file *file,
                        return -EINVAL;
                if (meye.grab_buffer[buf->index].state != MEYE_BUF_UNUSED)
                        return -EINVAL;
-               down(&meye.lock);
+               mutex_lock(&meye.lock);
                buf->flags |= V4L2_BUF_FLAG_QUEUED;
                buf->flags &= ~V4L2_BUF_FLAG_DONE;
                meye.grab_buffer[buf->index].state = MEYE_BUF_USING;
                kfifo_put(meye.grabq, (unsigned char *)&buf->index, sizeof(int));
-               up(&meye.lock);
+               mutex_unlock(&meye.lock);
                break;
        }
 
@@ -1587,23 +1587,23 @@ static int meye_do_ioctl(struct inode *inode, struct file *file,
                if (buf->memory != V4L2_MEMORY_MMAP)
                        return -EINVAL;
 
-               down(&meye.lock);
+               mutex_lock(&meye.lock);
                if (kfifo_len(meye.doneq) == 0 && file->f_flags & O_NONBLOCK) {
-                       up(&meye.lock);
+                       mutex_unlock(&meye.lock);
                        return -EAGAIN;
                }
                if (wait_event_interruptible(meye.proc_list,
                                             kfifo_len(meye.doneq) != 0) < 0) {
-                       up(&meye.lock);
+                       mutex_unlock(&meye.lock);
                        return -EINTR;
                }
                if (!kfifo_get(meye.doneq, (unsigned char *)&reqnr,
                               sizeof(int))) {
-                       up(&meye.lock);
+                       mutex_unlock(&meye.lock);
                        return -EBUSY;
                }
                if (meye.grab_buffer[reqnr].state != MEYE_BUF_DONE) {
-                       up(&meye.lock);
+                       mutex_unlock(&meye.lock);
                        return -EINVAL;
                }
                buf->index = reqnr;
@@ -1616,12 +1616,12 @@ static int meye_do_ioctl(struct inode *inode, struct file *file,
                buf->m.offset = reqnr * gbufsize;
                buf->length = gbufsize;
                meye.grab_buffer[reqnr].state = MEYE_BUF_UNUSED;
-               up(&meye.lock);
+               mutex_unlock(&meye.lock);
                break;
        }
 
        case VIDIOC_STREAMON: {
-               down(&meye.lock);
+               mutex_lock(&meye.lock);
                switch (meye.mchip_mode) {
                case MCHIP_HIC_MODE_CONT_OUT:
                        mchip_continuous_start();
@@ -1630,23 +1630,23 @@ static int meye_do_ioctl(struct inode *inode, struct file *file,
                        mchip_cont_compression_start();
                        break;
                default:
-                       up(&meye.lock);
+                       mutex_unlock(&meye.lock);
                        return -EINVAL;
                }
-               up(&meye.lock);
+               mutex_unlock(&meye.lock);
                break;
        }
 
        case VIDIOC_STREAMOFF: {
                int i;
 
-               down(&meye.lock);
+               mutex_lock(&meye.lock);
                mchip_hic_stop();
                kfifo_reset(meye.grabq);
                kfifo_reset(meye.doneq);
                for (i = 0; i < MEYE_MAX_BUFNBRS; i++)
                        meye.grab_buffer[i].state = MEYE_BUF_UNUSED;
-               up(&meye.lock);
+               mutex_unlock(&meye.lock);
                break;
        }
 
@@ -1672,11 +1672,11 @@ static unsigned int meye_poll(struct file *file, poll_table *wait)
 {
        unsigned int res = 0;
 
-       down(&meye.lock);
+       mutex_lock(&meye.lock);
        poll_wait(file, &meye.proc_list, wait);
        if (kfifo_len(meye.doneq))
                res = POLLIN | POLLRDNORM;
-       up(&meye.lock);
+       mutex_unlock(&meye.lock);
        return res;
 }
 
@@ -1704,9 +1704,9 @@ static int meye_mmap(struct file *file, struct vm_area_struct *vma)
        unsigned long offset = vma->vm_pgoff << PAGE_SHIFT;
        unsigned long page, pos;
 
-       down(&meye.lock);
+       mutex_lock(&meye.lock);
        if (size > gbuffers * gbufsize) {
-               up(&meye.lock);
+               mutex_unlock(&meye.lock);
                return -EINVAL;
        }
        if (!meye.grab_fbuffer) {
@@ -1716,7 +1716,7 @@ static int meye_mmap(struct file *file, struct vm_area_struct *vma)
                meye.grab_fbuffer = rvmalloc(gbuffers*gbufsize);
                if (!meye.grab_fbuffer) {
                        printk(KERN_ERR "meye: v4l framebuffer allocation failed\n");
-                       up(&meye.lock);
+                       mutex_unlock(&meye.lock);
                        return -ENOMEM;
                }
                for (i = 0; i < gbuffers; i++)
@@ -1727,7 +1727,7 @@ static int meye_mmap(struct file *file, struct vm_area_struct *vma)
        while (size > 0) {
                page = vmalloc_to_pfn((void *)pos);
                if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED)) {
-                       up(&meye.lock);
+                       mutex_unlock(&meye.lock);
                        return -EAGAIN;
                }
                start += PAGE_SIZE;
@@ -1744,7 +1744,7 @@ static int meye_mmap(struct file *file, struct vm_area_struct *vma)
        vma->vm_private_data = (void *) (offset / gbufsize);
        meye_vm_open(vma);
 
-       up(&meye.lock);
+       mutex_unlock(&meye.lock);
        return 0;
 }
 
@@ -1913,7 +1913,7 @@ static int __devinit meye_probe(struct pci_dev *pcidev,
                goto outvideoreg;
        }
 
-       init_MUTEX(&meye.lock);
+       mutex_init(&meye.lock);
        init_waitqueue_head(&meye.proc_list);
        meye.picture.depth = 16;
        meye.picture.palette = VIDEO_PALETTE_YUV422;
index e8cd897..0d09a0e 100644 (file)
 
 /* private API definitions */
 #include <linux/meye.h>
+#include <linux/mutex.h>
+
 
 /* Enable jpg software correction */
 #define MEYE_JPEG_CORRECTION   1
@@ -301,7 +303,7 @@ struct meye {
                                        /* list of buffers */
        struct meye_grab_buffer grab_buffer[MEYE_MAX_BUFNBRS];
        int vma_use_count[MEYE_MAX_BUFNBRS]; /* mmap count */
-       struct semaphore lock;          /* semaphore for open/mmap... */
+       struct mutex lock;              /* mutex for open/mmap... */
        struct kfifo *grabq;            /* queue for buffers to be grabbed */
        spinlock_t grabq_lock;          /* lock protecting the queue */
        struct kfifo *doneq;            /* queue for grabbed buffers */
index 8416cef..69a7edd 100644 (file)
@@ -625,9 +625,9 @@ static int mxb_ioctl(struct saa7146_fh *fh, unsigned int cmd, void *arg)
                }
                
                /* fixme: locke das setzen des inputs mit hilfe des mutexes
-               down(&dev->lock);
+               mutex_lock(&dev->lock);
                video_mux(dev,*i);
-               up(&dev->lock);
+               mutex_unlock(&dev->lock);
                */
                                
                /* fixme: check if streaming capture
index f3fc361..15fd85a 100644 (file)
@@ -48,7 +48,7 @@
 #include <asm/pgtable.h>
 #include <asm/page.h>
 #include <asm/irq.h>
-#include <asm/semaphore.h>
+#include <linux/mutex.h>
 
 #include "planb.h"
 #include "saa7196.h"
@@ -329,12 +329,12 @@ static volatile struct dbdma_cmd *cmd_geo_setup(
 
 static inline void planb_lock(struct planb *pb)
 {
-       down(&pb->lock);
+       mutex_lock(&pb->lock);
 }
 
 static inline void planb_unlock(struct planb *pb)
 {
-       up(&pb->lock);
+       mutex_unlock(&pb->lock);
 }
 
 /***************/
@@ -2067,7 +2067,7 @@ static int init_planb(struct planb *pb)
 #endif
        pb->tab_size = PLANB_MAXLINES + 40;
        pb->suspend = 0;
-       init_MUTEX(&pb->lock);
+       mutex_init(&pb->lock);
        pb->ch1_cmd = 0;
        pb->ch2_cmd = 0;
        pb->mask = 0;
index 8a0faad..79b6b56 100644 (file)
@@ -174,7 +174,7 @@ struct planb {
        int     user;
        unsigned int tab_size;
        int     maxlines;
-       struct semaphore lock;
+       struct mutex lock;
        unsigned int    irq;                    /* interrupt number */
        volatile unsigned int intr_mask;
 
index 9e64486..05ca559 100644 (file)
@@ -30,6 +30,8 @@
 #include <asm/io.h>
 #include <linux/sched.h>
 #include <linux/videodev.h>
+#include <linux/mutex.h>
+
 #include <asm/uaccess.h>
 
 
@@ -44,7 +46,7 @@ struct pms_device
        struct video_picture picture;
        int height;
        int width;
-       struct semaphore lock;
+       struct mutex lock;
 };
 
 struct i2c_info
@@ -724,10 +726,10 @@ static int pms_do_ioctl(struct inode *inode, struct file *file,
                        struct video_channel *v = arg;
                        if(v->channel<0 || v->channel>3)
                                return -EINVAL;
-                       down(&pd->lock);
+                       mutex_lock(&pd->lock);
                        pms_videosource(v->channel&1);
                        pms_vcrinput(v->channel>>1);
-                       up(&pd->lock);
+                       mutex_unlock(&pd->lock);
                        return 0;
                }
                case VIDIOCGTUNER:
@@ -761,7 +763,7 @@ static int pms_do_ioctl(struct inode *inode, struct file *file,
                        struct video_tuner *v = arg;
                        if(v->tuner)
                                return -EINVAL;
-                       down(&pd->lock);
+                       mutex_lock(&pd->lock);
                        switch(v->mode)
                        {
                                case VIDEO_MODE_AUTO:
@@ -785,10 +787,10 @@ static int pms_do_ioctl(struct inode *inode, struct file *file,
                                        pms_format(2);
                                        break;
                                default:
-                                       up(&pd->lock);
+                                       mutex_unlock(&pd->lock);
                                        return -EINVAL;
                        }
-                       up(&pd->lock);
+                       mutex_unlock(&pd->lock);
                        return 0;
                }
                case VIDIOCGPICT:
@@ -809,12 +811,12 @@ static int pms_do_ioctl(struct inode *inode, struct file *file,
                         *      Now load the card.
                         */
 
-                       down(&pd->lock);
+                       mutex_lock(&pd->lock);
                        pms_brightness(p->brightness>>8);
                        pms_hue(p->hue>>8);
                        pms_colour(p->colour>>8);
                        pms_contrast(p->contrast>>8);   
-                       up(&pd->lock);
+                       mutex_unlock(&pd->lock);
                        return 0;
                }
                case VIDIOCSWIN:
@@ -830,9 +832,9 @@ static int pms_do_ioctl(struct inode *inode, struct file *file,
                                return -EINVAL;
                        pd->width=vw->width;
                        pd->height=vw->height;
-                       down(&pd->lock);
+                       mutex_lock(&pd->lock);
                        pms_resolution(pd->width, pd->height);
-                       up(&pd->lock);                  /* Ok we figured out what to use from our wide choice */
+                       mutex_unlock(&pd->lock);                        /* Ok we figured out what to use from our wide choice */
                        return 0;
                }
                case VIDIOCGWIN:
@@ -872,9 +874,9 @@ static ssize_t pms_read(struct file *file, char __user *buf,
        struct pms_device *pd=(struct pms_device *)v;
        int len;
        
-       down(&pd->lock);
+       mutex_lock(&pd->lock);
        len=pms_capture(pd, buf, (pd->picture.depth==16)?0:1,count);
-       up(&pd->lock);
+       mutex_unlock(&pd->lock);
        return len;
 }
 
@@ -1029,7 +1031,7 @@ static int __init init_pms_cards(void)
                return -ENODEV;
        }
        memcpy(&pms_device, &pms_template, sizeof(pms_template));
-       init_MUTEX(&pms_device.lock);
+       mutex_init(&pms_device.lock);
        pms_device.height=240;
        pms_device.width=320;
        pms_swsense(75);
index 2ce0102..dd830e0 100644 (file)
@@ -46,6 +46,8 @@
 #include <linux/i2c.h>
 #include <linux/videotext.h>
 #include <linux/videodev.h>
+#include <linux/mutex.h>
+
 #include "saa5246a.h"
 
 MODULE_AUTHOR("Michael Geng <linux@MichaelGeng.de>");
@@ -57,7 +59,7 @@ struct saa5246a_device
        u8     pgbuf[NUM_DAUS][VTX_VIRTUALSIZE];
        int    is_searching[NUM_DAUS];
        struct i2c_client *client;
-       struct semaphore lock;
+       struct mutex lock;
 };
 
 static struct video_device saa_template;       /* Declared near bottom */
@@ -90,7 +92,7 @@ static int saa5246a_attach(struct i2c_adapter *adap, int addr, int kind)
                return -ENOMEM;
        }
        strlcpy(client->name, IF_NAME, I2C_NAME_SIZE);
-       init_MUTEX(&t->lock);
+       mutex_init(&t->lock);
 
        /*
         *      Now create a video4linux device
@@ -719,9 +721,9 @@ static int saa5246a_ioctl(struct inode *inode, struct file *file,
        int err;
 
        cmd = vtx_fix_command(cmd);
-       down(&t->lock);
+       mutex_lock(&t->lock);
        err = video_usercopy(inode, file, cmd, arg, do_saa5246a_ioctl);
-       up(&t->lock);
+       mutex_unlock(&t->lock);
        return err;
 }
 
index 5694eb5..a9f3cf0 100644 (file)
@@ -56,6 +56,8 @@
 #include <linux/i2c.h>
 #include <linux/videotext.h>
 #include <linux/videodev.h>
+#include <linux/mutex.h>
+
 
 #include <asm/io.h>
 #include <asm/uaccess.h>
@@ -105,7 +107,7 @@ struct saa5249_device
        int disp_mode;
        int virtual_mode;
        struct i2c_client *client;
-       struct semaphore lock;
+       struct mutex lock;
 };
 
 
@@ -158,7 +160,7 @@ static int saa5249_attach(struct i2c_adapter *adap, int addr, int kind)
                return -ENOMEM;
        }
        strlcpy(client->name, IF_NAME, I2C_NAME_SIZE);
-       init_MUTEX(&t->lock);
+       mutex_init(&t->lock);
        
        /*
         *      Now create a video4linux device
@@ -619,9 +621,9 @@ static int saa5249_ioctl(struct inode *inode, struct file *file,
        int err;
        
        cmd = vtx_fix_command(cmd);
-       down(&t->lock);
+       mutex_lock(&t->lock);
        err = video_usercopy(inode,file,cmd,arg,do_saa5249_ioctl);
-       up(&t->lock);
+       mutex_unlock(&t->lock);
        return err;
 }
 
index a7a6ab9..d3c7345 100644 (file)
@@ -609,12 +609,12 @@ static int snd_card_saa7134_capture_open(snd_pcm_substream_t * substream)
        struct saa7134_dev *dev = saa7134->dev;
        int err;
 
-       down(&dev->dmasound.lock);
+       mutex_lock(&dev->dmasound.lock);
 
        dev->dmasound.read_count  = 0;
        dev->dmasound.read_offset = 0;
 
-       up(&dev->dmasound.lock);
+       mutex_unlock(&dev->dmasound.lock);
 
        pcm = kzalloc(sizeof(*pcm), GFP_KERNEL);
        if (pcm == NULL)
@@ -932,7 +932,7 @@ static int alsa_card_saa7134_create(struct saa7134_dev *dev, int devnum)
 
        chip->irq = dev->pci->irq;
 
-       init_MUTEX(&dev->dmasound.lock);
+       mutex_init(&dev->dmasound.lock);
 
        if ((err = snd_card_saa7134_new_mixer(chip)) < 0)
                goto __nodev;
index 028904b..e7c3066 100644 (file)
@@ -613,7 +613,7 @@ static int saa7134_hwinit1(struct saa7134_dev *dev)
 
        saa_writel(SAA7134_IRQ1, 0);
        saa_writel(SAA7134_IRQ2, 0);
-       init_MUTEX(&dev->lock);
+       mutex_init(&dev->lock);
        spin_lock_init(&dev->slock);
 
        saa7134_track_gpio(dev,"pre-init");
index bd4c389..1d972ed 100644 (file)
@@ -89,7 +89,7 @@ static int ts_open(struct inode *inode, struct file *file)
 
        dprintk("open minor=%d\n",minor);
        err = -EBUSY;
-       if (down_trylock(&dev->empress_tsq.lock))
+       if (!mutex_trylock(&dev->empress_tsq.lock))
                goto done;
        if (dev->empress_users)
                goto done_up;
@@ -99,7 +99,7 @@ static int ts_open(struct inode *inode, struct file *file)
        err = 0;
 
 done_up:
-       up(&dev->empress_tsq.lock);
+       mutex_unlock(&dev->empress_tsq.lock);
 done:
        return err;
 }
@@ -110,7 +110,7 @@ static int ts_release(struct inode *inode, struct file *file)
 
        if (dev->empress_tsq.streaming)
                videobuf_streamoff(&dev->empress_tsq);
-       down(&dev->empress_tsq.lock);
+       mutex_lock(&dev->empress_tsq.lock);
        if (dev->empress_tsq.reading)
                videobuf_read_stop(&dev->empress_tsq);
        videobuf_mmap_free(&dev->empress_tsq);
@@ -119,7 +119,7 @@ static int ts_release(struct inode *inode, struct file *file)
        /* stop the encoder */
        ts_reset_encoder(dev);
 
-       up(&dev->empress_tsq.lock);
+       mutex_unlock(&dev->empress_tsq.lock);
        return 0;
 }
 
index 7448e38..80e34a5 100644 (file)
@@ -254,7 +254,7 @@ static int dsp_open(struct inode *inode, struct file *file)
        if (NULL == dev)
                return -ENODEV;
 
-       down(&dev->dmasound.lock);
+       mutex_lock(&dev->dmasound.lock);
        err = -EBUSY;
        if (dev->dmasound.users_dsp)
                goto fail1;
@@ -270,13 +270,13 @@ static int dsp_open(struct inode *inode, struct file *file)
        if (0 != err)
                goto fail2;
 
-       up(&dev->dmasound.lock);
+       mutex_unlock(&dev->dmasound.lock);
        return 0;
 
  fail2:
        dev->dmasound.users_dsp--;
  fail1:
-       up(&dev->dmasound.lock);
+       mutex_unlock(&dev->dmasound.lock);
        return err;
 }
 
@@ -284,13 +284,13 @@ static int dsp_release(struct inode *inode, struct file *file)
 {
        struct saa7134_dev *dev = file->private_data;
 
-       down(&dev->dmasound.lock);
+       mutex_lock(&dev->dmasound.lock);
        if (dev->dmasound.recording_on)
                dsp_rec_stop(dev);
        dsp_buffer_free(dev);
        dev->dmasound.users_dsp--;
        file->private_data = NULL;
-       up(&dev->dmasound.lock);
+       mutex_unlock(&dev->dmasound.lock);
        return 0;
 }
 
@@ -304,7 +304,7 @@ static ssize_t dsp_read(struct file *file, char __user *buffer,
        int err,ret = 0;
 
        add_wait_queue(&dev->dmasound.wq, &wait);
-       down(&dev->dmasound.lock);
+       mutex_lock(&dev->dmasound.lock);
        while (count > 0) {
                /* wait for data if needed */
                if (0 == dev->dmasound.read_count) {
@@ -328,12 +328,12 @@ static ssize_t dsp_read(struct file *file, char __user *buffer,
                                        ret = -EAGAIN;
                                break;
                        }
-                       up(&dev->dmasound.lock);
+                       mutex_unlock(&dev->dmasound.lock);
                        set_current_state(TASK_INTERRUPTIBLE);
                        if (0 == dev->dmasound.read_count)
                                schedule();
                        set_current_state(TASK_RUNNING);
-                       down(&dev->dmasound.lock);
+                       mutex_lock(&dev->dmasound.lock);
                        if (signal_pending(current)) {
                                if (0 == ret)
                                        ret = -EINTR;
@@ -362,7 +362,7 @@ static ssize_t dsp_read(struct file *file, char __user *buffer,
                if (dev->dmasound.read_offset == dev->dmasound.bufsize)
                        dev->dmasound.read_offset = 0;
        }
-       up(&dev->dmasound.lock);
+       mutex_unlock(&dev->dmasound.lock);
        remove_wait_queue(&dev->dmasound.wq, &wait);
        return ret;
 }
@@ -435,13 +435,13 @@ static int dsp_ioctl(struct inode *inode, struct file *file,
        case SNDCTL_DSP_STEREO:
                if (get_user(val, p))
                        return -EFAULT;
-               down(&dev->dmasound.lock);
+               mutex_lock(&dev->dmasound.lock);
                dev->dmasound.channels = val ? 2 : 1;
                if (dev->dmasound.recording_on) {
                        dsp_rec_stop(dev);
                        dsp_rec_start(dev);
                }
-               up(&dev->dmasound.lock);
+               mutex_unlock(&dev->dmasound.lock);
                return put_user(dev->dmasound.channels-1, p);
 
        case SNDCTL_DSP_CHANNELS:
@@ -449,13 +449,13 @@ static int dsp_ioctl(struct inode *inode, struct file *file,
                        return -EFAULT;
                if (val != 1 && val != 2)
                        return -EINVAL;
-               down(&dev->dmasound.lock);
+               mutex_lock(&dev->dmasound.lock);
                dev->dmasound.channels = val;
                if (dev->dmasound.recording_on) {
                        dsp_rec_stop(dev);
                        dsp_rec_start(dev);
                }
-               up(&dev->dmasound.lock);
+               mutex_unlock(&dev->dmasound.lock);
                /* fall through */
        case SOUND_PCM_READ_CHANNELS:
                return put_user(dev->dmasound.channels, p);
@@ -478,13 +478,13 @@ static int dsp_ioctl(struct inode *inode, struct file *file,
                case AFMT_U16_BE:
                case AFMT_S16_LE:
                case AFMT_S16_BE:
-                       down(&dev->dmasound.lock);
+                       mutex_lock(&dev->dmasound.lock);
                        dev->dmasound.afmt = val;
                        if (dev->dmasound.recording_on) {
                                dsp_rec_stop(dev);
                                dsp_rec_start(dev);
                        }
-                       up(&dev->dmasound.lock);
+                       mutex_unlock(&dev->dmasound.lock);
                        return put_user(dev->dmasound.afmt, p);
                default:
                        return -EINVAL;
@@ -509,10 +509,10 @@ static int dsp_ioctl(struct inode *inode, struct file *file,
                return 0;
 
        case SNDCTL_DSP_RESET:
-               down(&dev->dmasound.lock);
+               mutex_lock(&dev->dmasound.lock);
                if (dev->dmasound.recording_on)
                        dsp_rec_stop(dev);
-               up(&dev->dmasound.lock);
+               mutex_unlock(&dev->dmasound.lock);
                return 0;
        case SNDCTL_DSP_GETBLKSIZE:
                return put_user(dev->dmasound.blksize, p);
@@ -556,10 +556,10 @@ static unsigned int dsp_poll(struct file *file, struct poll_table_struct *wait)
        poll_wait(file, &dev->dmasound.wq, wait);
 
        if (0 == dev->dmasound.read_count) {
-               down(&dev->dmasound.lock);
+               mutex_lock(&dev->dmasound.lock);
                if (!dev->dmasound.recording_on)
                        dsp_rec_start(dev);
-               up(&dev->dmasound.lock);
+               mutex_unlock(&dev->dmasound.lock);
        } else
                mask |= (POLLIN | POLLRDNORM);
        return mask;
@@ -852,7 +852,7 @@ int saa7134_oss_init1(struct saa7134_dev *dev)
                return -1;
 
        /* general */
-       init_MUTEX(&dev->dmasound.lock);
+       mutex_init(&dev->dmasound.lock);
        init_waitqueue_head(&dev->dmasound.wq);
 
        switch (dev->pci->device) {
index e97426b..72f389a 100644 (file)
@@ -460,17 +460,17 @@ static int res_get(struct saa7134_dev *dev, struct saa7134_fh *fh, unsigned int
                return 1;
 
        /* is it free? */
-       down(&dev->lock);
+       mutex_lock(&dev->lock);
        if (dev->resources & bit) {
                /* no, someone else uses it */
-               up(&dev->lock);
+               mutex_unlock(&dev->lock);
                return 0;
        }
        /* it's free, grab it */
        fh->resources  |= bit;
        dev->resources |= bit;
        dprintk("res: get %d\n",bit);
-       up(&dev->lock);
+       mutex_unlock(&dev->lock);
        return 1;
 }
 
@@ -492,11 +492,11 @@ void res_free(struct saa7134_dev *dev, struct saa7134_fh *fh, unsigned int bits)
        if ((fh->resources & bits) != bits)
                BUG();
 
-       down(&dev->lock);
+       mutex_lock(&dev->lock);
        fh->resources  &= ~bits;
        dev->resources &= ~bits;
        dprintk("res: put %d\n",bits);
-       up(&dev->lock);
+       mutex_unlock(&dev->lock);
 }
 
 /* ------------------------------------------------------------------ */
@@ -1340,21 +1340,21 @@ video_poll(struct file *file, struct poll_table_struct *wait)
                if (!list_empty(&fh->cap.stream))
                        buf = list_entry(fh->cap.stream.next, struct videobuf_buffer, stream);
        } else {
-               down(&fh->cap.lock);
+               mutex_lock(&fh->cap.lock);
                if (UNSET == fh->cap.read_off) {
                        /* need to capture a new frame */
                        if (res_locked(fh->dev,RESOURCE_VIDEO)) {
-                               up(&fh->cap.lock);
+                               mutex_unlock(&fh->cap.lock);
                                return POLLERR;
                        }
                        if (0 != fh->cap.ops->buf_prepare(&fh->cap,fh->cap.read_buf,fh->cap.field)) {
-                               up(&fh->cap.lock);
+                               mutex_unlock(&fh->cap.lock);
                                return POLLERR;
                        }
                        fh->cap.ops->buf_queue(&fh->cap,fh->cap.read_buf);
                        fh->cap.read_off = 0;
                }
-               up(&fh->cap.lock);
+               mutex_unlock(&fh->cap.lock);
                buf = fh->cap.read_buf;
        }
 
@@ -1561,14 +1561,14 @@ static int saa7134_s_fmt(struct saa7134_dev *dev, struct saa7134_fh *fh,
                if (0 != err)
                        return err;
 
-               down(&dev->lock);
+               mutex_lock(&dev->lock);
                fh->win    = f->fmt.win;
                fh->nclips = f->fmt.win.clipcount;
                if (fh->nclips > 8)
                        fh->nclips = 8;
                if (copy_from_user(fh->clips,f->fmt.win.clips,
                                   sizeof(struct v4l2_clip)*fh->nclips)) {
-                       up(&dev->lock);
+                       mutex_unlock(&dev->lock);
                        return -EFAULT;
                }
 
@@ -1578,7 +1578,7 @@ static int saa7134_s_fmt(struct saa7134_dev *dev, struct saa7134_fh *fh,
                        start_preview(dev,fh);
                        spin_unlock_irqrestore(&dev->slock,flags);
                }
-               up(&dev->lock);
+               mutex_unlock(&dev->lock);
                return 0;
        case V4L2_BUF_TYPE_VBI_CAPTURE:
                saa7134_vbi_fmt(dev,f);
@@ -1612,9 +1612,9 @@ int saa7134_common_ioctl(struct saa7134_dev *dev,
                return get_control(dev,arg);
        case VIDIOC_S_CTRL:
        {
-               down(&dev->lock);
+               mutex_lock(&dev->lock);
                err = set_control(dev,NULL,arg);
-               up(&dev->lock);
+               mutex_unlock(&dev->lock);
                return err;
        }
        /* --- input switching --------------------------------------- */
@@ -1664,9 +1664,9 @@ int saa7134_common_ioctl(struct saa7134_dev *dev,
                        return -EINVAL;
                if (NULL == card_in(dev,*i).name)
                        return -EINVAL;
-               down(&dev->lock);
+               mutex_lock(&dev->lock);
                video_mux(dev,*i);
-               up(&dev->lock);
+               mutex_unlock(&dev->lock);
                return 0;
        }
 
@@ -1766,7 +1766,7 @@ static int video_do_ioctl(struct inode *inode, struct file *file,
                if (i == TVNORMS)
                        return -EINVAL;
 
-               down(&dev->lock);
+               mutex_lock(&dev->lock);
                if (res_check(fh, RESOURCE_OVERLAY)) {
                        spin_lock_irqsave(&dev->slock,flags);
                        stop_preview(dev,fh);
@@ -1776,7 +1776,7 @@ static int video_do_ioctl(struct inode *inode, struct file *file,
                } else
                        set_tvnorm(dev,&tvnorms[i]);
                saa7134_tvaudio_do_scan(dev);
-               up(&dev->lock);
+               mutex_unlock(&dev->lock);
                return 0;
        }
 
@@ -1909,13 +1909,13 @@ static int video_do_ioctl(struct inode *inode, struct file *file,
                        return -EINVAL;
                if (1 == fh->radio && V4L2_TUNER_RADIO != f->type)
                        return -EINVAL;
-               down(&dev->lock);
+               mutex_lock(&dev->lock);
                dev->ctl_freq = f->frequency;
 
                saa7134_i2c_call_clients(dev,VIDIOC_S_FREQUENCY,f);
 
                saa7134_tvaudio_do_scan(dev);
-               up(&dev->lock);
+               mutex_unlock(&dev->lock);
                return 0;
        }
 
index ff39a63..691c10b 100644 (file)
@@ -29,6 +29,7 @@
 #include <linux/input.h>
 #include <linux/notifier.h>
 #include <linux/delay.h>
+#include <linux/mutex.h>
 
 #include <asm/io.h>
 
@@ -364,7 +365,7 @@ struct saa7134_fh {
 
 /* dmasound dsp status */
 struct saa7134_dmasound {
-       struct semaphore           lock;
+       struct mutex               lock;
        int                        minor_mixer;
        int                        minor_dsp;
        unsigned int               users_dsp;
@@ -428,7 +429,7 @@ struct saa7134_mpeg_ops {
 /* global device status */
 struct saa7134_dev {
        struct list_head           devlist;
-       struct semaphore           lock;
+       struct mutex               lock;
        spinlock_t                 slock;
 #ifdef VIDIOC_G_PRIORITY
        struct v4l2_prio_state     prio;
index 0a4004a..caf3e7e 100644 (file)
@@ -96,7 +96,7 @@ static int videobuf_dvb_start_feed(struct dvb_demux_feed *feed)
        if (!demux->dmx.frontend)
                return -EINVAL;
 
-       down(&dvb->lock);
+       mutex_lock(&dvb->lock);
        dvb->nfeeds++;
        rc = dvb->nfeeds;
 
@@ -110,7 +110,7 @@ static int videobuf_dvb_start_feed(struct dvb_demux_feed *feed)
        }
 
 out:
-       up(&dvb->lock);
+       mutex_unlock(&dvb->lock);
        return rc;
 }
 
@@ -120,14 +120,14 @@ static int videobuf_dvb_stop_feed(struct dvb_demux_feed *feed)
        struct videobuf_dvb *dvb = demux->priv;
        int err = 0;
 
-       down(&dvb->lock);
+       mutex_lock(&dvb->lock);
        dvb->nfeeds--;
        if (0 == dvb->nfeeds  &&  NULL != dvb->thread) {
                // FIXME: cx8802_cancel_buffers(dev);
                err = kthread_stop(dvb->thread);
                dvb->thread = NULL;
        }
-       up(&dvb->lock);
+       mutex_unlock(&dvb->lock);
        return err;
 }
 
@@ -139,7 +139,7 @@ int videobuf_dvb_register(struct videobuf_dvb *dvb,
 {
        int result;
 
-       init_MUTEX(&dvb->lock);
+       mutex_init(&dvb->lock);
 
        /* register adapter */
        result = dvb_register_adapter(&dvb->adapter, dvb->name, module);
index 9ef4775..cb1c228 100644 (file)
@@ -385,7 +385,7 @@ void videobuf_queue_init(struct videobuf_queue* q,
        q->ops     = ops;
        q->priv_data = priv;
 
-       init_MUTEX(&q->lock);
+       mutex_init(&q->lock);
        INIT_LIST_HEAD(&q->stream);
 }
 
@@ -549,7 +549,7 @@ videobuf_reqbufs(struct videobuf_queue *q,
        if (!list_empty(&q->stream))
                return -EBUSY;
 
-       down(&q->lock);
+       mutex_lock(&q->lock);
        count = req->count;
        if (count > VIDEO_MAX_FRAME)
                count = VIDEO_MAX_FRAME;
@@ -566,7 +566,7 @@ videobuf_reqbufs(struct videobuf_queue *q,
        req->count = count;
 
  done:
-       up(&q->lock);
+       mutex_unlock(&q->lock);
        return retval;
 }
 
@@ -592,7 +592,7 @@ videobuf_qbuf(struct videobuf_queue *q,
        unsigned long flags;
        int retval;
 
-       down(&q->lock);
+       mutex_lock(&q->lock);
        retval = -EBUSY;
        if (q->reading)
                goto done;
@@ -652,7 +652,7 @@ videobuf_qbuf(struct videobuf_queue *q,
        retval = 0;
 
  done:
-       up(&q->lock);
+       mutex_unlock(&q->lock);
        return retval;
 }
 
@@ -663,7 +663,7 @@ videobuf_dqbuf(struct videobuf_queue *q,
        struct videobuf_buffer *buf;
        int retval;
 
-       down(&q->lock);
+       mutex_lock(&q->lock);
        retval = -EBUSY;
        if (q->reading)
                goto done;
@@ -693,7 +693,7 @@ videobuf_dqbuf(struct videobuf_queue *q,
        videobuf_status(b,buf,q->type);
 
  done:
-       up(&q->lock);
+       mutex_unlock(&q->lock);
        return retval;
 }
 
@@ -704,7 +704,7 @@ int videobuf_streamon(struct videobuf_queue *q)
        unsigned long flags;
        int retval;
 
-       down(&q->lock);
+       mutex_lock(&q->lock);
        retval = -EBUSY;
        if (q->reading)
                goto done;
@@ -721,7 +721,7 @@ int videobuf_streamon(struct videobuf_queue *q)
        spin_unlock_irqrestore(q->irqlock,flags);
 
  done:
-       up(&q->lock);
+       mutex_unlock(&q->lock);
        return retval;
 }
 
@@ -729,7 +729,7 @@ int videobuf_streamoff(struct videobuf_queue *q)
 {
        int retval = -EINVAL;
 
-       down(&q->lock);
+       mutex_lock(&q->lock);
        if (!q->streaming)
                goto done;
        videobuf_queue_cancel(q);
@@ -737,7 +737,7 @@ int videobuf_streamoff(struct videobuf_queue *q)
        retval = 0;
 
  done:
-       up(&q->lock);
+       mutex_unlock(&q->lock);
        return retval;
 }
 
@@ -792,7 +792,7 @@ ssize_t videobuf_read_one(struct videobuf_queue *q,
        unsigned size, nbufs, bytes;
        int retval;
 
-       down(&q->lock);
+       mutex_lock(&q->lock);
 
        nbufs = 1; size = 0;
        q->ops->buf_setup(q,&nbufs,&size);
@@ -860,7 +860,7 @@ ssize_t videobuf_read_one(struct videobuf_queue *q,
        }
 
  done:
-       up(&q->lock);
+       mutex_unlock(&q->lock);
        return retval;
 }
 
@@ -922,7 +922,7 @@ ssize_t videobuf_read_stream(struct videobuf_queue *q,
        unsigned long flags;
 
        dprintk(2,"%s\n",__FUNCTION__);
-       down(&q->lock);
+       mutex_lock(&q->lock);
        retval = -EBUSY;
        if (q->streaming)
                goto done;
@@ -996,7 +996,7 @@ ssize_t videobuf_read_stream(struct videobuf_queue *q,
        }
 
  done:
-       up(&q->lock);
+       mutex_unlock(&q->lock);
        return retval;
 }
 
@@ -1007,7 +1007,7 @@ unsigned int videobuf_poll_stream(struct file *file,
        struct videobuf_buffer *buf = NULL;
        unsigned int rc = 0;
 
-       down(&q->lock);
+       mutex_lock(&q->lock);
        if (q->streaming) {
                if (!list_empty(&q->stream))
                        buf = list_entry(q->stream.next,
@@ -1035,7 +1035,7 @@ unsigned int videobuf_poll_stream(struct file *file,
                    buf->state == STATE_ERROR)
                        rc = POLLIN|POLLRDNORM;
        }
-       up(&q->lock);
+       mutex_unlock(&q->lock);
        return rc;
 }
 
@@ -1064,7 +1064,7 @@ videobuf_vm_close(struct vm_area_struct *vma)
        map->count--;
        if (0 == map->count) {
                dprintk(1,"munmap %p q=%p\n",map,q);
-               down(&q->lock);
+               mutex_lock(&q->lock);
                for (i = 0; i < VIDEO_MAX_FRAME; i++) {
                        if (NULL == q->bufs[i])
                                continue;
@@ -1076,7 +1076,7 @@ videobuf_vm_close(struct vm_area_struct *vma)
                        q->bufs[i]->baddr = 0;
                        q->ops->buf_release(q,q->bufs[i]);
                }
-               up(&q->lock);
+               mutex_unlock(&q->lock);
                kfree(map);
        }
        return;
@@ -1170,7 +1170,7 @@ int videobuf_mmap_mapper(struct videobuf_queue *q,
        unsigned int first,last,size,i;
        int retval;
 
-       down(&q->lock);
+       mutex_lock(&q->lock);
        retval = -EINVAL;
        if (!(vma->vm_flags & VM_WRITE)) {
                dprintk(1,"mmap app bug: PROT_WRITE please\n");
@@ -1238,7 +1238,7 @@ int videobuf_mmap_mapper(struct videobuf_queue *q,
        retval = 0;
 
  done:
-       up(&q->lock);
+       mutex_unlock(&q->lock);
        return retval;
 }
 
index 908fbec..75e3d41 100644 (file)
@@ -224,13 +224,13 @@ int video_exclusive_open(struct inode *inode, struct file *file)
        struct  video_device *vfl = video_devdata(file);
        int retval = 0;
 
-       down(&vfl->lock);
+       mutex_lock(&vfl->lock);
        if (vfl->users) {
                retval = -EBUSY;
        } else {
                vfl->users++;
        }
-       up(&vfl->lock);
+       mutex_unlock(&vfl->lock);
        return retval;
 }
 
@@ -328,7 +328,7 @@ int video_register_device(struct video_device *vfd, int type, int nr)
        sprintf(vfd->devfs_name, "v4l/%s%d", name_base, i - base);
        devfs_mk_cdev(MKDEV(VIDEO_MAJOR, vfd->minor),
                        S_IFCHR | S_IRUSR | S_IWUSR, vfd->devfs_name);
-       init_MUTEX(&vfd->lock);
+       mutex_init(&vfd->lock);
 
        /* sysfs class */
        memset(&vfd->class_dev, 0x00, sizeof(vfd->class_dev));
index c8fd823..0229819 100644 (file)
@@ -42,6 +42,7 @@
 #include <linux/videodev.h>
 #include <linux/videodev2.h>
 #include <linux/video_decoder.h>
+#include <linux/mutex.h>
 
 #include <asm/paccess.h>
 #include <asm/io.h>
@@ -245,7 +246,7 @@ struct vino_framebuffer_queue {
        struct vino_framebuffer *buffer[VINO_FRAMEBUFFER_COUNT_MAX];
 
        spinlock_t queue_lock;
-       struct semaphore queue_sem;
+       struct mutex queue_mutex;
        wait_queue_head_t frame_wait_queue;
 };
 
@@ -283,7 +284,7 @@ struct vino_channel_settings {
        /* the driver is currently processing the queue */
        int capturing;
 
-       struct semaphore sem;
+       struct mutex mutex;
        spinlock_t capture_lock;
 
        unsigned int users;
@@ -1131,11 +1132,11 @@ static void vino_queue_free(struct vino_framebuffer_queue *q)
        if (q->type != VINO_MEMORY_MMAP)
                return;
 
-       down(&q->queue_sem);
+       mutex_lock(&q->queue_mutex);
 
        vino_queue_free_with_count(q, q->length);
 
-       up(&q->queue_sem);
+       mutex_unlock(&q->queue_mutex);
 }
 
 static int vino_queue_init(struct vino_framebuffer_queue *q,
@@ -1159,7 +1160,7 @@ static int vino_queue_init(struct vino_framebuffer_queue *q,
        if (*length < 1)
                return -EINVAL;
 
-       down(&q->queue_sem);
+       mutex_lock(&q->queue_mutex);
 
        if (*length > VINO_FRAMEBUFFER_COUNT_MAX)
                *length = VINO_FRAMEBUFFER_COUNT_MAX;
@@ -1211,7 +1212,7 @@ static int vino_queue_init(struct vino_framebuffer_queue *q,
                q->magic = VINO_QUEUE_MAGIC;
        }
 
-       up(&q->queue_sem);
+       mutex_unlock(&q->queue_mutex);
 
        return ret;
 }
@@ -4045,7 +4046,7 @@ static int vino_open(struct inode *inode, struct file *file)
        dprintk("open(): channel = %c\n",
               (vcs->channel == VINO_CHANNEL_A) ? 'A' : 'B');
 
-       down(&vcs->sem);
+       mutex_lock(&vcs->mutex);
 
        if (vcs->users) {
                dprintk("open(): driver busy\n");
@@ -4062,7 +4063,7 @@ static int vino_open(struct inode *inode, struct file *file)
        vcs->users++;
 
  out:
-       up(&vcs->sem);
+       mutex_unlock(&vcs->mutex);
 
        dprintk("open(): %s!\n", ret ? "failed" : "complete");
 
@@ -4075,7 +4076,7 @@ static int vino_close(struct inode *inode, struct file *file)
        struct vino_channel_settings *vcs = video_get_drvdata(dev);
        dprintk("close():\n");
 
-       down(&vcs->sem);
+       mutex_lock(&vcs->mutex);
 
        vcs->users--;
 
@@ -4087,7 +4088,7 @@ static int vino_close(struct inode *inode, struct file *file)
                vino_queue_free(&vcs->fb_queue);
        }
 
-       up(&vcs->sem);
+       mutex_unlock(&vcs->mutex);
 
        return 0;
 }
@@ -4130,7 +4131,7 @@ static int vino_mmap(struct file *file, struct vm_area_struct *vma)
 
        // TODO: reject mmap if already mapped
 
-       if (down_interruptible(&vcs->sem))
+       if (mutex_lock_interruptible(&vcs->mutex))
                return -EINTR;
 
        if (vcs->reading) {
@@ -4214,7 +4215,7 @@ found:
        vma->vm_ops = &vino_vm_ops;
 
 out:
-       up(&vcs->sem);
+       mutex_unlock(&vcs->mutex);
 
        return ret;
 }
@@ -4374,12 +4375,12 @@ static int vino_ioctl(struct inode *inode, struct file *file,
        struct vino_channel_settings *vcs = video_get_drvdata(dev);
        int ret;
 
-       if (down_interruptible(&vcs->sem))
+       if (mutex_lock_interruptible(&vcs->mutex))
                return -EINTR;
 
        ret = video_usercopy(inode, file, cmd, arg, vino_do_ioctl);
 
-       up(&vcs->sem);
+       mutex_unlock(&vcs->mutex);
 
        return ret;
 }
@@ -4564,10 +4565,10 @@ static int vino_init_channel_settings(struct vino_channel_settings *vcs,
 
        vcs->capturing = 0;
 
-       init_MUTEX(&vcs->sem);
+       mutex_init(&vcs->mutex);
        spin_lock_init(&vcs->capture_lock);
 
-       init_MUTEX(&vcs->fb_queue.queue_sem);
+       mutex_init(&vcs->fb_queue.queue_mutex);
        spin_lock_init(&vcs->fb_queue.queue_lock);
        init_waitqueue_head(&vcs->fb_queue.frame_wait_queue);
 
index 965c890..1dd8efe 100644 (file)
@@ -17,6 +17,7 @@
 #include <linux/time.h> /* need struct timeval */
 #include <linux/poll.h>
 #include <linux/device.h>
+#include <linux/mutex.h>
 #endif
 #include <linux/compiler.h> /* need __user */
 
@@ -90,7 +91,7 @@ struct video_device
 
        /* for videodev.c intenal usage -- please don't touch */
        int users;                     /* video_exclusive_{open|close} ... */
-       struct semaphore lock;         /* ... helper function uses these   */
+       struct mutex lock;             /* ... helper function uses these   */
        char devfs_name[64];           /* devfs */
        struct class_device class_dev; /* sysfs */
 };
index 2bc634f..fee579f 100644 (file)
@@ -11,6 +11,8 @@
 #include <linux/i2c.h>         /* for i2c subsystem */
 #include <asm/io.h>            /* for accessing devices */
 #include <linux/stringify.h>
+#include <linux/mutex.h>
+
 #include <linux/vmalloc.h>     /* for vmalloc() */
 #include <linux/mm.h>          /* for vmalloc_to_page() */
 
@@ -112,7 +114,7 @@ struct saa7146_dev
 
        /* different device locks */
        spinlock_t                      slock;
-       struct semaphore                lock;
+       struct mutex                    lock;
 
        unsigned char                   __iomem *mem;           /* pointer to mapped IO memory */
        int                             revision;       /* chip revision; needed for bug-workarounds*/
@@ -133,15 +135,16 @@ struct saa7146_dev
        void (*vv_callback)(struct saa7146_dev *dev, unsigned long status);
 
        /* i2c-stuff */
-       struct semaphore        i2c_lock;
-       u32                     i2c_bitrate;
-       struct saa7146_dma      d_i2c;  /* pointer to i2c memory */
-       wait_queue_head_t       i2c_wq;
-       int                     i2c_op;
+       struct mutex                    i2c_lock;
+
+       u32                             i2c_bitrate;
+       struct saa7146_dma              d_i2c;  /* pointer to i2c memory */
+       wait_queue_head_t               i2c_wq;
+       int                             i2c_op;
 
        /* memories */
-       struct saa7146_dma      d_rps0;
-       struct saa7146_dma      d_rps1;
+       struct saa7146_dma              d_rps0;
+       struct saa7146_dma              d_rps1;
 };
 
 /* from saa7146_i2c.c */
@@ -150,7 +153,7 @@ int saa7146_i2c_transfer(struct saa7146_dev *saa, const struct i2c_msg *msgs, in
 
 /* from saa7146_core.c */
 extern struct list_head saa7146_devices;
-extern struct semaphore saa7146_devices_lock;
+extern struct mutex saa7146_devices_lock;
 int saa7146_register_extension(struct saa7146_extension*);
 int saa7146_unregister_extension(struct saa7146_extension*);
 struct saa7146_format* format_by_fourcc(struct saa7146_dev *dev, int fourcc);