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