V4L/DVB (10638): gspca - t613: Bad debug level when displaying the sensor type.
[linux-2.6] / drivers / media / video / gspca / mars.c
1 /*
2  *              Mars-Semi MR97311A library
3  *              Copyright (C) 2005 <bradlch@hotmail.com>
4  *
5  * V4L2 by Jean-Francois Moine <http://moinejf.free.fr>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20  */
21
22 #define MODULE_NAME "mars"
23
24 #include "gspca.h"
25 #define QUANT_VAL 1             /* quantization table */
26 #include "jpeg.h"
27
28 MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
29 MODULE_DESCRIPTION("GSPCA/Mars USB Camera Driver");
30 MODULE_LICENSE("GPL");
31
32 /* specific webcam descriptor */
33 struct sd {
34         struct gspca_dev gspca_dev;     /* !! must be the first item */
35
36         u8 brightness;
37         u8 colors;
38         u8 gamma;
39         u8 sharpness;
40 };
41
42 /* V4L2 controls supported by the driver */
43 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val);
44 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val);
45 static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val);
46 static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val);
47 static int sd_setgamma(struct gspca_dev *gspca_dev, __s32 val);
48 static int sd_getgamma(struct gspca_dev *gspca_dev, __s32 *val);
49 static int sd_setsharpness(struct gspca_dev *gspca_dev, __s32 val);
50 static int sd_getsharpness(struct gspca_dev *gspca_dev, __s32 *val);
51
52 static struct ctrl sd_ctrls[] = {
53         {
54             {
55                 .id      = V4L2_CID_BRIGHTNESS,
56                 .type    = V4L2_CTRL_TYPE_INTEGER,
57                 .name    = "Brightness",
58                 .minimum = 0,
59                 .maximum = 30,
60                 .step    = 1,
61 #define BRIGHTNESS_DEF 15
62                 .default_value = BRIGHTNESS_DEF,
63             },
64             .set = sd_setbrightness,
65             .get = sd_getbrightness,
66         },
67         {
68             {
69                 .id      = V4L2_CID_SATURATION,
70                 .type    = V4L2_CTRL_TYPE_INTEGER,
71                 .name    = "Color",
72                 .minimum = 0,
73                 .maximum = 220,
74                 .step    = 1,
75 #define COLOR_DEF 190
76                 .default_value = COLOR_DEF,
77             },
78             .set = sd_setcolors,
79             .get = sd_getcolors,
80         },
81         {
82             {
83                 .id      = V4L2_CID_GAMMA,
84                 .type    = V4L2_CTRL_TYPE_INTEGER,
85                 .name    = "Gamma",
86                 .minimum = 0,
87                 .maximum = 3,
88                 .step    = 1,
89 #define GAMMA_DEF 1
90                 .default_value = GAMMA_DEF,
91             },
92             .set = sd_setgamma,
93             .get = sd_getgamma,
94         },
95         {
96             {
97                 .id      = V4L2_CID_SHARPNESS,
98                 .type    = V4L2_CTRL_TYPE_INTEGER,
99                 .name    = "Sharpness",
100                 .minimum = 0,
101                 .maximum = 2,
102                 .step    = 1,
103 #define SHARPNESS_DEF 1
104                 .default_value = SHARPNESS_DEF,
105             },
106             .set = sd_setsharpness,
107             .get = sd_getsharpness,
108         },
109 };
110
111 static const struct v4l2_pix_format vga_mode[] = {
112         {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
113                 .bytesperline = 320,
114                 .sizeimage = 320 * 240 * 3 / 8 + 590,
115                 .colorspace = V4L2_COLORSPACE_JPEG,
116                 .priv = 2},
117         {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
118                 .bytesperline = 640,
119                 .sizeimage = 640 * 480 * 3 / 8 + 590,
120                 .colorspace = V4L2_COLORSPACE_JPEG,
121                 .priv = 1},
122 };
123
124 static const __u8 mi_data[0x20] = {
125 /*       01    02   03     04    05    06    07    08 */
126         0x48, 0x22, 0x01, 0x47, 0x10, 0x00, 0x00, 0x00,
127 /*       09    0a   0b     0c    0d    0e    0f    10 */
128         0x00, 0x01, 0x30, 0x01, 0x30, 0x01, 0x30, 0x01,
129 /*       11    12   13     14    15    16    17    18 */
130         0x30, 0x00, 0x04, 0x00, 0x06, 0x01, 0xe2, 0x02,
131 /*       19    1a   1b     1c    1d    1e    1f    20 */
132         0x82, 0x00, 0x20, 0x17, 0x80, 0x08, 0x0c, 0x00
133 };
134
135 /* write <len> bytes from gspca_dev->usb_buf */
136 static int reg_w(struct gspca_dev *gspca_dev,
137                  int len)
138 {
139         int alen, ret;
140
141         ret = usb_bulk_msg(gspca_dev->dev,
142                         usb_sndbulkpipe(gspca_dev->dev, 4),
143                         gspca_dev->usb_buf,
144                         len,
145                         &alen,
146                         500);   /* timeout in milliseconds */
147         if (ret < 0)
148                 PDEBUG(D_ERR, "reg write [%02x] error %d",
149                         gspca_dev->usb_buf[0], ret);
150         return ret;
151 }
152
153 static void mi_w(struct gspca_dev *gspca_dev,
154                  u8 addr,
155                  u8 value)
156 {
157         gspca_dev->usb_buf[0] = 0x1f;
158         gspca_dev->usb_buf[1] = 0;                      /* control byte */
159         gspca_dev->usb_buf[2] = addr;
160         gspca_dev->usb_buf[3] = value;
161
162         reg_w(gspca_dev, 4);
163 }
164
165 /* this function is called at probe time */
166 static int sd_config(struct gspca_dev *gspca_dev,
167                         const struct usb_device_id *id)
168 {
169         struct sd *sd = (struct sd *) gspca_dev;
170         struct cam *cam;
171
172         cam = &gspca_dev->cam;
173         cam->cam_mode = vga_mode;
174         cam->nmodes = ARRAY_SIZE(vga_mode);
175         sd->brightness = BRIGHTNESS_DEF;
176         sd->colors = COLOR_DEF;
177         sd->gamma = GAMMA_DEF;
178         sd->sharpness = SHARPNESS_DEF;
179         gspca_dev->nbalt = 9;           /* use the altsetting 08 */
180         return 0;
181 }
182
183 /* this function is called at probe and resume time */
184 static int sd_init(struct gspca_dev *gspca_dev)
185 {
186         return 0;
187 }
188
189 static int sd_start(struct gspca_dev *gspca_dev)
190 {
191         struct sd *sd = (struct sd *) gspca_dev;
192         int err_code;
193         u8 *data;
194         int i, val;
195
196         data = gspca_dev->usb_buf;
197
198         data[0] = 0x01;         /* address */
199         data[1] = 0x01;
200         err_code = reg_w(gspca_dev, 2);
201         if (err_code < 0)
202                 return err_code;
203
204         /*
205            Initialize the MR97113 chip register
206          */
207         data[0] = 0x00;         /* address */
208         data[1] = 0x0c | 0x01;  /* reg 0 */
209         data[2] = 0x01;         /* reg 1 */
210         data[3] = gspca_dev->width / 8;         /* h_size , reg 2 */
211         data[4] = gspca_dev->height / 8;        /* v_size , reg 3 */
212         data[5] = 0x30;         /* reg 4, MI, PAS5101 :
213                                  *      0x30 for 24mhz , 0x28 for 12mhz */
214         data[6] = 0x02;         /* reg 5, H start - was 0x04 */
215         data[7] = sd->gamma * 0x40;     /* reg 0x06: gamma */
216         data[8] = 0x01;         /* reg 7, V start - was 0x03 */
217 /*      if (h_size == 320 ) */
218 /*              data[9]= 0x56;   * reg 8, 24MHz, 2:1 scale down */
219 /*      else */
220         data[9] = 0x52;         /* reg 8, 24MHz, no scale down */
221 /*jfm: from win trace*/
222         data[10] = 0x18;
223
224         err_code = reg_w(gspca_dev, 11);
225         if (err_code < 0)
226                 return err_code;
227
228         data[0] = 0x23;         /* address */
229         data[1] = 0x09;         /* reg 35, append frame header */
230
231         err_code = reg_w(gspca_dev, 2);
232         if (err_code < 0)
233                 return err_code;
234
235         data[0] = 0x3c;         /* address */
236 /*      if (gspca_dev->width == 1280) */
237 /*              data[1] = 200;   * reg 60, pc-cam frame size
238                                  *      (unit: 4KB) 800KB */
239 /*      else */
240         data[1] = 50;           /* 50 reg 60, pc-cam frame size
241                                  *      (unit: 4KB) 200KB */
242         err_code = reg_w(gspca_dev, 2);
243         if (err_code < 0)
244                 return err_code;
245
246         /* auto dark-gain */
247         data[0] = 0x5e;         /* address */
248         data[1] = 0;            /* reg 94, Y Gain (auto) */
249 /*jfm: from win trace*/
250         val = sd->colors * 0x40 + 0x400;
251         data[2] = val;          /* reg 0x5f/0x60 (LE) = saturation */
252         data[3] = val >> 8;
253         data[4] = sd->brightness; /* reg 0x61 = brightness */
254         data[5] = 0x00;
255
256         err_code = reg_w(gspca_dev, 6);
257         if (err_code < 0)
258                 return err_code;
259
260         data[0] = 0x67;
261 /*jfm: from win trace*/
262         data[1] = sd->sharpness * 4 + 3;
263         data[2] = 0x14;
264         err_code = reg_w(gspca_dev, 3);
265         if (err_code < 0)
266                 return err_code;
267
268         data[0] = 0x69;
269         data[1] = 0x2f;
270         data[2] = 0x28;
271         data[3] = 0x42;
272         err_code = reg_w(gspca_dev, 4);
273         if (err_code < 0)
274                 return err_code;
275
276         data[0] = 0x63;
277         data[1] = 0x07;
278         err_code = reg_w(gspca_dev, 2);
279 /*jfm: win trace - many writes here to reg 0x64*/
280         if (err_code < 0)
281                 return err_code;
282
283         /* initialize the MI sensor */
284         for (i = 0; i < sizeof mi_data; i++)
285                 mi_w(gspca_dev, i + 1, mi_data[i]);
286
287         data[0] = 0x00;
288         data[1] = 0x4d;         /* ISOC transfering enable... */
289         reg_w(gspca_dev, 2);
290         return 0;
291 }
292
293 static void sd_stopN(struct gspca_dev *gspca_dev)
294 {
295         int result;
296
297         gspca_dev->usb_buf[0] = 1;
298         gspca_dev->usb_buf[1] = 0;
299         result = reg_w(gspca_dev, 2);
300         if (result < 0)
301                 PDEBUG(D_ERR, "Camera Stop failed");
302 }
303
304 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
305                         struct gspca_frame *frame,      /* target */
306                         __u8 *data,                     /* isoc packet */
307                         int len)                        /* iso packet length */
308 {
309         int p;
310
311         if (len < 6) {
312 /*              gspca_dev->last_packet_type = DISCARD_PACKET; */
313                 return;
314         }
315         for (p = 0; p < len - 6; p++) {
316                 if (data[0 + p] == 0xff
317                     && data[1 + p] == 0xff
318                     && data[2 + p] == 0x00
319                     && data[3 + p] == 0xff
320                     && data[4 + p] == 0x96) {
321                         if (data[5 + p] == 0x64
322                             || data[5 + p] == 0x65
323                             || data[5 + p] == 0x66
324                             || data[5 + p] == 0x67) {
325                                 PDEBUG(D_PACK, "sof offset: %d len: %d",
326                                         p, len);
327                                 frame = gspca_frame_add(gspca_dev, LAST_PACKET,
328                                                         frame, data, p);
329
330                                 /* put the JPEG header */
331                                 jpeg_put_header(gspca_dev, frame, 0x21);
332                                 data += p + 16;
333                                 len -= p + 16;
334                                 break;
335                         }
336                 }
337         }
338         gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
339 }
340
341 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
342 {
343         struct sd *sd = (struct sd *) gspca_dev;
344
345         sd->brightness = val;
346         if (gspca_dev->streaming) {
347                 gspca_dev->usb_buf[0] = 0x61;
348                 gspca_dev->usb_buf[1] = val;
349                 reg_w(gspca_dev, 2);
350         }
351         return 0;
352 }
353
354 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
355 {
356         struct sd *sd = (struct sd *) gspca_dev;
357
358         *val = sd->brightness;
359         return 0;
360 }
361
362 static int sd_setcolors(struct gspca_dev *gspca_dev, __s32 val)
363 {
364         struct sd *sd = (struct sd *) gspca_dev;
365
366         sd->colors = val;
367         if (gspca_dev->streaming) {
368                 val = val * 0x40 + 0x400;
369                 gspca_dev->usb_buf[0] = 0x5f;
370                 gspca_dev->usb_buf[1] = val;
371                 gspca_dev->usb_buf[2] = val >> 8;
372                 reg_w(gspca_dev, 3);
373         }
374         return 0;
375 }
376
377 static int sd_getcolors(struct gspca_dev *gspca_dev, __s32 *val)
378 {
379         struct sd *sd = (struct sd *) gspca_dev;
380
381         *val = sd->colors;
382         return 0;
383 }
384
385 static int sd_setgamma(struct gspca_dev *gspca_dev, __s32 val)
386 {
387         struct sd *sd = (struct sd *) gspca_dev;
388
389         sd->gamma = val;
390         if (gspca_dev->streaming) {
391                 gspca_dev->usb_buf[0] = 0x06;
392                 gspca_dev->usb_buf[1] = val * 0x40;
393                 reg_w(gspca_dev, 2);
394         }
395         return 0;
396 }
397
398 static int sd_getgamma(struct gspca_dev *gspca_dev, __s32 *val)
399 {
400         struct sd *sd = (struct sd *) gspca_dev;
401
402         *val = sd->gamma;
403         return 0;
404 }
405
406 static int sd_setsharpness(struct gspca_dev *gspca_dev, __s32 val)
407 {
408         struct sd *sd = (struct sd *) gspca_dev;
409
410         sd->sharpness = val;
411         if (gspca_dev->streaming) {
412                 gspca_dev->usb_buf[0] = 0x67;
413                 gspca_dev->usb_buf[1] = val * 4 + 3;
414                 reg_w(gspca_dev, 2);
415         }
416         return 0;
417 }
418
419 static int sd_getsharpness(struct gspca_dev *gspca_dev, __s32 *val)
420 {
421         struct sd *sd = (struct sd *) gspca_dev;
422
423         *val = sd->sharpness;
424         return 0;
425 }
426
427 /* sub-driver description */
428 static const struct sd_desc sd_desc = {
429         .name = MODULE_NAME,
430         .ctrls = sd_ctrls,
431         .nctrls = ARRAY_SIZE(sd_ctrls),
432         .config = sd_config,
433         .init = sd_init,
434         .start = sd_start,
435         .stopN = sd_stopN,
436         .pkt_scan = sd_pkt_scan,
437 };
438
439 /* -- module initialisation -- */
440 static const __devinitdata struct usb_device_id device_table[] = {
441         {USB_DEVICE(0x093a, 0x050f)},
442         {}
443 };
444 MODULE_DEVICE_TABLE(usb, device_table);
445
446 /* -- device connect -- */
447 static int sd_probe(struct usb_interface *intf,
448                         const struct usb_device_id *id)
449 {
450         return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
451                                 THIS_MODULE);
452 }
453
454 static struct usb_driver sd_driver = {
455         .name = MODULE_NAME,
456         .id_table = device_table,
457         .probe = sd_probe,
458         .disconnect = gspca_disconnect,
459 #ifdef CONFIG_PM
460         .suspend = gspca_suspend,
461         .resume = gspca_resume,
462 #endif
463 };
464
465 /* -- module insert / remove -- */
466 static int __init sd_mod_init(void)
467 {
468         int ret;
469
470         ret = usb_register(&sd_driver);
471         if (ret < 0)
472                 return ret;
473         PDEBUG(D_PROBE, "registered");
474         return 0;
475 }
476 static void __exit sd_mod_exit(void)
477 {
478         usb_deregister(&sd_driver);
479         PDEBUG(D_PROBE, "deregistered");
480 }
481
482 module_init(sd_mod_init);
483 module_exit(sd_mod_exit);