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