]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - drivers/media/video/gspca/t613.c
projects / mirror_ubuntu-artful-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
V4L/DVB (9124): gspca: Bad name of the tv8532 subdriver in Kconfig.
[mirror_ubuntu-artful-kernel.git] / drivers / media / video / gspca / t613.c
CommitLineData
6a7eba24 1/*
6a7eba24
JFM		 2 * V4L2 by Jean-Francois Moine <http://moinejf.free.fr>
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
10b0e96e
JFM		 17 *
18 *Notes: * t613 + tas5130A
19 * * Focus to light do not balance well as in win.
20 * Quality in win is not good, but its kinda better.
21 * * Fix some "extraneous bytes", most of apps will show the image anyway
22 * * Gamma table, is there, but its really doing something?
23 * * 7~8 Fps, its ok, max on win its 10.
24 * Costantino Leandro
6a7eba24
JFM		 25 */
26
27#define MODULE_NAME "t613"
10b0e96e 28
6a7eba24 29#include "gspca.h"
6a7eba24
JFM		 30
31#define MAX_GAMMA 0x10 /* 0 to 15 */
32
f9b4a377 33#define V4L2_CID_EFFECTS (V4L2_CID_PRIVATE_BASE + 0)
6a7eba24
JFM		 34
35MODULE_AUTHOR("Leandro Costantino <le_costantino@pixartargentina.com.ar>");
36MODULE_DESCRIPTION("GSPCA/T613 (JPEG Compliance) USB Camera Driver");
37MODULE_LICENSE("GPL");
38
39struct sd {
40 struct gspca_dev gspca_dev; /* !! must be the first item */
41
42 unsigned char brightness;
43 unsigned char contrast;
44 unsigned char colors;
45 unsigned char autogain;
46 unsigned char gamma;
47 unsigned char sharpness;
48 unsigned char freq;
49 unsigned char whitebalance;
50 unsigned char mirror;
51 unsigned char effect;
52};
53
54/* V4L2 controls supported by the driver */
55static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
56static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
57static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val);
58static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val);
59static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val);
60static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val);
61static int sd_setlowlight(struct gspca_dev *gspca_dev, __s32 val);
62static int sd_getlowlight(struct gspca_dev *gspca_dev, __s32 *val);
63static int sd_setgamma(struct gspca_dev *gspca_dev, __s32 val);
64static int sd_getgamma(struct gspca_dev *gspca_dev, __s32 *val);
65static int sd_setsharpness(struct gspca_dev *gspca_dev, __s32 val);
66static int sd_getsharpness(struct gspca_dev *gspca_dev, __s32 *val);
67static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val);
68static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val);
69static int sd_setwhitebalance(struct gspca_dev *gspca_dev, __s32 val);
70static int sd_getwhitebalance(struct gspca_dev *gspca_dev, __s32 *val);
71static int sd_setflip(struct gspca_dev *gspca_dev, __s32 val);
72static int sd_getflip(struct gspca_dev *gspca_dev, __s32 *val);
73static int sd_seteffect(struct gspca_dev *gspca_dev, __s32 val);
74static int sd_geteffect(struct gspca_dev *gspca_dev, __s32 *val);
75static int sd_querymenu(struct gspca_dev *gspca_dev,
76 struct v4l2_querymenu *menu);
77
78static struct ctrl sd_ctrls[] = {
79#define SD_BRIGHTNESS 0
80 {
81 {
82 .id = V4L2_CID_BRIGHTNESS,
83 .type = V4L2_CTRL_TYPE_INTEGER,
84 .name = "Brightness",
85 .minimum = 0,
86 .maximum = 0x0f,
87 .step = 1,
88 .default_value = 0x09,
89 },
90 .set = sd_setbrightness,
91 .get = sd_getbrightness,
92 },
93#define SD_CONTRAST 1
94 {
95 {
96 .id = V4L2_CID_CONTRAST,
97 .type = V4L2_CTRL_TYPE_INTEGER,
98 .name = "Contrast",
99 .minimum = 0,
100 .maximum = 0x0d,
101 .step = 1,
102 .default_value = 0x07,
103 },
104 .set = sd_setcontrast,
105 .get = sd_getcontrast,
106 },
107#define SD_COLOR 2
108 {
109 {
110 .id = V4L2_CID_SATURATION,
111 .type = V4L2_CTRL_TYPE_INTEGER,
112 .name = "Color",
113 .minimum = 0,
114 .maximum = 0x0f,
115 .step = 1,
116 .default_value = 0x05,
117 },
118 .set = sd_setcolors,
119 .get = sd_getcolors,
120 },
121#define SD_GAMMA 3
122 {
123 {
124 .id = V4L2_CID_GAMMA, /* (gamma on win) */
125 .type = V4L2_CTRL_TYPE_INTEGER,
126 .name = "Gamma (Untested)",
127 .minimum = 0,
128 .maximum = MAX_GAMMA,
129 .step = 1,
130 .default_value = 0x09,
131 },
132 .set = sd_setgamma,
133 .get = sd_getgamma,
134 },
135#define SD_AUTOGAIN 4
136 {
137 {
138 .id = V4L2_CID_GAIN, /* here, i activate only the lowlight,
139 * some apps dont bring up the
140 * backligth_compensation control) */
141 .type = V4L2_CTRL_TYPE_INTEGER,
142 .name = "Low Light",
143 .minimum = 0,
144 .maximum = 1,
145 .step = 1,
146 .default_value = 0x01,
147 },
148 .set = sd_setlowlight,
149 .get = sd_getlowlight,
150 },
151#define SD_MIRROR 5
152 {
153 {
154 .id = V4L2_CID_HFLIP,
155 .type = V4L2_CTRL_TYPE_BOOLEAN,
156 .name = "Mirror Image",
157 .minimum = 0,
158 .maximum = 1,
159 .step = 1,
160 .default_value = 0,
161 },
162 .set = sd_setflip,
163 .get = sd_getflip
164 },
165#define SD_LIGHTFREQ 6
166 {
167 {
168 .id = V4L2_CID_POWER_LINE_FREQUENCY,
169 .type = V4L2_CTRL_TYPE_MENU,
170 .name = "Light Frequency Filter",
171 .minimum = 1, /* 1 -> 0x50, 2->0x60 */
172 .maximum = 2,
173 .step = 1,
174 .default_value = 1,
175 },
176 .set = sd_setfreq,
177 .get = sd_getfreq},
178
179#define SD_WHITE_BALANCE 7
180 {
181 {
182 .id = V4L2_CID_WHITE_BALANCE_TEMPERATURE,
183 .type = V4L2_CTRL_TYPE_INTEGER,
184 .name = "White Balance",
185 .minimum = 0,
186 .maximum = 1,
187 .step = 1,
188 .default_value = 1,
189 },
190 .set = sd_setwhitebalance,
191 .get = sd_getwhitebalance
192 },
193#define SD_SHARPNESS 8 /* (aka definition on win) */
194 {
195 {
196 .id = V4L2_CID_SHARPNESS,
197 .type = V4L2_CTRL_TYPE_INTEGER,
198 .name = "Sharpness",
199 .minimum = 0,
200 .maximum = MAX_GAMMA, /* 0 to 16 */
201 .step = 1,
202 .default_value = 0x06,
203 },
204 .set = sd_setsharpness,
205 .get = sd_getsharpness,
206 },
207#define SD_EFFECTS 9
208 {
209 {
210 .id = V4L2_CID_EFFECTS,
211 .type = V4L2_CTRL_TYPE_MENU,
212 .name = "Webcam Effects",
213 .minimum = 0,
214 .maximum = 4,
215 .step = 1,
216 .default_value = 0,
217 },
218 .set = sd_seteffect,
219 .get = sd_geteffect
220 },
221};
222
a5ae2062
JFM		 223static char *effects_control[] = {
224 "Normal",
225 "Emboss", /* disabled */
226 "Monochrome",
227 "Sepia",
228 "Sketch",
229 "Sun Effect", /* disabled */
230 "Negative",
6a7eba24
JFM		 231};
232
c2446b3e
JFM		 233static struct v4l2_pix_format vga_mode_t16[] = {
234 {160, 120, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
235 .bytesperline = 160,
5d05294a 236 .sizeimage = 160 * 120 * 4 / 8 + 590,
c2446b3e
JFM		 237 .colorspace = V4L2_COLORSPACE_JPEG,
238 .priv = 4},
239 {176, 144, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
240 .bytesperline = 176,
241 .sizeimage = 176 * 144 * 3 / 8 + 590,
242 .colorspace = V4L2_COLORSPACE_JPEG,
243 .priv = 3},
244 {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
245 .bytesperline = 320,
246 .sizeimage = 320 * 240 * 3 / 8 + 590,
247 .colorspace = V4L2_COLORSPACE_JPEG,
248 .priv = 2},
249 {352, 288, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
250 .bytesperline = 352,
251 .sizeimage = 352 * 288 * 3 / 8 + 590,
252 .colorspace = V4L2_COLORSPACE_JPEG,
253 .priv = 1},
254 {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
255 .bytesperline = 640,
256 .sizeimage = 640 * 480 * 3 / 8 + 590,
257 .colorspace = V4L2_COLORSPACE_JPEG,
258 .priv = 0},
6a7eba24
JFM		 259};
260
261#define T16_OFFSET_DATA 631
262#define MAX_EFFECTS 7
263/* easily done by soft, this table could be removed,
264 * i keep it here just in case */
a5ae2062 265static const __u8 effects_table[MAX_EFFECTS][6] = {
6a7eba24
JFM		 266 {0xa8, 0xe8, 0xc6, 0xd2, 0xc0, 0x00}, /* Normal */
267 {0xa8, 0xc8, 0xc6, 0x52, 0xc0, 0x04}, /* Repujar */
268 {0xa8, 0xe8, 0xc6, 0xd2, 0xc0, 0x20}, /* Monochrome */
269 {0xa8, 0xe8, 0xc6, 0xd2, 0xc0, 0x80}, /* Sepia */
270 {0xa8, 0xc8, 0xc6, 0x52, 0xc0, 0x02}, /* Croquis */
271 {0xa8, 0xc8, 0xc6, 0xd2, 0xc0, 0x10}, /* Sun Effect */
272 {0xa8, 0xc8, 0xc6, 0xd2, 0xc0, 0x40}, /* Negative */
273};
274
a5ae2062 275static const __u8 gamma_table[MAX_GAMMA][34] = {
6a7eba24
JFM		 276 {0x90, 0x00, 0x91, 0x3e, 0x92, 0x69, 0x93, 0x85,
277 0x94, 0x95, 0x95, 0xa1, 0x96, 0xae, 0x97, 0xb9,
278 0x98, 0xc2, 0x99, 0xcb, 0x9a, 0xd4, 0x9b, 0xdb,
279 0x9c, 0xe3, 0x9d, 0xea, 0x9e, 0xf1, 0x9f, 0xf8,
280 0xa0, 0xff},
281 {0x90, 0x00, 0x91, 0x33, 0x92, 0x5A, 0x93, 0x75,
282 0x94, 0x85, 0x95, 0x93, 0x96, 0xA1, 0x97, 0xAD,
283 0x98, 0xB7, 0x99, 0xC2, 0x9A, 0xCB, 0x9B, 0xD4,
284 0x9C, 0xDE, 0x9D, 0xE7, 0x9E, 0xF0, 0x9F, 0xF7,
285 0xa0, 0xff},
286 {0x90, 0x00, 0x91, 0x2F, 0x92, 0x51, 0x93, 0x6B,
287 0x94, 0x7C, 0x95, 0x8A, 0x96, 0x99, 0x97, 0xA6,
288 0x98, 0xB1, 0x99, 0xBC, 0x9A, 0xC6, 0x9B, 0xD0,
289 0x9C, 0xDB, 0x9D, 0xE4, 0x9E, 0xED, 0x9F, 0xF6,
290 0xa0, 0xff},
291 {0x90, 0x00, 0x91, 0x29, 0x92, 0x48, 0x93, 0x60,
292 0x94, 0x72, 0x95, 0x81, 0x96, 0x90, 0x97, 0x9E,
293 0x98, 0xAA, 0x99, 0xB5, 0x9A, 0xBF, 0x9B, 0xCB,
294 0x9C, 0xD6, 0x9D, 0xE1, 0x9E, 0xEB, 0x9F, 0xF5,
295 0xa0, 0xff},
296 {0x90, 0x00, 0x91, 0x23, 0x92, 0x3F, 0x93, 0x55,
297 0x94, 0x68, 0x95, 0x77, 0x96, 0x86, 0x97, 0x95,
298 0x98, 0xA2, 0x99, 0xAD, 0x9A, 0xB9, 0x9B, 0xC6,
299 0x9C, 0xD2, 0x9D, 0xDE, 0x9E, 0xE9, 0x9F, 0xF4,
300 0xa0, 0xff},
301 {0x90, 0x00, 0x91, 0x1B, 0x92, 0x33, 0x93, 0x48,
302 0x94, 0x59, 0x95, 0x69, 0x96, 0x79, 0x97, 0x87,
303 0x98, 0x96, 0x99, 0xA3, 0x9A, 0xB1, 0x9B, 0xBE,
304 0x9C, 0xCC, 0x9D, 0xDA, 0x9E, 0xE7, 0x9F, 0xF3,
305 0xa0, 0xff},
306 {0x90, 0x00, 0x91, 0x02, 0x92, 0x10, 0x93, 0x20,
307 0x94, 0x32, 0x95, 0x40, 0x96, 0x57, 0x97, 0x67,
308 0x98, 0x77, 0x99, 0x88, 0x9a, 0x99, 0x9b, 0xaa,
309 0x9c, 0xbb, 0x9d, 0xcc, 0x9e, 0xdd, 0x9f, 0xee,
310 0xa0, 0xff},
311 {0x90, 0x00, 0x91, 0x02, 0x92, 0x14, 0x93, 0x26,
312 0x94, 0x38, 0x95, 0x4A, 0x96, 0x60, 0x97, 0x70,
313 0x98, 0x80, 0x99, 0x90, 0x9A, 0xA0, 0x9B, 0xB0,
314 0x9C, 0xC0, 0x9D, 0xD0, 0x9E, 0xE0, 0x9F, 0xF0,
315 0xa0, 0xff},
316 {0x90, 0x00, 0x91, 0x10, 0x92, 0x22, 0x93, 0x35,
317 0x94, 0x47, 0x95, 0x5A, 0x96, 0x69, 0x97, 0x79,
318 0x98, 0x88, 0x99, 0x97, 0x9A, 0xA7, 0x9B, 0xB6,
319 0x9C, 0xC4, 0x9D, 0xD3, 0x9E, 0xE0, 0x9F, 0xF0,
320 0xa0, 0xff},
321 {0x90, 0x00, 0x91, 0x10, 0x92, 0x26, 0x93, 0x40,
322 0x94, 0x54, 0x95, 0x65, 0x96, 0x75, 0x97, 0x84,
323 0x98, 0x93, 0x99, 0xa1, 0x9a, 0xb0, 0x9b, 0xbd,
324 0x9c, 0xca, 0x9d, 0xd6, 0x9e, 0xe0, 0x9f, 0xf0,
325 0xa0, 0xff},
326 {0x90, 0x00, 0x91, 0x18, 0x92, 0x2B, 0x93, 0x44,
327 0x94, 0x60, 0x95, 0x70, 0x96, 0x80, 0x97, 0x8E,
328 0x98, 0x9C, 0x99, 0xAA, 0x9A, 0xB7, 0x9B, 0xC4,
329 0x9C, 0xD0, 0x9D, 0xD8, 0x9E, 0xE2, 0x9F, 0xF0,
330 0xa0, 0xff},
331 {0x90, 0x00, 0x91, 0x1A, 0x92, 0x34, 0x93, 0x52,
332 0x94, 0x66, 0x95, 0x7E, 0x96, 0x8D, 0x97, 0x9B,
333 0x98, 0xA8, 0x99, 0xB4, 0x9A, 0xC0, 0x9B, 0xCB,
334 0x9C, 0xD6, 0x9D, 0xE1, 0x9E, 0xEB, 0x9F, 0xF5,
335 0xa0, 0xff},
336 {0x90, 0x00, 0x91, 0x3F, 0x92, 0x5A, 0x93, 0x6E,
337 0x94, 0x7F, 0x95, 0x8E, 0x96, 0x9C, 0x97, 0xA8,
338 0x98, 0xB4, 0x99, 0xBF, 0x9A, 0xC9, 0x9B, 0xD3,
339 0x9C, 0xDC, 0x9D, 0xE5, 0x9E, 0xEE, 0x9F, 0xF6,
340 0xA0, 0xFF},
341 {0x90, 0x00, 0x91, 0x54, 0x92, 0x6F, 0x93, 0x83,
342 0x94, 0x93, 0x95, 0xA0, 0x96, 0xAD, 0x97, 0xB7,
343 0x98, 0xC2, 0x99, 0xCB, 0x9A, 0xD4, 0x9B, 0xDC,
344 0x9C, 0xE4, 0x9D, 0xEB, 0x9E, 0xF2, 0x9F, 0xF9,
345 0xa0, 0xff},
346 {0x90, 0x00, 0x91, 0x6E, 0x92, 0x88, 0x93, 0x9A,
347 0x94, 0xA8, 0x95, 0xB3, 0x96, 0xBD, 0x97, 0xC6,
348 0x98, 0xCF, 0x99, 0xD6, 0x9A, 0xDD, 0x9B, 0xE3,
349 0x9C, 0xE9, 0x9D, 0xEF, 0x9E, 0xF4, 0x9F, 0xFA,
350 0xa0, 0xff},
351 {0x90, 0x00, 0x91, 0x93, 0x92, 0xA8, 0x93, 0xB7,
352 0x94, 0xC1, 0x95, 0xCA, 0x96, 0xD2, 0x97, 0xD8,
353 0x98, 0xDE, 0x99, 0xE3, 0x9A, 0xE8, 0x9B, 0xED,
354 0x9C, 0xF1, 0x9D, 0xF5, 0x9E, 0xF8, 0x9F, 0xFC,
355 0xA0, 0xFF}
356};
357
a5ae2062 358static const __u8 tas5130a_sensor_init[][8] = {
6a7eba24
JFM		 359 {0x62, 0x08, 0x63, 0x70, 0x64, 0x1d, 0x60, 0x09},
360 {0x62, 0x20, 0x63, 0x01, 0x64, 0x02, 0x60, 0x09},
361 {0x62, 0x07, 0x63, 0x03, 0x64, 0x00, 0x60, 0x09},
362 {0x62, 0x07, 0x63, 0x03, 0x64, 0x00, 0x60, 0x09},
363 {},
364};
365
739570bb
JFM		 366/* read 1 byte */
367static int reg_r_1(struct gspca_dev *gspca_dev,
368 __u16 index)
6a7eba24 369{
739570bb
JFM		 370 usb_control_msg(gspca_dev->dev,
371 usb_rcvctrlpipe(gspca_dev->dev, 0),
6a7eba24
JFM		 372 0, /* request */
373 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
374 0, /* value */
739570bb
JFM		 375 index,
376 gspca_dev->usb_buf, 1, 500);
377 return gspca_dev->usb_buf[0];
6a7eba24
JFM		 378}
379
739570bb 380static void reg_w(struct gspca_dev *gspca_dev,
6a7eba24 381 __u16 value,
a5ae2062
JFM		 382 __u16 index,
383 const __u8 *buffer, __u16 len)
6a7eba24 384{
a5ae2062 385 if (buffer == NULL) {
739570bb
JFM		 386 usb_control_msg(gspca_dev->dev,
387 usb_sndctrlpipe(gspca_dev->dev, 0),
a5ae2062
JFM		 388 0,
389 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
390 value, index,
391 NULL, 0, 500);
bf7f0b98
JFM		 392 return;
393 }
8295d99e 394 if (len <= USB_BUF_SZ) {
739570bb
JFM		 395 memcpy(gspca_dev->usb_buf, buffer, len);
396 usb_control_msg(gspca_dev->dev,
397 usb_sndctrlpipe(gspca_dev->dev, 0),
a5ae2062
JFM		 398 0,
399 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
400 value, index,
739570bb 401 gspca_dev->usb_buf, len, 500);
a5ae2062
JFM		 402 } else {
403 __u8 *tmpbuf;
404
405 tmpbuf = kmalloc(len, GFP_KERNEL);
406 memcpy(tmpbuf, buffer, len);
739570bb
JFM		 407 usb_control_msg(gspca_dev->dev,
408 usb_sndctrlpipe(gspca_dev->dev, 0),
a5ae2062
JFM		 409 0,
410 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
411 value, index,
412 tmpbuf, len, 500);
413 kfree(tmpbuf);
414 }
6a7eba24
JFM		 415}
416
417/* this function is called at probe time */
418static int sd_config(struct gspca_dev *gspca_dev,
419 const struct usb_device_id *id)
420{
421 struct sd *sd = (struct sd *) gspca_dev;
422 struct cam *cam;
423
424 cam = &gspca_dev->cam;
6a7eba24
JFM		 425 cam->epaddr = 0x01;
426
427 cam->cam_mode = vga_mode_t16;
428 cam->nmodes = ARRAY_SIZE(vga_mode_t16);
429
430 sd->brightness = sd_ctrls[SD_BRIGHTNESS].qctrl.default_value;
431 sd->contrast = sd_ctrls[SD_CONTRAST].qctrl.default_value;
432 sd->colors = sd_ctrls[SD_COLOR].qctrl.default_value;
433 sd->gamma = sd_ctrls[SD_GAMMA].qctrl.default_value;
434 sd->mirror = sd_ctrls[SD_MIRROR].qctrl.default_value;
435 sd->freq = sd_ctrls[SD_LIGHTFREQ].qctrl.default_value;
436 sd->whitebalance = sd_ctrls[SD_WHITE_BALANCE].qctrl.default_value;
437 sd->sharpness = sd_ctrls[SD_SHARPNESS].qctrl.default_value;
438 sd->effect = sd_ctrls[SD_EFFECTS].qctrl.default_value;
439 return 0;
440}
441
442static int init_default_parameters(struct gspca_dev *gspca_dev)
443{
6a7eba24
JFM		 444 /* some of this registers are not really neded, because
445 * they are overriden by setbrigthness, setcontrast, etc,
446 * but wont hurt anyway, and can help someone with similar webcam
447 * to see the initial parameters.*/
448 int i = 0;
449 __u8 test_byte;
450
a5ae2062 451 static const __u8 read_indexs[] =
6a7eba24
JFM		 452 { 0x06, 0x07, 0x0a, 0x0b, 0x66, 0x80, 0x81, 0x8e, 0x8f, 0xa5,
453 0xa6, 0xa8, 0xbb, 0xbc, 0xc6, 0x00, 0x00 };
a5ae2062 454 static const __u8 n1[6] =
6a7eba24 455 {0x08, 0x03, 0x09, 0x03, 0x12, 0x04};
a5ae2062 456 static const __u8 n2[2] =
6a7eba24 457 {0x08, 0x00};
a5ae2062 458 static const __u8 nset[6] =
6a7eba24 459 { 0x61, 0x68, 0x62, 0xff, 0x60, 0x07 };
a5ae2062 460 static const __u8 n3[6] =
6a7eba24 461 {0x61, 0x68, 0x65, 0x0a, 0x60, 0x04};
a5ae2062 462 static const __u8 n4[0x46] =
6a7eba24
JFM		 463 {0x09, 0x01, 0x12, 0x04, 0x66, 0x8a, 0x80, 0x3c,
464 0x81, 0x22, 0x84, 0x50, 0x8a, 0x78, 0x8b, 0x68,
465 0x8c, 0x88, 0x8e, 0x33, 0x8f, 0x24, 0xaa, 0xb1,
466 0xa2, 0x60, 0xa5, 0x30, 0xa6, 0x3a, 0xa8, 0xe8,
467 0xae, 0x05, 0xb1, 0x00, 0xbb, 0x04, 0xbc, 0x48,
468 0xbe, 0x36, 0xc6, 0x88, 0xe9, 0x00, 0xc5, 0xc0,
469 0x65, 0x0a, 0xbb, 0x86, 0xaf, 0x58, 0xb0, 0x68,
470 0x87, 0x40, 0x89, 0x2b, 0x8d, 0xff, 0x83, 0x40,
471 0xac, 0x84, 0xad, 0x86, 0xaf, 0x46};
a5ae2062 472 static const __u8 nset4[18] = {
6a7eba24
JFM		 473 0xe0, 0x60, 0xe1, 0xa8, 0xe2, 0xe0, 0xe3, 0x60, 0xe4, 0xa8,
474 0xe5, 0xe0, 0xe6, 0x60, 0xe7, 0xa8,
475 0xe8, 0xe0
476 };
477 /* ojo puede ser 0xe6 en vez de 0xe9 */
a5ae2062 478 static const __u8 nset2[20] = {
6a7eba24
JFM		 479 0xd0, 0xbb, 0xd1, 0x28, 0xd2, 0x10, 0xd3, 0x10, 0xd4, 0xbb,
480 0xd5, 0x28, 0xd6, 0x1e, 0xd7, 0x27,
481 0xd8, 0xc8, 0xd9, 0xfc
482 };
a5ae2062 483 static const __u8 missing[8] =
6a7eba24 484 { 0x87, 0x20, 0x88, 0x20, 0x89, 0x20, 0x80, 0x38 };
a5ae2062 485 static const __u8 nset3[18] = {
6a7eba24
JFM		 486 0xc7, 0x60, 0xc8, 0xa8, 0xc9, 0xe0, 0xca, 0x60, 0xcb, 0xa8,
487 0xcc, 0xe0, 0xcd, 0x60, 0xce, 0xa8,
488 0xcf, 0xe0
489 };
a5ae2062 490 static const __u8 nset5[4] =
6a7eba24 491 { 0x8f, 0x24, 0xc3, 0x00 }; /* bright */
a5ae2062 492 static const __u8 nset6[34] = {
6a7eba24
JFM		 493 0x90, 0x00, 0x91, 0x1c, 0x92, 0x30, 0x93, 0x43, 0x94, 0x54,
494 0x95, 0x65, 0x96, 0x75, 0x97, 0x84,
495 0x98, 0x93, 0x99, 0xa1, 0x9a, 0xb0, 0x9b, 0xbd, 0x9c, 0xca,
496 0x9d, 0xd8, 0x9e, 0xe5, 0x9f, 0xf2,
497 0xa0, 0xff
498 }; /* Gamma */
a5ae2062 499 static const __u8 nset7[4] =
6a7eba24 500 { 0x66, 0xca, 0xa8, 0xf8 }; /* 50/60 Hz */
a5ae2062 501 static const __u8 nset9[4] =
6a7eba24 502 { 0x0b, 0x04, 0x0a, 0x78 };
a5ae2062 503 static const __u8 nset8[6] =
6a7eba24 504 { 0xa8, 0xf0, 0xc6, 0x88, 0xc0, 0x00 };
a5ae2062 505 static const __u8 nset10[6] =
6a7eba24
JFM		 506 { 0x0c, 0x03, 0xab, 0x10, 0x81, 0x20 };
507
739570bb
JFM		 508 reg_w(gspca_dev, 0x01, 0x0000, n1, 0x06);
509 reg_w(gspca_dev, 0x01, 0x0000, nset, 0x06);
510 reg_r_1(gspca_dev, 0x0063);
511 reg_w(gspca_dev, 0x01, 0x0000, n2, 0x02);
6a7eba24
JFM		 512
513 while (read_indexs[i] != 0x00) {
739570bb
JFM		 514 test_byte = reg_r_1(gspca_dev, read_indexs[i]);
515 PDEBUG(D_CONF, "Reg 0x%02x => 0x%02x", read_indexs[i],
6a7eba24
JFM		 516 test_byte);
517 i++;
518 }
519
739570bb
JFM		 520 reg_w(gspca_dev, 0x01, 0x0000, n3, 0x06);
521 reg_w(gspca_dev, 0x01, 0x0000, n4, 0x46);
522 reg_r_1(gspca_dev, 0x0080);
523 reg_w(gspca_dev, 0x00, 0x2c80, NULL, 0);
524 reg_w(gspca_dev, 0x01, 0x0000, nset2, 0x14);
525 reg_w(gspca_dev, 0x01, 0x0000, nset3, 0x12);
526 reg_w(gspca_dev, 0x01, 0x0000, nset4, 0x12);
527 reg_w(gspca_dev, 0x00, 0x3880, NULL, 0);
528 reg_w(gspca_dev, 0x00, 0x3880, NULL, 0);
529 reg_w(gspca_dev, 0x00, 0x338e, NULL, 0);
530 reg_w(gspca_dev, 0x01, 0x0000, nset5, 0x04);
531 reg_w(gspca_dev, 0x00, 0x00a9, NULL, 0);
532 reg_w(gspca_dev, 0x01, 0x0000, nset6, 0x22);
533 reg_w(gspca_dev, 0x00, 0x86bb, NULL, 0);
534 reg_w(gspca_dev, 0x00, 0x4aa6, NULL, 0);
535
536 reg_w(gspca_dev, 0x01, 0x0000, missing, 0x08);
537
538 reg_w(gspca_dev, 0x00, 0x2087, NULL, 0);
539 reg_w(gspca_dev, 0x00, 0x2088, NULL, 0);
540 reg_w(gspca_dev, 0x00, 0x2089, NULL, 0);
541
542 reg_w(gspca_dev, 0x01, 0x0000, nset7, 0x04);
543 reg_w(gspca_dev, 0x01, 0x0000, nset10, 0x06);
544 reg_w(gspca_dev, 0x01, 0x0000, nset8, 0x06);
545 reg_w(gspca_dev, 0x01, 0x0000, nset9, 0x04);
546
547 reg_w(gspca_dev, 0x00, 0x2880, NULL, 0);
548 reg_w(gspca_dev, 0x01, 0x0000, nset2, 0x14);
549 reg_w(gspca_dev, 0x01, 0x0000, nset3, 0x12);
550 reg_w(gspca_dev, 0x01, 0x0000, nset4, 0x12);
6a7eba24
JFM		 551
552 return 0;
553}
554
012d6b02
JFM		 555/* this function is called at probe and resume time */
556static int sd_init(struct gspca_dev *gspca_dev)
557{
558 init_default_parameters(gspca_dev);
559 return 0;
560}
561
6a7eba24
JFM		 562static void setbrightness(struct gspca_dev *gspca_dev)
563{
564 struct sd *sd = (struct sd *) gspca_dev;
6a7eba24 565 unsigned int brightness;
a5ae2062 566 __u8 set6[4] = { 0x8f, 0x26, 0xc3, 0x80 };
6a7eba24
JFM		 567 brightness = sd->brightness;
568
569 if (brightness < 7) {
570 set6[3] = 0x70 - (brightness * 0xa);
571 } else {
572 set6[1] = 0x24;
573 set6[3] = 0x00 + ((brightness - 7) * 0xa);
574 }
575
739570bb 576 reg_w(gspca_dev, 0x01, 0x0000, set6, 4);
6a7eba24
JFM		 577}
578
579static void setflip(struct gspca_dev *gspca_dev)
580{
581 struct sd *sd = (struct sd *) gspca_dev;
6a7eba24 582
a5ae2062 583 __u8 flipcmd[8] =
6a7eba24
JFM		 584 { 0x62, 0x07, 0x63, 0x03, 0x64, 0x00, 0x60, 0x09 };
585
586 if (sd->mirror == 1)
587 flipcmd[3] = 0x01;
588
739570bb 589 reg_w(gspca_dev, 0x01, 0x0000, flipcmd, 8);
6a7eba24
JFM		 590}
591
592static void seteffect(struct gspca_dev *gspca_dev)
593{
594 struct sd *sd = (struct sd *) gspca_dev;
6a7eba24 595
739570bb 596 reg_w(gspca_dev, 0x01, 0x0000, effects_table[sd->effect], 0x06);
6a7eba24
JFM		 597 if (sd->effect == 1 || sd->effect == 5) {
598 PDEBUG(D_CONF,
599 "This effect have been disabled for webcam \"safety\"");
600 return;
601 }
602
603 if (sd->effect == 1 || sd->effect == 4)
739570bb 604 reg_w(gspca_dev, 0x00, 0x4aa6, NULL, 0);
6a7eba24 605 else
739570bb 606 reg_w(gspca_dev, 0x00, 0xfaa6, NULL, 0);
6a7eba24
JFM		 607}
608
609static void setwhitebalance(struct gspca_dev *gspca_dev)
610{
611 struct sd *sd = (struct sd *) gspca_dev;
6a7eba24 612
a5ae2062 613 __u8 white_balance[8] =
6a7eba24
JFM		 614 { 0x87, 0x20, 0x88, 0x20, 0x89, 0x20, 0x80, 0x38 };
615
616 if (sd->whitebalance == 1)
617 white_balance[7] = 0x3c;
618
739570bb 619 reg_w(gspca_dev, 0x01, 0x0000, white_balance, 8);
6a7eba24
JFM		 620}
621
622static void setlightfreq(struct gspca_dev *gspca_dev)
623{
624 struct sd *sd = (struct sd *) gspca_dev;
6a7eba24
JFM		 625 __u8 freq[4] = { 0x66, 0x40, 0xa8, 0xe8 };
626
627 if (sd->freq == 2) /* 60hz */
628 freq[1] = 0x00;
629
739570bb 630 reg_w(gspca_dev, 0x1, 0x0000, freq, 0x4);
6a7eba24
JFM		 631}
632
633static void setcontrast(struct gspca_dev *gspca_dev)
634{
635 struct sd *sd = (struct sd *) gspca_dev;
6a7eba24
JFM		 636 unsigned int contrast = sd->contrast;
637 __u16 reg_to_write = 0x00;
638
639 if (contrast < 7)
640 reg_to_write = 0x8ea9 - (0x200 * contrast);
641 else
642 reg_to_write = (0x00a9 + ((contrast - 7) * 0x200));
643
739570bb 644 reg_w(gspca_dev, 0x00, reg_to_write, NULL, 0);
6a7eba24
JFM		 645}
646
647static void setcolors(struct gspca_dev *gspca_dev)
648{
649 struct sd *sd = (struct sd *) gspca_dev;
a5ae2062 650 __u16 reg_to_write;
6a7eba24
JFM		 651
652 reg_to_write = 0xc0bb + sd->colors * 0x100;
739570bb 653 reg_w(gspca_dev, 0x00, reg_to_write, NULL, 0);
6a7eba24
JFM		 654}
655
656static void setgamma(struct gspca_dev *gspca_dev)
657{
658}
659
660static void setsharpness(struct gspca_dev *gspca_dev)
661{
662 struct sd *sd = (struct sd *) gspca_dev;
a5ae2062 663 __u16 reg_to_write;
6a7eba24
JFM		 664
665 reg_to_write = 0x0aa6 + 0x1000 * sd->sharpness;
666
739570bb 667 reg_w(gspca_dev, 0x00, reg_to_write, NULL, 0);
6a7eba24
JFM		 668}
669
670static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
671{
672 struct sd *sd = (struct sd *) gspca_dev;
673
674 sd->brightness = val;
675 if (gspca_dev->streaming)
676 setbrightness(gspca_dev);
677 return 0;
678}
679
680static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
681{
682 struct sd *sd = (struct sd *) gspca_dev;
a5ae2062 683
6a7eba24
JFM		 684 *val = sd->brightness;
685 return *val;
686}
687
688static int sd_setwhitebalance(struct gspca_dev *gspca_dev, __s32 val)
689{
690 struct sd *sd = (struct sd *) gspca_dev;
691
692 sd->whitebalance = val;
693 if (gspca_dev->streaming)
694 setwhitebalance(gspca_dev);
695 return 0;
696}
697
698static int sd_getwhitebalance(struct gspca_dev *gspca_dev, __s32 *val)
699{
700 struct sd *sd = (struct sd *) gspca_dev;
701
702 *val = sd->whitebalance;
703 return *val;
704}
705
6a7eba24
JFM		 706static int sd_setflip(struct gspca_dev *gspca_dev, __s32 val)
707{
708 struct sd *sd = (struct sd *) gspca_dev;
709
710 sd->mirror = val;
711 if (gspca_dev->streaming)
712 setflip(gspca_dev);
713 return 0;
714}
715
716static int sd_getflip(struct gspca_dev *gspca_dev, __s32 *val)
717{
718 struct sd *sd = (struct sd *) gspca_dev;
719
720 *val = sd->mirror;
721 return *val;
722}
723
724static int sd_seteffect(struct gspca_dev *gspca_dev, __s32 val)
725{
726 struct sd *sd = (struct sd *) gspca_dev;
727
728 sd->effect = val;
729 if (gspca_dev->streaming)
730 seteffect(gspca_dev);
731 return 0;
732}
733
734static int sd_geteffect(struct gspca_dev *gspca_dev, __s32 *val)
735{
736 struct sd *sd = (struct sd *) gspca_dev;
737
738 *val = sd->effect;
739 return *val;
740}
741
742static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val)
743{
744 struct sd *sd = (struct sd *) gspca_dev;
745
746 sd->contrast = val;
747 if (gspca_dev->streaming)
748 setcontrast(gspca_dev);
749 return 0;
750}
751
752static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val)
753{
754 struct sd *sd = (struct sd *) gspca_dev;
755
756 *val = sd->contrast;
757 return *val;
758}
759
760static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val)
761{
762 struct sd *sd = (struct sd *) gspca_dev;
763
764 sd->colors = val;
765 if (gspca_dev->streaming)
766 setcolors(gspca_dev);
767 return 0;
768}
769
770static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val)
771{
772 struct sd *sd = (struct sd *) gspca_dev;
773
774 *val = sd->colors;
775 return 0;
776}
777
778static int sd_setgamma(struct gspca_dev *gspca_dev, __s32 val)
779{
780 struct sd *sd = (struct sd *) gspca_dev;
781
782 sd->gamma = val;
783 if (gspca_dev->streaming)
784 setgamma(gspca_dev);
785 return 0;
786}
787
788static int sd_getgamma(struct gspca_dev *gspca_dev, __s32 *val)
789{
790 struct sd *sd = (struct sd *) gspca_dev;
791 *val = sd->gamma;
792 return 0;
793}
794
795static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val)
796{
797 struct sd *sd = (struct sd *) gspca_dev;
798
799 sd->freq = val;
800 if (gspca_dev->streaming)
801 setlightfreq(gspca_dev);
802 return 0;
803}
804
805static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val)
806{
807 struct sd *sd = (struct sd *) gspca_dev;
808
809 *val = sd->freq;
810 return 0;
811}
812
813static int sd_setsharpness(struct gspca_dev *gspca_dev, __s32 val)
814{
815 struct sd *sd = (struct sd *) gspca_dev;
816
817 sd->sharpness = val;
818 if (gspca_dev->streaming)
819 setsharpness(gspca_dev);
820 return 0;
821}
822
823static int sd_getsharpness(struct gspca_dev *gspca_dev, __s32 *val)
824{
825 struct sd *sd = (struct sd *) gspca_dev;
826
827 *val = sd->sharpness;
828 return 0;
829}
830
831/* Low Light set here......*/
832static int sd_setlowlight(struct gspca_dev *gspca_dev, __s32 val)
833{
834 struct sd *sd = (struct sd *) gspca_dev;
6a7eba24
JFM		 835
836 sd->autogain = val;
837 if (val != 0)
739570bb 838 reg_w(gspca_dev, 0x00, 0xf48e, NULL, 0);
6a7eba24 839 else
739570bb 840 reg_w(gspca_dev, 0x00, 0xb48e, NULL, 0);
6a7eba24
JFM		 841 return 0;
842}
843
844static int sd_getlowlight(struct gspca_dev *gspca_dev, __s32 *val)
845{
846 struct sd *sd = (struct sd *) gspca_dev;
847
848 *val = sd->autogain;
849 return 0;
850}
851
72ab97ce 852static int sd_start(struct gspca_dev *gspca_dev)
6a7eba24 853{
6a7eba24 854 int mode;
6a7eba24 855
a5ae2062 856 static const __u8 t1[] = { 0x66, 0x00, 0xa8, 0xe8 };
6a7eba24 857 __u8 t2[] = { 0x07, 0x00, 0x0d, 0x60, 0x0e, 0x80 };
a5ae2062 858 static const __u8 t3[] =
6a7eba24
JFM		 859 { 0xb3, 0x07, 0xb4, 0x00, 0xb5, 0x88, 0xb6, 0x02, 0xb7, 0x06,
860 0xb8, 0x00, 0xb9, 0xe7, 0xba, 0x01 };
a5ae2062 861 static const __u8 t4[] = { 0x0b, 0x04, 0x0a, 0x40 };
6a7eba24 862
c2446b3e 863 mode = gspca_dev->cam.cam_mode[(int) gspca_dev->curr_mode]. priv;
6a7eba24
JFM		 864 switch (mode) {
865 case 1: /* 352x288 */
866 t2[1] = 0x40;
867 break;
868 case 2: /* 320x240 */
869 t2[1] = 0x10;
870 break;
871 case 3: /* 176x144 */
872 t2[1] = 0x50;
873 break;
874 case 4: /* 160x120 */
875 t2[1] = 0x20;
876 break;
877 default: /* 640x480 (0x00) */
878 break;
879 }
880
739570bb
JFM		 881 reg_w(gspca_dev, 0x01, 0x0000, tas5130a_sensor_init[0], 0x8);
882 reg_w(gspca_dev, 0x01, 0x0000, tas5130a_sensor_init[1], 0x8);
883 reg_w(gspca_dev, 0x01, 0x0000, tas5130a_sensor_init[2], 0x8);
884 reg_w(gspca_dev, 0x01, 0x0000, tas5130a_sensor_init[3], 0x8);
885 reg_w(gspca_dev, 0x00, 0x3c80, NULL, 0);
6a7eba24 886 /* just in case and to keep sync with logs (for mine) */
739570bb
JFM		 887 reg_w(gspca_dev, 0x01, 0x0000, tas5130a_sensor_init[3], 0x8);
888 reg_w(gspca_dev, 0x00, 0x3c80, NULL, 0);
6a7eba24 889 /* just in case and to keep sync with logs (for mine) */
739570bb
JFM		 890 reg_w(gspca_dev, 0x01, 0x0000, t1, 4);
891 reg_w(gspca_dev, 0x01, 0x0000, t2, 6);
892 reg_r_1(gspca_dev, 0x0012);
893 reg_w(gspca_dev, 0x01, 0x0000, t3, 0x10);
894 reg_w(gspca_dev, 0x00, 0x0013, NULL, 0);
895 reg_w(gspca_dev, 0x01, 0x0000, t4, 0x4);
6a7eba24
JFM		 896 /* restart on each start, just in case, sometimes regs goes wrong
897 * when using controls from app */
898 setbrightness(gspca_dev);
899 setcontrast(gspca_dev);
900 setcolors(gspca_dev);
72ab97ce 901 return 0;
6a7eba24
JFM		 902}
903
6a7eba24
JFM		 904static void sd_pkt_scan(struct gspca_dev *gspca_dev,
905 struct gspca_frame *frame, /* target */
a5ae2062 906 __u8 *data, /* isoc packet */
6a7eba24
JFM		 907 int len) /* iso packet length */
908{
909 int sof = 0;
a5ae2062 910 static __u8 ffd9[] = { 0xff, 0xd9 };
6a7eba24
JFM		 911
912 if (data[0] == 0x5a) {
913 /* Control Packet, after this came the header again,
914 * but extra bytes came in the packet before this,
915 * sometimes an EOF arrives, sometimes not... */
916 return;
917 }
918
b1043e56 919 if (data[len - 2] == 0xff && data[len - 1] == 0xd9) {
6a7eba24
JFM		 920 /* Just in case, i have seen packets with the marker,
921 * other's do not include it... */
922 data += 2;
923 len -= 4;
924 } else if (data[2] == 0xff && data[3] == 0xd8) {
925 sof = 1;
926 data += 2;
927 len -= 2;
928 } else {
929 data += 2;
930 len -= 2;
931 }
932
933 if (sof) {
934 /* extra bytes....., could be processed too but would be
935 * a waste of time, right now leave the application and
936 * libjpeg do it for ourserlves.. */
937 frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame,
938 ffd9, 2);
939 gspca_frame_add(gspca_dev, FIRST_PACKET, frame, data, len);
940 return;
941 }
942
943 gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
944}
945
946static int sd_querymenu(struct gspca_dev *gspca_dev,
947 struct v4l2_querymenu *menu)
948{
6a7eba24
JFM		 949 switch (menu->id) {
950 case V4L2_CID_POWER_LINE_FREQUENCY:
951 switch (menu->index) {
952 case 1: /* V4L2_CID_POWER_LINE_FREQUENCY_50HZ */
a5ae2062 953 strcpy((char *) menu->name, "50 Hz");
6a7eba24
JFM		 954 return 0;
955 case 2: /* V4L2_CID_POWER_LINE_FREQUENCY_60HZ */
a5ae2062 956 strcpy((char *) menu->name, "60 Hz");
6a7eba24
JFM		 957 return 0;
958 }
959 break;
960 case V4L2_CID_EFFECTS:
a5ae2062
JFM		 961 if ((unsigned) menu->index < ARRAY_SIZE(effects_control)) {
962 strncpy((char *) menu->name,
963 effects_control[menu->index], 32);
964 return 0;
965 }
6a7eba24
JFM		 966 break;
967 }
a5ae2062 968 return -EINVAL;
6a7eba24
JFM		 969}
970
6a7eba24 971/* sub-driver description */
a5ae2062 972static const struct sd_desc sd_desc = {
6a7eba24
JFM		 973 .name = MODULE_NAME,
974 .ctrls = sd_ctrls,
975 .nctrls = ARRAY_SIZE(sd_ctrls),
976 .config = sd_config,
012d6b02 977 .init = sd_init,
6a7eba24 978 .start = sd_start,
6a7eba24
JFM		 979 .pkt_scan = sd_pkt_scan,
980 .querymenu = sd_querymenu,
981};
982
983/* -- module initialisation -- */
a5ae2062 984static const __devinitdata struct usb_device_id device_table[] = {
9d64fdb1 985 {USB_DEVICE(0x17a1, 0x0128)},
6a7eba24
JFM		 986 {}
987};
6a7eba24
JFM		 988MODULE_DEVICE_TABLE(usb, device_table);
989
990/* -- device connect -- */
991static int sd_probe(struct usb_interface *intf,
992 const struct usb_device_id *id)
993{
994 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
995 THIS_MODULE);
996}
997
998static struct usb_driver sd_driver = {
999 .name = MODULE_NAME,
1000 .id_table = device_table,
1001 .probe = sd_probe,
1002 .disconnect = gspca_disconnect,
6a709749
JFM		 1003#ifdef CONFIG_PM
1004 .suspend = gspca_suspend,
1005 .resume = gspca_resume,
1006#endif
6a7eba24
JFM		 1007};
1008
1009/* -- module insert / remove -- */
1010static int __init sd_mod_init(void)
1011{
1012 if (usb_register(&sd_driver) < 0)
1013 return -1;
10b0e96e 1014 PDEBUG(D_PROBE, "registered");
6a7eba24
JFM		 1015 return 0;
1016}
1017static void __exit sd_mod_exit(void)
1018{
1019 usb_deregister(&sd_driver);
1020 PDEBUG(D_PROBE, "deregistered");
1021}
1022
1023module_init(sd_mod_init);
1024module_exit(sd_mod_exit);
Ubuntu Artful kernel mirror