1 /* 2 * T613 subdriver 3 * 4 * Copyright (C) 2010 Jean-Francois Moine (http://moinejf.free.fr) 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * any later version. 10 * 11 * This program is distributed in the hope that it will be useful, 12 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * GNU General Public License for more details. 15 * 16 * You should have received a copy of the GNU General Public License 17 * along with this program; if not, write to the Free Software 18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 19 * 20 *Notes: * t613 + tas5130A 21 * * Focus to light do not balance well as in win. 22 * Quality in win is not good, but its kinda better. 23 * * Fix some "extraneous bytes", most of apps will show the image anyway 24 * * Gamma table, is there, but its really doing something? 25 * * 7~8 Fps, its ok, max on win its 10. 26 * Costantino Leandro 27 */ 28 29 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 30 31 #define MODULE_NAME "t613" 32 33 #include <linux/input.h> 34 #include <linux/slab.h> 35 #include "gspca.h" 36 37 MODULE_AUTHOR("Leandro Costantino <le_costantino@pixartargentina.com.ar>"); 38 MODULE_DESCRIPTION("GSPCA/T613 (JPEG Compliance) USB Camera Driver"); 39 MODULE_LICENSE("GPL"); 40 41 struct sd { 42 struct gspca_dev gspca_dev; /* !! must be the first item */ 43 struct v4l2_ctrl *freq; 44 struct { /* awb / color gains control cluster */ 45 struct v4l2_ctrl *awb; 46 struct v4l2_ctrl *gain; 47 struct v4l2_ctrl *red_balance; 48 struct v4l2_ctrl *blue_balance; 49 }; 50 51 u8 sensor; 52 u8 button_pressed; 53 }; 54 enum sensors { 55 SENSOR_OM6802, 56 SENSOR_OTHER, 57 SENSOR_TAS5130A, 58 SENSOR_LT168G, /* must verify if this is the actual model */ 59 }; 60 61 static const struct v4l2_pix_format vga_mode_t16[] = { 62 {160, 120, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, 63 .bytesperline = 160, 64 .sizeimage = 160 * 120 * 4 / 8 + 590, 65 .colorspace = V4L2_COLORSPACE_JPEG, 66 .priv = 4}, 67 #if 0 /* HDG: broken with my test cam, so lets disable it */ 68 {176, 144, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, 69 .bytesperline = 176, 70 .sizeimage = 176 * 144 * 3 / 8 + 590, 71 .colorspace = V4L2_COLORSPACE_JPEG, 72 .priv = 3}, 73 #endif 74 {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, 75 .bytesperline = 320, 76 .sizeimage = 320 * 240 * 3 / 8 + 590, 77 .colorspace = V4L2_COLORSPACE_JPEG, 78 .priv = 2}, 79 #if 0 /* HDG: broken with my test cam, so lets disable it */ 80 {352, 288, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, 81 .bytesperline = 352, 82 .sizeimage = 352 * 288 * 3 / 8 + 590, 83 .colorspace = V4L2_COLORSPACE_JPEG, 84 .priv = 1}, 85 #endif 86 {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, 87 .bytesperline = 640, 88 .sizeimage = 640 * 480 * 3 / 8 + 590, 89 .colorspace = V4L2_COLORSPACE_JPEG, 90 .priv = 0}, 91 }; 92 93 /* sensor specific data */ 94 struct additional_sensor_data { 95 const u8 n3[6]; 96 const u8 *n4, n4sz; 97 const u8 reg80, reg8e; 98 const u8 nset8[6]; 99 const u8 data1[10]; 100 const u8 data2[9]; 101 const u8 data3[9]; 102 const u8 data5[6]; 103 const u8 stream[4]; 104 }; 105 106 static const u8 n4_om6802[] = { 107 0x09, 0x01, 0x12, 0x04, 0x66, 0x8a, 0x80, 0x3c, 108 0x81, 0x22, 0x84, 0x50, 0x8a, 0x78, 0x8b, 0x68, 109 0x8c, 0x88, 0x8e, 0x33, 0x8f, 0x24, 0xaa, 0xb1, 110 0xa2, 0x60, 0xa5, 0x30, 0xa6, 0x3a, 0xa8, 0xe8, 111 0xae, 0x05, 0xb1, 0x00, 0xbb, 0x04, 0xbc, 0x48, 112 0xbe, 0x36, 0xc6, 0x88, 0xe9, 0x00, 0xc5, 0xc0, 113 0x65, 0x0a, 0xbb, 0x86, 0xaf, 0x58, 0xb0, 0x68, 114 0x87, 0x40, 0x89, 0x2b, 0x8d, 0xff, 0x83, 0x40, 115 0xac, 0x84, 0xad, 0x86, 0xaf, 0x46 116 }; 117 static const u8 n4_other[] = { 118 0x66, 0x00, 0x7f, 0x00, 0x80, 0xac, 0x81, 0x69, 119 0x84, 0x40, 0x85, 0x70, 0x86, 0x20, 0x8a, 0x68, 120 0x8b, 0x58, 0x8c, 0x88, 0x8d, 0xff, 0x8e, 0xb8, 121 0x8f, 0x28, 0xa2, 0x60, 0xa5, 0x40, 0xa8, 0xa8, 122 0xac, 0x84, 0xad, 0x84, 0xae, 0x24, 0xaf, 0x56, 123 0xb0, 0x68, 0xb1, 0x00, 0xb2, 0x88, 0xbb, 0xc5, 124 0xbc, 0x4a, 0xbe, 0x36, 0xc2, 0x88, 0xc5, 0xc0, 125 0xc6, 0xda, 0xe9, 0x26, 0xeb, 0x00 126 }; 127 static const u8 n4_tas5130a[] = { 128 0x80, 0x3c, 0x81, 0x68, 0x83, 0xa0, 0x84, 0x20, 129 0x8a, 0x68, 0x8b, 0x58, 0x8c, 0x88, 0x8e, 0xb4, 130 0x8f, 0x24, 0xa1, 0xb1, 0xa2, 0x30, 0xa5, 0x10, 131 0xa6, 0x4a, 0xae, 0x03, 0xb1, 0x44, 0xb2, 0x08, 132 0xb7, 0x06, 0xb9, 0xe7, 0xbb, 0xc4, 0xbc, 0x4a, 133 0xbe, 0x36, 0xbf, 0xff, 0xc2, 0x88, 0xc5, 0xc8, 134 0xc6, 0xda 135 }; 136 static const u8 n4_lt168g[] = { 137 0x66, 0x01, 0x7f, 0x00, 0x80, 0x7c, 0x81, 0x28, 138 0x83, 0x44, 0x84, 0x20, 0x86, 0x20, 0x8a, 0x70, 139 0x8b, 0x58, 0x8c, 0x88, 0x8d, 0xa0, 0x8e, 0xb3, 140 0x8f, 0x24, 0xa1, 0xb0, 0xa2, 0x38, 0xa5, 0x20, 141 0xa6, 0x4a, 0xa8, 0xe8, 0xaf, 0x38, 0xb0, 0x68, 142 0xb1, 0x44, 0xb2, 0x88, 0xbb, 0x86, 0xbd, 0x40, 143 0xbe, 0x26, 0xc1, 0x05, 0xc2, 0x88, 0xc5, 0xc0, 144 0xda, 0x8e, 0xdb, 0xca, 0xdc, 0xa8, 0xdd, 0x8c, 145 0xde, 0x44, 0xdf, 0x0c, 0xe9, 0x80 146 }; 147 148 static const struct additional_sensor_data sensor_data[] = { 149 [SENSOR_OM6802] = { 150 .n3 = 151 {0x61, 0x68, 0x65, 0x0a, 0x60, 0x04}, 152 .n4 = n4_om6802, 153 .n4sz = sizeof n4_om6802, 154 .reg80 = 0x3c, 155 .reg8e = 0x33, 156 .nset8 = {0xa8, 0xf0, 0xc6, 0x88, 0xc0, 0x00}, 157 .data1 = 158 {0xc2, 0x28, 0x0f, 0x22, 0xcd, 0x27, 0x2c, 0x06, 159 0xb3, 0xfc}, 160 .data2 = 161 {0x80, 0xff, 0xff, 0x80, 0xff, 0xff, 0x80, 0xff, 162 0xff}, 163 .data3 = 164 {0x80, 0xff, 0xff, 0x80, 0xff, 0xff, 0x80, 0xff, 165 0xff}, 166 .data5 = /* this could be removed later */ 167 {0x0c, 0x03, 0xab, 0x13, 0x81, 0x23}, 168 .stream = 169 {0x0b, 0x04, 0x0a, 0x78}, 170 }, 171 [SENSOR_OTHER] = { 172 .n3 = 173 {0x61, 0xc2, 0x65, 0x88, 0x60, 0x00}, 174 .n4 = n4_other, 175 .n4sz = sizeof n4_other, 176 .reg80 = 0xac, 177 .reg8e = 0xb8, 178 .nset8 = {0xa8, 0xa8, 0xc6, 0xda, 0xc0, 0x00}, 179 .data1 = 180 {0xc1, 0x48, 0x04, 0x1b, 0xca, 0x2e, 0x33, 0x3a, 181 0xe8, 0xfc}, 182 .data2 = 183 {0x4e, 0x9c, 0xec, 0x40, 0x80, 0xc0, 0x48, 0x96, 184 0xd9}, 185 .data3 = 186 {0x4e, 0x9c, 0xec, 0x40, 0x80, 0xc0, 0x48, 0x96, 187 0xd9}, 188 .data5 = 189 {0x0c, 0x03, 0xab, 0x29, 0x81, 0x69}, 190 .stream = 191 {0x0b, 0x04, 0x0a, 0x00}, 192 }, 193 [SENSOR_TAS5130A] = { 194 .n3 = 195 {0x61, 0xc2, 0x65, 0x0d, 0x60, 0x08}, 196 .n4 = n4_tas5130a, 197 .n4sz = sizeof n4_tas5130a, 198 .reg80 = 0x3c, 199 .reg8e = 0xb4, 200 .nset8 = {0xa8, 0xf0, 0xc6, 0xda, 0xc0, 0x00}, 201 .data1 = 202 {0xbb, 0x28, 0x10, 0x10, 0xbb, 0x28, 0x1e, 0x27, 203 0xc8, 0xfc}, 204 .data2 = 205 {0x60, 0xa8, 0xe0, 0x60, 0xa8, 0xe0, 0x60, 0xa8, 206 0xe0}, 207 .data3 = 208 {0x60, 0xa8, 0xe0, 0x60, 0xa8, 0xe0, 0x60, 0xa8, 209 0xe0}, 210 .data5 = 211 {0x0c, 0x03, 0xab, 0x10, 0x81, 0x20}, 212 .stream = 213 {0x0b, 0x04, 0x0a, 0x40}, 214 }, 215 [SENSOR_LT168G] = { 216 .n3 = {0x61, 0xc2, 0x65, 0x68, 0x60, 0x00}, 217 .n4 = n4_lt168g, 218 .n4sz = sizeof n4_lt168g, 219 .reg80 = 0x7c, 220 .reg8e = 0xb3, 221 .nset8 = {0xa8, 0xf0, 0xc6, 0xba, 0xc0, 0x00}, 222 .data1 = {0xc0, 0x38, 0x08, 0x10, 0xc0, 0x30, 0x10, 0x40, 223 0xb0, 0xf4}, 224 .data2 = {0x40, 0x80, 0xc0, 0x50, 0xa0, 0xf0, 0x53, 0xa6, 225 0xff}, 226 .data3 = {0x40, 0x80, 0xc0, 0x50, 0xa0, 0xf0, 0x53, 0xa6, 227 0xff}, 228 .data5 = {0x0c, 0x03, 0xab, 0x4b, 0x81, 0x2b}, 229 .stream = {0x0b, 0x04, 0x0a, 0x28}, 230 }, 231 }; 232 233 #define MAX_EFFECTS 7 234 static const u8 effects_table[MAX_EFFECTS][6] = { 235 {0xa8, 0xe8, 0xc6, 0xd2, 0xc0, 0x00}, /* Normal */ 236 {0xa8, 0xc8, 0xc6, 0x52, 0xc0, 0x04}, /* Repujar */ 237 {0xa8, 0xe8, 0xc6, 0xd2, 0xc0, 0x20}, /* Monochrome */ 238 {0xa8, 0xe8, 0xc6, 0xd2, 0xc0, 0x80}, /* Sepia */ 239 {0xa8, 0xc8, 0xc6, 0x52, 0xc0, 0x02}, /* Croquis */ 240 {0xa8, 0xc8, 0xc6, 0xd2, 0xc0, 0x10}, /* Sun Effect */ 241 {0xa8, 0xc8, 0xc6, 0xd2, 0xc0, 0x40}, /* Negative */ 242 }; 243 244 #define GAMMA_MAX (15) 245 static const u8 gamma_table[GAMMA_MAX+1][17] = { 246 /* gamma table from cam1690.ini */ 247 {0x00, 0x00, 0x01, 0x04, 0x08, 0x0e, 0x16, 0x21, /* 0 */ 248 0x2e, 0x3d, 0x50, 0x65, 0x7d, 0x99, 0xb8, 0xdb, 249 0xff}, 250 {0x00, 0x01, 0x03, 0x08, 0x0e, 0x16, 0x21, 0x2d, /* 1 */ 251 0x3c, 0x4d, 0x60, 0x75, 0x8d, 0xa6, 0xc2, 0xe1, 252 0xff}, 253 {0x00, 0x01, 0x05, 0x0b, 0x12, 0x1c, 0x28, 0x35, /* 2 */ 254 0x45, 0x56, 0x69, 0x7e, 0x95, 0xad, 0xc7, 0xe3, 255 0xff}, 256 {0x00, 0x02, 0x07, 0x0f, 0x18, 0x24, 0x30, 0x3f, /* 3 */ 257 0x4f, 0x61, 0x73, 0x88, 0x9d, 0xb4, 0xcd, 0xe6, 258 0xff}, 259 {0x00, 0x04, 0x0b, 0x15, 0x20, 0x2d, 0x3b, 0x4a, /* 4 */ 260 0x5b, 0x6c, 0x7f, 0x92, 0xa7, 0xbc, 0xd2, 0xe9, 261 0xff}, 262 {0x00, 0x07, 0x11, 0x15, 0x20, 0x2d, 0x48, 0x58, /* 5 */ 263 0x68, 0x79, 0x8b, 0x9d, 0xb0, 0xc4, 0xd7, 0xec, 264 0xff}, 265 {0x00, 0x0c, 0x1a, 0x29, 0x38, 0x47, 0x57, 0x67, /* 6 */ 266 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 267 0xff}, 268 {0x00, 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, /* 7 */ 269 0x80, 0x90, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0, 0xf0, 270 0xff}, 271 {0x00, 0x15, 0x27, 0x38, 0x49, 0x59, 0x69, 0x79, /* 8 */ 272 0x88, 0x97, 0xa7, 0xb6, 0xc4, 0xd3, 0xe2, 0xf0, 273 0xff}, 274 {0x00, 0x1c, 0x30, 0x43, 0x54, 0x65, 0x75, 0x84, /* 9 */ 275 0x93, 0xa1, 0xb0, 0xbd, 0xca, 0xd8, 0xe5, 0xf2, 276 0xff}, 277 {0x00, 0x24, 0x3b, 0x4f, 0x60, 0x70, 0x80, 0x8e, /* 10 */ 278 0x9c, 0xaa, 0xb7, 0xc4, 0xd0, 0xdc, 0xe8, 0xf3, 279 0xff}, 280 {0x00, 0x2a, 0x3c, 0x5d, 0x6e, 0x7e, 0x8d, 0x9b, /* 11 */ 281 0xa8, 0xb4, 0xc0, 0xcb, 0xd6, 0xe1, 0xeb, 0xf5, 282 0xff}, 283 {0x00, 0x3f, 0x5a, 0x6e, 0x7f, 0x8e, 0x9c, 0xa8, /* 12 */ 284 0xb4, 0xbf, 0xc9, 0xd3, 0xdc, 0xe5, 0xee, 0xf6, 285 0xff}, 286 {0x00, 0x54, 0x6f, 0x83, 0x93, 0xa0, 0xad, 0xb7, /* 13 */ 287 0xc2, 0xcb, 0xd4, 0xdc, 0xe4, 0xeb, 0xf2, 0xf9, 288 0xff}, 289 {0x00, 0x6e, 0x88, 0x9a, 0xa8, 0xb3, 0xbd, 0xc6, /* 14 */ 290 0xcf, 0xd6, 0xdd, 0xe3, 0xe9, 0xef, 0xf4, 0xfa, 291 0xff}, 292 {0x00, 0x93, 0xa8, 0xb7, 0xc1, 0xca, 0xd2, 0xd8, /* 15 */ 293 0xde, 0xe3, 0xe8, 0xed, 0xf1, 0xf5, 0xf8, 0xfc, 294 0xff} 295 }; 296 297 static const u8 tas5130a_sensor_init[][8] = { 298 {0x62, 0x08, 0x63, 0x70, 0x64, 0x1d, 0x60, 0x09}, 299 {0x62, 0x20, 0x63, 0x01, 0x64, 0x02, 0x60, 0x09}, 300 {0x62, 0x07, 0x63, 0x03, 0x64, 0x00, 0x60, 0x09}, 301 }; 302 303 static u8 sensor_reset[] = {0x61, 0x68, 0x62, 0xff, 0x60, 0x07}; 304 305 /* read 1 byte */ 306 static u8 reg_r(struct gspca_dev *gspca_dev, 307 u16 index) 308 { 309 usb_control_msg(gspca_dev->dev, 310 usb_rcvctrlpipe(gspca_dev->dev, 0), 311 0, /* request */ 312 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 313 0, /* value */ 314 index, 315 gspca_dev->usb_buf, 1, 500); 316 return gspca_dev->usb_buf[0]; 317 } 318 319 static void reg_w(struct gspca_dev *gspca_dev, 320 u16 index) 321 { 322 usb_control_msg(gspca_dev->dev, 323 usb_sndctrlpipe(gspca_dev->dev, 0), 324 0, 325 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 326 0, index, 327 NULL, 0, 500); 328 } 329 330 static void reg_w_buf(struct gspca_dev *gspca_dev, 331 const u8 *buffer, u16 len) 332 { 333 if (len <= USB_BUF_SZ) { 334 memcpy(gspca_dev->usb_buf, buffer, len); 335 usb_control_msg(gspca_dev->dev, 336 usb_sndctrlpipe(gspca_dev->dev, 0), 337 0, 338 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 339 0x01, 0, 340 gspca_dev->usb_buf, len, 500); 341 } else { 342 u8 *tmpbuf; 343 344 tmpbuf = kmemdup(buffer, len, GFP_KERNEL); 345 if (!tmpbuf) { 346 pr_err("Out of memory\n"); 347 return; 348 } 349 usb_control_msg(gspca_dev->dev, 350 usb_sndctrlpipe(gspca_dev->dev, 0), 351 0, 352 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 353 0x01, 0, 354 tmpbuf, len, 500); 355 kfree(tmpbuf); 356 } 357 } 358 359 /* write values to consecutive registers */ 360 static void reg_w_ixbuf(struct gspca_dev *gspca_dev, 361 u8 reg, 362 const u8 *buffer, u16 len) 363 { 364 int i; 365 u8 *p, *tmpbuf; 366 367 if (len * 2 <= USB_BUF_SZ) { 368 p = tmpbuf = gspca_dev->usb_buf; 369 } else { 370 p = tmpbuf = kmalloc(len * 2, GFP_KERNEL); 371 if (!tmpbuf) { 372 pr_err("Out of memory\n"); 373 return; 374 } 375 } 376 i = len; 377 while (--i >= 0) { 378 *p++ = reg++; 379 *p++ = *buffer++; 380 } 381 usb_control_msg(gspca_dev->dev, 382 usb_sndctrlpipe(gspca_dev->dev, 0), 383 0, 384 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 385 0x01, 0, 386 tmpbuf, len * 2, 500); 387 if (len * 2 > USB_BUF_SZ) 388 kfree(tmpbuf); 389 } 390 391 static void om6802_sensor_init(struct gspca_dev *gspca_dev) 392 { 393 int i; 394 const u8 *p; 395 u8 byte; 396 u8 val[6] = {0x62, 0, 0x64, 0, 0x60, 0x05}; 397 static const u8 sensor_init[] = { 398 0xdf, 0x6d, 399 0xdd, 0x18, 400 0x5a, 0xe0, 401 0x5c, 0x07, 402 0x5d, 0xb0, 403 0x5e, 0x1e, 404 0x60, 0x71, 405 0xef, 0x00, 406 0xe9, 0x00, 407 0xea, 0x00, 408 0x90, 0x24, 409 0x91, 0xb2, 410 0x82, 0x32, 411 0xfd, 0x41, 412 0x00 /* table end */ 413 }; 414 415 reg_w_buf(gspca_dev, sensor_reset, sizeof sensor_reset); 416 msleep(100); 417 i = 4; 418 while (--i > 0) { 419 byte = reg_r(gspca_dev, 0x0060); 420 if (!(byte & 0x01)) 421 break; 422 msleep(100); 423 } 424 byte = reg_r(gspca_dev, 0x0063); 425 if (byte != 0x17) { 426 pr_err("Bad sensor reset %02x\n", byte); 427 /* continue? */ 428 } 429 430 p = sensor_init; 431 while (*p != 0) { 432 val[1] = *p++; 433 val[3] = *p++; 434 if (*p == 0) 435 reg_w(gspca_dev, 0x3c80); 436 reg_w_buf(gspca_dev, val, sizeof val); 437 i = 4; 438 while (--i >= 0) { 439 msleep(15); 440 byte = reg_r(gspca_dev, 0x60); 441 if (!(byte & 0x01)) 442 break; 443 } 444 } 445 msleep(15); 446 reg_w(gspca_dev, 0x3c80); 447 } 448 449 /* this function is called at probe time */ 450 static int sd_config(struct gspca_dev *gspca_dev, 451 const struct usb_device_id *id) 452 { 453 struct cam *cam = &gspca_dev->cam; 454 455 cam->cam_mode = vga_mode_t16; 456 cam->nmodes = ARRAY_SIZE(vga_mode_t16); 457 458 return 0; 459 } 460 461 static void setbrightness(struct gspca_dev *gspca_dev, s32 brightness) 462 { 463 u8 set6[4] = { 0x8f, 0x24, 0xc3, 0x00 }; 464 465 if (brightness < 7) { 466 set6[1] = 0x26; 467 set6[3] = 0x70 - brightness * 0x10; 468 } else { 469 set6[3] = 0x00 + ((brightness - 7) * 0x10); 470 } 471 472 reg_w_buf(gspca_dev, set6, sizeof set6); 473 } 474 475 static void setcontrast(struct gspca_dev *gspca_dev, s32 contrast) 476 { 477 u16 reg_to_write; 478 479 if (contrast < 7) 480 reg_to_write = 0x8ea9 - contrast * 0x200; 481 else 482 reg_to_write = 0x00a9 + (contrast - 7) * 0x200; 483 484 reg_w(gspca_dev, reg_to_write); 485 } 486 487 static void setcolors(struct gspca_dev *gspca_dev, s32 val) 488 { 489 u16 reg_to_write; 490 491 reg_to_write = 0x80bb + val * 0x100; /* was 0xc0 */ 492 reg_w(gspca_dev, reg_to_write); 493 } 494 495 static void setgamma(struct gspca_dev *gspca_dev, s32 val) 496 { 497 PDEBUG(D_CONF, "Gamma: %d", val); 498 reg_w_ixbuf(gspca_dev, 0x90, 499 gamma_table[val], sizeof gamma_table[0]); 500 } 501 502 static void setawb_n_RGB(struct gspca_dev *gspca_dev) 503 { 504 struct sd *sd = (struct sd *) gspca_dev; 505 u8 all_gain_reg[8] = { 506 0x87, 0x00, 0x88, 0x00, 0x89, 0x00, 0x80, 0x00 }; 507 s32 red_gain, blue_gain, green_gain; 508 509 green_gain = sd->gain->val; 510 511 red_gain = green_gain + sd->red_balance->val; 512 if (red_gain > 0x40) 513 red_gain = 0x40; 514 else if (red_gain < 0x10) 515 red_gain = 0x10; 516 517 blue_gain = green_gain + sd->blue_balance->val; 518 if (blue_gain > 0x40) 519 blue_gain = 0x40; 520 else if (blue_gain < 0x10) 521 blue_gain = 0x10; 522 523 all_gain_reg[1] = red_gain; 524 all_gain_reg[3] = blue_gain; 525 all_gain_reg[5] = green_gain; 526 all_gain_reg[7] = sensor_data[sd->sensor].reg80; 527 if (!sd->awb->val) 528 all_gain_reg[7] &= ~0x04; /* AWB off */ 529 530 reg_w_buf(gspca_dev, all_gain_reg, sizeof all_gain_reg); 531 } 532 533 static void setsharpness(struct gspca_dev *gspca_dev, s32 val) 534 { 535 u16 reg_to_write; 536 537 reg_to_write = 0x0aa6 + 0x1000 * val; 538 539 reg_w(gspca_dev, reg_to_write); 540 } 541 542 static void setfreq(struct gspca_dev *gspca_dev, s32 val) 543 { 544 struct sd *sd = (struct sd *) gspca_dev; 545 u8 reg66; 546 u8 freq[4] = { 0x66, 0x00, 0xa8, 0xe8 }; 547 548 switch (sd->sensor) { 549 case SENSOR_LT168G: 550 if (val != 0) 551 freq[3] = 0xa8; 552 reg66 = 0x41; 553 break; 554 case SENSOR_OM6802: 555 reg66 = 0xca; 556 break; 557 default: 558 reg66 = 0x40; 559 break; 560 } 561 switch (val) { 562 case 0: /* no flicker */ 563 freq[3] = 0xf0; 564 break; 565 case 2: /* 60Hz */ 566 reg66 &= ~0x40; 567 break; 568 } 569 freq[1] = reg66; 570 571 reg_w_buf(gspca_dev, freq, sizeof freq); 572 } 573 574 /* this function is called at probe and resume time */ 575 static int sd_init(struct gspca_dev *gspca_dev) 576 { 577 /* some of this registers are not really neded, because 578 * they are overriden by setbrigthness, setcontrast, etc, 579 * but wont hurt anyway, and can help someone with similar webcam 580 * to see the initial parameters.*/ 581 struct sd *sd = (struct sd *) gspca_dev; 582 const struct additional_sensor_data *sensor; 583 int i; 584 u16 sensor_id; 585 u8 test_byte = 0; 586 587 static const u8 read_indexs[] = 588 { 0x0a, 0x0b, 0x66, 0x80, 0x81, 0x8e, 0x8f, 0xa5, 589 0xa6, 0xa8, 0xbb, 0xbc, 0xc6, 0x00 }; 590 static const u8 n1[] = 591 {0x08, 0x03, 0x09, 0x03, 0x12, 0x04}; 592 static const u8 n2[] = 593 {0x08, 0x00}; 594 595 sensor_id = (reg_r(gspca_dev, 0x06) << 8) 596 | reg_r(gspca_dev, 0x07); 597 switch (sensor_id & 0xff0f) { 598 case 0x0801: 599 PDEBUG(D_PROBE, "sensor tas5130a"); 600 sd->sensor = SENSOR_TAS5130A; 601 break; 602 case 0x0802: 603 PDEBUG(D_PROBE, "sensor lt168g"); 604 sd->sensor = SENSOR_LT168G; 605 break; 606 case 0x0803: 607 PDEBUG(D_PROBE, "sensor 'other'"); 608 sd->sensor = SENSOR_OTHER; 609 break; 610 case 0x0807: 611 PDEBUG(D_PROBE, "sensor om6802"); 612 sd->sensor = SENSOR_OM6802; 613 break; 614 default: 615 pr_err("unknown sensor %04x\n", sensor_id); 616 return -EINVAL; 617 } 618 619 if (sd->sensor == SENSOR_OM6802) { 620 reg_w_buf(gspca_dev, n1, sizeof n1); 621 i = 5; 622 while (--i >= 0) { 623 reg_w_buf(gspca_dev, sensor_reset, sizeof sensor_reset); 624 test_byte = reg_r(gspca_dev, 0x0063); 625 msleep(100); 626 if (test_byte == 0x17) 627 break; /* OK */ 628 } 629 if (i < 0) { 630 pr_err("Bad sensor reset %02x\n", test_byte); 631 return -EIO; 632 } 633 reg_w_buf(gspca_dev, n2, sizeof n2); 634 } 635 636 i = 0; 637 while (read_indexs[i] != 0x00) { 638 test_byte = reg_r(gspca_dev, read_indexs[i]); 639 PDEBUG(D_STREAM, "Reg 0x%02x = 0x%02x", read_indexs[i], 640 test_byte); 641 i++; 642 } 643 644 sensor = &sensor_data[sd->sensor]; 645 reg_w_buf(gspca_dev, sensor->n3, sizeof sensor->n3); 646 reg_w_buf(gspca_dev, sensor->n4, sensor->n4sz); 647 648 if (sd->sensor == SENSOR_LT168G) { 649 test_byte = reg_r(gspca_dev, 0x80); 650 PDEBUG(D_STREAM, "Reg 0x%02x = 0x%02x", 0x80, 651 test_byte); 652 reg_w(gspca_dev, 0x6c80); 653 } 654 655 reg_w_ixbuf(gspca_dev, 0xd0, sensor->data1, sizeof sensor->data1); 656 reg_w_ixbuf(gspca_dev, 0xc7, sensor->data2, sizeof sensor->data2); 657 reg_w_ixbuf(gspca_dev, 0xe0, sensor->data3, sizeof sensor->data3); 658 659 reg_w(gspca_dev, (sensor->reg80 << 8) + 0x80); 660 reg_w(gspca_dev, (sensor->reg80 << 8) + 0x80); 661 reg_w(gspca_dev, (sensor->reg8e << 8) + 0x8e); 662 reg_w(gspca_dev, (0x20 << 8) + 0x87); 663 reg_w(gspca_dev, (0x20 << 8) + 0x88); 664 reg_w(gspca_dev, (0x20 << 8) + 0x89); 665 666 reg_w_buf(gspca_dev, sensor->data5, sizeof sensor->data5); 667 reg_w_buf(gspca_dev, sensor->nset8, sizeof sensor->nset8); 668 reg_w_buf(gspca_dev, sensor->stream, sizeof sensor->stream); 669 670 if (sd->sensor == SENSOR_LT168G) { 671 test_byte = reg_r(gspca_dev, 0x80); 672 PDEBUG(D_STREAM, "Reg 0x%02x = 0x%02x", 0x80, 673 test_byte); 674 reg_w(gspca_dev, 0x6c80); 675 } 676 677 reg_w_ixbuf(gspca_dev, 0xd0, sensor->data1, sizeof sensor->data1); 678 reg_w_ixbuf(gspca_dev, 0xc7, sensor->data2, sizeof sensor->data2); 679 reg_w_ixbuf(gspca_dev, 0xe0, sensor->data3, sizeof sensor->data3); 680 681 return 0; 682 } 683 684 static void setmirror(struct gspca_dev *gspca_dev, s32 val) 685 { 686 u8 hflipcmd[8] = 687 {0x62, 0x07, 0x63, 0x03, 0x64, 0x00, 0x60, 0x09}; 688 689 if (val) 690 hflipcmd[3] = 0x01; 691 692 reg_w_buf(gspca_dev, hflipcmd, sizeof hflipcmd); 693 } 694 695 static void seteffect(struct gspca_dev *gspca_dev, s32 val) 696 { 697 int idx = 0; 698 699 switch (val) { 700 case V4L2_COLORFX_NONE: 701 break; 702 case V4L2_COLORFX_BW: 703 idx = 2; 704 break; 705 case V4L2_COLORFX_SEPIA: 706 idx = 3; 707 break; 708 case V4L2_COLORFX_SKETCH: 709 idx = 4; 710 break; 711 case V4L2_COLORFX_NEGATIVE: 712 idx = 6; 713 break; 714 default: 715 break; 716 } 717 718 reg_w_buf(gspca_dev, effects_table[idx], 719 sizeof effects_table[0]); 720 721 if (val == V4L2_COLORFX_SKETCH) 722 reg_w(gspca_dev, 0x4aa6); 723 else 724 reg_w(gspca_dev, 0xfaa6); 725 } 726 727 /* Is this really needed? 728 * i added some module parameters for test with some users */ 729 static void poll_sensor(struct gspca_dev *gspca_dev) 730 { 731 static const u8 poll1[] = 732 {0x67, 0x05, 0x68, 0x81, 0x69, 0x80, 0x6a, 0x82, 733 0x6b, 0x68, 0x6c, 0x69, 0x72, 0xd9, 0x73, 0x34, 734 0x74, 0x32, 0x75, 0x92, 0x76, 0x00, 0x09, 0x01, 735 0x60, 0x14}; 736 static const u8 poll2[] = 737 {0x67, 0x02, 0x68, 0x71, 0x69, 0x72, 0x72, 0xa9, 738 0x73, 0x02, 0x73, 0x02, 0x60, 0x14}; 739 static const u8 noise03[] = /* (some differences / ms-drv) */ 740 {0xa6, 0x0a, 0xea, 0xcf, 0xbe, 0x26, 0xb1, 0x5f, 741 0xa1, 0xb1, 0xda, 0x6b, 0xdb, 0x98, 0xdf, 0x0c, 742 0xc2, 0x80, 0xc3, 0x10}; 743 744 PDEBUG(D_STREAM, "[Sensor requires polling]"); 745 reg_w_buf(gspca_dev, poll1, sizeof poll1); 746 reg_w_buf(gspca_dev, poll2, sizeof poll2); 747 reg_w_buf(gspca_dev, noise03, sizeof noise03); 748 } 749 750 static int sd_start(struct gspca_dev *gspca_dev) 751 { 752 struct sd *sd = (struct sd *) gspca_dev; 753 const struct additional_sensor_data *sensor; 754 int i, mode; 755 u8 t2[] = { 0x07, 0x00, 0x0d, 0x60, 0x0e, 0x80 }; 756 static const u8 t3[] = 757 { 0x07, 0x00, 0x88, 0x02, 0x06, 0x00, 0xe7, 0x01 }; 758 759 mode = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv; 760 switch (mode) { 761 case 0: /* 640x480 (0x00) */ 762 break; 763 case 1: /* 352x288 */ 764 t2[1] = 0x40; 765 break; 766 case 2: /* 320x240 */ 767 t2[1] = 0x10; 768 break; 769 case 3: /* 176x144 */ 770 t2[1] = 0x50; 771 break; 772 default: 773 /* case 4: * 160x120 */ 774 t2[1] = 0x20; 775 break; 776 } 777 778 switch (sd->sensor) { 779 case SENSOR_OM6802: 780 om6802_sensor_init(gspca_dev); 781 break; 782 case SENSOR_TAS5130A: 783 i = 0; 784 for (;;) { 785 reg_w_buf(gspca_dev, tas5130a_sensor_init[i], 786 sizeof tas5130a_sensor_init[0]); 787 if (i >= ARRAY_SIZE(tas5130a_sensor_init) - 1) 788 break; 789 i++; 790 } 791 reg_w(gspca_dev, 0x3c80); 792 /* just in case and to keep sync with logs (for mine) */ 793 reg_w_buf(gspca_dev, tas5130a_sensor_init[i], 794 sizeof tas5130a_sensor_init[0]); 795 reg_w(gspca_dev, 0x3c80); 796 break; 797 } 798 sensor = &sensor_data[sd->sensor]; 799 setfreq(gspca_dev, v4l2_ctrl_g_ctrl(sd->freq)); 800 reg_r(gspca_dev, 0x0012); 801 reg_w_buf(gspca_dev, t2, sizeof t2); 802 reg_w_ixbuf(gspca_dev, 0xb3, t3, sizeof t3); 803 reg_w(gspca_dev, 0x0013); 804 msleep(15); 805 reg_w_buf(gspca_dev, sensor->stream, sizeof sensor->stream); 806 reg_w_buf(gspca_dev, sensor->stream, sizeof sensor->stream); 807 808 if (sd->sensor == SENSOR_OM6802) 809 poll_sensor(gspca_dev); 810 811 return 0; 812 } 813 814 static void sd_stopN(struct gspca_dev *gspca_dev) 815 { 816 struct sd *sd = (struct sd *) gspca_dev; 817 818 reg_w_buf(gspca_dev, sensor_data[sd->sensor].stream, 819 sizeof sensor_data[sd->sensor].stream); 820 reg_w_buf(gspca_dev, sensor_data[sd->sensor].stream, 821 sizeof sensor_data[sd->sensor].stream); 822 if (sd->sensor == SENSOR_OM6802) { 823 msleep(20); 824 reg_w(gspca_dev, 0x0309); 825 } 826 #if IS_ENABLED(CONFIG_INPUT) 827 /* If the last button state is pressed, release it now! */ 828 if (sd->button_pressed) { 829 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0); 830 input_sync(gspca_dev->input_dev); 831 sd->button_pressed = 0; 832 } 833 #endif 834 } 835 836 static void sd_pkt_scan(struct gspca_dev *gspca_dev, 837 u8 *data, /* isoc packet */ 838 int len) /* iso packet length */ 839 { 840 struct sd *sd = (struct sd *) gspca_dev; 841 int pkt_type; 842 843 if (data[0] == 0x5a) { 844 #if IS_ENABLED(CONFIG_INPUT) 845 if (len > 20) { 846 u8 state = (data[20] & 0x80) ? 1 : 0; 847 if (sd->button_pressed != state) { 848 input_report_key(gspca_dev->input_dev, 849 KEY_CAMERA, state); 850 input_sync(gspca_dev->input_dev); 851 sd->button_pressed = state; 852 } 853 } 854 #endif 855 /* Control Packet, after this came the header again, 856 * but extra bytes came in the packet before this, 857 * sometimes an EOF arrives, sometimes not... */ 858 return; 859 } 860 data += 2; 861 len -= 2; 862 if (data[0] == 0xff && data[1] == 0xd8) 863 pkt_type = FIRST_PACKET; 864 else if (data[len - 2] == 0xff && data[len - 1] == 0xd9) 865 pkt_type = LAST_PACKET; 866 else 867 pkt_type = INTER_PACKET; 868 gspca_frame_add(gspca_dev, pkt_type, data, len); 869 } 870 871 static int sd_g_volatile_ctrl(struct v4l2_ctrl *ctrl) 872 { 873 struct gspca_dev *gspca_dev = 874 container_of(ctrl->handler, struct gspca_dev, ctrl_handler); 875 struct sd *sd = (struct sd *)gspca_dev; 876 s32 red_gain, blue_gain, green_gain; 877 878 gspca_dev->usb_err = 0; 879 880 switch (ctrl->id) { 881 case V4L2_CID_AUTO_WHITE_BALANCE: 882 red_gain = reg_r(gspca_dev, 0x0087); 883 if (red_gain > 0x40) 884 red_gain = 0x40; 885 else if (red_gain < 0x10) 886 red_gain = 0x10; 887 888 blue_gain = reg_r(gspca_dev, 0x0088); 889 if (blue_gain > 0x40) 890 blue_gain = 0x40; 891 else if (blue_gain < 0x10) 892 blue_gain = 0x10; 893 894 green_gain = reg_r(gspca_dev, 0x0089); 895 if (green_gain > 0x40) 896 green_gain = 0x40; 897 else if (green_gain < 0x10) 898 green_gain = 0x10; 899 900 sd->gain->val = green_gain; 901 sd->red_balance->val = red_gain - green_gain; 902 sd->blue_balance->val = blue_gain - green_gain; 903 break; 904 } 905 return 0; 906 } 907 908 static int sd_s_ctrl(struct v4l2_ctrl *ctrl) 909 { 910 struct gspca_dev *gspca_dev = 911 container_of(ctrl->handler, struct gspca_dev, ctrl_handler); 912 913 gspca_dev->usb_err = 0; 914 915 if (!gspca_dev->streaming) 916 return 0; 917 918 switch (ctrl->id) { 919 case V4L2_CID_BRIGHTNESS: 920 setbrightness(gspca_dev, ctrl->val); 921 break; 922 case V4L2_CID_CONTRAST: 923 setcontrast(gspca_dev, ctrl->val); 924 break; 925 case V4L2_CID_SATURATION: 926 setcolors(gspca_dev, ctrl->val); 927 break; 928 case V4L2_CID_GAMMA: 929 setgamma(gspca_dev, ctrl->val); 930 break; 931 case V4L2_CID_HFLIP: 932 setmirror(gspca_dev, ctrl->val); 933 break; 934 case V4L2_CID_SHARPNESS: 935 setsharpness(gspca_dev, ctrl->val); 936 break; 937 case V4L2_CID_POWER_LINE_FREQUENCY: 938 setfreq(gspca_dev, ctrl->val); 939 break; 940 case V4L2_CID_BACKLIGHT_COMPENSATION: 941 reg_w(gspca_dev, ctrl->val ? 0xf48e : 0xb48e); 942 break; 943 case V4L2_CID_AUTO_WHITE_BALANCE: 944 setawb_n_RGB(gspca_dev); 945 break; 946 case V4L2_CID_COLORFX: 947 seteffect(gspca_dev, ctrl->val); 948 break; 949 } 950 return gspca_dev->usb_err; 951 } 952 953 static const struct v4l2_ctrl_ops sd_ctrl_ops = { 954 .g_volatile_ctrl = sd_g_volatile_ctrl, 955 .s_ctrl = sd_s_ctrl, 956 }; 957 958 static int sd_init_controls(struct gspca_dev *gspca_dev) 959 { 960 struct sd *sd = (struct sd *)gspca_dev; 961 struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler; 962 963 gspca_dev->vdev.ctrl_handler = hdl; 964 v4l2_ctrl_handler_init(hdl, 12); 965 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 966 V4L2_CID_BRIGHTNESS, 0, 14, 1, 8); 967 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 968 V4L2_CID_CONTRAST, 0, 0x0d, 1, 7); 969 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 970 V4L2_CID_SATURATION, 0, 0xf, 1, 5); 971 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 972 V4L2_CID_GAMMA, 0, GAMMA_MAX, 1, 10); 973 /* Activate lowlight, some apps dont bring up the 974 backlight_compensation control) */ 975 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 976 V4L2_CID_BACKLIGHT_COMPENSATION, 0, 1, 1, 1); 977 if (sd->sensor == SENSOR_TAS5130A) 978 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 979 V4L2_CID_HFLIP, 0, 1, 1, 0); 980 sd->awb = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 981 V4L2_CID_AUTO_WHITE_BALANCE, 0, 1, 1, 1); 982 sd->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 983 V4L2_CID_GAIN, 0x10, 0x40, 1, 0x20); 984 sd->blue_balance = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 985 V4L2_CID_BLUE_BALANCE, -0x30, 0x30, 1, 0); 986 sd->red_balance = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 987 V4L2_CID_RED_BALANCE, -0x30, 0x30, 1, 0); 988 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 989 V4L2_CID_SHARPNESS, 0, 15, 1, 6); 990 v4l2_ctrl_new_std_menu(hdl, &sd_ctrl_ops, 991 V4L2_CID_COLORFX, V4L2_COLORFX_SKETCH, 992 ~((1 << V4L2_COLORFX_NONE) | 993 (1 << V4L2_COLORFX_BW) | 994 (1 << V4L2_COLORFX_SEPIA) | 995 (1 << V4L2_COLORFX_SKETCH) | 996 (1 << V4L2_COLORFX_NEGATIVE)), 997 V4L2_COLORFX_NONE); 998 sd->freq = v4l2_ctrl_new_std_menu(hdl, &sd_ctrl_ops, 999 V4L2_CID_POWER_LINE_FREQUENCY, 1000 V4L2_CID_POWER_LINE_FREQUENCY_60HZ, 1, 1001 V4L2_CID_POWER_LINE_FREQUENCY_50HZ); 1002 1003 if (hdl->error) { 1004 pr_err("Could not initialize controls\n"); 1005 return hdl->error; 1006 } 1007 1008 v4l2_ctrl_auto_cluster(4, &sd->awb, 0, true); 1009 1010 return 0; 1011 } 1012 1013 /* sub-driver description */ 1014 static const struct sd_desc sd_desc = { 1015 .name = MODULE_NAME, 1016 .config = sd_config, 1017 .init = sd_init, 1018 .init_controls = sd_init_controls, 1019 .start = sd_start, 1020 .stopN = sd_stopN, 1021 .pkt_scan = sd_pkt_scan, 1022 #if IS_ENABLED(CONFIG_INPUT) 1023 .other_input = 1, 1024 #endif 1025 }; 1026 1027 /* -- module initialisation -- */ 1028 static const struct usb_device_id device_table[] = { 1029 {USB_DEVICE(0x17a1, 0x0128)}, 1030 {} 1031 }; 1032 MODULE_DEVICE_TABLE(usb, device_table); 1033 1034 /* -- device connect -- */ 1035 static int sd_probe(struct usb_interface *intf, 1036 const struct usb_device_id *id) 1037 { 1038 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd), 1039 THIS_MODULE); 1040 } 1041 1042 static struct usb_driver sd_driver = { 1043 .name = MODULE_NAME, 1044 .id_table = device_table, 1045 .probe = sd_probe, 1046 .disconnect = gspca_disconnect, 1047 #ifdef CONFIG_PM 1048 .suspend = gspca_suspend, 1049 .resume = gspca_resume, 1050 .reset_resume = gspca_resume, 1051 #endif 1052 }; 1053 1054 module_usb_driver(sd_driver); 1055