[media] gspca: Update / fix various comments wrt workqueue usb_lock usage
authorHans de Goede <hdegoede@redhat.com>
Sun, 9 Sep 2012 10:30:02 +0000 (07:30 -0300)
committerMauro Carvalho Chehab <mchehab@redhat.com>
Thu, 13 Sep 2012 20:52:58 +0000 (17:52 -0300)
Signed-off-by: Hans de Goede <hdegoede@redhat.com>
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>
drivers/media/usb/gspca/finepix.c
drivers/media/usb/gspca/jl2005bcd.c
drivers/media/usb/gspca/sn9c20x.c
drivers/media/usb/gspca/sonixj.c
drivers/media/usb/gspca/sq905.c
drivers/media/usb/gspca/sq905c.c
drivers/media/usb/gspca/vicam.c
drivers/media/usb/gspca/zc3xx.c

index fb68a2934255ac58e2135a1fc5724ed3648f382c..52bdb569760b4139bb20dfca693746b5a267ddf6 100644 (file)
@@ -77,7 +77,14 @@ static int command(struct gspca_dev *gspca_dev,
                        12, FPIX_TIMEOUT);
 }
 
-/* workqueue */
+/*
+ * This function is called as a workqueue function and runs whenever the camera
+ * is streaming data. Because it is a workqueue function it is allowed to sleep
+ * so we can use synchronous USB calls. To avoid possible collisions with other
+ * threads attempting to use gspca_dev->usb_buf we take the usb_lock when
+ * performing USB operations using it. In practice we don't really need this
+ * as the camera doesn't provide any controls.
+ */
 static void dostream(struct work_struct *work)
 {
        struct usb_fpix *dev = container_of(work, struct usb_fpix, work_struct);
index c4b4a9598db46b62c0ae7b9ca14f743cdebcab07..62ba80d9b9988478dbc9727eb1b6a50d210b583c 100644 (file)
@@ -306,15 +306,13 @@ static int jl2005c_stop(struct gspca_dev *gspca_dev)
        return retval;
 }
 
-/* This function is called as a workqueue function and runs whenever the camera
+/*
+ * This function is called as a workqueue function and runs whenever the camera
  * is streaming data. Because it is a workqueue function it is allowed to sleep
  * so we can use synchronous USB calls. To avoid possible collisions with other
- * threads attempting to use the camera's USB interface the gspca usb_lock is
- * used when performing the one USB control operation inside the workqueue,
- * which tells the camera to close the stream. In practice the only thing
- * which needs to be protected against is the usb_set_interface call that
- * gspca makes during stream_off. Otherwise the camera doesn't provide any
- * controls that the user could try to change.
+ * threads attempting to use gspca_dev->usb_buf we take the usb_lock when
+ * performing USB operations using it. In practice we don't really need this
+ * as the camera doesn't provide any controls.
  */
 static void jl2005c_dostream(struct work_struct *work)
 {
index b9c6f17eabb245fde118e3b198f163782d92a7bc..41f769fe340c9f1a6a9f01ef7a84e4e9feb323b1 100644 (file)
@@ -2197,8 +2197,10 @@ static void qual_upd(struct work_struct *work)
        struct gspca_dev *gspca_dev = &sd->gspca_dev;
        s32 qual = v4l2_ctrl_g_ctrl(sd->jpegqual);
 
+       /* To protect gspca_dev->usb_buf and gspca_dev->usb_err */
        mutex_lock(&gspca_dev->usb_lock);
        PDEBUG(D_STREAM, "qual_upd %d%%", qual);
+       gspca_dev->usb_err = 0;
        set_quality(gspca_dev, qual);
        mutex_unlock(&gspca_dev->usb_lock);
 }
index 150b2df40f7f56e54e29a5acffd7c7b42f3b3d13..5a86047b846f484c2d1c22d88023878d2249b646 100644 (file)
@@ -2380,8 +2380,10 @@ static void qual_upd(struct work_struct *work)
        struct sd *sd = container_of(work, struct sd, work);
        struct gspca_dev *gspca_dev = &sd->gspca_dev;
 
+       /* To protect gspca_dev->usb_buf and gspca_dev->usb_err */
        mutex_lock(&gspca_dev->usb_lock);
        PDEBUG(D_STREAM, "qual_upd %d%%", sd->quality);
+       gspca_dev->usb_err = 0;
        setjpegqual(gspca_dev);
        mutex_unlock(&gspca_dev->usb_lock);
 }
index 2e05acab304c3e64bd859e6f020b151c1566cfb3..1d99f10a3e19962e4263acbdb630b8d6912165c8 100644 (file)
@@ -201,14 +201,13 @@ sq905_read_data(struct gspca_dev *gspca_dev, u8 *data, int size, int need_lock)
        return 0;
 }
 
-/* This function is called as a workqueue function and runs whenever the camera
+/*
+ * This function is called as a workqueue function and runs whenever the camera
  * is streaming data. Because it is a workqueue function it is allowed to sleep
  * so we can use synchronous USB calls. To avoid possible collisions with other
- * threads attempting to use the camera's USB interface we take the gspca
- * usb_lock when performing USB operations. In practice the only thing we need
- * to protect against is the usb_set_interface call that gspca makes during
- * stream_off as the camera doesn't provide any controls that the user could try
- * to change.
+ * threads attempting to use gspca_dev->usb_buf we take the usb_lock when
+ * performing USB operations using it. In practice we don't really need this
+ * as the camera doesn't provide any controls.
  */
 static void sq905_dostream(struct work_struct *work)
 {
index 784620c102b17ebb32193723d70337b0293ec3e7..410cdcbb55d45984a9d81a9f630ad7bff4aca0bf 100644 (file)
@@ -123,15 +123,13 @@ static int sq905c_read(struct gspca_dev *gspca_dev, u16 command, u16 index,
        return 0;
 }
 
-/* This function is called as a workqueue function and runs whenever the camera
+/*
+ * This function is called as a workqueue function and runs whenever the camera
  * is streaming data. Because it is a workqueue function it is allowed to sleep
  * so we can use synchronous USB calls. To avoid possible collisions with other
- * threads attempting to use the camera's USB interface the gspca usb_lock is
- * used when performing the one USB control operation inside the workqueue,
- * which tells the camera to close the stream. In practice the only thing
- * which needs to be protected against is the usb_set_interface call that
- * gspca makes during stream_off. Otherwise the camera doesn't provide any
- * controls that the user could try to change.
+ * threads attempting to use gspca_dev->usb_buf we take the usb_lock when
+ * performing USB operations using it. In practice we don't really need this
+ * as the camera doesn't provide any controls.
  */
 static void sq905c_dostream(struct work_struct *work)
 {
index 57d88f70c399ad70f979cb8e60ea55bd77047832..d6890bc3719862e54c87af2fe6b1f60ba958997e 100644 (file)
@@ -110,7 +110,7 @@ static int vicam_set_camera_power(struct gspca_dev *gspca_dev, int state)
 }
 
 /*
- *  request and read a block of data - see warning on vicam_command.
+ *  request and read a block of data
  */
 static int vicam_read_frame(struct gspca_dev *gspca_dev, u8 *data, int size)
 {
@@ -170,14 +170,13 @@ static int vicam_read_frame(struct gspca_dev *gspca_dev, u8 *data, int size)
        return 0;
 }
 
-/* This function is called as a workqueue function and runs whenever the camera
+/*
+ * This function is called as a workqueue function and runs whenever the camera
  * is streaming data. Because it is a workqueue function it is allowed to sleep
  * so we can use synchronous USB calls. To avoid possible collisions with other
- * threads attempting to use the camera's USB interface we take the gspca
- * usb_lock when performing USB operations. In practice the only thing we need
- * to protect against is the usb_set_interface call that gspca makes during
- * stream_off as the camera doesn't provide any controls that the user could try
- * to change.
+ * threads attempting to use gspca_dev->usb_buf we take the usb_lock when
+ * performing USB operations using it. In practice we don't really need this
+ * as the cameras controls are only written from the workqueue.
  */
 static void vicam_dostream(struct work_struct *work)
 {
index 234d9eaa8eea31e5edf4b02e02e85c8de01b825d..c47ba14c76190ebaa89ff62463e7ad7b2d82388f 100644 (file)
@@ -5945,6 +5945,7 @@ static void transfer_update(struct work_struct *work)
        for (;;) {
                msleep(100);
 
+               /* To protect gspca_dev->usb_buf and gspca_dev->usb_err */
                mutex_lock(&gspca_dev->usb_lock);
 #ifdef CONFIG_PM
                if (gspca_dev->frozen)
@@ -6831,7 +6832,8 @@ static int sd_start(struct gspca_dev *gspca_dev)
        return 0;
 }
 
-/* called on streamoff with alt 0 and on disconnect */
+/* called on streamoff with alt==0 and on disconnect */
+/* the usb_lock is held at entry - restore on exit */
 static void sd_stop0(struct gspca_dev *gspca_dev)
 {
        struct sd *sd = (struct sd *) gspca_dev;