V4L/DVB: gspca - sq930x: New subdriver
authorJean-François Moine <moinejf@free.fr>
Sat, 5 Jun 2010 10:45:04 +0000 (07:45 -0300)
committerMauro Carvalho Chehab <mchehab@redhat.com>
Mon, 2 Aug 2010 17:44:38 +0000 (14:44 -0300)
Signed-off-by: Jean-François Moine <moinejf@free.fr>
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>
Documentation/video4linux/gspca.txt
drivers/media/video/gspca/Kconfig
drivers/media/video/gspca/Makefile
drivers/media/video/gspca/sq930x.c [new file with mode: 0644]

index f13eb036c439a4af60310fff845a4e3b82552fa5..a258107f81266284b5fe80cd08467e703f07b719 100644 (file)
@@ -29,8 +29,12 @@ zc3xx                041e:4029       Creative WebCam Vista Pro
 zc3xx          041e:4034       Creative Instant P0620
 zc3xx          041e:4035       Creative Instant P0620D
 zc3xx          041e:4036       Creative Live !
+sq930x         041e:4038       Creative Joy-IT
 zc3xx          041e:403a       Creative Nx Pro 2
 spca561                041e:403b       Creative Webcam Vista (VF0010)
+sq930x         041e:403c       Creative Live! Ultra
+sq930x         041e:403d       Creative Live! Ultra for Notebooks
+sq930x         041e:4041       Creative Live! Motion
 zc3xx          041e:4051       Creative Live!Cam Notebook Pro (VF0250)
 ov519          041e:4052       Creative Live! VISTA IM
 zc3xx          041e:4053       Creative Live!Cam Video IM
@@ -362,6 +366,8 @@ sq905c              2770:9052       Disney pix micro 2 (VGA)
 sq905c         2770:905c       All 11 known cameras with this ID
 sq905          2770:9120       All 24 known cameras with this ID
 sq905c         2770:913d       All 4 known cameras with this ID
+sq930x         2770:930b       Sweex Motion Tracking / I-Tec iCam Tracer
+sq930x         2770:930c       Trust WB-3500T / NSG Robbie 2.0
 spca500                2899:012c       Toptro Industrial
 ov519          8020:ef04       ov519
 spca508                8086:0110       Intel Easy PC Camera
index 5d920e584de724c4a73e3b366a54f91d376718a3..f805d9772ba008383616d919ac88aaedca423635 100644 (file)
@@ -264,6 +264,15 @@ config USB_GSPCA_SQ905C
          To compile this driver as a module, choose M here: the
          module will be called gspca_sq905c.
 
+config USB_GSPCA_SQ930X
+       tristate "SQ Technologies SQ930X based USB Camera Driver"
+       depends on VIDEO_V4L2 && USB_GSPCA
+       help
+         Say Y here if you want support for cameras based on the SQ930X chip.
+
+         To compile this driver as a module, choose M here: the
+         module will be called gspca_sq930x.
+
 config USB_GSPCA_STK014
        tristate "Syntek DV4000 (STK014) USB Camera Driver"
        depends on VIDEO_V4L2 && USB_GSPCA
index 6e4cf1ce01c9f5044a1500cb01decdc66c87d6f0..0900c0e704730f042df957c2e6e293474e03bd3f 100644 (file)
@@ -25,6 +25,7 @@ obj-$(CONFIG_USB_GSPCA_SPCA508)  += gspca_spca508.o
 obj-$(CONFIG_USB_GSPCA_SPCA561)  += gspca_spca561.o
 obj-$(CONFIG_USB_GSPCA_SQ905)    += gspca_sq905.o
 obj-$(CONFIG_USB_GSPCA_SQ905C)   += gspca_sq905c.o
+obj-$(CONFIG_USB_GSPCA_SQ930X)   += gspca_sq930x.o
 obj-$(CONFIG_USB_GSPCA_SUNPLUS)  += gspca_sunplus.o
 obj-$(CONFIG_USB_GSPCA_STK014)   += gspca_stk014.o
 obj-$(CONFIG_USB_GSPCA_STV0680)  += gspca_stv0680.o
@@ -60,6 +61,7 @@ gspca_spca508-objs  := spca508.o
 gspca_spca561-objs  := spca561.o
 gspca_sq905-objs    := sq905.o
 gspca_sq905c-objs   := sq905c.o
+gspca_sq930x-objs   := sq930x.o
 gspca_stk014-objs   := stk014.o
 gspca_stv0680-objs  := stv0680.o
 gspca_sunplus-objs  := sunplus.o
diff --git a/drivers/media/video/gspca/sq930x.c b/drivers/media/video/gspca/sq930x.c
new file mode 100644 (file)
index 0000000..7e4381b
--- /dev/null
@@ -0,0 +1,1140 @@
+/*
+ * SQ930x subdriver
+ *
+ * Copyright (C) 2010 Jean-François Moine <http://moinejf.free.fr>
+ * Copyright (C) 2006 -2008 Gerard Klaver <gerard at gkall dot hobby dot nl>
+ * Copyright (C) 2007 Sam Revitch <samr7@cs.washington.edu>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#define MODULE_NAME "sq930x"
+
+#include "gspca.h"
+#include "jpeg.h"
+
+MODULE_AUTHOR("Jean-Francois Moine <http://moinejf.free.fr>\n"
+               "Gerard Klaver <gerard at gkall dot hobby dot nl\n"
+               "Sam Revitch <samr7@cs.washington.edu>");
+MODULE_DESCRIPTION("GSPCA/SQ930x USB Camera Driver");
+MODULE_LICENSE("GPL");
+
+#define BULK_TRANSFER_LEN 5128
+
+/* Structure to hold all of our device specific stuff */
+struct sd {
+       struct gspca_dev gspca_dev;     /* !! must be the first item */
+
+       u16 expo;
+       u8 gain;
+
+       u8 quality;             /* webcam quality 0..3 */
+#define QUALITY_DEF 1
+
+       u8 gpio[2];
+
+       u8 eof_len;
+       u8 do_ctrl;
+
+       u8 sensor;
+enum {
+       SENSOR_ICX098BQ,
+       SENSOR_MI0360,
+       SENSOR_LZ24BP,
+} sensors;
+       u8 type;
+#define Generic 0
+#define Creative_live_motion 1
+
+       u8 jpeg_hdr[JPEG_HDR_SZ];
+};
+
+static int sd_setexpo(struct gspca_dev *gspca_dev, __s32 val);
+static int sd_getexpo(struct gspca_dev *gspca_dev, __s32 *val);
+static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val);
+static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val);
+
+static const struct ctrl sd_ctrls[] = {
+       {
+           {
+               .id = V4L2_CID_EXPOSURE,
+               .type = V4L2_CTRL_TYPE_INTEGER,
+               .name = "Exposure",
+               .minimum = 0x0001,
+               .maximum = 0x0fff,
+               .step = 1,
+#define EXPO_DEF 0x027d
+               .default_value = EXPO_DEF,
+           },
+           .set = sd_setexpo,
+           .get = sd_getexpo,
+       },
+       {
+           {
+               .id = V4L2_CID_GAIN,
+               .type = V4L2_CTRL_TYPE_INTEGER,
+               .name = "Gain",
+               .minimum = 0x01,
+               .maximum = 0xff,
+               .step = 1,
+#define GAIN_DEF 0x61
+               .default_value = GAIN_DEF,
+           },
+           .set = sd_setgain,
+           .get = sd_getgain,
+       },
+};
+
+static struct v4l2_pix_format vga_mode[] = {
+       {160, 120, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
+               .bytesperline = 160,
+               .sizeimage = 160 * 120 * 5 / 8 + 590,
+               .colorspace = V4L2_COLORSPACE_JPEG,
+               .priv = 0},
+       {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
+               .bytesperline = 320,
+               .sizeimage = 320 * 240 * 4 / 8 + 590,
+               .colorspace = V4L2_COLORSPACE_JPEG,
+               .priv = 1},
+       {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
+               .bytesperline = 640,
+               .sizeimage = 640 * 480 * 3 / 8 + 590,
+               .colorspace = V4L2_COLORSPACE_JPEG,
+               .priv = 2},
+};
+
+/* JPEG quality indexed by webcam quality */
+#define QUAL_0 90
+#define QUAL_1 85
+#define QUAL_2 75
+#define QUAL_3 70
+static const u8 quality_tb[4] = { QUAL_0, QUAL_1, QUAL_2, QUAL_3 };
+
+/* sq930x registers */
+#define SQ930_CTRL_UCBUS_IO    0x0001
+#define SQ930_CTRL_I2C_IO      0x0002
+#define SQ930_CTRL_GPIO                0x0005
+#define SQ930_CTRL_CAP_START   0x0010
+#define SQ930_CTRL_CAP_STOP    0x0011
+#define SQ930_CTRL_SET_EXPOSURE 0x001d
+#define SQ930_CTRL_RESET       0x001e
+#define SQ930_CTRL_GET_DEV_INFO 0x001f
+
+/* gpio 1 (8..15) */
+#define SQ930_GPIO_DFL_I2C_SDA 0x0001
+#define SQ930_GPIO_DFL_I2C_SCL 0x0002
+#define SQ930_GPIO_RSTBAR      0x0004
+#define SQ930_GPIO_EXTRA1      0x0040
+#define SQ930_GPIO_EXTRA2      0x0080
+/* gpio 3 (24..31) */
+#define SQ930_GPIO_POWER       0x0200
+#define SQ930_GPIO_DFL_LED     0x1000
+
+struct ucbus_write_cmd {
+       u16     bw_addr;
+       u8      bw_data;
+};
+struct i2c_write_cmd {
+       u8      reg;
+       u16     val;
+};
+
+static const struct ucbus_write_cmd icx098bq_start_0[] = {
+       {0x0354, 0x00}, {0x03fa, 0x00}, {0xf800, 0x02}, {0xf801, 0xce},
+       {0xf802, 0xc1}, {0xf804, 0x00}, {0xf808, 0x00}, {0xf809, 0x0e},
+       {0xf80a, 0x01}, {0xf80b, 0xee}, {0xf807, 0x60}, {0xf80c, 0x02},
+       {0xf80d, 0xf0}, {0xf80e, 0x03}, {0xf80f, 0x0a}, {0xf81c, 0x02},
+       {0xf81d, 0xf0}, {0xf81e, 0x03}, {0xf81f, 0x0a}, {0xf83a, 0x00},
+       {0xf83b, 0x10}, {0xf83c, 0x00}, {0xf83d, 0x4e}, {0xf810, 0x04},
+       {0xf811, 0x00}, {0xf812, 0x02}, {0xf813, 0x10}, {0xf803, 0x00},
+       {0xf814, 0x01}, {0xf815, 0x18}, {0xf816, 0x00}, {0xf817, 0x48},
+       {0xf818, 0x00}, {0xf819, 0x25}, {0xf81a, 0x00}, {0xf81b, 0x3c},
+       {0xf82f, 0x03}, {0xf820, 0xff}, {0xf821, 0x0d}, {0xf822, 0xff},
+       {0xf823, 0x07}, {0xf824, 0xff}, {0xf825, 0x03}, {0xf826, 0xff},
+       {0xf827, 0x06}, {0xf828, 0xff}, {0xf829, 0x03}, {0xf82a, 0xff},
+       {0xf82b, 0x0c}, {0xf82c, 0xfd}, {0xf82d, 0x01}, {0xf82e, 0x00},
+       {0xf830, 0x00}, {0xf831, 0x47}, {0xf832, 0x00}, {0xf833, 0x00},
+       {0xf850, 0x00}, {0xf851, 0x00}, {0xf852, 0x00}, {0xf853, 0x24},
+       {0xf854, 0x00}, {0xf855, 0x18}, {0xf856, 0x00}, {0xf857, 0x3c},
+       {0xf858, 0x00}, {0xf859, 0x0c}, {0xf85a, 0x00}, {0xf85b, 0x30},
+       {0xf85c, 0x00}, {0xf85d, 0x0c}, {0xf85e, 0x00}, {0xf85f, 0x30},
+       {0xf860, 0x00}, {0xf861, 0x48}, {0xf862, 0x01}, {0xf863, 0xdc},
+       {0xf864, 0xff}, {0xf865, 0x98}, {0xf866, 0xff}, {0xf867, 0xc0},
+       {0xf868, 0xff}, {0xf869, 0x70}, {0xf86c, 0xff}, {0xf86d, 0x00},
+       {0xf86a, 0xff}, {0xf86b, 0x48}, {0xf86e, 0xff}, {0xf86f, 0x00},
+       {0xf870, 0x01}, {0xf871, 0xdb}, {0xf872, 0x01}, {0xf873, 0xfa},
+       {0xf874, 0x01}, {0xf875, 0xdb}, {0xf876, 0x01}, {0xf877, 0xfa},
+       {0xf878, 0x0f}, {0xf879, 0x0f}, {0xf87a, 0xff}, {0xf87b, 0xff},
+       {0xf800, 0x03}
+};
+static const struct ucbus_write_cmd icx098bq_start_1[] = {
+       {0xf5f0, 0x00}, {0xf5f1, 0xcd}, {0xf5f2, 0x80}, {0xf5f3, 0x80},
+       {0xf5f4, 0xc0},
+       {0xf5f0, 0x49}, {0xf5f1, 0xcd}, {0xf5f2, 0x80}, {0xf5f3, 0x80},
+       {0xf5f4, 0xc0},
+       {0xf5fa, 0x00}, {0xf5f6, 0x00}, {0xf5f7, 0x00}, {0xf5f8, 0x00},
+       {0xf5f9, 0x00}
+};
+
+static const struct ucbus_write_cmd icx098bq_start_2[] = {
+       {0xf800, 0x02}, {0xf807, 0xff}, {0xf805, 0x82}, {0xf806, 0x00},
+       {0xf807, 0x7f}, {0xf800, 0x03},
+       {0xf800, 0x02}, {0xf807, 0xff}, {0xf805, 0x40}, {0xf806, 0x00},
+       {0xf807, 0x7f}, {0xf800, 0x03},
+       {0xf800, 0x02}, {0xf807, 0xff}, {0xf805, 0xcf}, {0xf806, 0xd0},
+       {0xf807, 0x7f}, {0xf800, 0x03},
+       {0xf800, 0x02}, {0xf807, 0xff}, {0xf805, 0x00}, {0xf806, 0x00},
+       {0xf807, 0x7f}, {0xf800, 0x03}
+};
+
+static const struct ucbus_write_cmd lz24bp_start_0[] = {
+       {0x0354, 0x00}, {0x03fa, 0x00}, {0xf800, 0x02}, {0xf801, 0xbe},
+       {0xf802, 0xc6}, {0xf804, 0x00}, {0xf808, 0x00}, {0xf809, 0x06},
+       {0xf80a, 0x01}, {0xf80b, 0xfe}, {0xf807, 0x84}, {0xf80c, 0x02},
+       {0xf80d, 0xf7}, {0xf80e, 0x03}, {0xf80f, 0x0b}, {0xf81c, 0x00},
+       {0xf81d, 0x49}, {0xf81e, 0x03}, {0xf81f, 0x0b}, {0xf83a, 0x00},
+       {0xf83b, 0x01}, {0xf83c, 0x00}, {0xf83d, 0x6b}, {0xf810, 0x03},
+       {0xf811, 0x10}, {0xf812, 0x02}, {0xf813, 0x6f}, {0xf803, 0x00},
+       {0xf814, 0x00}, {0xf815, 0x44}, {0xf816, 0x00}, {0xf817, 0x48},
+       {0xf818, 0x00}, {0xf819, 0x25}, {0xf81a, 0x00}, {0xf81b, 0x3c},
+       {0xf82f, 0x03}, {0xf820, 0xff}, {0xf821, 0x0d}, {0xf822, 0xff},
+       {0xf823, 0x07}, {0xf824, 0xfd}, {0xf825, 0x07}, {0xf826, 0xf0},
+       {0xf827, 0x0c}, {0xf828, 0xff}, {0xf829, 0x03}, {0xf82a, 0xff},
+       {0xf82b, 0x0c}, {0xf82c, 0xfc}, {0xf82d, 0x01}, {0xf82e, 0x00},
+       {0xf830, 0x00}, {0xf831, 0x47}, {0xf832, 0x00}, {0xf833, 0x00},
+       {0xf850, 0x00}, {0xf851, 0x00}, {0xf852, 0x00}, {0xf853, 0x24},
+       {0xf854, 0x00}, {0xf855, 0x0c}, {0xf856, 0x00}, {0xf857, 0x30},
+       {0xf858, 0x00}, {0xf859, 0x18}, {0xf85a, 0x00}, {0xf85b, 0x3c},
+       {0xf85c, 0x00}, {0xf85d, 0x18}, {0xf85e, 0x00}, {0xf85f, 0x3c},
+       {0xf860, 0xff}, {0xf861, 0x37}, {0xf862, 0xff}, {0xf863, 0x1d},
+       {0xf864, 0xff}, {0xf865, 0x98}, {0xf866, 0xff}, {0xf867, 0xc0},
+       {0xf868, 0x00}, {0xf869, 0x37}, {0xf86c, 0x02}, {0xf86d, 0x1d},
+       {0xf86a, 0x00}, {0xf86b, 0x37}, {0xf86e, 0x02}, {0xf86f, 0x1d},
+       {0xf870, 0x01}, {0xf871, 0xc6}, {0xf872, 0x02}, {0xf873, 0x04},
+       {0xf874, 0x01}, {0xf875, 0xc6}, {0xf876, 0x02}, {0xf877, 0x04},
+       {0xf878, 0x0f}, {0xf879, 0x0f}, {0xf87a, 0xff}, {0xf87b, 0xff},
+       {0xf800, 0x03}
+};
+static const struct ucbus_write_cmd lz24bp_start_1_gen[] = {
+       {0xf5f0, 0x00}, {0xf5f1, 0xff}, {0xf5f2, 0x80}, {0xf5f3, 0x80},
+       {0xf5f4, 0xb3},
+       {0xf5f0, 0x40}, {0xf5f1, 0xff}, {0xf5f2, 0x80}, {0xf5f3, 0x80},
+       {0xf5f4, 0xb3},
+       {0xf5fa, 0x00}, {0xf5f6, 0x00}, {0xf5f7, 0x00}, {0xf5f8, 0x00},
+       {0xf5f9, 0x00}
+};
+
+static const struct ucbus_write_cmd lz24bp_start_1_clm[] = {
+       {0xf5f0, 0x00}, {0xf5f1, 0xff}, {0xf5f2, 0x88}, {0xf5f3, 0x88},
+       {0xf5f4, 0xc0},
+       {0xf5f0, 0x40}, {0xf5f1, 0xff}, {0xf5f2, 0x88}, {0xf5f3, 0x88},
+       {0xf5f4, 0xc0},
+       {0xf5fa, 0x00}, {0xf5f6, 0x00}, {0xf5f7, 0x00}, {0xf5f8, 0x00},
+       {0xf5f9, 0x00}
+};
+
+static const struct ucbus_write_cmd lz24bp_start_2[] = {
+       {0xf800, 0x02}, {0xf807, 0xff}, {0xf805, 0x80}, {0xf806, 0x00},
+       {0xf807, 0x7f}, {0xf800, 0x03},
+       {0xf800, 0x02}, {0xf807, 0xff}, {0xf805, 0x4e}, {0xf806, 0x00},
+       {0xf807, 0x7f}, {0xf800, 0x03},
+       {0xf800, 0x02}, {0xf807, 0xff}, {0xf805, 0xc0}, {0xf806, 0x48},
+       {0xf807, 0x7f}, {0xf800, 0x03},
+       {0xf800, 0x02}, {0xf807, 0xff}, {0xf805, 0x00}, {0xf806, 0x00},
+       {0xf807, 0x7f}, {0xf800, 0x03}
+};
+
+static const struct ucbus_write_cmd mi0360_start_0[] = {
+       {0x0354, 0x00}, {0x03fa, 0x00}, {0xf332, 0xcc}, {0xf333, 0xcc},
+       {0xf334, 0xcc}, {0xf335, 0xcc}, {0xf33f, 0x00}
+};
+static const struct i2c_write_cmd mi0360_init_23[] = {
+       {0x30, 0x0040},         /* reserved - def 0x0005 */
+       {0x31, 0x0000},         /* reserved - def 0x002a */
+       {0x34, 0x0100},         /* reserved - def 0x0100 */
+       {0x3d, 0x068f},         /* reserved - def 0x068f */
+};
+static const struct i2c_write_cmd mi0360_init_24[] = {
+       {0x03, 0x01e5},         /* window height */
+       {0x04, 0x0285},         /* window width */
+};
+static const struct i2c_write_cmd mi0360_init_25[] = {
+       {0x35, 0x0020},         /* global gain */
+       {0x2b, 0x0020},         /* green1 gain */
+       {0x2c, 0x002a},         /* blue gain */
+       {0x2d, 0x0028},         /* red gain */
+       {0x2e, 0x0020},         /* green2 gain */
+};
+static const struct ucbus_write_cmd mi0360_start_1[] = {
+       {0xf5f0, 0x11}, {0xf5f1, 0x99}, {0xf5f2, 0x80}, {0xf5f3, 0x80},
+       {0xf5f4, 0xa6},
+       {0xf5f0, 0x51}, {0xf5f1, 0x99}, {0xf5f2, 0x80}, {0xf5f3, 0x80},
+       {0xf5f4, 0xa6},
+       {0xf5fa, 0x00}, {0xf5f6, 0x00}, {0xf5f7, 0x00}, {0xf5f8, 0x00},
+       {0xf5f9, 0x00}
+};
+static const struct i2c_write_cmd mi0360_start_2[] = {
+       {0x62, 0x041d},         /* reserved - def 0x0418 */
+};
+static const struct i2c_write_cmd mi0360_start_3[] = {
+       {0x05, 0x007b},         /* horiz blanking */
+};
+static const struct i2c_write_cmd mi0360_start_4[] = {
+       {0x05, 0x03f5},         /* horiz blanking */
+};
+
+static const struct cap_s {
+       u8      cc_sizeid;
+       u8      cc_bytes[32];
+} capconfig[3][3] = {
+       [SENSOR_ICX098BQ] = {
+               {0,                             /* JPEG, 160x120 */
+                 {0x01, 0x1f, 0x20, 0x0e, 0x00, 0x9f, 0x02, 0xee,
+                  0x01, 0x02, 0x00, 0x08, 0x18, 0x12, 0x78, 0xc8,
+                  0x02, 0x8b, 0x00, 0x8b, 0x00, 0x41, 0x01, 0x41,
+                  0x01, 0x41, 0x01, 0x05, 0x40, 0x01, 0xf0, 0x00} },
+               {2,                             /* JPEG, 320x240 */
+                 {0x01, 0x1f, 0x20, 0x0e, 0x00, 0x9f, 0x02, 0xee,
+                  0x01, 0x02, 0x00, 0x08, 0x18, 0x12, 0x78, 0xc8,
+                  0x02, 0xdf, 0x01, 0x00, 0x00, 0x3f, 0x01, 0x3f,
+                  0x01, 0x00, 0x00, 0x05, 0x40, 0x01, 0xf0, 0x00} },
+               {4,                             /* JPEG, 640x480 */
+                 {0x01, 0x22, 0x20, 0x0e, 0x00, 0xa2, 0x02, 0xf0,
+                  0x01, 0x02, 0x00, 0x08, 0x18, 0x12, 0x78, 0xc8,
+                  0x07, 0xe1, 0x01, 0xe1, 0x01, 0x3f, 0x01, 0x3f,
+                  0x01, 0x3f, 0x01, 0x05, 0x80, 0x02, 0xe0, 0x01} },
+       },
+       [SENSOR_LZ24BP] = {
+               {0,                             /* JPEG, 160x120 */
+                 {0x01, 0x1f, 0x20, 0x0e, 0x00, 0x9f, 0x02, 0xee,
+                  0x01, 0x02, 0x00, 0x08, 0x18, 0x12, 0x78, 0xc8,
+                  0x02, 0x8b, 0x00, 0x8b, 0x00, 0x41, 0x01, 0x41,
+                  0x01, 0x41, 0x01, 0x05, 0x40, 0x01, 0xf0, 0x00} },
+               {2,                             /* JPEG, 320x240 */
+                 {0x01, 0x22, 0x20, 0x0e, 0x00, 0xa2, 0x02, 0xee,
+                  0x01, 0x02, 0x00, 0x08, 0x18, 0x12, 0x78, 0xc8,
+                  0x02, 0xdf, 0x01, 0x00, 0x00, 0x3f, 0x01, 0x3f,
+                  0x01, 0x00, 0x00, 0x05, 0x40, 0x01, 0xf0, 0x00} },
+               {4,                             /* JPEG, 640x480 */
+                 {0x01, 0x22, 0x20, 0x0e, 0x00, 0xa2, 0x02, 0xf0,
+                  0x01, 0x02, 0x00, 0x08, 0x18, 0x12, 0x78, 0xc8,
+                  0x07, 0xe1, 0x01, 0xe1, 0x01, 0x3f, 0x01, 0x3f,
+                  0x01, 0x3f, 0x01, 0x05, 0x80, 0x02, 0xe0, 0x01} },
+       },
+       [SENSOR_MI0360] = {
+               {0,                             /* JPEG, 160x120 */
+                 {0x05, 0x3d, 0x20, 0x0b, 0x00, 0xbd, 0x02, 0x0b,
+                  0x02, 0x02, 0x00, 0x08, 0x18, 0x12, 0x78, 0xc8,
+                  0x02, 0x01, 0x01, 0x01, 0x01, 0x9f, 0x00, 0x9f,
+                  0x00, 0x9f, 0x01, 0x05, 0xa0, 0x00, 0x80, 0x00} },
+               {2,                             /* JPEG, 320x240 */
+                 {0x01, 0x02, 0x20, 0x01, 0x20, 0x82, 0x02, 0xe1,
+/*fixme                                       03                      e3 */
+                  0x01, 0x02, 0x00, 0x08, 0x18, 0x12, 0x78, 0xc8,
+                  0x02, 0xdf, 0x01, 0x00, 0x00, 0x3f, 0x01, 0x3f,
+                  0x01, 0x00, 0x00, 0x05, 0x40, 0x01, 0xf0, 0x00} },
+               {4,                             /* JPEG, 640x480 */
+                 {0x01, 0x02, 0x20, 0x01, 0x20, 0x82, 0x02, 0xe3,
+                  0x01, 0x02, 0x00, 0x08, 0x18, 0x12, 0x78, 0xc8,
+                  0x07, 0xe1, 0x01, 0xe1, 0x01, 0x3f, 0x01, 0x3f,
+                  0x01, 0x3f, 0x01, 0x05, 0x80, 0x02, 0xe0, 0x01} },
+       },
+};
+
+static void reg_r(struct gspca_dev *gspca_dev,
+               u16 value, int len)
+{
+       usb_control_msg(gspca_dev->dev,
+                       usb_rcvctrlpipe(gspca_dev->dev, 0),
+                       0x0c,
+                       USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                       value, 0, gspca_dev->usb_buf, len,
+                       500);
+}
+
+static void reg_w(struct gspca_dev *gspca_dev, u16 value, u16 index)
+{
+       int ret;
+
+       if (gspca_dev->usb_err < 0)
+               return;
+       PDEBUG(D_USBO, "reg_w v: %04x i: %04x", value, index);
+       ret = usb_control_msg(gspca_dev->dev,
+                       usb_sndctrlpipe(gspca_dev->dev, 0),
+                       0x0c,                   /* request */
+                       USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                       value, index, NULL, 0,
+                       500);
+       msleep(30);
+       if (ret < 0) {
+               PDEBUG(D_ERR, "reg_w %04x %04x failed %d", value, index, ret);
+               gspca_dev->usb_err = ret;
+       }
+}
+
+static void reg_wb(struct gspca_dev *gspca_dev, u16 value, u16 index,
+               const u8 *data, int len)
+{
+       int ret;
+
+       if (gspca_dev->usb_err < 0)
+               return;
+       PDEBUG(D_USBO, "reg_wb v: %04x i: %04x %02x...%02x",
+                       value, index, *data, data[len - 1]);
+       memcpy(gspca_dev->usb_buf, data, len);
+       ret = usb_control_msg(gspca_dev->dev,
+                       usb_sndctrlpipe(gspca_dev->dev, 0),
+                       0x0c,                   /* request */
+                       USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                       value, index, gspca_dev->usb_buf, len,
+                       1000);
+       msleep(30);
+       if (ret < 0) {
+               PDEBUG(D_ERR, "reg_wb %04x %04x failed %d", value, index, ret);
+               gspca_dev->usb_err = ret;
+       }
+}
+
+static void i2c_write(struct gspca_dev *gspca_dev,
+                       const struct i2c_write_cmd *cmd,
+                       int ncmds)
+{
+       u16 val, idx;
+       u8 *buf;
+       int ret;
+
+       if (gspca_dev->usb_err < 0)
+               return;
+
+       val = (0x5d << 8) | SQ930_CTRL_I2C_IO;  /* 0x5d = mi0360 i2c addr */
+       idx = (cmd->val & 0xff00) | cmd->reg;
+
+       buf = gspca_dev->usb_buf;
+       *buf++ = 0x80;
+       *buf++ = cmd->val;
+
+       while (--ncmds > 0) {
+               cmd++;
+               *buf++ = cmd->reg;
+               *buf++ = cmd->val >> 8;
+               *buf++ = 0x80;
+               *buf++ = cmd->val;
+       }
+
+       PDEBUG(D_USBO, "i2c_w v: %04x i: %04x %02x...%02x",
+                       val, idx, gspca_dev->usb_buf[0], buf[-1]);
+       ret = usb_control_msg(gspca_dev->dev,
+                       usb_sndctrlpipe(gspca_dev->dev, 0),
+                       0x0c,                   /* request */
+                       USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                       val, idx,
+                       gspca_dev->usb_buf, buf - gspca_dev->usb_buf,
+                       500);
+       if (ret < 0) {
+               PDEBUG(D_ERR, "i2c_write failed %d", ret);
+               gspca_dev->usb_err = ret;
+       }
+}
+
+static void ucbus_write(struct gspca_dev *gspca_dev,
+                       const struct ucbus_write_cmd *cmd,
+                       int ncmds,
+                       int batchsize)
+{
+       u8 *buf;
+       u16 val, idx;
+       int len, ret;
+
+       if (gspca_dev->usb_err < 0)
+               return;
+
+#ifdef GSPCA_DEBUG
+       if ((batchsize - 1) * 3 > USB_BUF_SZ) {
+               err("Bug: usb_buf overflow");
+               gspca_dev->usb_err = -ENOMEM;
+               return;
+       }
+#endif
+
+       for (;;) {
+               len = ncmds;
+               if (len > batchsize)
+                       len = batchsize;
+               ncmds -= len;
+
+               val = (cmd->bw_addr << 8) | SQ930_CTRL_UCBUS_IO;
+               idx = (cmd->bw_data << 8) | (cmd->bw_addr >> 8);
+
+               buf = gspca_dev->usb_buf;
+               while (--len > 0) {
+                       cmd++;
+                       *buf++ = cmd->bw_addr;
+                       *buf++ = cmd->bw_addr >> 8;
+                       *buf++ = cmd->bw_data;
+               }
+               if (buf != gspca_dev->usb_buf)
+                       PDEBUG(D_USBO, "ucbus v: %04x i: %04x %02x...%02x",
+                                       val, idx,
+                                       gspca_dev->usb_buf[0], buf[-1]);
+               else
+                       PDEBUG(D_USBO, "ucbus v: %04x i: %04x",
+                                       val, idx);
+               ret = usb_control_msg(gspca_dev->dev,
+                               usb_sndctrlpipe(gspca_dev->dev, 0),
+                               0x0c,                   /* request */
+                          USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                               val, idx,
+                               gspca_dev->usb_buf, buf - gspca_dev->usb_buf,
+                               500);
+               if (ret < 0) {
+                       PDEBUG(D_ERR, "ucbus_write failed %d", ret);
+                       gspca_dev->usb_err = ret;
+                       return;
+               }
+               msleep(30);
+               if (ncmds <= 0)
+                       break;
+               cmd++;
+       }
+}
+
+static void gpio_set(struct sd *sd, u16 val, u16 mask)
+{
+       struct gspca_dev *gspca_dev = &sd->gspca_dev;
+
+       if (mask & 0x00ff) {
+               sd->gpio[0] &= ~mask;
+               sd->gpio[0] |= val;
+               reg_w(gspca_dev, 0x0100 | SQ930_CTRL_GPIO,
+                       ~sd->gpio[0] << 8);
+       }
+       mask >>= 8;
+       val >>= 8;
+       if (mask) {
+               sd->gpio[1] &= ~mask;
+               sd->gpio[1] |= val;
+               reg_w(gspca_dev, 0x0300 | SQ930_CTRL_GPIO,
+                       ~sd->gpio[1] << 8);
+       }
+}
+
+static void global_init(struct sd *sd, int first_time)
+{
+       static const struct ucbus_write_cmd clkfreq_cmd = {
+                               0xf031, 0       /* SQ930_CLKFREQ_60MHZ */
+       };
+
+       ucbus_write(&sd->gspca_dev, &clkfreq_cmd, 1, 1);
+
+       gpio_set(sd, SQ930_GPIO_POWER, 0xff00);
+       switch (sd->sensor) {
+       case SENSOR_ICX098BQ:
+               if (first_time)
+                       ucbus_write(&sd->gspca_dev,
+                                       icx098bq_start_0,
+                                       8, 8);
+               gpio_set(sd, 0, 0x00ff);
+               gpio_set(sd, SQ930_GPIO_DFL_I2C_SCL | SQ930_GPIO_DFL_I2C_SDA,
+                            SQ930_GPIO_DFL_I2C_SCL | SQ930_GPIO_DFL_I2C_SDA);
+               gpio_set(sd, 0, SQ930_GPIO_DFL_I2C_SCL);
+               gpio_set(sd, 0, SQ930_GPIO_DFL_I2C_SDA);
+               gpio_set(sd, SQ930_GPIO_RSTBAR,
+                            SQ930_GPIO_RSTBAR);
+               break;
+       case SENSOR_LZ24BP:
+               if (sd->type != Creative_live_motion)
+                       gpio_set(sd, SQ930_GPIO_EXTRA1, 0x00ff);
+               else
+                       gpio_set(sd, 0, 0x00ff);
+               msleep(50);
+               if (first_time)
+                       ucbus_write(&sd->gspca_dev,
+                                       lz24bp_start_0,
+                                       8, 8);
+               gpio_set(sd, 0, 0x0001);                /* no change */
+               gpio_set(sd, SQ930_GPIO_DFL_I2C_SCL | SQ930_GPIO_DFL_I2C_SDA,
+                            SQ930_GPIO_DFL_I2C_SCL | SQ930_GPIO_DFL_I2C_SDA);
+               gpio_set(sd, 0, SQ930_GPIO_DFL_I2C_SCL);
+               gpio_set(sd, 0, SQ930_GPIO_DFL_I2C_SDA);
+               gpio_set(sd, SQ930_GPIO_RSTBAR,
+                            SQ930_GPIO_RSTBAR);
+               break;
+       default:
+/*     case SENSOR_MI0360: */
+               if (first_time) {
+                       ucbus_write(&sd->gspca_dev,
+                                       mi0360_start_0,
+                                       ARRAY_SIZE(mi0360_start_0),
+                                       8);
+                       gpio_set(sd, SQ930_GPIO_RSTBAR, 0x00ff);
+               } else {
+                       gpio_set(sd, SQ930_GPIO_EXTRA2 | SQ930_GPIO_RSTBAR,
+                                       0x00ff);
+               }
+               gpio_set(sd, SQ930_GPIO_DFL_I2C_SCL | SQ930_GPIO_DFL_I2C_SDA,
+                            SQ930_GPIO_RSTBAR |
+                            SQ930_GPIO_DFL_I2C_SCL | SQ930_GPIO_DFL_I2C_SDA);
+               gpio_set(sd, 0, SQ930_GPIO_DFL_I2C_SCL);
+               gpio_set(sd, 0, SQ930_GPIO_DFL_I2C_SDA);
+               gpio_set(sd, 0, SQ930_GPIO_DFL_I2C_SDA);
+               gpio_set(sd, SQ930_GPIO_EXTRA2, SQ930_GPIO_EXTRA2);
+               break;
+       }
+}
+
+static void lz24bp_ppl(struct sd *sd, u16 ppl)
+{
+       struct ucbus_write_cmd cmds[2] = {
+               {0xf810, ppl >> 8},
+               {0xf811, ppl}
+       };
+
+       ucbus_write(&sd->gspca_dev, cmds, ARRAY_SIZE(cmds), 2);
+}
+
+static void setexposure(struct gspca_dev *gspca_dev)
+{
+       struct sd *sd = (struct sd *) gspca_dev;
+       int i, integclks, intstartclk, frameclks, min_frclk;
+       u16 cmd;
+       u8 buf[15];
+
+       integclks = sd->expo;
+       i = 0;
+       cmd = SQ930_CTRL_SET_EXPOSURE;
+       if (sd->sensor == SENSOR_MI0360) {
+               cmd |= 0x0100;
+               buf[i++] = 0x5d;        /* i2c_slave_addr */
+               buf[i++] = 0x08;        /* 2 * ni2c */
+               buf[i++] = 0x09;        /* reg = shutter width */
+               buf[i++] = integclks >> 8; /* val H */
+               buf[i++] = 0x80;
+               buf[i++] = integclks;   /* val L */
+               buf[i++] = 0x35;        /* reg = global gain */
+               buf[i++] = 0x00;        /* val H */
+               buf[i++] = 0x80;
+               buf[i++] = sd->gain;    /* val L */
+               buf[i++] = 0x00;
+               buf[i++] = 0x00;
+               buf[i++] = 0x00;
+               buf[i++] = 0x00;
+               buf[i++] = 0x83;
+       } else {
+               min_frclk = sd->sensor == SENSOR_ICX098BQ ? 0x210 : 0x26f;
+               if (integclks >= min_frclk) {
+                       intstartclk = 0;
+                       frameclks = integclks;
+               } else {
+                       intstartclk = min_frclk - integclks;
+                       frameclks = min_frclk;
+               }
+               buf[i++] = intstartclk >> 8;
+               buf[i++] = intstartclk;
+               buf[i++] = frameclks >> 8;
+               buf[i++] = frameclks;
+               buf[i++] = sd->gain;
+       }
+       reg_wb(gspca_dev, cmd, 0, buf, i);
+}
+
+/* This function is called at probe time just before sd_init */
+static int sd_config(struct gspca_dev *gspca_dev,
+               const struct usb_device_id *id)
+{
+       struct sd *sd = (struct sd *) gspca_dev;
+       struct cam *cam = &gspca_dev->cam;
+
+       sd->sensor = id->driver_info >> 8;
+       sd->type = id->driver_info;
+
+       cam->cam_mode = vga_mode;
+       cam->nmodes = ARRAY_SIZE(vga_mode);
+
+       cam->bulk = 1;
+       cam->bulk_size = BULK_TRANSFER_LEN;
+/*     cam->bulk_nurbs = 2;    fixme: if no setexpo sync */
+
+       sd->quality = QUALITY_DEF;
+       sd->gain = GAIN_DEF;
+       sd->expo = EXPO_DEF;
+
+       return 0;
+}
+
+/* this function is called at probe and resume time */
+static int sd_init(struct gspca_dev *gspca_dev)
+{
+       struct sd *sd = (struct sd *) gspca_dev;
+
+       sd->gpio[0] = sd->gpio[1] = 0xff;       /* force gpio rewrite */
+
+       if (sd->sensor != SENSOR_LZ24BP)
+               reg_w(gspca_dev, SQ930_CTRL_RESET, 0x0000);
+
+       reg_r(gspca_dev, SQ930_CTRL_GET_DEV_INFO, 8);
+/* it returns:
+ * 03 00 12 93 0b f6 c9 00     live! ultra
+ * 03 00 07 93 0b f6 ca 00     live! ultra for notebook
+ * 03 00 12 93 0b fe c8 00     Trust WB-3500T
+ * 02 00 06 93 0b fe c8 00     Joy-IT 318S
+ * 03 00 12 93 0b f6 cf 00     icam tracer - sensor icx098bq
+ * 02 00 12 93 0b fe cf 00     ProQ Motion Webcam
+ *
+ * byte
+ * 0: 02 = usb 1.0 (12Mbit) / 03 = usb2.0 (480Mbit)
+ * 1: 00
+ * 2: 06 / 07 / 12 = mode webcam? firmware??
+ * 3: 93 chip = 930b (930b or 930c)
+ * 4: 0b
+ * 5: f6 = cdd (icx098bq, lz24bp) / fe = cmos (i2c) (mi0360, ov9630)
+ * 6: c8 / c9 / ca / cf = mode webcam?, sensor? webcam?
+ * 7: 00
+ */
+       PDEBUG(D_PROBE, "info: %02x %02x %02x %02x %02x %02x %02x %02x",
+                       gspca_dev->usb_buf[0],
+                       gspca_dev->usb_buf[1],
+                       gspca_dev->usb_buf[2],
+                       gspca_dev->usb_buf[3],
+                       gspca_dev->usb_buf[4],
+                       gspca_dev->usb_buf[5],
+                       gspca_dev->usb_buf[6],
+                       gspca_dev->usb_buf[7]);
+
+/*fixme: no sensor probe - special case for icam tracer */
+       if (gspca_dev->usb_buf[5] == 0xf6
+        && sd->sensor == SENSOR_MI0360) {
+               sd->sensor = SENSOR_ICX098BQ;
+               gspca_dev->cam.cam_mode = &vga_mode[1]; /* only 320x240 */
+               gspca_dev->cam.nmodes = 1;
+       }
+
+       global_init(sd, 1);
+       return gspca_dev->usb_err;
+}
+
+/* special function to create the quantization tables of the JPEG header */
+static void sd_jpeg_set_qual(u8 *jpeg_hdr,
+                               int quality)
+{
+       int i, sc1, sc2;
+
+       quality = quality_tb[quality];  /* convert to JPEG quality */
+/*
+ * approximative qualities for Y and U/V:
+ *     quant = 0:94%/91% 1:91%/87% 2:82%/73% 3:69%/56%
+ * should have:
+ *     quant = 0:94%/91% 1:91%/87.5% 2:81.5%/72% 3:69%/54.5%
+ */
+       sc1 = 200 - quality * 2;
+       quality = quality * 7 / 5 - 40;         /* UV quality */
+       sc2 = 200 - quality * 2;
+       for (i = 0; i < 64; i++) {
+               jpeg_hdr[JPEG_QT0_OFFSET + i] =
+                       (jpeg_head[JPEG_QT0_OFFSET + i] * sc1 + 50) / 100;
+               jpeg_hdr[JPEG_QT1_OFFSET + i] =
+                       (jpeg_head[JPEG_QT1_OFFSET + i] * sc2 + 50) / 100;
+       }
+}
+
+/* send the start/stop commands to the webcam */
+static void send_start(struct gspca_dev *gspca_dev)
+{
+       struct sd *sd = (struct sd *) gspca_dev;
+       const struct cap_s *cap;
+       int mode, quality;
+
+       mode = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
+       cap = &capconfig[sd->sensor][mode];
+       quality = sd->quality;
+       reg_wb(gspca_dev, (quality << 12)
+                                | 0x0a00       /* 900 for Bayer */
+                                | SQ930_CTRL_CAP_START,
+                       0x0500                  /* a00 for Bayer */
+                                | cap->cc_sizeid,
+                       cap->cc_bytes, 32);
+};
+static void send_stop(struct gspca_dev *gspca_dev)
+{
+       reg_w(gspca_dev, SQ930_CTRL_CAP_STOP, 0);
+};
+
+/* function called at start time before URB creation */
+static int sd_isoc_init(struct gspca_dev *gspca_dev)
+{
+       struct sd *sd = (struct sd *) gspca_dev;
+
+       gspca_dev->cam.bulk_nurbs = 1;  /* there must be one URB only */
+       sd->do_ctrl = 0;
+       return 0;
+}
+
+/* start the capture */
+static int sd_start(struct gspca_dev *gspca_dev)
+{
+       struct sd *sd = (struct sd *) gspca_dev;
+       int mode;
+
+       /* initialize the JPEG header */
+       jpeg_define(sd->jpeg_hdr, gspca_dev->height, gspca_dev->width,
+                       0x21);          /* JPEG 422 */
+       sd_jpeg_set_qual(sd->jpeg_hdr, sd->quality);
+
+       global_init(sd, 0);
+       msleep(100);
+
+       switch (sd->sensor) {
+       case SENSOR_ICX098BQ:
+               ucbus_write(gspca_dev, icx098bq_start_0,
+                               ARRAY_SIZE(icx098bq_start_0),
+                               8);
+               ucbus_write(gspca_dev, icx098bq_start_1,
+                               ARRAY_SIZE(icx098bq_start_1),
+                               5);
+               ucbus_write(gspca_dev, icx098bq_start_2,
+                               ARRAY_SIZE(icx098bq_start_2),
+                               6);
+               msleep(50);
+
+               /* 1st start */
+               send_start(gspca_dev);
+               gpio_set(sd, SQ930_GPIO_EXTRA2 | SQ930_GPIO_RSTBAR, 0x00ff);
+               msleep(70);
+               reg_w(gspca_dev, SQ930_CTRL_CAP_STOP, 0x0000);
+               gpio_set(sd, 0x7f, 0x00ff);
+
+               /* 2nd start */
+               send_start(gspca_dev);
+               gpio_set(sd, SQ930_GPIO_EXTRA2 | SQ930_GPIO_RSTBAR, 0x00ff);
+               goto out;
+       case SENSOR_LZ24BP:
+               ucbus_write(gspca_dev, lz24bp_start_0,
+                               ARRAY_SIZE(lz24bp_start_0),
+                               8);
+               if (sd->type != Creative_live_motion)
+                       ucbus_write(gspca_dev, lz24bp_start_1_gen,
+                                       ARRAY_SIZE(lz24bp_start_1_gen),
+                                       5);
+               else
+                       ucbus_write(gspca_dev, lz24bp_start_1_clm,
+                                       ARRAY_SIZE(lz24bp_start_1_clm),
+                                       5);
+               ucbus_write(gspca_dev, lz24bp_start_2,
+                               ARRAY_SIZE(lz24bp_start_2),
+                               6);
+               mode = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
+               lz24bp_ppl(sd, mode == 2 ? 0x0564 : 0x0310);
+               msleep(10);
+               break;
+       default:
+/*     case SENSOR_MI0360: */
+               ucbus_write(gspca_dev, mi0360_start_0,
+                               ARRAY_SIZE(mi0360_start_0),
+                               8);
+               i2c_write(gspca_dev, mi0360_init_23,
+                               ARRAY_SIZE(mi0360_init_23));
+               i2c_write(gspca_dev, mi0360_init_24,
+                               ARRAY_SIZE(mi0360_init_24));
+               i2c_write(gspca_dev, mi0360_init_25,
+                               ARRAY_SIZE(mi0360_init_25));
+               ucbus_write(gspca_dev, mi0360_start_1,
+                               ARRAY_SIZE(mi0360_start_1),
+                               5);
+               i2c_write(gspca_dev, mi0360_start_2,
+                               ARRAY_SIZE(mi0360_start_2));
+               i2c_write(gspca_dev, mi0360_start_3,
+                               ARRAY_SIZE(mi0360_start_3));
+
+               /* 1st start */
+               send_start(gspca_dev);
+               msleep(60);
+               reg_w(gspca_dev, SQ930_CTRL_CAP_STOP, 0x0000);
+
+               i2c_write(gspca_dev,
+                       mi0360_start_4, ARRAY_SIZE(mi0360_start_4));
+               break;
+       }
+
+       send_start(gspca_dev);
+out:
+       msleep(1000);
+
+       sd->eof_len = 0;        /* init packet scan */
+
+       sd->do_ctrl = 1;        /* set the exposure */
+
+       return gspca_dev->usb_err;
+}
+
+static void sd_stopN(struct gspca_dev *gspca_dev)
+{
+       send_stop(gspca_dev);
+}
+
+/* function called when the application gets a new frame */
+/* It sets the exposure if required and restart the bulk transfer. */
+static void sd_dq_callback(struct gspca_dev *gspca_dev)
+{
+       struct sd *sd = (struct sd *) gspca_dev;
+       int ret;
+
+       if (!sd->do_ctrl || gspca_dev->cam.bulk_nurbs != 0)
+               return;
+       sd->do_ctrl = 0;
+
+       setexposure(gspca_dev);
+
+       gspca_dev->cam.bulk_nurbs = 1;
+       ret = usb_submit_urb(gspca_dev->urb[0], GFP_ATOMIC);
+       if (ret < 0)
+               PDEBUG(D_ERR|D_PACK, "sd_dq_callback() err %d", ret);
+
+       /* wait a little time, otherwise the webcam crashes */
+       msleep(100);
+}
+
+/* move a packet adding 0x00 after 0xff */
+static void add_packet(struct gspca_dev *gspca_dev,
+                       u8 *data,
+                       int len)
+{
+       int i;
+
+       i = 0;
+       do {
+               if (data[i] == 0xff) {
+                       gspca_frame_add(gspca_dev, INTER_PACKET,
+                                       data, i + 1);
+                       len -= i;
+                       data += i;
+                       *data = 0x00;
+                       i = 0;
+               }
+       } while (++i < len);
+       gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
+}
+
+/* end a frame and start a new one */
+static void eof_sof(struct gspca_dev *gspca_dev)
+{
+       struct sd *sd = (struct sd *) gspca_dev;
+       static const u8 ffd9[] = {0xff, 0xd9};
+
+       /* if control set, stop bulk transfer */
+       if (sd->do_ctrl
+        && gspca_dev->last_packet_type == INTER_PACKET)
+               gspca_dev->cam.bulk_nurbs = 0;
+       gspca_frame_add(gspca_dev, LAST_PACKET,
+                       ffd9, 2);
+       gspca_frame_add(gspca_dev, FIRST_PACKET,
+                       sd->jpeg_hdr, JPEG_HDR_SZ);
+}
+
+static void sd_pkt_scan(struct gspca_dev *gspca_dev,
+                       u8 *data,               /* isoc packet */
+                       int len)                /* iso packet length */
+{
+       struct sd *sd = (struct sd *) gspca_dev;
+       u8 *p;
+       int l;
+
+       len -= 8;       /* ignore last 8 bytes (00 00 55 aa 55 aa 00 00) */
+
+       /*
+        * the end/start of frame is indicated by
+        *      0x00 * 16 -  0xab * 8
+        * aligned on 8 bytes boundary
+        */
+       if (sd->eof_len != 0) {         /* if 'abababab' in previous pkt */
+               if (*((u32 *) data) == 0xabababab) {
+                               /*fixme: should remove previous 0000ababab*/
+                       eof_sof(gspca_dev);
+                       data += 4;
+                       len -= 4;
+               }
+               sd->eof_len = 0;
+       }
+       p = data;
+       l = len;
+       for (;;) {
+               if (*((u32 *) p) == 0xabababab) {
+                       if (l < 8) {            /* (may be 4 only) */
+                               sd->eof_len = 1;
+                               break;
+                       }
+                       if (*((u32 *) p + 1) == 0xabababab) {
+                               add_packet(gspca_dev, data, p - data - 16);
+                                               /* remove previous zeros */
+                               eof_sof(gspca_dev);
+                               p += 8;
+                               l -= 8;
+                               if (l <= 0)
+                                       return;
+                               len = l;
+                               data = p;
+                               continue;
+                       }
+               }
+               p += 4;
+               l -= 4;
+               if (l <= 0)
+                       break;
+       }
+       add_packet(gspca_dev, data, len);
+}
+
+static int sd_setgain(struct gspca_dev *gspca_dev, __s32 val)
+{
+       struct sd *sd = (struct sd *) gspca_dev;
+
+       sd->gain = val;
+       if (gspca_dev->streaming)
+               sd->do_ctrl = 1;
+       return 0;
+}
+
+static int sd_getgain(struct gspca_dev *gspca_dev, __s32 *val)
+{
+       struct sd *sd = (struct sd *) gspca_dev;
+
+       *val = sd->gain;
+       return 0;
+}
+static int sd_setexpo(struct gspca_dev *gspca_dev, __s32 val)
+{
+       struct sd *sd = (struct sd *) gspca_dev;
+
+       sd->expo = val;
+       if (gspca_dev->streaming)
+               sd->do_ctrl = 1;
+       return 0;
+}
+
+static int sd_getexpo(struct gspca_dev *gspca_dev, __s32 *val)
+{
+       struct sd *sd = (struct sd *) gspca_dev;
+
+       *val = sd->expo;
+       return 0;
+}
+
+static int sd_set_jcomp(struct gspca_dev *gspca_dev,
+                       struct v4l2_jpegcompression *jcomp)
+{
+       struct sd *sd = (struct sd *) gspca_dev;
+       int quality;
+
+       if (jcomp->quality >= (QUAL_0 + QUAL_1) / 2)
+               quality = 0;
+       else if (jcomp->quality >= (QUAL_1 + QUAL_2) / 2)
+               quality = 1;
+       else if (jcomp->quality >= (QUAL_2 + QUAL_3) / 2)
+               quality = 2;
+       else
+               quality = 3;
+
+       if (quality != sd->quality) {
+               sd->quality = quality;
+               if (gspca_dev->streaming) {
+                       send_stop(gspca_dev);
+                       sd_jpeg_set_qual(sd->jpeg_hdr, sd->quality);
+                       msleep(70);
+                       send_start(gspca_dev);
+               }
+       }
+       return gspca_dev->usb_err;
+}
+
+static int sd_get_jcomp(struct gspca_dev *gspca_dev,
+                       struct v4l2_jpegcompression *jcomp)
+{
+       struct sd *sd = (struct sd *) gspca_dev;
+
+       memset(jcomp, 0, sizeof *jcomp);
+       jcomp->quality = quality_tb[sd->quality];
+       jcomp->jpeg_markers = V4L2_JPEG_MARKER_DHT
+                       | V4L2_JPEG_MARKER_DQT;
+       return 0;
+}
+
+/* sub-driver description */
+static const struct sd_desc sd_desc = {
+       .name   = MODULE_NAME,
+       .ctrls = sd_ctrls,
+       .nctrls = ARRAY_SIZE(sd_ctrls),
+       .config = sd_config,
+       .init   = sd_init,
+       .isoc_init = sd_isoc_init,
+       .start  = sd_start,
+       .stopN  = sd_stopN,
+       .pkt_scan = sd_pkt_scan,
+       .dq_callback = sd_dq_callback,
+       .get_jcomp = sd_get_jcomp,
+       .set_jcomp = sd_set_jcomp,
+};
+
+/* Table of supported USB devices */
+#define ST(sensor, type) \
+       .driver_info = (SENSOR_ ## sensor << 8) \
+                       | (type)
+static const __devinitdata struct usb_device_id device_table[] = {
+       {USB_DEVICE(0x041e, 0x4038), ST(MI0360, 0)},
+       {USB_DEVICE(0x041e, 0x403c), ST(LZ24BP, 0)},
+       {USB_DEVICE(0x041e, 0x403d), ST(LZ24BP, 0)},
+       {USB_DEVICE(0x041e, 0x4041), ST(LZ24BP, Creative_live_motion)},
+       {USB_DEVICE(0x2770, 0x930b), ST(MI0360, 0)}, /* or ICX098BQ */
+       {USB_DEVICE(0x2770, 0x930c), ST(MI0360, 0)},
+       {}
+};
+MODULE_DEVICE_TABLE(usb, device_table);
+
+
+/* -- device connect -- */
+static int sd_probe(struct usb_interface *intf,
+               const struct usb_device_id *id)
+{
+       return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
+                       THIS_MODULE);
+}
+
+static struct usb_driver sd_driver = {
+       .name       = MODULE_NAME,
+       .id_table   = device_table,
+       .probe      = sd_probe,
+       .disconnect = gspca_disconnect,
+#ifdef CONFIG_PM
+       .suspend    = gspca_suspend,
+       .resume     = gspca_resume,
+#endif
+};
+
+/* -- module insert / remove -- */
+static int __init sd_mod_init(void)
+{
+       int ret;
+
+       ret = usb_register(&sd_driver);
+       if (ret < 0)
+               return ret;
+       info("registered");
+       return 0;
+}
+static void __exit sd_mod_exit(void)
+{
+       usb_deregister(&sd_driver);
+       info("deregistered");
+}
+
+module_init(sd_mod_init);
+module_exit(sd_mod_exit);