Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

Linux/drivers/media/usb/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 pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 23 
 24 #define MODULE_NAME "mars"
 25 
 26 #include "gspca.h"
 27 #include "jpeg.h"
 28 
 29 MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>");
 30 MODULE_DESCRIPTION("GSPCA/Mars USB Camera Driver");
 31 MODULE_LICENSE("GPL");
 32 
 33 #define QUALITY 50
 34 
 35 /* specific webcam descriptor */
 36 struct sd {
 37         struct gspca_dev gspca_dev;     /* !! must be the first item */
 38 
 39         struct v4l2_ctrl *brightness;
 40         struct v4l2_ctrl *saturation;
 41         struct v4l2_ctrl *sharpness;
 42         struct v4l2_ctrl *gamma;
 43         struct { /* illuminator control cluster */
 44                 struct v4l2_ctrl *illum_top;
 45                 struct v4l2_ctrl *illum_bottom;
 46         };
 47         u8 jpeg_hdr[JPEG_HDR_SZ];
 48 };
 49 
 50 /* V4L2 controls supported by the driver */
 51 static void setbrightness(struct gspca_dev *gspca_dev, s32 val);
 52 static void setcolors(struct gspca_dev *gspca_dev, s32 val);
 53 static void setgamma(struct gspca_dev *gspca_dev, s32 val);
 54 static void setsharpness(struct gspca_dev *gspca_dev, s32 val);
 55 
 56 static const struct v4l2_pix_format vga_mode[] = {
 57         {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
 58                 .bytesperline = 320,
 59                 .sizeimage = 320 * 240 * 3 / 8 + 590,
 60                 .colorspace = V4L2_COLORSPACE_JPEG,
 61                 .priv = 2},
 62         {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE,
 63                 .bytesperline = 640,
 64                 .sizeimage = 640 * 480 * 3 / 8 + 590,
 65                 .colorspace = V4L2_COLORSPACE_JPEG,
 66                 .priv = 1},
 67 };
 68 
 69 static const __u8 mi_data[0x20] = {
 70 /*       01    02   03     04    05    06    07    08 */
 71         0x48, 0x22, 0x01, 0x47, 0x10, 0x00, 0x00, 0x00,
 72 /*       09    0a   0b     0c    0d    0e    0f    10 */
 73         0x00, 0x01, 0x30, 0x01, 0x30, 0x01, 0x30, 0x01,
 74 /*       11    12   13     14    15    16    17    18 */
 75         0x30, 0x00, 0x04, 0x00, 0x06, 0x01, 0xe2, 0x02,
 76 /*       19    1a   1b     1c    1d    1e    1f    20 */
 77         0x82, 0x00, 0x20, 0x17, 0x80, 0x08, 0x0c, 0x00
 78 };
 79 
 80 /* write <len> bytes from gspca_dev->usb_buf */
 81 static void reg_w(struct gspca_dev *gspca_dev,
 82                  int len)
 83 {
 84         int alen, ret;
 85 
 86         if (gspca_dev->usb_err < 0)
 87                 return;
 88 
 89         ret = usb_bulk_msg(gspca_dev->dev,
 90                         usb_sndbulkpipe(gspca_dev->dev, 4),
 91                         gspca_dev->usb_buf,
 92                         len,
 93                         &alen,
 94                         500);   /* timeout in milliseconds */
 95         if (ret < 0) {
 96                 pr_err("reg write [%02x] error %d\n",
 97                        gspca_dev->usb_buf[0], ret);
 98                 gspca_dev->usb_err = ret;
 99         }
100 }
101 
102 static void mi_w(struct gspca_dev *gspca_dev,
103                  u8 addr,
104                  u8 value)
105 {
106         gspca_dev->usb_buf[0] = 0x1f;
107         gspca_dev->usb_buf[1] = 0;                      /* control byte */
108         gspca_dev->usb_buf[2] = addr;
109         gspca_dev->usb_buf[3] = value;
110 
111         reg_w(gspca_dev, 4);
112 }
113 
114 static void setbrightness(struct gspca_dev *gspca_dev, s32 val)
115 {
116         gspca_dev->usb_buf[0] = 0x61;
117         gspca_dev->usb_buf[1] = val;
118         reg_w(gspca_dev, 2);
119 }
120 
121 static void setcolors(struct gspca_dev *gspca_dev, s32 val)
122 {
123         gspca_dev->usb_buf[0] = 0x5f;
124         gspca_dev->usb_buf[1] = val << 3;
125         gspca_dev->usb_buf[2] = ((val >> 2) & 0xf8) | 0x04;
126         reg_w(gspca_dev, 3);
127 }
128 
129 static void setgamma(struct gspca_dev *gspca_dev, s32 val)
130 {
131         gspca_dev->usb_buf[0] = 0x06;
132         gspca_dev->usb_buf[1] = val * 0x40;
133         reg_w(gspca_dev, 2);
134 }
135 
136 static void setsharpness(struct gspca_dev *gspca_dev, s32 val)
137 {
138         gspca_dev->usb_buf[0] = 0x67;
139         gspca_dev->usb_buf[1] = val * 4 + 3;
140         reg_w(gspca_dev, 2);
141 }
142 
143 static void setilluminators(struct gspca_dev *gspca_dev, bool top, bool bottom)
144 {
145         /* both are off if not streaming */
146         gspca_dev->usb_buf[0] = 0x22;
147         if (top)
148                 gspca_dev->usb_buf[1] = 0x76;
149         else if (bottom)
150                 gspca_dev->usb_buf[1] = 0x7a;
151         else
152                 gspca_dev->usb_buf[1] = 0x7e;
153         reg_w(gspca_dev, 2);
154 }
155 
156 static int mars_s_ctrl(struct v4l2_ctrl *ctrl)
157 {
158         struct gspca_dev *gspca_dev =
159                 container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
160         struct sd *sd = (struct sd *)gspca_dev;
161 
162         gspca_dev->usb_err = 0;
163 
164         if (ctrl->id == V4L2_CID_ILLUMINATORS_1) {
165                 /* only one can be on at a time */
166                 if (ctrl->is_new && ctrl->val)
167                         sd->illum_bottom->val = 0;
168                 if (sd->illum_bottom->is_new && sd->illum_bottom->val)
169                         sd->illum_top->val = 0;
170         }
171 
172         if (!gspca_dev->streaming)
173                 return 0;
174 
175         switch (ctrl->id) {
176         case V4L2_CID_BRIGHTNESS:
177                 setbrightness(gspca_dev, ctrl->val);
178                 break;
179         case V4L2_CID_SATURATION:
180                 setcolors(gspca_dev, ctrl->val);
181                 break;
182         case V4L2_CID_GAMMA:
183                 setgamma(gspca_dev, ctrl->val);
184                 break;
185         case V4L2_CID_ILLUMINATORS_1:
186                 setilluminators(gspca_dev, sd->illum_top->val,
187                                            sd->illum_bottom->val);
188                 break;
189         case V4L2_CID_SHARPNESS:
190                 setsharpness(gspca_dev, ctrl->val);
191                 break;
192         default:
193                 return -EINVAL;
194         }
195         return gspca_dev->usb_err;
196 }
197 
198 static const struct v4l2_ctrl_ops mars_ctrl_ops = {
199         .s_ctrl = mars_s_ctrl,
200 };
201 
202 /* this function is called at probe time */
203 static int sd_init_controls(struct gspca_dev *gspca_dev)
204 {
205         struct sd *sd = (struct sd *) gspca_dev;
206         struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
207 
208         gspca_dev->vdev.ctrl_handler = hdl;
209         v4l2_ctrl_handler_init(hdl, 6);
210         sd->brightness = v4l2_ctrl_new_std(hdl, &mars_ctrl_ops,
211                         V4L2_CID_BRIGHTNESS, 0, 30, 1, 15);
212         sd->saturation = v4l2_ctrl_new_std(hdl, &mars_ctrl_ops,
213                         V4L2_CID_SATURATION, 0, 255, 1, 200);
214         sd->gamma = v4l2_ctrl_new_std(hdl, &mars_ctrl_ops,
215                         V4L2_CID_GAMMA, 0, 3, 1, 1);
216         sd->sharpness = v4l2_ctrl_new_std(hdl, &mars_ctrl_ops,
217                         V4L2_CID_SHARPNESS, 0, 2, 1, 1);
218         sd->illum_top = v4l2_ctrl_new_std(hdl, &mars_ctrl_ops,
219                         V4L2_CID_ILLUMINATORS_1, 0, 1, 1, 0);
220         sd->illum_top->flags |= V4L2_CTRL_FLAG_UPDATE;
221         sd->illum_bottom = v4l2_ctrl_new_std(hdl, &mars_ctrl_ops,
222                         V4L2_CID_ILLUMINATORS_2, 0, 1, 1, 0);
223         sd->illum_bottom->flags |= V4L2_CTRL_FLAG_UPDATE;
224         if (hdl->error) {
225                 pr_err("Could not initialize controls\n");
226                 return hdl->error;
227         }
228         v4l2_ctrl_cluster(2, &sd->illum_top);
229         return 0;
230 }
231 
232 /* this function is called at probe time */
233 static int sd_config(struct gspca_dev *gspca_dev,
234                         const struct usb_device_id *id)
235 {
236         struct cam *cam;
237 
238         cam = &gspca_dev->cam;
239         cam->cam_mode = vga_mode;
240         cam->nmodes = ARRAY_SIZE(vga_mode);
241         return 0;
242 }
243 
244 /* this function is called at probe and resume time */
245 static int sd_init(struct gspca_dev *gspca_dev)
246 {
247         return 0;
248 }
249 
250 static int sd_start(struct gspca_dev *gspca_dev)
251 {
252         struct sd *sd = (struct sd *) gspca_dev;
253         u8 *data;
254         int i;
255 
256         /* create the JPEG header */
257         jpeg_define(sd->jpeg_hdr, gspca_dev->pixfmt.height,
258                         gspca_dev->pixfmt.width,
259                         0x21);          /* JPEG 422 */
260         jpeg_set_qual(sd->jpeg_hdr, QUALITY);
261 
262         data = gspca_dev->usb_buf;
263 
264         data[0] = 0x01;         /* address */
265         data[1] = 0x01;
266         reg_w(gspca_dev, 2);
267 
268         /*
269            Initialize the MR97113 chip register
270          */
271         data[0] = 0x00;         /* address */
272         data[1] = 0x0c | 0x01;  /* reg 0 */
273         data[2] = 0x01;         /* reg 1 */
274         data[3] = gspca_dev->pixfmt.width / 8;  /* h_size , reg 2 */
275         data[4] = gspca_dev->pixfmt.height / 8; /* v_size , reg 3 */
276         data[5] = 0x30;         /* reg 4, MI, PAS5101 :
277                                  *      0x30 for 24mhz , 0x28 for 12mhz */
278         data[6] = 0x02;         /* reg 5, H start - was 0x04 */
279         data[7] = v4l2_ctrl_g_ctrl(sd->gamma) * 0x40;   /* reg 0x06: gamma */
280         data[8] = 0x01;         /* reg 7, V start - was 0x03 */
281 /*      if (h_size == 320 ) */
282 /*              data[9]= 0x56;   * reg 8, 24MHz, 2:1 scale down */
283 /*      else */
284         data[9] = 0x52;         /* reg 8, 24MHz, no scale down */
285 /*jfm: from win trace*/
286         data[10] = 0x18;
287 
288         reg_w(gspca_dev, 11);
289 
290         data[0] = 0x23;         /* address */
291         data[1] = 0x09;         /* reg 35, append frame header */
292 
293         reg_w(gspca_dev, 2);
294 
295         data[0] = 0x3c;         /* address */
296 /*      if (gspca_dev->width == 1280) */
297 /*              data[1] = 200;   * reg 60, pc-cam frame size
298                                  *      (unit: 4KB) 800KB */
299 /*      else */
300         data[1] = 50;           /* 50 reg 60, pc-cam frame size
301                                  *      (unit: 4KB) 200KB */
302         reg_w(gspca_dev, 2);
303 
304         /* auto dark-gain */
305         data[0] = 0x5e;         /* address */
306         data[1] = 0;            /* reg 94, Y Gain (auto) */
307 /*jfm: from win trace*/
308                                 /* reg 0x5f/0x60 (LE) = saturation */
309                                 /* h (60): xxxx x100
310                                  * l (5f): xxxx x000 */
311         data[2] = v4l2_ctrl_g_ctrl(sd->saturation) << 3;
312         data[3] = ((v4l2_ctrl_g_ctrl(sd->saturation) >> 2) & 0xf8) | 0x04;
313         data[4] = v4l2_ctrl_g_ctrl(sd->brightness); /* reg 0x61 = brightness */
314         data[5] = 0x00;
315 
316         reg_w(gspca_dev, 6);
317 
318         data[0] = 0x67;
319 /*jfm: from win trace*/
320         data[1] = v4l2_ctrl_g_ctrl(sd->sharpness) * 4 + 3;
321         data[2] = 0x14;
322         reg_w(gspca_dev, 3);
323 
324         data[0] = 0x69;
325         data[1] = 0x2f;
326         data[2] = 0x28;
327         data[3] = 0x42;
328         reg_w(gspca_dev, 4);
329 
330         data[0] = 0x63;
331         data[1] = 0x07;
332         reg_w(gspca_dev, 2);
333 /*jfm: win trace - many writes here to reg 0x64*/
334 
335         /* initialize the MI sensor */
336         for (i = 0; i < sizeof mi_data; i++)
337                 mi_w(gspca_dev, i + 1, mi_data[i]);
338 
339         data[0] = 0x00;
340         data[1] = 0x4d;         /* ISOC transferring enable... */
341         reg_w(gspca_dev, 2);
342 
343         setilluminators(gspca_dev, v4l2_ctrl_g_ctrl(sd->illum_top),
344                                    v4l2_ctrl_g_ctrl(sd->illum_bottom));
345 
346         return gspca_dev->usb_err;
347 }
348 
349 static void sd_stopN(struct gspca_dev *gspca_dev)
350 {
351         struct sd *sd = (struct sd *) gspca_dev;
352 
353         if (v4l2_ctrl_g_ctrl(sd->illum_top) ||
354             v4l2_ctrl_g_ctrl(sd->illum_bottom)) {
355                 setilluminators(gspca_dev, false, false);
356                 msleep(20);
357         }
358 
359         gspca_dev->usb_buf[0] = 1;
360         gspca_dev->usb_buf[1] = 0;
361         reg_w(gspca_dev, 2);
362 }
363 
364 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
365                         u8 *data,                       /* isoc packet */
366                         int len)                        /* iso packet length */
367 {
368         struct sd *sd = (struct sd *) gspca_dev;
369         int p;
370 
371         if (len < 6) {
372 /*              gspca_dev->last_packet_type = DISCARD_PACKET; */
373                 return;
374         }
375         for (p = 0; p < len - 6; p++) {
376                 if (data[0 + p] == 0xff
377                     && data[1 + p] == 0xff
378                     && data[2 + p] == 0x00
379                     && data[3 + p] == 0xff
380                     && data[4 + p] == 0x96) {
381                         if (data[5 + p] == 0x64
382                             || data[5 + p] == 0x65
383                             || data[5 + p] == 0x66
384                             || data[5 + p] == 0x67) {
385                                 PDEBUG(D_PACK, "sof offset: %d len: %d",
386                                         p, len);
387                                 gspca_frame_add(gspca_dev, LAST_PACKET,
388                                                 data, p);
389 
390                                 /* put the JPEG header */
391                                 gspca_frame_add(gspca_dev, FIRST_PACKET,
392                                         sd->jpeg_hdr, JPEG_HDR_SZ);
393                                 data += p + 16;
394                                 len -= p + 16;
395                                 break;
396                         }
397                 }
398         }
399         gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
400 }
401 
402 /* sub-driver description */
403 static const struct sd_desc sd_desc = {
404         .name = MODULE_NAME,
405         .config = sd_config,
406         .init = sd_init,
407         .init_controls = sd_init_controls,
408         .start = sd_start,
409         .stopN = sd_stopN,
410         .pkt_scan = sd_pkt_scan,
411 };
412 
413 /* -- module initialisation -- */
414 static const struct usb_device_id device_table[] = {
415         {USB_DEVICE(0x093a, 0x050f)},
416         {}
417 };
418 MODULE_DEVICE_TABLE(usb, device_table);
419 
420 /* -- device connect -- */
421 static int sd_probe(struct usb_interface *intf,
422                         const struct usb_device_id *id)
423 {
424         return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
425                                 THIS_MODULE);
426 }
427 
428 static struct usb_driver sd_driver = {
429         .name = MODULE_NAME,
430         .id_table = device_table,
431         .probe = sd_probe,
432         .disconnect = gspca_disconnect,
433 #ifdef CONFIG_PM
434         .suspend = gspca_suspend,
435         .resume = gspca_resume,
436         .reset_resume = gspca_resume,
437 #endif
438 };
439 
440 module_usb_driver(sd_driver);
441 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us