Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux...
[linux-2.6] / drivers / media / video / gspca / stk014.c
1 /*
2  * Syntek DV4000 (STK014) subdriver
3  *
4  * Copyright (C) 2008 Jean-Francois Moine (http://moinejf.free.fr)
5  *
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
9  * any later version.
10  *
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.
15  *
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
19  */
20
21 #define MODULE_NAME "stk014"
22
23 #include "gspca.h"
24 #include "jpeg.h"
25
26 MODULE_AUTHOR("Jean-Francois Moine <http://moinejf.free.fr>");
27 MODULE_DESCRIPTION("Syntek DV4000 (STK014) USB Camera Driver");
28 MODULE_LICENSE("GPL");
29
30 /* specific webcam descriptor */
31 struct sd {
32         struct gspca_dev gspca_dev;     /* !! must be the first item */
33
34         unsigned char brightness;
35         unsigned char contrast;
36         unsigned char colors;
37         unsigned char lightfreq;
38 };
39
40 /* global parameters */
41 static int sd_quant = 7;                /* <= 4 KO - 7: good (enough!) */
42
43 /* V4L2 controls supported by the driver */
44 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
45 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
46 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val);
47 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val);
48 static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val);
49 static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val);
50 static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val);
51 static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val);
52
53 static struct ctrl sd_ctrls[] = {
54         {
55             {
56                 .id      = V4L2_CID_BRIGHTNESS,
57                 .type    = V4L2_CTRL_TYPE_INTEGER,
58                 .name    = "Brightness",
59                 .minimum = 0,
60                 .maximum = 255,
61                 .step    = 1,
62 #define BRIGHTNESS_DEF 127
63                 .default_value = BRIGHTNESS_DEF,
64             },
65             .set = sd_setbrightness,
66             .get = sd_getbrightness,
67         },
68         {
69             {
70                 .id      = V4L2_CID_CONTRAST,
71                 .type    = V4L2_CTRL_TYPE_INTEGER,
72                 .name    = "Contrast",
73                 .minimum = 0,
74                 .maximum = 255,
75                 .step    = 1,
76 #define CONTRAST_DEF 127
77                 .default_value = CONTRAST_DEF,
78             },
79             .set = sd_setcontrast,
80             .get = sd_getcontrast,
81         },
82         {
83             {
84                 .id      = V4L2_CID_SATURATION,
85                 .type    = V4L2_CTRL_TYPE_INTEGER,
86                 .name    = "Color",
87                 .minimum = 0,
88                 .maximum = 255,
89                 .step    = 1,
90 #define COLOR_DEF 127
91                 .default_value = COLOR_DEF,
92             },
93             .set = sd_setcolors,
94             .get = sd_getcolors,
95         },
96         {
97             {
98                 .id      = V4L2_CID_POWER_LINE_FREQUENCY,
99                 .type    = V4L2_CTRL_TYPE_MENU,
100                 .name    = "Light frequency filter",
101                 .minimum = 1,
102                 .maximum = 2,   /* 0: 0, 1: 50Hz, 2:60Hz */
103                 .step    = 1,
104 #define FREQ_DEF 1
105                 .default_value = FREQ_DEF,
106             },
107             .set = sd_setfreq,
108             .get = sd_getfreq,
109         },
110 };
111
112 static const struct v4l2_pix_format vga_mode[] = {
113         {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
114                 .bytesperline = 320,
115                 .sizeimage = 320 * 240 * 3 / 8 + 590,
116                 .colorspace = V4L2_COLORSPACE_JPEG,
117                 .priv = 1},
118         {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
119                 .bytesperline = 640,
120                 .sizeimage = 640 * 480 * 3 / 8 + 590,
121                 .colorspace = V4L2_COLORSPACE_JPEG,
122                 .priv = 0},
123 };
124
125 /* -- read a register -- */
126 static int reg_r(struct gspca_dev *gspca_dev,
127                         __u16 index)
128 {
129         struct usb_device *dev = gspca_dev->dev;
130         int ret;
131
132         ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
133                         0x00,
134                         USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
135                         0x00,
136                         index,
137                         gspca_dev->usb_buf, 1,
138                         500);
139         if (ret < 0) {
140                 PDEBUG(D_ERR, "reg_r err %d", ret);
141                 return ret;
142         }
143         return gspca_dev->usb_buf[0];
144 }
145
146 /* -- write a register -- */
147 static int reg_w(struct gspca_dev *gspca_dev,
148                         __u16 index, __u16 value)
149 {
150         struct usb_device *dev = gspca_dev->dev;
151         int ret;
152
153         ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
154                         0x01,
155                         USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
156                         value,
157                         index,
158                         NULL,
159                         0,
160                         500);
161         if (ret < 0)
162                 PDEBUG(D_ERR, "reg_w err %d", ret);
163         return ret;
164 }
165
166 /* -- get a bulk value (4 bytes) -- */
167 static int rcv_val(struct gspca_dev *gspca_dev,
168                         int ads)
169 {
170         struct usb_device *dev = gspca_dev->dev;
171         int alen, ret;
172
173         reg_w(gspca_dev, 0x634, (ads >> 16) & 0xff);
174         reg_w(gspca_dev, 0x635, (ads >> 8) & 0xff);
175         reg_w(gspca_dev, 0x636, ads & 0xff);
176         reg_w(gspca_dev, 0x637, 0);
177         reg_w(gspca_dev, 0x638, 4);     /* len & 0xff */
178         reg_w(gspca_dev, 0x639, 0);     /* len >> 8 */
179         reg_w(gspca_dev, 0x63a, 0);
180         reg_w(gspca_dev, 0x63b, 0);
181         reg_w(gspca_dev, 0x630, 5);
182         ret = usb_bulk_msg(dev,
183                         usb_rcvbulkpipe(dev, 5),
184                         gspca_dev->usb_buf,
185                         4,              /* length */
186                         &alen,
187                         500);           /* timeout in milliseconds */
188         return ret;
189 }
190
191 /* -- send a bulk value -- */
192 static int snd_val(struct gspca_dev *gspca_dev,
193                         int ads,
194                         unsigned int val)
195 {
196         struct usb_device *dev = gspca_dev->dev;
197         int alen, ret;
198         __u8 seq = 0;
199
200         if (ads == 0x003f08) {
201                 ret = reg_r(gspca_dev, 0x0704);
202                 if (ret < 0)
203                         goto ko;
204                 ret = reg_r(gspca_dev, 0x0705);
205                 if (ret < 0)
206                         goto ko;
207                 seq = ret;              /* keep the sequence number */
208                 ret = reg_r(gspca_dev, 0x0650);
209                 if (ret < 0)
210                         goto ko;
211                 reg_w(gspca_dev, 0x654, seq);
212         } else {
213                 reg_w(gspca_dev, 0x654, (ads >> 16) & 0xff);
214         }
215         reg_w(gspca_dev, 0x655, (ads >> 8) & 0xff);
216         reg_w(gspca_dev, 0x656, ads & 0xff);
217         reg_w(gspca_dev, 0x657, 0);
218         reg_w(gspca_dev, 0x658, 0x04);  /* size */
219         reg_w(gspca_dev, 0x659, 0);
220         reg_w(gspca_dev, 0x65a, 0);
221         reg_w(gspca_dev, 0x65b, 0);
222         reg_w(gspca_dev, 0x650, 5);
223         gspca_dev->usb_buf[0] = val >> 24;
224         gspca_dev->usb_buf[1] = val >> 16;
225         gspca_dev->usb_buf[2] = val >> 8;
226         gspca_dev->usb_buf[3] = val;
227         ret = usb_bulk_msg(dev,
228                         usb_sndbulkpipe(dev, 6),
229                         gspca_dev->usb_buf,
230                         4,
231                         &alen,
232                         500);   /* timeout in milliseconds */
233         if (ret < 0)
234                 goto ko;
235         if (ads == 0x003f08) {
236                 seq += 4;
237                 seq &= 0x3f;
238                 reg_w(gspca_dev, 0x705, seq);
239         }
240         return ret;
241 ko:
242         PDEBUG(D_ERR, "snd_val err %d", ret);
243         return ret;
244 }
245
246 /* set a camera parameter */
247 static int set_par(struct gspca_dev *gspca_dev,
248                    int parval)
249 {
250         return snd_val(gspca_dev, 0x003f08, parval);
251 }
252
253 static void setbrightness(struct gspca_dev *gspca_dev)
254 {
255         struct sd *sd = (struct sd *) gspca_dev;
256         int parval;
257
258         parval = 0x06000000             /* whiteness */
259                 + (sd->brightness << 16);
260         set_par(gspca_dev, parval);
261 }
262
263 static void setcontrast(struct gspca_dev *gspca_dev)
264 {
265         struct sd *sd = (struct sd *) gspca_dev;
266         int parval;
267
268         parval = 0x07000000             /* contrast */
269                 + (sd->contrast << 16);
270         set_par(gspca_dev, parval);
271 }
272
273 static void setcolors(struct gspca_dev *gspca_dev)
274 {
275         struct sd *sd = (struct sd *) gspca_dev;
276         int parval;
277
278         parval = 0x08000000             /* saturation */
279                 + (sd->colors << 16);
280         set_par(gspca_dev, parval);
281 }
282
283 static void setfreq(struct gspca_dev *gspca_dev)
284 {
285         struct sd *sd = (struct sd *) gspca_dev;
286
287         set_par(gspca_dev, sd->lightfreq == 1
288                         ? 0x33640000            /* 50 Hz */
289                         : 0x33780000);          /* 60 Hz */
290 }
291
292 /* this function is called at probe time */
293 static int sd_config(struct gspca_dev *gspca_dev,
294                         const struct usb_device_id *id)
295 {
296         struct sd *sd = (struct sd *) gspca_dev;
297         struct cam *cam = &gspca_dev->cam;
298
299         cam->epaddr = 0x02;
300         gspca_dev->cam.cam_mode = vga_mode;
301         gspca_dev->cam.nmodes = ARRAY_SIZE(vga_mode);
302         sd->brightness = BRIGHTNESS_DEF;
303         sd->contrast = CONTRAST_DEF;
304         sd->colors = COLOR_DEF;
305         sd->lightfreq = FREQ_DEF;
306         return 0;
307 }
308
309 /* this function is called at probe and resume time */
310 static int sd_init(struct gspca_dev *gspca_dev)
311 {
312         int ret;
313
314         /* check if the device responds */
315         usb_set_interface(gspca_dev->dev, gspca_dev->iface, 1);
316         ret = reg_r(gspca_dev, 0x0740);
317         if (ret < 0)
318                 return ret;
319         if (ret != 0xff) {
320                 PDEBUG(D_ERR|D_STREAM, "init reg: 0x%02x", ret);
321                 return -1;
322         }
323         return 0;
324 }
325
326 /* -- start the camera -- */
327 static int sd_start(struct gspca_dev *gspca_dev)
328 {
329         int ret, value;
330
331         /* work on alternate 1 */
332         usb_set_interface(gspca_dev->dev, gspca_dev->iface, 1);
333
334         set_par(gspca_dev, 0x10000000);
335         set_par(gspca_dev, 0x00000000);
336         set_par(gspca_dev, 0x8002e001);
337         set_par(gspca_dev, 0x14000000);
338         if (gspca_dev->width > 320)
339                 value = 0x8002e001;             /* 640x480 */
340         else
341                 value = 0x4001f000;             /* 320x240 */
342         set_par(gspca_dev, value);
343         ret = usb_set_interface(gspca_dev->dev,
344                                         gspca_dev->iface,
345                                         gspca_dev->alt);
346         if (ret < 0) {
347                 PDEBUG(D_ERR|D_STREAM, "set intf %d %d failed",
348                         gspca_dev->iface, gspca_dev->alt);
349                 goto out;
350         }
351         ret = reg_r(gspca_dev, 0x0630);
352         if (ret < 0)
353                 goto out;
354         rcv_val(gspca_dev, 0x000020);   /* << (value ff ff ff ff) */
355         ret = reg_r(gspca_dev, 0x0650);
356         if (ret < 0)
357                 goto out;
358         snd_val(gspca_dev, 0x000020, 0xffffffff);
359         reg_w(gspca_dev, 0x0620, 0);
360         reg_w(gspca_dev, 0x0630, 0);
361         reg_w(gspca_dev, 0x0640, 0);
362         reg_w(gspca_dev, 0x0650, 0);
363         reg_w(gspca_dev, 0x0660, 0);
364         setbrightness(gspca_dev);               /* whiteness */
365         setcontrast(gspca_dev);                 /* contrast */
366         setcolors(gspca_dev);                   /* saturation */
367         set_par(gspca_dev, 0x09800000);         /* Red ? */
368         set_par(gspca_dev, 0x0a800000);         /* Green ? */
369         set_par(gspca_dev, 0x0b800000);         /* Blue ? */
370         set_par(gspca_dev, 0x0d030000);         /* Gamma ? */
371         setfreq(gspca_dev);                     /* light frequency */
372
373         /* start the video flow */
374         set_par(gspca_dev, 0x01000000);
375         set_par(gspca_dev, 0x01000000);
376         PDEBUG(D_STREAM, "camera started alt: 0x%02x", gspca_dev->alt);
377         return 0;
378 out:
379         PDEBUG(D_ERR|D_STREAM, "camera start err %d", ret);
380         return ret;
381 }
382
383 static void sd_stopN(struct gspca_dev *gspca_dev)
384 {
385         struct usb_device *dev = gspca_dev->dev;
386
387         set_par(gspca_dev, 0x02000000);
388         set_par(gspca_dev, 0x02000000);
389         usb_set_interface(dev, gspca_dev->iface, 1);
390         reg_r(gspca_dev, 0x0630);
391         rcv_val(gspca_dev, 0x000020);   /* << (value ff ff ff ff) */
392         reg_r(gspca_dev, 0x0650);
393         snd_val(gspca_dev, 0x000020, 0xffffffff);
394         reg_w(gspca_dev, 0x0620, 0);
395         reg_w(gspca_dev, 0x0630, 0);
396         reg_w(gspca_dev, 0x0640, 0);
397         reg_w(gspca_dev, 0x0650, 0);
398         reg_w(gspca_dev, 0x0660, 0);
399         PDEBUG(D_STREAM, "camera stopped");
400 }
401
402 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
403                         struct gspca_frame *frame,      /* target */
404                         __u8 *data,                     /* isoc packet */
405                         int len)                        /* iso packet length */
406 {
407         static unsigned char ffd9[] = {0xff, 0xd9};
408
409         /* a frame starts with:
410          *      - 0xff 0xfe
411          *      - 0x08 0x00     - length (little endian ?!)
412          *      - 4 bytes = size of whole frame (BE - including header)
413          *      - 0x00 0x0c
414          *      - 0xff 0xd8
415          *      - ..    JPEG image with escape sequences (ff 00)
416          *              (without ending - ff d9)
417          */
418         if (data[0] == 0xff && data[1] == 0xfe) {
419                 frame = gspca_frame_add(gspca_dev, LAST_PACKET, frame,
420                                         ffd9, 2);
421
422                 /* put the JPEG 411 header */
423                 jpeg_put_header(gspca_dev, frame, sd_quant, 0x22);
424
425                 /* beginning of the frame */
426 #define STKHDRSZ 12
427                 data += STKHDRSZ;
428                 len -= STKHDRSZ;
429         }
430         gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
431 }
432
433 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
434 {
435         struct sd *sd = (struct sd *) gspca_dev;
436
437         sd->brightness = val;
438         if (gspca_dev->streaming)
439                 setbrightness(gspca_dev);
440         return 0;
441 }
442
443 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
444 {
445         struct sd *sd = (struct sd *) gspca_dev;
446
447         *val = sd->brightness;
448         return 0;
449 }
450
451 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val)
452 {
453         struct sd *sd = (struct sd *) gspca_dev;
454
455         sd->contrast = val;
456         if (gspca_dev->streaming)
457                 setcontrast(gspca_dev);
458         return 0;
459 }
460
461 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val)
462 {
463         struct sd *sd = (struct sd *) gspca_dev;
464
465         *val = sd->contrast;
466         return 0;
467 }
468
469 static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val)
470 {
471         struct sd *sd = (struct sd *) gspca_dev;
472
473         sd->colors = val;
474         if (gspca_dev->streaming)
475                 setcolors(gspca_dev);
476         return 0;
477 }
478
479 static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val)
480 {
481         struct sd *sd = (struct sd *) gspca_dev;
482
483         *val = sd->colors;
484         return 0;
485 }
486
487 static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val)
488 {
489         struct sd *sd = (struct sd *) gspca_dev;
490
491         sd->lightfreq = val;
492         if (gspca_dev->streaming)
493                 setfreq(gspca_dev);
494         return 0;
495 }
496
497 static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val)
498 {
499         struct sd *sd = (struct sd *) gspca_dev;
500
501         *val = sd->lightfreq;
502         return 0;
503 }
504
505 static int sd_querymenu(struct gspca_dev *gspca_dev,
506                         struct v4l2_querymenu *menu)
507 {
508         switch (menu->id) {
509         case V4L2_CID_POWER_LINE_FREQUENCY:
510                 switch (menu->index) {
511                 case 1:         /* V4L2_CID_POWER_LINE_FREQUENCY_50HZ */
512                         strcpy((char *) menu->name, "50 Hz");
513                         return 0;
514                 case 2:         /* V4L2_CID_POWER_LINE_FREQUENCY_60HZ */
515                         strcpy((char *) menu->name, "60 Hz");
516                         return 0;
517                 }
518                 break;
519         }
520         return -EINVAL;
521 }
522
523 /* sub-driver description */
524 static const struct sd_desc sd_desc = {
525         .name = MODULE_NAME,
526         .ctrls = sd_ctrls,
527         .nctrls = ARRAY_SIZE(sd_ctrls),
528         .config = sd_config,
529         .init = sd_init,
530         .start = sd_start,
531         .stopN = sd_stopN,
532         .pkt_scan = sd_pkt_scan,
533         .querymenu = sd_querymenu,
534 };
535
536 /* -- module initialisation -- */
537 static const __devinitdata struct usb_device_id device_table[] = {
538         {USB_DEVICE(0x05e1, 0x0893)},
539         {}
540 };
541 MODULE_DEVICE_TABLE(usb, device_table);
542
543 /* -- device connect -- */
544 static int sd_probe(struct usb_interface *intf,
545                         const struct usb_device_id *id)
546 {
547         return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
548                                 THIS_MODULE);
549 }
550
551 static struct usb_driver sd_driver = {
552         .name = MODULE_NAME,
553         .id_table = device_table,
554         .probe = sd_probe,
555         .disconnect = gspca_disconnect,
556 #ifdef CONFIG_PM
557         .suspend = gspca_suspend,
558         .resume = gspca_resume,
559 #endif
560 };
561
562 /* -- module insert / remove -- */
563 static int __init sd_mod_init(void)
564 {
565         if (usb_register(&sd_driver) < 0)
566                 return -1;
567         info("registered");
568         return 0;
569 }
570 static void __exit sd_mod_exit(void)
571 {
572         usb_deregister(&sd_driver);
573         info("deregistered");
574 }
575
576 module_init(sd_mod_init);
577 module_exit(sd_mod_exit);
578
579 module_param_named(quant, sd_quant, int, 0644);
580 MODULE_PARM_DESC(quant, "Quantization index (0..8)");