Merge git://git.kernel.org/pub/scm/linux/kernel/git/herbert/crypto-2.6
[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 #include "jpeg.h"
26
27 MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
28 MODULE_DESCRIPTION("GSPCA/Mars USB Camera Driver");
29 MODULE_LICENSE("GPL");
30
31 /* specific webcam descriptor */
32 struct sd {
33         struct gspca_dev gspca_dev;     /* !! must be the first item */
34
35         char qindex;
36 };
37
38 /* V4L2 controls supported by the driver */
39 static struct ctrl sd_ctrls[] = {
40 };
41
42 static struct v4l2_pix_format vga_mode[] = {
43         {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
44                 .bytesperline = 320,
45                 .sizeimage = 320 * 240 * 3 / 8 + 589,
46                 .colorspace = V4L2_COLORSPACE_JPEG,
47                 .priv = 2},
48         {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
49                 .bytesperline = 640,
50                 .sizeimage = 640 * 480 * 3 / 8 + 590,
51                 .colorspace = V4L2_COLORSPACE_JPEG,
52                 .priv = 1},
53 };
54
55 /* MI Register table //elvis */
56 enum {
57         REG_HW_MI_0,
58         REG_HW_MI_1,
59         REG_HW_MI_2,
60         REG_HW_MI_3,
61         REG_HW_MI_4,
62         REG_HW_MI_5,
63         REG_HW_MI_6,
64         REG_HW_MI_7,
65         REG_HW_MI_9 = 0x09,
66         REG_HW_MI_B = 0x0B,
67         REG_HW_MI_C,
68         REG_HW_MI_D,
69         REG_HW_MI_1E = 0x1E,
70         REG_HW_MI_20 = 0x20,
71         REG_HW_MI_2B = 0x2B,
72         REG_HW_MI_2C,
73         REG_HW_MI_2D,
74         REG_HW_MI_2E,
75         REG_HW_MI_35 = 0x35,
76         REG_HW_MI_5F = 0x5f,
77         REG_HW_MI_60,
78         REG_HW_MI_61,
79         REG_HW_MI_62,
80         REG_HW_MI_63,
81         REG_HW_MI_64,
82         REG_HW_MI_F1 = 0xf1,
83         ATTR_TOTAL_MI_REG = 0xf2
84 };
85
86 /* the bytes to write are in gspca_dev->usb_buf */
87 static int reg_w(struct gspca_dev *gspca_dev,
88                  __u16 index, int len)
89 {
90         int rc;
91
92         rc = usb_control_msg(gspca_dev->dev,
93                          usb_sndbulkpipe(gspca_dev->dev, 4),
94                          0x12,
95                          0xc8,          /* ?? */
96                          0,             /* value */
97                          index, gspca_dev->usb_buf, len, 500);
98         if (rc < 0)
99                 PDEBUG(D_ERR, "reg write [%02x] error %d", index, rc);
100         return rc;
101 }
102
103 static void bulk_w(struct gspca_dev *gspca_dev,
104                    __u16 *pch,
105                    __u16 Address)
106 {
107         gspca_dev->usb_buf[0] = 0x1f;
108         gspca_dev->usb_buf[1] = 0;                      /* control byte */
109         gspca_dev->usb_buf[2] = Address;
110         gspca_dev->usb_buf[3] = *pch >> 8;              /* high byte */
111         gspca_dev->usb_buf[4] = *pch;                   /* low byte */
112
113         reg_w(gspca_dev, Address, 5);
114 }
115
116 /* this function is called at probe time */
117 static int sd_config(struct gspca_dev *gspca_dev,
118                         const struct usb_device_id *id)
119 {
120         struct sd *sd = (struct sd *) gspca_dev;
121         struct cam *cam;
122
123         cam = &gspca_dev->cam;
124         cam->epaddr = 0x01;
125         cam->cam_mode = vga_mode;
126         cam->nmodes = sizeof vga_mode / sizeof vga_mode[0];
127         sd->qindex = 1;                 /* set the quantization table */
128         return 0;
129 }
130
131 /* this function is called at probe and resume time */
132 static int sd_init(struct gspca_dev *gspca_dev)
133 {
134         return 0;
135 }
136
137 static void sd_start(struct gspca_dev *gspca_dev)
138 {
139         int err_code;
140         __u8 *data;
141         __u16 *MI_buf;
142         int h_size, v_size;
143         int intpipe;
144
145         PDEBUG(D_STREAM, "camera start, iface %d, alt 8", gspca_dev->iface);
146         if (usb_set_interface(gspca_dev->dev, gspca_dev->iface, 8) < 0) {
147                 PDEBUG(D_ERR|D_STREAM, "Set packet size: set interface error");
148                 return;
149         }
150
151         data = gspca_dev->usb_buf;
152         data[0] = 0x01;         /* address */
153         data[1] = 0x01;
154
155         err_code = reg_w(gspca_dev, data[0], 2);
156         if (err_code < 0)
157                 return;
158
159         /*
160            Initialize the MR97113 chip register
161          */
162         data[0] = 0x00;         /* address */
163         data[1] = 0x0c | 0x01;  /* reg 0 */
164         data[2] = 0x01;         /* reg 1 */
165         h_size = gspca_dev->width;
166         v_size = gspca_dev->height;
167         data[3] = h_size / 8;   /* h_size , reg 2 */
168         data[4] = v_size / 8;   /* v_size , reg 3 */
169         data[5] = 0x30;         /* reg 4, MI, PAS5101 :
170                                  *      0x30 for 24mhz , 0x28 for 12mhz */
171         data[6] = 4;            /* reg 5, H start */
172         data[7] = 0xc0;         /* reg 6, gamma 1.5 */
173         data[8] = 3;            /* reg 7, V start */
174 /*      if (h_size == 320 ) */
175 /*              data[9]= 0x56;   * reg 8, 24MHz, 2:1 scale down */
176 /*      else */
177         data[9] = 0x52;         /* reg 8, 24MHz, no scale down */
178         data[10] = 0x5d;        /* reg 9, I2C device address
179                                  *      [for PAS5101 (0x40)] [for MI (0x5d)] */
180
181         err_code = reg_w(gspca_dev, data[0], 11);
182         if (err_code < 0)
183                 return;
184
185         data[0] = 0x23;         /* address */
186         data[1] = 0x09;         /* reg 35, append frame header */
187
188         err_code = reg_w(gspca_dev, data[0], 2);
189         if (err_code < 0)
190                 return;
191
192         data[0] = 0x3c;         /* address */
193 /*      if (gspca_dev->width == 1280) */
194 /*              data[1] = 200;   * reg 60, pc-cam frame size
195                                  *      (unit: 4KB) 800KB */
196 /*      else */
197         data[1] = 50;           /* 50 reg 60, pc-cam frame size
198                                  *      (unit: 4KB) 200KB */
199         err_code = reg_w(gspca_dev, data[0], 2);
200         if (err_code < 0)
201                 return;
202
203         if (0) {                        /* fixed dark-gain */
204                 data[1] = 0;            /* reg 94, Y Gain (1.75) */
205                 data[2] = 0;            /* reg 95, UV Gain (1.75) */
206                 data[3] = 0x3f;         /* reg 96, Y Gain/UV Gain/disable
207                                          *      auto dark-gain */
208                 data[4] = 0;            /* reg 97, set fixed dark level */
209                 data[5] = 0;            /* reg 98, don't care */
210         } else {                        /* auto dark-gain */
211                 data[1] = 0;            /* reg 94, Y Gain (auto) */
212                 data[2] = 0;            /* reg 95, UV Gain (1.75) */
213                 data[3] = 0x78;         /* reg 96, Y Gain/UV Gain/disable
214                                          *      auto dark-gain */
215                 switch (gspca_dev->width) {
216 /*              case 1280: */
217 /*                      data[4] = 154;
218                                  * reg 97, %3 shadow point (unit: 256 pixel) */
219 /*                      data[5] = 51;
220                                  * reg 98, %1 highlight point
221                                  *      (uint: 256 pixel) */
222 /*                      break; */
223                 default:
224 /*              case 640: */
225                         data[4] = 36;   /* reg 97, %3 shadow point
226                                          *      (unit: 256 pixel) */
227                         data[5] = 12;   /* reg 98, %1 highlight point
228                                          *      (uint: 256 pixel) */
229                         break;
230                 case 320:
231                         data[4] = 9;    /* reg 97, %3 shadow point
232                                          *      (unit: 256 pixel) */
233                         data[5] = 3;    /* reg 98, %1 highlight point
234                                          *      (uint: 256 pixel) */
235                         break;
236                 }
237         }
238         /* auto dark-gain */
239         data[0] = 0x5e;         /* address */
240
241         err_code = reg_w(gspca_dev, data[0], 6);
242         if (err_code < 0)
243                 return;
244
245         data[0] = 0x67;
246         data[1] = 0x13;         /* reg 103, first pixel B, disable sharpness */
247         err_code = reg_w(gspca_dev, data[0], 2);
248         if (err_code < 0)
249                 return;
250
251         /*
252          * initialize the value of MI sensor...
253          */
254         MI_buf = kzalloc(ATTR_TOTAL_MI_REG * sizeof *MI_buf, GFP_KERNEL);
255         MI_buf[REG_HW_MI_1] = 0x000a;
256         MI_buf[REG_HW_MI_2] = 0x000c;
257         MI_buf[REG_HW_MI_3] = 0x0405;
258         MI_buf[REG_HW_MI_4] = 0x0507;
259         /* mi_Attr_Reg_[REG_HW_MI_5]     = 0x01ff;//13 */
260         MI_buf[REG_HW_MI_5] = 0x0013;   /* 13 */
261         MI_buf[REG_HW_MI_6] = 0x001f;   /* vertical blanking */
262         /* mi_Attr_Reg_[REG_HW_MI_6]     = 0x0400;  // vertical blanking */
263         MI_buf[REG_HW_MI_7] = 0x0002;
264         /* mi_Attr_Reg_[REG_HW_MI_9]     = 0x015f; */
265         /* mi_Attr_Reg_[REG_HW_MI_9]     = 0x030f; */
266         MI_buf[REG_HW_MI_9] = 0x0374;
267         MI_buf[REG_HW_MI_B] = 0x0000;
268         MI_buf[REG_HW_MI_C] = 0x0000;
269         MI_buf[REG_HW_MI_D] = 0x0000;
270         MI_buf[REG_HW_MI_1E] = 0x8000;
271 /* mi_Attr_Reg_[REG_HW_MI_20]     = 0x1104; */
272         MI_buf[REG_HW_MI_20] = 0x1104;  /* 0x111c; */
273         MI_buf[REG_HW_MI_2B] = 0x0008;
274 /* mi_Attr_Reg_[REG_HW_MI_2C]     = 0x000f; */
275         MI_buf[REG_HW_MI_2C] = 0x001f;  /* lita suggest */
276         MI_buf[REG_HW_MI_2D] = 0x0008;
277         MI_buf[REG_HW_MI_2E] = 0x0008;
278         MI_buf[REG_HW_MI_35] = 0x0051;
279         MI_buf[REG_HW_MI_5F] = 0x0904;  /* fail to write */
280         MI_buf[REG_HW_MI_60] = 0x0000;
281         MI_buf[REG_HW_MI_61] = 0x0000;
282         MI_buf[REG_HW_MI_62] = 0x0498;
283         MI_buf[REG_HW_MI_63] = 0x0000;
284         MI_buf[REG_HW_MI_64] = 0x0000;
285         MI_buf[REG_HW_MI_F1] = 0x0001;
286         /* changing while setting up the different value of dx/dy */
287
288         if (gspca_dev->width != 1280) {
289                 MI_buf[0x01] = 0x010a;
290                 MI_buf[0x02] = 0x014c;
291                 MI_buf[0x03] = 0x01e5;
292                 MI_buf[0x04] = 0x0287;
293         }
294         MI_buf[0x20] = 0x1104;
295
296         bulk_w(gspca_dev, MI_buf + 1, 1);
297         bulk_w(gspca_dev, MI_buf + 2, 2);
298         bulk_w(gspca_dev, MI_buf + 3, 3);
299         bulk_w(gspca_dev, MI_buf + 4, 4);
300         bulk_w(gspca_dev, MI_buf + 5, 5);
301         bulk_w(gspca_dev, MI_buf + 6, 6);
302         bulk_w(gspca_dev, MI_buf + 7, 7);
303         bulk_w(gspca_dev, MI_buf + 9, 9);
304         bulk_w(gspca_dev, MI_buf + 0x0b, 0x0b);
305         bulk_w(gspca_dev, MI_buf + 0x0c, 0x0c);
306         bulk_w(gspca_dev, MI_buf + 0x0d, 0x0d);
307         bulk_w(gspca_dev, MI_buf + 0x1e, 0x1e);
308         bulk_w(gspca_dev, MI_buf + 0x20, 0x20);
309         bulk_w(gspca_dev, MI_buf + 0x2b, 0x2b);
310         bulk_w(gspca_dev, MI_buf + 0x2c, 0x2c);
311         bulk_w(gspca_dev, MI_buf + 0x2d, 0x2d);
312         bulk_w(gspca_dev, MI_buf + 0x2e, 0x2e);
313         bulk_w(gspca_dev, MI_buf + 0x35, 0x35);
314         bulk_w(gspca_dev, MI_buf + 0x5f, 0x5f);
315         bulk_w(gspca_dev, MI_buf + 0x60, 0x60);
316         bulk_w(gspca_dev, MI_buf + 0x61, 0x61);
317         bulk_w(gspca_dev, MI_buf + 0x62, 0x62);
318         bulk_w(gspca_dev, MI_buf + 0x63, 0x63);
319         bulk_w(gspca_dev, MI_buf + 0x64, 0x64);
320         bulk_w(gspca_dev, MI_buf + 0xf1, 0xf1);
321         kfree(MI_buf);
322
323         intpipe = usb_sndintpipe(gspca_dev->dev, 0);
324         err_code = usb_clear_halt(gspca_dev->dev, intpipe);
325
326         data[0] = 0x00;
327         data[1] = 0x4d;         /* ISOC transfering enable... */
328         reg_w(gspca_dev, data[0], 2);
329 }
330
331 static void sd_stopN(struct gspca_dev *gspca_dev)
332 {
333         int result;
334
335         gspca_dev->usb_buf[0] = 1;
336         gspca_dev->usb_buf[1] = 0;
337         result = reg_w(gspca_dev, gspca_dev->usb_buf[0], 2);
338         if (result < 0)
339                 PDEBUG(D_ERR, "Camera Stop failed");
340 }
341
342 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
343                         struct gspca_frame *frame,      /* target */
344                         __u8 *data,                     /* isoc packet */
345                         int len)                        /* iso packet length */
346 {
347         struct sd *sd = (struct sd *) gspca_dev;
348         int p;
349
350         if (len < 6) {
351 /*              gspca_dev->last_packet_type = DISCARD_PACKET; */
352                 return;
353         }
354         for (p = 0; p < len - 6; p++) {
355                 if (data[0 + p] == 0xff
356                     && data[1 + p] == 0xff
357                     && data[2 + p] == 0x00
358                     && data[3 + p] == 0xff
359                     && data[4 + p] == 0x96) {
360                         if (data[5 + p] == 0x64
361                             || data[5 + p] == 0x65
362                             || data[5 + p] == 0x66
363                             || data[5 + p] == 0x67) {
364                                 PDEBUG(D_PACK, "sof offset: %d leng: %d",
365                                         p, len);
366                                 frame = gspca_frame_add(gspca_dev, LAST_PACKET,
367                                                         frame, data, 0);
368
369                                 /* put the JPEG header */
370                                 jpeg_put_header(gspca_dev, frame,
371                                                 sd->qindex, 0x21);
372                                 data += 16;
373                                 len -= 16;
374                                 break;
375                         }
376                 }
377         }
378         gspca_frame_add(gspca_dev, INTER_PACKET, frame, data, len);
379 }
380
381 /* sub-driver description */
382 static const struct sd_desc sd_desc = {
383         .name = MODULE_NAME,
384         .ctrls = sd_ctrls,
385         .nctrls = ARRAY_SIZE(sd_ctrls),
386         .config = sd_config,
387         .init = sd_init,
388         .start = sd_start,
389         .stopN = sd_stopN,
390         .pkt_scan = sd_pkt_scan,
391 };
392
393 /* -- module initialisation -- */
394 static const __devinitdata struct usb_device_id device_table[] = {
395         {USB_DEVICE(0x093a, 0x050f)},
396         {}
397 };
398 MODULE_DEVICE_TABLE(usb, device_table);
399
400 /* -- device connect -- */
401 static int sd_probe(struct usb_interface *intf,
402                         const struct usb_device_id *id)
403 {
404         return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
405                                 THIS_MODULE);
406 }
407
408 static struct usb_driver sd_driver = {
409         .name = MODULE_NAME,
410         .id_table = device_table,
411         .probe = sd_probe,
412         .disconnect = gspca_disconnect,
413 #ifdef CONFIG_PM
414         .suspend = gspca_suspend,
415         .resume = gspca_resume,
416 #endif
417 };
418
419 /* -- module insert / remove -- */
420 static int __init sd_mod_init(void)
421 {
422         if (usb_register(&sd_driver) < 0)
423                 return -1;
424         PDEBUG(D_PROBE, "registered");
425         return 0;
426 }
427 static void __exit sd_mod_exit(void)
428 {
429         usb_deregister(&sd_driver);
430         PDEBUG(D_PROBE, "deregistered");
431 }
432
433 module_init(sd_mod_init);
434 module_exit(sd_mod_exit);