u8 sequence;
        int led_state;
        unsigned char data[256];
-       struct mutex data_mutex;
 };
 
 static int af9005_generic_read_write(struct dvb_usb_device *d, u16 reg,
                return -EINVAL;
        }
 
-       mutex_lock(&st->data_mutex);
+       mutex_lock(&d->data_mutex);
        st->data[0] = 14;               /* rest of buffer length low */
        st->data[1] = 0;                /* rest of buffer length high */
 
                        values[i] = st->data[8 + i];
 
 ret:
-       mutex_unlock(&st->data_mutex);
+       mutex_unlock(&d->data_mutex);
        return ret;
 
 }
        }
        packet_len = wlen + 5;
 
-       mutex_lock(&st->data_mutex);
+       mutex_lock(&d->data_mutex);
 
        st->data[0] = (u8) (packet_len & 0xff);
        st->data[1] = (u8) ((packet_len & 0xff00) >> 8);
                        rbuf[i] = st->data[i + 7];
        }
 
-       mutex_unlock(&st->data_mutex);
+       mutex_unlock(&d->data_mutex);
        return ret;
 }
 
        u8 seq;
        int ret, i;
 
-       mutex_lock(&st->data_mutex);
+       mutex_lock(&d->data_mutex);
 
        memset(st->data, 0, sizeof(st->data));
 
                for (i = 0; i < len; i++)
                        values[i] = st->data[6 + i];
        }
-       mutex_unlock(&st->data_mutex);
+       mutex_unlock(&d->data_mutex);
 
        return ret;
 }
                return 0;
        }
 
-       mutex_lock(&st->data_mutex);
+       mutex_lock(&d->data_mutex);
 
        /* deb_info("rc_query\n"); */
        st->data[0] = 3;                /* rest of packet length low */
        }
 
 ret:
-       mutex_unlock(&st->data_mutex);
+       mutex_unlock(&d->data_mutex);
        return ret;
 }
 
 static int af9005_usb_probe(struct usb_interface *intf,
                            const struct usb_device_id *id)
 {
-       struct dvb_usb_device *d;
-       struct af9005_device_state *st;
-       int ret;
-
-       ret = dvb_usb_device_init(intf, &af9005_properties,
-                                 THIS_MODULE, &d, adapter_nr);
-
-       if (ret < 0)
-               return ret;
-
-       st = d->priv;
-       mutex_init(&st->data_mutex);
-
-       return 0;
+       return dvb_usb_device_init(intf, &af9005_properties,
+                                 THIS_MODULE, NULL, adapter_nr);
 }
 
 enum af9005_usb_table_entry {
 
 struct cinergyt2_state {
        u8 rc_counter;
        unsigned char data[64];
-       struct mutex data_mutex;
 };
 
 /* We are missing a release hook with usb_device data */
        struct cinergyt2_state *st = d->priv;
        int ret;
 
-       mutex_lock(&st->data_mutex);
+       mutex_lock(&d->data_mutex);
        st->data[0] = CINERGYT2_EP1_CONTROL_STREAM_TRANSFER;
        st->data[1] = enable ? 1 : 0;
 
        ret = dvb_usb_generic_rw(d, st->data, 2, st->data, 64, 0);
-       mutex_unlock(&st->data_mutex);
+       mutex_unlock(&d->data_mutex);
 
        return ret;
 }
        struct cinergyt2_state *st = d->priv;
        int ret;
 
-       mutex_lock(&st->data_mutex);
+       mutex_lock(&d->data_mutex);
        st->data[0] = CINERGYT2_EP1_SLEEP_MODE;
        st->data[1] = enable ? 0 : 1;
 
        ret = dvb_usb_generic_rw(d, st->data, 2, st->data, 3, 0);
-       mutex_unlock(&st->data_mutex);
+       mutex_unlock(&d->data_mutex);
 
        return ret;
 }
 
        adap->fe_adap[0].fe = cinergyt2_fe_attach(adap->dev);
 
-       mutex_lock(&st->data_mutex);
+       mutex_lock(&d->data_mutex);
        st->data[0] = CINERGYT2_EP1_GET_FIRMWARE_VERSION;
 
        ret = dvb_usb_generic_rw(d, st->data, 1, st->data, 3, 0);
                deb_rc("cinergyt2_power_ctrl() Failed to retrieve sleep "
                        "state info\n");
        }
-       mutex_unlock(&st->data_mutex);
+       mutex_unlock(&d->data_mutex);
 
        /* Copy this pointer as we are gonna need it in the release phase */
        cinergyt2_usb_device = adap->dev;
 
        *state = REMOTE_NO_KEY_PRESSED;
 
-       mutex_lock(&st->data_mutex);
+       mutex_lock(&d->data_mutex);
        st->data[0] = CINERGYT2_EP1_GET_RC_EVENTS;
 
        ret = dvb_usb_generic_rw(d, st->data, 1, st->data, 5, 0);
        }
 
 ret:
-       mutex_unlock(&st->data_mutex);
+       mutex_unlock(&d->data_mutex);
        return ret;
 }
 
 static int cinergyt2_usb_probe(struct usb_interface *intf,
                                const struct usb_device_id *id)
 {
-       struct dvb_usb_device *d;
-       struct cinergyt2_state *st;
-       int ret;
-
-       ret = dvb_usb_device_init(intf, &cinergyt2_properties,
-                                 THIS_MODULE, &d, adapter_nr);
-       if (ret < 0)
-               return ret;
-
-       st = d->priv;
-       mutex_init(&st->data_mutex);
-
-       return 0;
+       return dvb_usb_device_init(intf, &cinergyt2_properties,
+                                  THIS_MODULE, NULL, adapter_nr);
 }
 
-
 static struct usb_device_id cinergyt2_usb_table[] = {
        { USB_DEVICE(USB_VID_TERRATEC, 0x0038) },
        { 0 }
 
 
        wo = (rbuf == NULL || rlen == 0); /* write-only */
 
-       mutex_lock(&st->data_mutex);
+       mutex_lock(&d->data_mutex);
        st->data[0] = cmd;
        memcpy(&st->data[1], wbuf, wlen);
        if (wo)
                ret = dvb_usb_generic_rw(d, st->data, 1 + wlen,
                                         rbuf, rlen, 0);
 
-       mutex_unlock(&st->data_mutex);
+       mutex_unlock(&d->data_mutex);
        return ret;
 }
 
 static int cxusb_probe(struct usb_interface *intf,
                       const struct usb_device_id *id)
 {
-       struct dvb_usb_device *d;
-       struct cxusb_state *st;
-
        if (0 == dvb_usb_device_init(intf, &cxusb_medion_properties,
-                                    THIS_MODULE, &d, adapter_nr) ||
+                                    THIS_MODULE, NULL, adapter_nr) ||
            0 == dvb_usb_device_init(intf, &cxusb_bluebird_lgh064f_properties,
-                                    THIS_MODULE, &d, adapter_nr) ||
+                                    THIS_MODULE, NULL, adapter_nr) ||
            0 == dvb_usb_device_init(intf, &cxusb_bluebird_dee1601_properties,
-                                    THIS_MODULE, &d, adapter_nr) ||
+                                    THIS_MODULE, NULL, adapter_nr) ||
            0 == dvb_usb_device_init(intf, &cxusb_bluebird_lgz201_properties,
-                                    THIS_MODULE, &d, adapter_nr) ||
+                                    THIS_MODULE, NULL, adapter_nr) ||
            0 == dvb_usb_device_init(intf, &cxusb_bluebird_dtt7579_properties,
-                                    THIS_MODULE, &d, adapter_nr) ||
+                                    THIS_MODULE, NULL, adapter_nr) ||
            0 == dvb_usb_device_init(intf, &cxusb_bluebird_dualdig4_properties,
-                                    THIS_MODULE, &d, adapter_nr) ||
+                                    THIS_MODULE, NULL, adapter_nr) ||
            0 == dvb_usb_device_init(intf, &cxusb_bluebird_nano2_properties,
-                                    THIS_MODULE, &d, adapter_nr) ||
+                                    THIS_MODULE, NULL, adapter_nr) ||
            0 == dvb_usb_device_init(intf,
                                &cxusb_bluebird_nano2_needsfirmware_properties,
-                                    THIS_MODULE, &d, adapter_nr) ||
+                                    THIS_MODULE, NULL, adapter_nr) ||
            0 == dvb_usb_device_init(intf, &cxusb_aver_a868r_properties,
-                                    THIS_MODULE, &d, adapter_nr) ||
+                                    THIS_MODULE, NULL, adapter_nr) ||
            0 == dvb_usb_device_init(intf,
                                     &cxusb_bluebird_dualdig4_rev2_properties,
-                                    THIS_MODULE, &d, adapter_nr) ||
+                                    THIS_MODULE, NULL, adapter_nr) ||
            0 == dvb_usb_device_init(intf, &cxusb_d680_dmb_properties,
-                                    THIS_MODULE, &d, adapter_nr) ||
+                                    THIS_MODULE, NULL, adapter_nr) ||
            0 == dvb_usb_device_init(intf, &cxusb_mygica_d689_properties,
-                                    THIS_MODULE, &d, adapter_nr) ||
+                                    THIS_MODULE, NULL, adapter_nr) ||
            0 == dvb_usb_device_init(intf, &cxusb_mygica_t230_properties,
-                                    THIS_MODULE, &d, adapter_nr) ||
-           0) {
-               st = d->priv;
-               mutex_init(&st->data_mutex);
-
+                                    THIS_MODULE, NULL, adapter_nr) ||
+           0)
                return 0;
-       }
 
        return -EINVAL;
 }
 
        struct i2c_client *i2c_client_tuner;
 
        unsigned char data[MAX_XFER_SIZE];
-       struct mutex data_mutex;
 };
 
 #endif
 
 
 struct dtt200u_state {
        unsigned char data[80];
-       struct mutex data_mutex;
 };
 
 static int dtt200u_power_ctrl(struct dvb_usb_device *d, int onoff)
        struct dtt200u_state *st = d->priv;
        int ret = 0;
 
-       mutex_lock(&st->data_mutex);
+       mutex_lock(&d->data_mutex);
 
        st->data[0] = SET_INIT;
 
        if (onoff)
                ret = dvb_usb_generic_write(d, st->data, 2);
 
-       mutex_unlock(&st->data_mutex);
+       mutex_unlock(&d->data_mutex);
        return ret;
 }
 
 static int dtt200u_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
 {
-       struct dtt200u_state *st = adap->dev->priv;
+       struct dvb_usb_device *d = adap->dev;
+       struct dtt200u_state *st = d->priv;
        int ret;
 
-       mutex_lock(&st->data_mutex);
+       mutex_lock(&d->data_mutex);
        st->data[0] = SET_STREAMING;
        st->data[1] = onoff;
 
        ret = dvb_usb_generic_write(adap->dev, st->data, 1);
 
 ret:
-       mutex_unlock(&st->data_mutex);
+       mutex_unlock(&d->data_mutex);
 
        return ret;
 }
 
 static int dtt200u_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid, int onoff)
 {
-       struct dtt200u_state *st = adap->dev->priv;
+       struct dvb_usb_device *d = adap->dev;
+       struct dtt200u_state *st = d->priv;
        int ret;
 
        pid = onoff ? pid : 0;
 
-       mutex_lock(&st->data_mutex);
+       mutex_lock(&d->data_mutex);
        st->data[0] = SET_PID_FILTER;
        st->data[1] = index;
        st->data[2] = pid & 0xff;
        st->data[3] = (pid >> 8) & 0x1f;
 
        ret = dvb_usb_generic_write(adap->dev, st->data, 4);
-       mutex_unlock(&st->data_mutex);
+       mutex_unlock(&d->data_mutex);
 
        return ret;
 }
        u32 scancode;
        int ret;
 
-       mutex_lock(&st->data_mutex);
+       mutex_lock(&d->data_mutex);
        st->data[0] = GET_RC_CODE;
 
        ret = dvb_usb_generic_rw(d, st->data, 1, st->data, 5, 0);
                deb_info("st->data: %*ph\n", 5, st->data);
 
 ret:
-       mutex_unlock(&st->data_mutex);
+       mutex_unlock(&d->data_mutex);
        return ret;
 }
 
 static int dtt200u_usb_probe(struct usb_interface *intf,
                const struct usb_device_id *id)
 {
-       struct dvb_usb_device *d;
-       struct dtt200u_state *st;
-
        if (0 == dvb_usb_device_init(intf, &dtt200u_properties,
-                                    THIS_MODULE, &d, adapter_nr) ||
+                                    THIS_MODULE, NULL, adapter_nr) ||
            0 == dvb_usb_device_init(intf, &wt220u_properties,
-                                    THIS_MODULE, &d, adapter_nr) ||
+                                    THIS_MODULE, NULL, adapter_nr) ||
            0 == dvb_usb_device_init(intf, &wt220u_fc_properties,
-                                    THIS_MODULE, &d, adapter_nr) ||
+                                    THIS_MODULE, NULL, adapter_nr) ||
            0 == dvb_usb_device_init(intf, &wt220u_zl0353_properties,
-                                    THIS_MODULE, &d, adapter_nr) ||
+                                    THIS_MODULE, NULL, adapter_nr) ||
            0 == dvb_usb_device_init(intf, &wt220u_miglia_properties,
-                                    THIS_MODULE, &d, adapter_nr)) {
-               st = d->priv;
-               mutex_init(&st->data_mutex);
-
+                                    THIS_MODULE, NULL, adapter_nr))
                return 0;
-       }
 
        return -ENODEV;
 }
 
 {
        int ret = 0;
 
+       mutex_init(&d->data_mutex);
        mutex_init(&d->usb_mutex);
        mutex_init(&d->i2c_mutex);
 
 
  *  Powered is in/decremented for each call to modify the state.
  * @udev: pointer to the device's struct usb_device.
  *
- * @usb_mutex: semaphore of USB control messages (reading needs two messages)
- * @i2c_mutex: semaphore for i2c-transfers
+ * @data_mutex: mutex to protect the data structure used to store URB data
+ * @usb_mutex: mutex of USB control messages (reading needs two messages).
+ *     Please notice that this mutex is used internally at the generic
+ *     URB control functions. So, drivers using dvb_usb_generic_rw() and
+ *     derivated functions should not lock it internally.
+ * @i2c_mutex: mutex for i2c-transfers
  *
  * @i2c_adap: device's i2c_adapter if it uses I2CoverUSB
  *
        int powered;
 
        /* locking */
+       struct mutex data_mutex;
        struct mutex usb_mutex;
 
        /* i2c */