2 * SPCA505 chip based cameras initialization data
4 * V4L2 by Jean-Francis Moine <http://moinejf.free.fr>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #define MODULE_NAME "spca505"
26 #define DRIVER_VERSION_NUMBER KERNEL_VERSION(2, 1, 5)
27 static const char version
[] = "2.1.5";
29 MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
30 MODULE_DESCRIPTION("GSPCA/SPCA505 USB Camera Driver");
31 MODULE_LICENSE("GPL");
33 /* specific webcam descriptor */
35 struct gspca_dev gspca_dev
; /* !! must be the first item */
38 unsigned char tmpbuf
[640 * 480 * 3 / 2]; /* YYUV per line */
39 unsigned char tmpbuf2
[640 * 480 * 2]; /* YUYV */
41 unsigned char brightness
;
44 #define IntelPCCameraPro 0
48 /* V4L2 controls supported by the driver */
49 static int sd_setbrightness(struct gspca_dev
*gspca_dev
, __s32 val
);
50 static int sd_getbrightness(struct gspca_dev
*gspca_dev
, __s32
*val
);
52 static struct ctrl sd_ctrls
[] = {
53 #define SD_BRIGHTNESS 0
56 .id
= V4L2_CID_BRIGHTNESS
,
57 .type
= V4L2_CTRL_TYPE_INTEGER
,
64 .set
= sd_setbrightness
,
65 .get
= sd_getbrightness
,
69 static struct v4l2_pix_format vga_mode
[] = {
70 {160, 120, V4L2_PIX_FMT_YUYV
, V4L2_FIELD_NONE
,
71 .bytesperline
= 160 * 2,
72 .sizeimage
= 160 * 120 * 2,
73 .colorspace
= V4L2_COLORSPACE_SRGB
,
75 {176, 144, V4L2_PIX_FMT_YUYV
, V4L2_FIELD_NONE
,
76 .bytesperline
= 176 * 2,
77 .sizeimage
= 176 * 144 * 2,
78 .colorspace
= V4L2_COLORSPACE_SRGB
,
80 {320, 240, V4L2_PIX_FMT_YUYV
, V4L2_FIELD_NONE
,
81 .bytesperline
= 320 * 2,
82 .sizeimage
= 320 * 240 * 2,
83 .colorspace
= V4L2_COLORSPACE_SRGB
,
85 {352, 288, V4L2_PIX_FMT_YUYV
, V4L2_FIELD_NONE
,
86 .bytesperline
= 352 * 2,
87 .sizeimage
= 352 * 288 * 2,
88 .colorspace
= V4L2_COLORSPACE_SRGB
,
90 {640, 480, V4L2_PIX_FMT_YUYV
, V4L2_FIELD_NONE
,
91 .bytesperline
= 640 * 2,
92 .sizeimage
= 640 * 480 * 2,
93 .colorspace
= V4L2_COLORSPACE_SRGB
,
97 #define SPCA50X_OFFSET_DATA 10
99 #define SPCA50X_REG_USB 0x02 /* spca505 501 */
101 #define SPCA50X_USB_CTRL 0x00 /* spca505 */
102 #define SPCA50X_CUSB_ENABLE 0x01 /* spca505 */
103 #define SPCA50X_REG_GLOBAL 0x03 /* spca505 */
104 #define SPCA50X_GMISC0_IDSEL 0x01 /* Global control device ID select spca505 */
105 #define SPCA50X_GLOBAL_MISC0 0x00 /* Global control miscellaneous 0 spca505 */
107 #define SPCA50X_GLOBAL_MISC1 0x01 /* 505 */
108 #define SPCA50X_GLOBAL_MISC3 0x03 /* 505 */
109 #define SPCA50X_GMISC3_SAA7113RST 0x20 /* Not sure about this one spca505 */
112 * Data to initialize a SPCA505. Common to the CCD and external modes
114 static const __u16 spca505_init_data
[][3] = {
115 /* line bmRequest,value,index */
117 {SPCA50X_REG_GLOBAL
, SPCA50X_GMISC3_SAA7113RST
, SPCA50X_GLOBAL_MISC3
},
119 /* 1822 */ {SPCA50X_REG_GLOBAL
, 0x00, SPCA50X_GLOBAL_MISC3
},
120 /* 1825 */ {SPCA50X_REG_GLOBAL
, 0x00, SPCA50X_GLOBAL_MISC1
},
121 /* Block USB reset */
122 /* 1828 */ {SPCA50X_REG_GLOBAL
, SPCA50X_GMISC0_IDSEL
,
123 SPCA50X_GLOBAL_MISC0
},
125 /* 1831 */ {0x5, 0x01, 0x10},
126 /* Maybe power down some stuff */
127 /* 1834 */ {0x5, 0x0f, 0x11},
129 /* Setup internal CCD ? */
130 /* 1837 */ {0x6, 0x10, 0x08},
131 /* 1840 */ {0x6, 0x00, 0x09},
132 /* 1843 */ {0x6, 0x00, 0x0a},
133 /* 1846 */ {0x6, 0x00, 0x0b},
134 /* 1849 */ {0x6, 0x10, 0x0c},
135 /* 1852 */ {0x6, 0x00, 0x0d},
136 /* 1855 */ {0x6, 0x00, 0x0e},
137 /* 1858 */ {0x6, 0x00, 0x0f},
138 /* 1861 */ {0x6, 0x10, 0x10},
139 /* 1864 */ {0x6, 0x02, 0x11},
140 /* 1867 */ {0x6, 0x00, 0x12},
141 /* 1870 */ {0x6, 0x04, 0x13},
142 /* 1873 */ {0x6, 0x02, 0x14},
143 /* 1876 */ {0x6, 0x8a, 0x51},
144 /* 1879 */ {0x6, 0x40, 0x52},
145 /* 1882 */ {0x6, 0xb6, 0x53},
146 /* 1885 */ {0x6, 0x3d, 0x54},
151 * Data to initialize the camera using the internal CCD
153 static const __u16 spca505_open_data_ccd
[][3] = {
154 /* line bmRequest,value,index */
155 /* Internal CCD data set */
156 /* 1891 */ {0x3, 0x04, 0x01},
157 /* This could be a reset */
158 /* 1894 */ {0x3, 0x00, 0x01},
160 /* Setup compression and image registers. 0x6 and 0x7 seem to be
161 related to H&V hold, and are resolution mode specific */
162 /* 1897 */ {0x4, 0x10, 0x01},
163 /* DIFF(0x50), was (0x10) */
164 /* 1900 */ {0x4, 0x00, 0x04},
165 /* 1903 */ {0x4, 0x00, 0x05},
166 /* 1906 */ {0x4, 0x20, 0x06},
167 /* 1909 */ {0x4, 0x20, 0x07},
169 /* 1912 */ {0x8, 0x0a, 0x00},
170 /* DIFF (0x4a), was (0xa) */
172 /* 1915 */ {0x5, 0x00, 0x10},
173 /* 1918 */ {0x5, 0x00, 0x11},
174 /* 1921 */ {0x5, 0x00, 0x00},
175 /* DIFF not written */
176 /* 1924 */ {0x5, 0x00, 0x01},
177 /* DIFF not written */
178 /* 1927 */ {0x5, 0x00, 0x02},
179 /* DIFF not written */
180 /* 1930 */ {0x5, 0x00, 0x03},
181 /* DIFF not written */
182 /* 1933 */ {0x5, 0x00, 0x04},
183 /* DIFF not written */
184 /* 1936 */ {0x5, 0x80, 0x05},
185 /* DIFF not written */
186 /* 1939 */ {0x5, 0xe0, 0x06},
187 /* DIFF not written */
188 /* 1942 */ {0x5, 0x20, 0x07},
189 /* DIFF not written */
190 /* 1945 */ {0x5, 0xa0, 0x08},
191 /* DIFF not written */
192 /* 1948 */ {0x5, 0x0, 0x12},
193 /* DIFF not written */
194 /* 1951 */ {0x5, 0x02, 0x0f},
195 /* DIFF not written */
196 /* 1954 */ {0x5, 0x10, 0x46},
197 /* DIFF not written */
198 /* 1957 */ {0x5, 0x8, 0x4a},
199 /* DIFF not written */
201 /* 1960 */ {0x3, 0x08, 0x03},
202 /* DIFF (0x3,0x28,0x3) */
203 /* 1963 */ {0x3, 0x08, 0x01},
204 /* 1966 */ {0x3, 0x0c, 0x03},
205 /* DIFF not written */
206 /* 1969 */ {0x3, 0x21, 0x00},
209 /* Extra block copied from init to hopefully ensure CCD is in a sane state */
210 /* 1837 */ {0x6, 0x10, 0x08},
211 /* 1840 */ {0x6, 0x00, 0x09},
212 /* 1843 */ {0x6, 0x00, 0x0a},
213 /* 1846 */ {0x6, 0x00, 0x0b},
214 /* 1849 */ {0x6, 0x10, 0x0c},
215 /* 1852 */ {0x6, 0x00, 0x0d},
216 /* 1855 */ {0x6, 0x00, 0x0e},
217 /* 1858 */ {0x6, 0x00, 0x0f},
218 /* 1861 */ {0x6, 0x10, 0x10},
219 /* 1864 */ {0x6, 0x02, 0x11},
220 /* 1867 */ {0x6, 0x00, 0x12},
221 /* 1870 */ {0x6, 0x04, 0x13},
222 /* 1873 */ {0x6, 0x02, 0x14},
223 /* 1876 */ {0x6, 0x8a, 0x51},
224 /* 1879 */ {0x6, 0x40, 0x52},
225 /* 1882 */ {0x6, 0xb6, 0x53},
226 /* 1885 */ {0x6, 0x3d, 0x54},
227 /* End of extra block */
229 /* 1972 */ {0x6, 0x3f, 0x1},
231 /* 1975 */ {0x6, 0x10, 0x02},
232 /* 1978 */ {0x6, 0x64, 0x07},
233 /* 1981 */ {0x6, 0x10, 0x08},
234 /* 1984 */ {0x6, 0x00, 0x09},
235 /* 1987 */ {0x6, 0x00, 0x0a},
236 /* 1990 */ {0x6, 0x00, 0x0b},
237 /* 1993 */ {0x6, 0x10, 0x0c},
238 /* 1996 */ {0x6, 0x00, 0x0d},
239 /* 1999 */ {0x6, 0x00, 0x0e},
240 /* 2002 */ {0x6, 0x00, 0x0f},
241 /* 2005 */ {0x6, 0x10, 0x10},
242 /* 2008 */ {0x6, 0x02, 0x11},
243 /* 2011 */ {0x6, 0x00, 0x12},
244 /* 2014 */ {0x6, 0x04, 0x13},
245 /* 2017 */ {0x6, 0x02, 0x14},
246 /* 2020 */ {0x6, 0x8a, 0x51},
247 /* 2023 */ {0x6, 0x40, 0x52},
248 /* 2026 */ {0x6, 0xb6, 0x53},
249 /* 2029 */ {0x6, 0x3d, 0x54},
250 /* 2032 */ {0x6, 0x60, 0x57},
251 /* 2035 */ {0x6, 0x20, 0x58},
252 /* 2038 */ {0x6, 0x15, 0x59},
253 /* 2041 */ {0x6, 0x05, 0x5a},
255 /* 2044 */ {0x5, 0x01, 0xc0},
256 /* 2047 */ {0x5, 0x10, 0xcb},
257 /* 2050 */ {0x5, 0x80, 0xc1},
259 /* 2053 */ {0x5, 0x0, 0xc2},
261 /* 2056 */ {0x5, 0x00, 0xca},
262 /* 2059 */ {0x5, 0x80, 0xc1},
264 /* 2062 */ {0x5, 0x04, 0xc2},
265 /* 2065 */ {0x5, 0x00, 0xca},
266 /* 2068 */ {0x5, 0x0, 0xc1},
268 /* 2071 */ {0x5, 0x00, 0xc2},
269 /* 2074 */ {0x5, 0x00, 0xca},
270 /* 2077 */ {0x5, 0x40, 0xc1},
272 /* 2080 */ {0x5, 0x17, 0xc2},
273 /* 2083 */ {0x5, 0x00, 0xca},
274 /* 2086 */ {0x5, 0x80, 0xc1},
276 /* 2089 */ {0x5, 0x06, 0xc2},
277 /* 2092 */ {0x5, 0x00, 0xca},
278 /* 2095 */ {0x5, 0x80, 0xc1},
280 /* 2098 */ {0x5, 0x04, 0xc2},
281 /* 2101 */ {0x5, 0x00, 0xca},
283 /* 2104 */ {0x3, 0x4c, 0x3},
284 /* 2107 */ {0x3, 0x18, 0x1},
286 /* 2110 */ {0x6, 0x70, 0x51},
287 /* 2113 */ {0x6, 0xbe, 0x53},
288 /* 2116 */ {0x6, 0x71, 0x57},
289 /* 2119 */ {0x6, 0x20, 0x58},
290 /* 2122 */ {0x6, 0x05, 0x59},
291 /* 2125 */ {0x6, 0x15, 0x5a},
293 /* 2128 */ {0x4, 0x00, 0x08},
294 /* Compress = OFF (0x1 to turn on) */
295 /* 2131 */ {0x4, 0x12, 0x09},
296 /* 2134 */ {0x4, 0x21, 0x0a},
297 /* 2137 */ {0x4, 0x10, 0x0b},
298 /* 2140 */ {0x4, 0x21, 0x0c},
299 /* 2143 */ {0x4, 0x05, 0x00},
300 /* was 5 (Image Type ? ) */
301 /* 2146 */ {0x4, 0x00, 0x01},
303 /* 2149 */ {0x6, 0x3f, 0x01},
305 /* 2152 */ {0x4, 0x00, 0x04},
306 /* 2155 */ {0x4, 0x00, 0x05},
307 /* 2158 */ {0x4, 0x40, 0x06},
308 /* 2161 */ {0x4, 0x40, 0x07},
310 /* 2164 */ {0x6, 0x1c, 0x17},
311 /* 2167 */ {0x6, 0xe2, 0x19},
312 /* 2170 */ {0x6, 0x1c, 0x1b},
313 /* 2173 */ {0x6, 0xe2, 0x1d},
314 /* 2176 */ {0x6, 0xaa, 0x1f},
315 /* 2179 */ {0x6, 0x70, 0x20},
317 /* 2182 */ {0x5, 0x01, 0x10},
318 /* 2185 */ {0x5, 0x00, 0x11},
319 /* 2188 */ {0x5, 0x01, 0x00},
320 /* 2191 */ {0x5, 0x05, 0x01},
321 /* 2194 */ {0x5, 0x00, 0xc1},
323 /* 2197 */ {0x5, 0x00, 0xc2},
324 /* 2200 */ {0x5, 0x00, 0xca},
326 /* 2203 */ {0x6, 0x70, 0x51},
327 /* 2206 */ {0x6, 0xbe, 0x53},
332 Made by Tomasz Zablocki (skalamandra@poczta.onet.pl)
333 * SPCA505b chip based cameras initialization data
337 #define initial_brightness 0x7f /* 0x0(white)-0xff(black) */
338 /* #define initial_brightness 0x0 //0x0(white)-0xff(black) */
340 * Data to initialize a SPCA505. Common to the CCD and external modes
342 static const __u16 spca505b_init_data
[][3] = {
344 {0x02, 0x00, 0x00}, /* init */
404 * Data to initialize the camera using the internal CCD
406 static const __u16 spca505b_open_data_ccd
[][3] = {
408 /* {0x02,0x00,0x00}, */
409 {0x03, 0x04, 0x01}, /* rst */
435 {0x05, initial_brightness
>> 6, 0x00},
436 {0x05, initial_brightness
<< 2, 0x01},
446 {0x05, 128, 0x14}, /* max exposure off (0=on) */
465 {0x06, 0x11, 0x10}, /* contrast */
530 {0x06, 0x4d, 0x51}, /* maybe saturation (4d) */
531 {0x06, 0x84, 0x53}, /* making green (84) */
532 {0x06, 0x00, 0x57}, /* sharpness (1) */
537 {0x06, 0x18, 0x0c}, /* maybe hue (18) */
541 {0x06, 0x18, 0x10}, /* maybe contrast (18) */
545 {0x04, 0x00, 0x08}, /* compression */
550 {0x04, 0x1d, 0x00}, /* imagetype (1d) */
551 {0x04, 0x41, 0x01}, /* hardware snapcontrol */
569 {0x05, initial_brightness
>> 6, 0x00},
570 {0x05, initial_brightness
<< 2, 0x01},
578 static int reg_write(struct usb_device
*dev
,
579 __u16 reg
, __u16 index
, __u16 value
)
583 ret
= usb_control_msg(dev
,
584 usb_sndctrlpipe(dev
, 0),
586 USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
587 value
, index
, NULL
, 0, 500);
588 PDEBUG(D_PACK
, "reg write: 0x%02x,0x%02x:0x%02x, 0x%x",
589 reg
, index
, value
, ret
);
591 PDEBUG(D_ERR
, "reg write: error %d", ret
);
595 /* returns: negative is error, pos or zero is data */
596 static int reg_read(struct usb_device
*dev
,
597 __u16 reg
, /* bRequest */
598 __u16 index
, /* wIndex */
599 __u16 length
) /* wLength (1 or 2 only) */
605 ret
= usb_control_msg(dev
,
606 usb_rcvctrlpipe(dev
, 0),
608 USB_DIR_IN
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
,
609 (__u16
) 0, /* value */
615 PDEBUG(D_ERR
, "reg_read err %d", ret
);
618 return (buf
[1] << 8) + buf
[0];
621 static int write_vector(struct gspca_dev
*gspca_dev
,
622 const __u16 data
[][3])
624 struct usb_device
*dev
= gspca_dev
->dev
;
627 while (data
[i
][0] != 0 || data
[i
][1] != 0 || data
[i
][2] != 0) {
628 ret
= reg_write(dev
, data
[i
][0], data
[i
][2], data
[i
][1]);
631 "Register write failed for 0x%x,0x%x,0x%x",
632 data
[i
][0], data
[i
][1], data
[i
][2]);
640 /* this function is called at probe time */
641 static int sd_config(struct gspca_dev
*gspca_dev
,
642 const struct usb_device_id
*id
)
644 struct sd
*sd
= (struct sd
*) gspca_dev
;
649 vendor
= id
->idVendor
;
650 product
= id
->idProduct
;
652 case 0x041e: /* Creative cameras */
653 /* switch (product) { */
654 /* case 0x401d: * here505b */
655 sd
->subtype
= Nxultra
;
659 case 0x0733: /* Rebadged ViewQuest (Intel) and ViewQuest cameras */
660 /* switch (product) { */
662 /* fixme: may be UsbGrabberPV321 BRIDGE_SPCA506 SENSOR_SAA7113 */
663 sd
->subtype
= IntelPCCameraPro
;
669 cam
= &gspca_dev
->cam
;
670 cam
->dev_name
= (char *) id
->driver_info
;
672 cam
->cam_mode
= vga_mode
;
673 if (sd
->subtype
!= IntelPCCameraPro
)
674 cam
->nmodes
= sizeof vga_mode
/ sizeof vga_mode
[0];
675 else /* no 640x480 for IntelPCCameraPro */
676 cam
->nmodes
= sizeof vga_mode
/ sizeof vga_mode
[0] - 1;
677 sd
->brightness
= sd_ctrls
[SD_BRIGHTNESS
].qctrl
.default_value
;
679 if (sd
->subtype
== Nxultra
) {
680 if (write_vector(gspca_dev
, spca505b_init_data
))
683 if (write_vector(gspca_dev
, spca505_init_data
))
689 /* this function is called at open time */
690 static int sd_open(struct gspca_dev
*gspca_dev
)
692 struct sd
*sd
= (struct sd
*) gspca_dev
;
695 PDEBUG(D_STREAM
, "Initializing SPCA505");
696 if (sd
->subtype
== Nxultra
)
697 write_vector(gspca_dev
, spca505b_open_data_ccd
);
699 write_vector(gspca_dev
, spca505_open_data_ccd
);
700 ret
= reg_read(gspca_dev
->dev
, 6, 0x16, 2);
703 PDEBUG(D_ERR
|D_STREAM
,
704 "register read failed for after vector read err = %d",
709 "After vector read returns : 0x%x should be 0x0101",
712 ret
= reg_write(gspca_dev
->dev
, 6, 0x16, 0x0a);
714 PDEBUG(D_ERR
, "register write failed for (6,0xa,0x16) err=%d",
718 reg_write(gspca_dev
->dev
, 5, 0xc2, 18);
722 static void sd_start(struct gspca_dev
*gspca_dev
)
724 struct usb_device
*dev
= gspca_dev
->dev
;
727 /* necessary because without it we can see stream
728 * only once after loading module */
729 /* stopping usb registers Tomasz change */
730 reg_write(dev
, 0x02, 0x0, 0x0);
731 switch (gspca_dev
->cam
.cam_mode
[(int) gspca_dev
->curr_mode
].priv
) {
733 reg_write(dev
, 0x04, 0x00, 0x00);
734 reg_write(dev
, 0x04, 0x06, 0x10);
735 reg_write(dev
, 0x04, 0x07, 0x10);
738 reg_write(dev
, 0x04, 0x00, 0x01);
739 reg_write(dev
, 0x04, 0x06, 0x1a);
740 reg_write(dev
, 0x04, 0x07, 0x1a);
743 reg_write(dev
, 0x04, 0x00, 0x02);
744 reg_write(dev
, 0x04, 0x06, 0x1c);
745 reg_write(dev
, 0x04, 0x07, 0x1d);
748 reg_write(dev
, 0x04, 0x00, 0x04);
749 reg_write(dev
, 0x04, 0x06, 0x34);
750 reg_write(dev
, 0x04, 0x07, 0x34);
754 reg_write(dev
, 0x04, 0x00, 0x05);
755 reg_write(dev
, 0x04, 0x06, 0x40);
756 reg_write(dev
, 0x04, 0x07, 0x40);
759 /* Enable ISO packet machine - should we do this here or in ISOC init ? */
760 ret
= reg_write(dev
, SPCA50X_REG_USB
,
762 SPCA50X_CUSB_ENABLE
);
764 /* reg_write(dev, 0x5, 0x0, 0x0); */
765 /* reg_write(dev, 0x5, 0x0, 0x1); */
766 /* reg_write(dev, 0x5, 0x11, 0x2); */
769 static void sd_stopN(struct gspca_dev
*gspca_dev
)
771 /* Disable ISO packet machine */
772 reg_write(gspca_dev
->dev
, 0x02, 0x00, 0x00);
775 static void sd_stop0(struct gspca_dev
*gspca_dev
)
779 /* this function is called at close time */
780 static void sd_close(struct gspca_dev
*gspca_dev
)
782 /* This maybe reset or power control */
783 reg_write(gspca_dev
->dev
, 0x03, 0x03, 0x20);
784 reg_write(gspca_dev
->dev
, 0x03, 0x01, 0x0);
785 reg_write(gspca_dev
->dev
, 0x03, 0x00, 0x1);
786 reg_write(gspca_dev
->dev
, 0x05, 0x10, 0x1);
787 reg_write(gspca_dev
->dev
, 0x05, 0x11, 0xf);
790 /* convert YYUV per line to YUYV (YUV 4:2:2) */
791 static void yyuv_decode(unsigned char *out
,
796 unsigned char *Ui
, *Vi
, *yi
, *yi1
;
801 for (i
= height
/ 2; --i
>= 0; ) {
802 out1
= out
+ width
* 2; /* next line */
806 for (j
= width
/ 2; --j
>= 0; ) {
807 *out
++ = 128 + *yi
++;
809 *out
++ = 128 + *yi
++;
812 *out1
++ = 128 + *yi1
++;
813 *out1
++ = 128 + *Ui
++;
814 *out1
++ = 128 + *yi1
++;
815 *out1
++ = 128 + *Vi
++;
822 static void sd_pkt_scan(struct gspca_dev
*gspca_dev
,
823 struct gspca_frame
*frame
, /* target */
824 __u8
*data
, /* isoc packet */
825 int len
) /* iso packet length */
827 struct sd
*sd
= (struct sd
*) gspca_dev
;
830 case 0: /* start of frame */
831 if (gspca_dev
->last_packet_type
== FIRST_PACKET
) {
832 yyuv_decode(sd
->tmpbuf2
, sd
->tmpbuf
,
835 frame
= gspca_frame_add(gspca_dev
,
843 gspca_frame_add(gspca_dev
, FIRST_PACKET
, frame
,
845 data
+= SPCA50X_OFFSET_DATA
;
846 len
-= SPCA50X_OFFSET_DATA
;
848 memcpy(sd
->tmpbuf
, data
, len
);
853 case 0xff: /* drop */
854 /* gspca_dev->last_packet_type = DISCARD_PACKET; */
859 memcpy(&sd
->tmpbuf
[sd
->buflen
], data
, len
);
863 static void setbrightness(struct gspca_dev
*gspca_dev
)
865 struct sd
*sd
= (struct sd
*) gspca_dev
;
867 __u8 brightness
= sd
->brightness
;
868 reg_write(gspca_dev
->dev
, 5, 0x00, (255 - brightness
) >> 6);
869 reg_write(gspca_dev
->dev
, 5, 0x01, (255 - brightness
) << 2);
872 static void getbrightness(struct gspca_dev
*gspca_dev
)
874 struct sd
*sd
= (struct sd
*) gspca_dev
;
877 - ((reg_read(gspca_dev
->dev
, 5, 0x01, 1) >> 2)
878 + (reg_read(gspca_dev
->dev
, 5, 0x0, 1) << 6));
881 static int sd_setbrightness(struct gspca_dev
*gspca_dev
, __s32 val
)
883 struct sd
*sd
= (struct sd
*) gspca_dev
;
885 sd
->brightness
= val
;
886 if (gspca_dev
->streaming
)
887 setbrightness(gspca_dev
);
891 static int sd_getbrightness(struct gspca_dev
*gspca_dev
, __s32
*val
)
893 struct sd
*sd
= (struct sd
*) gspca_dev
;
895 getbrightness(gspca_dev
);
896 *val
= sd
->brightness
;
900 /* sub-driver description */
901 static const struct sd_desc sd_desc
= {
904 .nctrls
= ARRAY_SIZE(sd_ctrls
),
911 .pkt_scan
= sd_pkt_scan
,
914 /* -- module initialisation -- */
915 #define DVNM(name) .driver_info = (kernel_ulong_t) name
916 static const __devinitdata
struct usb_device_id device_table
[] = {
917 {USB_DEVICE(0x041e, 0x401d), DVNM("Creative Webcam NX ULTRA")},
918 {USB_DEVICE(0x0733, 0x0430), DVNM("Intel PC Camera Pro")},
921 MODULE_DEVICE_TABLE(usb
, device_table
);
923 /* -- device connect -- */
924 static int sd_probe(struct usb_interface
*intf
,
925 const struct usb_device_id
*id
)
927 return gspca_dev_probe(intf
, id
, &sd_desc
, sizeof(struct sd
),
931 static struct usb_driver sd_driver
= {
933 .id_table
= device_table
,
935 .disconnect
= gspca_disconnect
,
938 /* -- module insert / remove -- */
939 static int __init
sd_mod_init(void)
941 if (usb_register(&sd_driver
) < 0)
943 PDEBUG(D_PROBE
, "v%s registered", version
);
946 static void __exit
sd_mod_exit(void)
948 usb_deregister(&sd_driver
);
949 PDEBUG(D_PROBE
, "deregistered");
952 module_init(sd_mod_init
);
953 module_exit(sd_mod_exit
);