1 /* 2 * Sunplus spca504(abc) spca533 spca536 library 3 * Copyright (C) 2005 Michel Xhaard mxhaard@magic.fr 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 "sunplus" 25 26 #include "gspca.h" 27 #include "jpeg.h" 28 29 MODULE_AUTHOR("Michel Xhaard <mxhaard@users.sourceforge.net>"); 30 MODULE_DESCRIPTION("GSPCA/SPCA5xx USB Camera Driver"); 31 MODULE_LICENSE("GPL"); 32 33 #define QUALITY 85 34 35 /* specific webcam descriptor */ 36 struct sd { 37 struct gspca_dev gspca_dev; /* !! must be the first item */ 38 39 bool autogain; 40 41 u8 bridge; 42 #define BRIDGE_SPCA504 0 43 #define BRIDGE_SPCA504B 1 44 #define BRIDGE_SPCA504C 2 45 #define BRIDGE_SPCA533 3 46 #define BRIDGE_SPCA536 4 47 u8 subtype; 48 #define AiptekMiniPenCam13 1 49 #define LogitechClickSmart420 2 50 #define LogitechClickSmart820 3 51 #define MegapixV4 4 52 #define MegaImageVI 5 53 54 u8 jpeg_hdr[JPEG_HDR_SZ]; 55 }; 56 57 static const struct v4l2_pix_format vga_mode[] = { 58 {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, 59 .bytesperline = 320, 60 .sizeimage = 320 * 240 * 3 / 8 + 590, 61 .colorspace = V4L2_COLORSPACE_JPEG, 62 .priv = 2}, 63 {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, 64 .bytesperline = 640, 65 .sizeimage = 640 * 480 * 3 / 8 + 590, 66 .colorspace = V4L2_COLORSPACE_JPEG, 67 .priv = 1}, 68 }; 69 70 static const struct v4l2_pix_format custom_mode[] = { 71 {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, 72 .bytesperline = 320, 73 .sizeimage = 320 * 240 * 3 / 8 + 590, 74 .colorspace = V4L2_COLORSPACE_JPEG, 75 .priv = 2}, 76 {464, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, 77 .bytesperline = 464, 78 .sizeimage = 464 * 480 * 3 / 8 + 590, 79 .colorspace = V4L2_COLORSPACE_JPEG, 80 .priv = 1}, 81 }; 82 83 static const struct v4l2_pix_format vga_mode2[] = { 84 {176, 144, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, 85 .bytesperline = 176, 86 .sizeimage = 176 * 144 * 3 / 8 + 590, 87 .colorspace = V4L2_COLORSPACE_JPEG, 88 .priv = 4}, 89 {320, 240, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, 90 .bytesperline = 320, 91 .sizeimage = 320 * 240 * 3 / 8 + 590, 92 .colorspace = V4L2_COLORSPACE_JPEG, 93 .priv = 3}, 94 {352, 288, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, 95 .bytesperline = 352, 96 .sizeimage = 352 * 288 * 3 / 8 + 590, 97 .colorspace = V4L2_COLORSPACE_JPEG, 98 .priv = 2}, 99 {640, 480, V4L2_PIX_FMT_JPEG, V4L2_FIELD_NONE, 100 .bytesperline = 640, 101 .sizeimage = 640 * 480 * 3 / 8 + 590, 102 .colorspace = V4L2_COLORSPACE_JPEG, 103 .priv = 1}, 104 }; 105 106 #define SPCA50X_OFFSET_DATA 10 107 #define SPCA504_PCCAM600_OFFSET_SNAPSHOT 3 108 #define SPCA504_PCCAM600_OFFSET_COMPRESS 4 109 #define SPCA504_PCCAM600_OFFSET_MODE 5 110 #define SPCA504_PCCAM600_OFFSET_DATA 14 111 /* Frame packet header offsets for the spca533 */ 112 #define SPCA533_OFFSET_DATA 16 113 #define SPCA533_OFFSET_FRAMSEQ 15 114 /* Frame packet header offsets for the spca536 */ 115 #define SPCA536_OFFSET_DATA 4 116 #define SPCA536_OFFSET_FRAMSEQ 1 117 118 struct cmd { 119 u8 req; 120 u16 val; 121 u16 idx; 122 }; 123 124 /* Initialisation data for the Creative PC-CAM 600 */ 125 static const struct cmd spca504_pccam600_init_data[] = { 126 /* {0xa0, 0x0000, 0x0503}, * capture mode */ 127 {0x00, 0x0000, 0x2000}, 128 {0x00, 0x0013, 0x2301}, 129 {0x00, 0x0003, 0x2000}, 130 {0x00, 0x0001, 0x21ac}, 131 {0x00, 0x0001, 0x21a6}, 132 {0x00, 0x0000, 0x21a7}, /* brightness */ 133 {0x00, 0x0020, 0x21a8}, /* contrast */ 134 {0x00, 0x0001, 0x21ac}, /* sat/hue */ 135 {0x00, 0x0000, 0x21ad}, /* hue */ 136 {0x00, 0x001a, 0x21ae}, /* saturation */ 137 {0x00, 0x0002, 0x21a3}, /* gamma */ 138 {0x30, 0x0154, 0x0008}, 139 {0x30, 0x0004, 0x0006}, 140 {0x30, 0x0258, 0x0009}, 141 {0x30, 0x0004, 0x0000}, 142 {0x30, 0x0093, 0x0004}, 143 {0x30, 0x0066, 0x0005}, 144 {0x00, 0x0000, 0x2000}, 145 {0x00, 0x0013, 0x2301}, 146 {0x00, 0x0003, 0x2000}, 147 {0x00, 0x0013, 0x2301}, 148 {0x00, 0x0003, 0x2000}, 149 }; 150 151 /* Creative PC-CAM 600 specific open data, sent before using the 152 * generic initialisation data from spca504_open_data. 153 */ 154 static const struct cmd spca504_pccam600_open_data[] = { 155 {0x00, 0x0001, 0x2501}, 156 {0x20, 0x0500, 0x0001}, /* snapshot mode */ 157 {0x00, 0x0003, 0x2880}, 158 {0x00, 0x0001, 0x2881}, 159 }; 160 161 /* Initialisation data for the logitech clicksmart 420 */ 162 static const struct cmd spca504A_clicksmart420_init_data[] = { 163 /* {0xa0, 0x0000, 0x0503}, * capture mode */ 164 {0x00, 0x0000, 0x2000}, 165 {0x00, 0x0013, 0x2301}, 166 {0x00, 0x0003, 0x2000}, 167 {0x00, 0x0001, 0x21ac}, 168 {0x00, 0x0001, 0x21a6}, 169 {0x00, 0x0000, 0x21a7}, /* brightness */ 170 {0x00, 0x0020, 0x21a8}, /* contrast */ 171 {0x00, 0x0001, 0x21ac}, /* sat/hue */ 172 {0x00, 0x0000, 0x21ad}, /* hue */ 173 {0x00, 0x001a, 0x21ae}, /* saturation */ 174 {0x00, 0x0002, 0x21a3}, /* gamma */ 175 {0x30, 0x0004, 0x000a}, 176 {0xb0, 0x0001, 0x0000}, 177 178 {0xa1, 0x0080, 0x0001}, 179 {0x30, 0x0049, 0x0000}, 180 {0x30, 0x0060, 0x0005}, 181 {0x0c, 0x0004, 0x0000}, 182 {0x00, 0x0000, 0x0000}, 183 {0x00, 0x0000, 0x2000}, 184 {0x00, 0x0013, 0x2301}, 185 {0x00, 0x0003, 0x2000}, 186 }; 187 188 /* clicksmart 420 open data ? */ 189 static const struct cmd spca504A_clicksmart420_open_data[] = { 190 {0x00, 0x0001, 0x2501}, 191 {0x20, 0x0502, 0x0000}, 192 {0x06, 0x0000, 0x0000}, 193 {0x00, 0x0004, 0x2880}, 194 {0x00, 0x0001, 0x2881}, 195 196 {0xa0, 0x0000, 0x0503}, 197 }; 198 199 static const u8 qtable_creative_pccam[2][64] = { 200 { /* Q-table Y-components */ 201 0x05, 0x03, 0x03, 0x05, 0x07, 0x0c, 0x0f, 0x12, 202 0x04, 0x04, 0x04, 0x06, 0x08, 0x11, 0x12, 0x11, 203 0x04, 0x04, 0x05, 0x07, 0x0c, 0x11, 0x15, 0x11, 204 0x04, 0x05, 0x07, 0x09, 0x0f, 0x1a, 0x18, 0x13, 205 0x05, 0x07, 0x0b, 0x11, 0x14, 0x21, 0x1f, 0x17, 206 0x07, 0x0b, 0x11, 0x13, 0x18, 0x1f, 0x22, 0x1c, 207 0x0f, 0x13, 0x17, 0x1a, 0x1f, 0x24, 0x24, 0x1e, 208 0x16, 0x1c, 0x1d, 0x1d, 0x22, 0x1e, 0x1f, 0x1e}, 209 { /* Q-table C-components */ 210 0x05, 0x05, 0x07, 0x0e, 0x1e, 0x1e, 0x1e, 0x1e, 211 0x05, 0x06, 0x08, 0x14, 0x1e, 0x1e, 0x1e, 0x1e, 212 0x07, 0x08, 0x11, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 213 0x0e, 0x14, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 214 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 215 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 216 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 217 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e} 218 }; 219 220 /* FIXME: This Q-table is identical to the Creative PC-CAM one, 221 * except for one byte. Possibly a typo? 222 * NWG: 18/05/2003. 223 */ 224 static const u8 qtable_spca504_default[2][64] = { 225 { /* Q-table Y-components */ 226 0x05, 0x03, 0x03, 0x05, 0x07, 0x0c, 0x0f, 0x12, 227 0x04, 0x04, 0x04, 0x06, 0x08, 0x11, 0x12, 0x11, 228 0x04, 0x04, 0x05, 0x07, 0x0c, 0x11, 0x15, 0x11, 229 0x04, 0x05, 0x07, 0x09, 0x0f, 0x1a, 0x18, 0x13, 230 0x05, 0x07, 0x0b, 0x11, 0x14, 0x21, 0x1f, 0x17, 231 0x07, 0x0b, 0x11, 0x13, 0x18, 0x1f, 0x22, 0x1c, 232 0x0f, 0x13, 0x17, 0x1a, 0x1f, 0x24, 0x24, 0x1e, 233 0x16, 0x1c, 0x1d, 0x1d, 0x1d /* 0x22 */ , 0x1e, 0x1f, 0x1e, 234 }, 235 { /* Q-table C-components */ 236 0x05, 0x05, 0x07, 0x0e, 0x1e, 0x1e, 0x1e, 0x1e, 237 0x05, 0x06, 0x08, 0x14, 0x1e, 0x1e, 0x1e, 0x1e, 238 0x07, 0x08, 0x11, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 239 0x0e, 0x14, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 240 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 241 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 242 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 243 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e, 0x1e} 244 }; 245 246 /* read <len> bytes to gspca_dev->usb_buf */ 247 static void reg_r(struct gspca_dev *gspca_dev, 248 u8 req, 249 u16 index, 250 u16 len) 251 { 252 int ret; 253 254 #ifdef GSPCA_DEBUG 255 if (len > USB_BUF_SZ) { 256 pr_err("reg_r: buffer overflow\n"); 257 return; 258 } 259 #endif 260 if (gspca_dev->usb_err < 0) 261 return; 262 ret = usb_control_msg(gspca_dev->dev, 263 usb_rcvctrlpipe(gspca_dev->dev, 0), 264 req, 265 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 266 0, /* value */ 267 index, 268 len ? gspca_dev->usb_buf : NULL, len, 269 500); 270 if (ret < 0) { 271 pr_err("reg_r err %d\n", ret); 272 gspca_dev->usb_err = ret; 273 } 274 } 275 276 /* write one byte */ 277 static void reg_w_1(struct gspca_dev *gspca_dev, 278 u8 req, 279 u16 value, 280 u16 index, 281 u16 byte) 282 { 283 int ret; 284 285 if (gspca_dev->usb_err < 0) 286 return; 287 gspca_dev->usb_buf[0] = byte; 288 ret = usb_control_msg(gspca_dev->dev, 289 usb_sndctrlpipe(gspca_dev->dev, 0), 290 req, 291 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 292 value, index, 293 gspca_dev->usb_buf, 1, 294 500); 295 if (ret < 0) { 296 pr_err("reg_w_1 err %d\n", ret); 297 gspca_dev->usb_err = ret; 298 } 299 } 300 301 /* write req / index / value */ 302 static void reg_w_riv(struct gspca_dev *gspca_dev, 303 u8 req, u16 index, u16 value) 304 { 305 struct usb_device *dev = gspca_dev->dev; 306 int ret; 307 308 if (gspca_dev->usb_err < 0) 309 return; 310 ret = usb_control_msg(dev, 311 usb_sndctrlpipe(dev, 0), 312 req, 313 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE, 314 value, index, NULL, 0, 500); 315 if (ret < 0) { 316 pr_err("reg_w_riv err %d\n", ret); 317 gspca_dev->usb_err = ret; 318 return; 319 } 320 PDEBUG(D_USBO, "reg_w_riv: 0x%02x,0x%04x:0x%04x", 321 req, index, value); 322 } 323 324 static void write_vector(struct gspca_dev *gspca_dev, 325 const struct cmd *data, int ncmds) 326 { 327 while (--ncmds >= 0) { 328 reg_w_riv(gspca_dev, data->req, data->idx, data->val); 329 data++; 330 } 331 } 332 333 static void setup_qtable(struct gspca_dev *gspca_dev, 334 const u8 qtable[2][64]) 335 { 336 int i; 337 338 /* loop over y components */ 339 for (i = 0; i < 64; i++) 340 reg_w_riv(gspca_dev, 0x00, 0x2800 + i, qtable[0][i]); 341 342 /* loop over c components */ 343 for (i = 0; i < 64; i++) 344 reg_w_riv(gspca_dev, 0x00, 0x2840 + i, qtable[1][i]); 345 } 346 347 static void spca504_acknowledged_command(struct gspca_dev *gspca_dev, 348 u8 req, u16 idx, u16 val) 349 { 350 reg_w_riv(gspca_dev, req, idx, val); 351 reg_r(gspca_dev, 0x01, 0x0001, 1); 352 PDEBUG(D_FRAM, "before wait 0x%04x", gspca_dev->usb_buf[0]); 353 reg_w_riv(gspca_dev, req, idx, val); 354 355 msleep(200); 356 reg_r(gspca_dev, 0x01, 0x0001, 1); 357 PDEBUG(D_FRAM, "after wait 0x%04x", gspca_dev->usb_buf[0]); 358 } 359 360 #ifdef GSPCA_DEBUG 361 static void spca504_read_info(struct gspca_dev *gspca_dev) 362 { 363 int i; 364 u8 info[6]; 365 366 for (i = 0; i < 6; i++) { 367 reg_r(gspca_dev, 0, i, 1); 368 info[i] = gspca_dev->usb_buf[0]; 369 } 370 PDEBUG(D_STREAM, 371 "Read info: %d %d %d %d %d %d." 372 " Should be 1,0,2,2,0,0", 373 info[0], info[1], info[2], 374 info[3], info[4], info[5]); 375 } 376 #endif 377 378 static void spca504A_acknowledged_command(struct gspca_dev *gspca_dev, 379 u8 req, 380 u16 idx, u16 val, u8 endcode, u8 count) 381 { 382 u16 status; 383 384 reg_w_riv(gspca_dev, req, idx, val); 385 reg_r(gspca_dev, 0x01, 0x0001, 1); 386 if (gspca_dev->usb_err < 0) 387 return; 388 PDEBUG(D_FRAM, "Status 0x%02x Need 0x%02x", 389 gspca_dev->usb_buf[0], endcode); 390 if (!count) 391 return; 392 count = 200; 393 while (--count > 0) { 394 msleep(10); 395 /* gsmart mini2 write a each wait setting 1 ms is enough */ 396 /* reg_w_riv(gspca_dev, req, idx, val); */ 397 reg_r(gspca_dev, 0x01, 0x0001, 1); 398 status = gspca_dev->usb_buf[0]; 399 if (status == endcode) { 400 PDEBUG(D_FRAM, "status 0x%04x after wait %d", 401 status, 200 - count); 402 break; 403 } 404 } 405 } 406 407 static void spca504B_PollingDataReady(struct gspca_dev *gspca_dev) 408 { 409 int count = 10; 410 411 while (--count > 0) { 412 reg_r(gspca_dev, 0x21, 0, 1); 413 if ((gspca_dev->usb_buf[0] & 0x01) == 0) 414 break; 415 msleep(10); 416 } 417 } 418 419 static void spca504B_WaitCmdStatus(struct gspca_dev *gspca_dev) 420 { 421 int count = 50; 422 423 while (--count > 0) { 424 reg_r(gspca_dev, 0x21, 1, 1); 425 if (gspca_dev->usb_buf[0] != 0) { 426 reg_w_1(gspca_dev, 0x21, 0, 1, 0); 427 reg_r(gspca_dev, 0x21, 1, 1); 428 spca504B_PollingDataReady(gspca_dev); 429 break; 430 } 431 msleep(10); 432 } 433 } 434 435 #ifdef GSPCA_DEBUG 436 static void spca50x_GetFirmware(struct gspca_dev *gspca_dev) 437 { 438 u8 *data; 439 440 data = gspca_dev->usb_buf; 441 reg_r(gspca_dev, 0x20, 0, 5); 442 PDEBUG(D_STREAM, "FirmWare: %d %d %d %d %d", 443 data[0], data[1], data[2], data[3], data[4]); 444 reg_r(gspca_dev, 0x23, 0, 64); 445 reg_r(gspca_dev, 0x23, 1, 64); 446 } 447 #endif 448 449 static void spca504B_SetSizeType(struct gspca_dev *gspca_dev) 450 { 451 struct sd *sd = (struct sd *) gspca_dev; 452 u8 Size; 453 454 Size = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv; 455 switch (sd->bridge) { 456 case BRIDGE_SPCA533: 457 reg_w_riv(gspca_dev, 0x31, 0, 0); 458 spca504B_WaitCmdStatus(gspca_dev); 459 spca504B_PollingDataReady(gspca_dev); 460 #ifdef GSPCA_DEBUG 461 spca50x_GetFirmware(gspca_dev); 462 #endif 463 reg_w_1(gspca_dev, 0x24, 0, 8, 2); /* type */ 464 reg_r(gspca_dev, 0x24, 8, 1); 465 466 reg_w_1(gspca_dev, 0x25, 0, 4, Size); 467 reg_r(gspca_dev, 0x25, 4, 1); /* size */ 468 spca504B_PollingDataReady(gspca_dev); 469 470 /* Init the cam width height with some values get on init ? */ 471 reg_w_riv(gspca_dev, 0x31, 0x0004, 0x00); 472 spca504B_WaitCmdStatus(gspca_dev); 473 spca504B_PollingDataReady(gspca_dev); 474 break; 475 default: 476 /* case BRIDGE_SPCA504B: */ 477 /* case BRIDGE_SPCA536: */ 478 reg_w_1(gspca_dev, 0x25, 0, 4, Size); 479 reg_r(gspca_dev, 0x25, 4, 1); /* size */ 480 reg_w_1(gspca_dev, 0x27, 0, 0, 6); 481 reg_r(gspca_dev, 0x27, 0, 1); /* type */ 482 spca504B_PollingDataReady(gspca_dev); 483 break; 484 case BRIDGE_SPCA504: 485 Size += 3; 486 if (sd->subtype == AiptekMiniPenCam13) { 487 /* spca504a aiptek */ 488 spca504A_acknowledged_command(gspca_dev, 489 0x08, Size, 0, 490 0x80 | (Size & 0x0f), 1); 491 spca504A_acknowledged_command(gspca_dev, 492 1, 3, 0, 0x9f, 0); 493 } else { 494 spca504_acknowledged_command(gspca_dev, 0x08, Size, 0); 495 } 496 break; 497 case BRIDGE_SPCA504C: 498 /* capture mode */ 499 reg_w_riv(gspca_dev, 0xa0, (0x0500 | (Size & 0x0f)), 0x00); 500 reg_w_riv(gspca_dev, 0x20, 0x01, 0x0500 | (Size & 0x0f)); 501 break; 502 } 503 } 504 505 static void spca504_wait_status(struct gspca_dev *gspca_dev) 506 { 507 int cnt; 508 509 cnt = 256; 510 while (--cnt > 0) { 511 /* With this we get the status, when return 0 it's all ok */ 512 reg_r(gspca_dev, 0x06, 0x00, 1); 513 if (gspca_dev->usb_buf[0] == 0) 514 return; 515 msleep(10); 516 } 517 } 518 519 static void spca504B_setQtable(struct gspca_dev *gspca_dev) 520 { 521 reg_w_1(gspca_dev, 0x26, 0, 0, 3); 522 reg_r(gspca_dev, 0x26, 0, 1); 523 spca504B_PollingDataReady(gspca_dev); 524 } 525 526 static void setbrightness(struct gspca_dev *gspca_dev, s32 val) 527 { 528 struct sd *sd = (struct sd *) gspca_dev; 529 u16 reg; 530 531 reg = sd->bridge == BRIDGE_SPCA536 ? 0x20f0 : 0x21a7; 532 reg_w_riv(gspca_dev, 0x00, reg, val); 533 } 534 535 static void setcontrast(struct gspca_dev *gspca_dev, s32 val) 536 { 537 struct sd *sd = (struct sd *) gspca_dev; 538 u16 reg; 539 540 reg = sd->bridge == BRIDGE_SPCA536 ? 0x20f1 : 0x21a8; 541 reg_w_riv(gspca_dev, 0x00, reg, val); 542 } 543 544 static void setcolors(struct gspca_dev *gspca_dev, s32 val) 545 { 546 struct sd *sd = (struct sd *) gspca_dev; 547 u16 reg; 548 549 reg = sd->bridge == BRIDGE_SPCA536 ? 0x20f6 : 0x21ae; 550 reg_w_riv(gspca_dev, 0x00, reg, val); 551 } 552 553 static void init_ctl_reg(struct gspca_dev *gspca_dev) 554 { 555 struct sd *sd = (struct sd *) gspca_dev; 556 int pollreg = 1; 557 558 switch (sd->bridge) { 559 case BRIDGE_SPCA504: 560 case BRIDGE_SPCA504C: 561 pollreg = 0; 562 /* fall thru */ 563 default: 564 /* case BRIDGE_SPCA533: */ 565 /* case BRIDGE_SPCA504B: */ 566 reg_w_riv(gspca_dev, 0, 0x21ad, 0x00); /* hue */ 567 reg_w_riv(gspca_dev, 0, 0x21ac, 0x01); /* sat/hue */ 568 reg_w_riv(gspca_dev, 0, 0x21a3, 0x00); /* gamma */ 569 break; 570 case BRIDGE_SPCA536: 571 reg_w_riv(gspca_dev, 0, 0x20f5, 0x40); 572 reg_w_riv(gspca_dev, 0, 0x20f4, 0x01); 573 reg_w_riv(gspca_dev, 0, 0x2089, 0x00); 574 break; 575 } 576 if (pollreg) 577 spca504B_PollingDataReady(gspca_dev); 578 } 579 580 /* this function is called at probe time */ 581 static int sd_config(struct gspca_dev *gspca_dev, 582 const struct usb_device_id *id) 583 { 584 struct sd *sd = (struct sd *) gspca_dev; 585 struct cam *cam; 586 587 cam = &gspca_dev->cam; 588 589 sd->bridge = id->driver_info >> 8; 590 sd->subtype = id->driver_info; 591 592 if (sd->subtype == AiptekMiniPenCam13) { 593 594 /* try to get the firmware as some cam answer 2.0.1.2.2 595 * and should be a spca504b then overwrite that setting */ 596 reg_r(gspca_dev, 0x20, 0, 1); 597 switch (gspca_dev->usb_buf[0]) { 598 case 1: 599 break; /* (right bridge/subtype) */ 600 case 2: 601 sd->bridge = BRIDGE_SPCA504B; 602 sd->subtype = 0; 603 break; 604 default: 605 return -ENODEV; 606 } 607 } 608 609 switch (sd->bridge) { 610 default: 611 /* case BRIDGE_SPCA504B: */ 612 /* case BRIDGE_SPCA504: */ 613 /* case BRIDGE_SPCA536: */ 614 cam->cam_mode = vga_mode; 615 cam->nmodes = ARRAY_SIZE(vga_mode); 616 break; 617 case BRIDGE_SPCA533: 618 cam->cam_mode = custom_mode; 619 if (sd->subtype == MegaImageVI) /* 320x240 only */ 620 cam->nmodes = ARRAY_SIZE(custom_mode) - 1; 621 else 622 cam->nmodes = ARRAY_SIZE(custom_mode); 623 break; 624 case BRIDGE_SPCA504C: 625 cam->cam_mode = vga_mode2; 626 cam->nmodes = ARRAY_SIZE(vga_mode2); 627 break; 628 } 629 return 0; 630 } 631 632 /* this function is called at probe and resume time */ 633 static int sd_init(struct gspca_dev *gspca_dev) 634 { 635 struct sd *sd = (struct sd *) gspca_dev; 636 637 switch (sd->bridge) { 638 case BRIDGE_SPCA504B: 639 reg_w_riv(gspca_dev, 0x1d, 0x00, 0); 640 reg_w_riv(gspca_dev, 0x00, 0x2306, 0x01); 641 reg_w_riv(gspca_dev, 0x00, 0x0d04, 0x00); 642 reg_w_riv(gspca_dev, 0x00, 0x2000, 0x00); 643 reg_w_riv(gspca_dev, 0x00, 0x2301, 0x13); 644 reg_w_riv(gspca_dev, 0x00, 0x2306, 0x00); 645 /* fall thru */ 646 case BRIDGE_SPCA533: 647 spca504B_PollingDataReady(gspca_dev); 648 #ifdef GSPCA_DEBUG 649 spca50x_GetFirmware(gspca_dev); 650 #endif 651 break; 652 case BRIDGE_SPCA536: 653 #ifdef GSPCA_DEBUG 654 spca50x_GetFirmware(gspca_dev); 655 #endif 656 reg_r(gspca_dev, 0x00, 0x5002, 1); 657 reg_w_1(gspca_dev, 0x24, 0, 0, 0); 658 reg_r(gspca_dev, 0x24, 0, 1); 659 spca504B_PollingDataReady(gspca_dev); 660 reg_w_riv(gspca_dev, 0x34, 0, 0); 661 spca504B_WaitCmdStatus(gspca_dev); 662 break; 663 case BRIDGE_SPCA504C: /* pccam600 */ 664 PDEBUG(D_STREAM, "Opening SPCA504 (PC-CAM 600)"); 665 reg_w_riv(gspca_dev, 0xe0, 0x0000, 0x0000); 666 reg_w_riv(gspca_dev, 0xe0, 0x0000, 0x0001); /* reset */ 667 spca504_wait_status(gspca_dev); 668 if (sd->subtype == LogitechClickSmart420) 669 write_vector(gspca_dev, 670 spca504A_clicksmart420_open_data, 671 ARRAY_SIZE(spca504A_clicksmart420_open_data)); 672 else 673 write_vector(gspca_dev, spca504_pccam600_open_data, 674 ARRAY_SIZE(spca504_pccam600_open_data)); 675 setup_qtable(gspca_dev, qtable_creative_pccam); 676 break; 677 default: 678 /* case BRIDGE_SPCA504: */ 679 PDEBUG(D_STREAM, "Opening SPCA504"); 680 if (sd->subtype == AiptekMiniPenCam13) { 681 #ifdef GSPCA_DEBUG 682 spca504_read_info(gspca_dev); 683 #endif 684 685 /* Set AE AWB Banding Type 3-> 50Hz 2-> 60Hz */ 686 spca504A_acknowledged_command(gspca_dev, 0x24, 687 8, 3, 0x9e, 1); 688 /* Twice sequential need status 0xff->0x9e->0x9d */ 689 spca504A_acknowledged_command(gspca_dev, 0x24, 690 8, 3, 0x9e, 0); 691 692 spca504A_acknowledged_command(gspca_dev, 0x24, 693 0, 0, 0x9d, 1); 694 /******************************/ 695 /* spca504a aiptek */ 696 spca504A_acknowledged_command(gspca_dev, 0x08, 697 6, 0, 0x86, 1); 698 /* reg_write (dev, 0, 0x2000, 0); */ 699 /* reg_write (dev, 0, 0x2883, 1); */ 700 /* spca504A_acknowledged_command (gspca_dev, 0x08, 701 6, 0, 0x86, 1); */ 702 /* spca504A_acknowledged_command (gspca_dev, 0x24, 703 0, 0, 0x9D, 1); */ 704 reg_w_riv(gspca_dev, 0x00, 0x270c, 0x05); 705 /* L92 sno1t.txt */ 706 reg_w_riv(gspca_dev, 0x00, 0x2310, 0x05); 707 spca504A_acknowledged_command(gspca_dev, 0x01, 708 0x0f, 0, 0xff, 0); 709 } 710 /* setup qtable */ 711 reg_w_riv(gspca_dev, 0, 0x2000, 0); 712 reg_w_riv(gspca_dev, 0, 0x2883, 1); 713 setup_qtable(gspca_dev, qtable_spca504_default); 714 break; 715 } 716 return gspca_dev->usb_err; 717 } 718 719 static int sd_start(struct gspca_dev *gspca_dev) 720 { 721 struct sd *sd = (struct sd *) gspca_dev; 722 int enable; 723 724 /* create the JPEG header */ 725 jpeg_define(sd->jpeg_hdr, gspca_dev->height, gspca_dev->width, 726 0x22); /* JPEG 411 */ 727 jpeg_set_qual(sd->jpeg_hdr, QUALITY); 728 729 if (sd->bridge == BRIDGE_SPCA504B) 730 spca504B_setQtable(gspca_dev); 731 spca504B_SetSizeType(gspca_dev); 732 switch (sd->bridge) { 733 default: 734 /* case BRIDGE_SPCA504B: */ 735 /* case BRIDGE_SPCA533: */ 736 /* case BRIDGE_SPCA536: */ 737 switch (sd->subtype) { 738 case MegapixV4: 739 case LogitechClickSmart820: 740 case MegaImageVI: 741 reg_w_riv(gspca_dev, 0xf0, 0, 0); 742 spca504B_WaitCmdStatus(gspca_dev); 743 reg_r(gspca_dev, 0xf0, 4, 0); 744 spca504B_WaitCmdStatus(gspca_dev); 745 break; 746 default: 747 reg_w_riv(gspca_dev, 0x31, 0x0004, 0x00); 748 spca504B_WaitCmdStatus(gspca_dev); 749 spca504B_PollingDataReady(gspca_dev); 750 break; 751 } 752 break; 753 case BRIDGE_SPCA504: 754 if (sd->subtype == AiptekMiniPenCam13) { 755 #ifdef GSPCA_DEBUG 756 spca504_read_info(gspca_dev); 757 #endif 758 759 /* Set AE AWB Banding Type 3-> 50Hz 2-> 60Hz */ 760 spca504A_acknowledged_command(gspca_dev, 0x24, 761 8, 3, 0x9e, 1); 762 /* Twice sequential need status 0xff->0x9e->0x9d */ 763 spca504A_acknowledged_command(gspca_dev, 0x24, 764 8, 3, 0x9e, 0); 765 spca504A_acknowledged_command(gspca_dev, 0x24, 766 0, 0, 0x9d, 1); 767 } else { 768 spca504_acknowledged_command(gspca_dev, 0x24, 8, 3); 769 #ifdef GSPCA_DEBUG 770 spca504_read_info(gspca_dev); 771 #endif 772 spca504_acknowledged_command(gspca_dev, 0x24, 8, 3); 773 spca504_acknowledged_command(gspca_dev, 0x24, 0, 0); 774 } 775 spca504B_SetSizeType(gspca_dev); 776 reg_w_riv(gspca_dev, 0x00, 0x270c, 0x05); 777 /* L92 sno1t.txt */ 778 reg_w_riv(gspca_dev, 0x00, 0x2310, 0x05); 779 break; 780 case BRIDGE_SPCA504C: 781 if (sd->subtype == LogitechClickSmart420) { 782 write_vector(gspca_dev, 783 spca504A_clicksmart420_init_data, 784 ARRAY_SIZE(spca504A_clicksmart420_init_data)); 785 } else { 786 write_vector(gspca_dev, spca504_pccam600_init_data, 787 ARRAY_SIZE(spca504_pccam600_init_data)); 788 } 789 enable = (sd->autogain ? 0x04 : 0x01); 790 reg_w_riv(gspca_dev, 0x0c, 0x0000, enable); 791 /* auto exposure */ 792 reg_w_riv(gspca_dev, 0xb0, 0x0000, enable); 793 /* auto whiteness */ 794 795 /* set default exposure compensation and whiteness balance */ 796 reg_w_riv(gspca_dev, 0x30, 0x0001, 800); /* ~ 20 fps */ 797 reg_w_riv(gspca_dev, 0x30, 0x0002, 1600); 798 spca504B_SetSizeType(gspca_dev); 799 break; 800 } 801 init_ctl_reg(gspca_dev); 802 return gspca_dev->usb_err; 803 } 804 805 static void sd_stopN(struct gspca_dev *gspca_dev) 806 { 807 struct sd *sd = (struct sd *) gspca_dev; 808 809 switch (sd->bridge) { 810 default: 811 /* case BRIDGE_SPCA533: */ 812 /* case BRIDGE_SPCA536: */ 813 /* case BRIDGE_SPCA504B: */ 814 reg_w_riv(gspca_dev, 0x31, 0, 0); 815 spca504B_WaitCmdStatus(gspca_dev); 816 spca504B_PollingDataReady(gspca_dev); 817 break; 818 case BRIDGE_SPCA504: 819 case BRIDGE_SPCA504C: 820 reg_w_riv(gspca_dev, 0x00, 0x2000, 0x0000); 821 822 if (sd->subtype == AiptekMiniPenCam13) { 823 /* spca504a aiptek */ 824 /* spca504A_acknowledged_command(gspca_dev, 0x08, 825 6, 0, 0x86, 1); */ 826 spca504A_acknowledged_command(gspca_dev, 0x24, 827 0x00, 0x00, 0x9d, 1); 828 spca504A_acknowledged_command(gspca_dev, 0x01, 829 0x0f, 0x00, 0xff, 1); 830 } else { 831 spca504_acknowledged_command(gspca_dev, 0x24, 0, 0); 832 reg_w_riv(gspca_dev, 0x01, 0x000f, 0x0000); 833 } 834 break; 835 } 836 } 837 838 static void sd_pkt_scan(struct gspca_dev *gspca_dev, 839 u8 *data, /* isoc packet */ 840 int len) /* iso packet length */ 841 { 842 struct sd *sd = (struct sd *) gspca_dev; 843 int i, sof = 0; 844 static u8 ffd9[] = {0xff, 0xd9}; 845 846 /* frames are jpeg 4.1.1 without 0xff escape */ 847 switch (sd->bridge) { 848 case BRIDGE_SPCA533: 849 if (data[0] == 0xff) { 850 if (data[1] != 0x01) { /* drop packet */ 851 /* gspca_dev->last_packet_type = DISCARD_PACKET; */ 852 return; 853 } 854 sof = 1; 855 data += SPCA533_OFFSET_DATA; 856 len -= SPCA533_OFFSET_DATA; 857 } else { 858 data += 1; 859 len -= 1; 860 } 861 break; 862 case BRIDGE_SPCA536: 863 if (data[0] == 0xff) { 864 sof = 1; 865 data += SPCA536_OFFSET_DATA; 866 len -= SPCA536_OFFSET_DATA; 867 } else { 868 data += 2; 869 len -= 2; 870 } 871 break; 872 default: 873 /* case BRIDGE_SPCA504: */ 874 /* case BRIDGE_SPCA504B: */ 875 switch (data[0]) { 876 case 0xfe: /* start of frame */ 877 sof = 1; 878 data += SPCA50X_OFFSET_DATA; 879 len -= SPCA50X_OFFSET_DATA; 880 break; 881 case 0xff: /* drop packet */ 882 /* gspca_dev->last_packet_type = DISCARD_PACKET; */ 883 return; 884 default: 885 data += 1; 886 len -= 1; 887 break; 888 } 889 break; 890 case BRIDGE_SPCA504C: 891 switch (data[0]) { 892 case 0xfe: /* start of frame */ 893 sof = 1; 894 data += SPCA504_PCCAM600_OFFSET_DATA; 895 len -= SPCA504_PCCAM600_OFFSET_DATA; 896 break; 897 case 0xff: /* drop packet */ 898 /* gspca_dev->last_packet_type = DISCARD_PACKET; */ 899 return; 900 default: 901 data += 1; 902 len -= 1; 903 break; 904 } 905 break; 906 } 907 if (sof) { /* start of frame */ 908 gspca_frame_add(gspca_dev, LAST_PACKET, 909 ffd9, 2); 910 911 /* put the JPEG header in the new frame */ 912 gspca_frame_add(gspca_dev, FIRST_PACKET, 913 sd->jpeg_hdr, JPEG_HDR_SZ); 914 } 915 916 /* add 0x00 after 0xff */ 917 i = 0; 918 do { 919 if (data[i] == 0xff) { 920 gspca_frame_add(gspca_dev, INTER_PACKET, 921 data, i + 1); 922 len -= i; 923 data += i; 924 *data = 0x00; 925 i = 0; 926 } 927 i++; 928 } while (i < len); 929 gspca_frame_add(gspca_dev, INTER_PACKET, data, len); 930 } 931 932 static int sd_s_ctrl(struct v4l2_ctrl *ctrl) 933 { 934 struct gspca_dev *gspca_dev = 935 container_of(ctrl->handler, struct gspca_dev, ctrl_handler); 936 struct sd *sd = (struct sd *)gspca_dev; 937 938 gspca_dev->usb_err = 0; 939 940 if (!gspca_dev->streaming) 941 return 0; 942 943 switch (ctrl->id) { 944 case V4L2_CID_BRIGHTNESS: 945 setbrightness(gspca_dev, ctrl->val); 946 break; 947 case V4L2_CID_CONTRAST: 948 setcontrast(gspca_dev, ctrl->val); 949 break; 950 case V4L2_CID_SATURATION: 951 setcolors(gspca_dev, ctrl->val); 952 break; 953 case V4L2_CID_AUTOGAIN: 954 sd->autogain = ctrl->val; 955 break; 956 } 957 return gspca_dev->usb_err; 958 } 959 960 static const struct v4l2_ctrl_ops sd_ctrl_ops = { 961 .s_ctrl = sd_s_ctrl, 962 }; 963 964 static int sd_init_controls(struct gspca_dev *gspca_dev) 965 { 966 struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler; 967 968 gspca_dev->vdev.ctrl_handler = hdl; 969 v4l2_ctrl_handler_init(hdl, 4); 970 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 971 V4L2_CID_BRIGHTNESS, -128, 127, 1, 0); 972 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 973 V4L2_CID_CONTRAST, 0, 255, 1, 0x20); 974 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 975 V4L2_CID_SATURATION, 0, 255, 1, 0x1a); 976 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops, 977 V4L2_CID_AUTOGAIN, 0, 1, 1, 1); 978 979 if (hdl->error) { 980 pr_err("Could not initialize controls\n"); 981 return hdl->error; 982 } 983 return 0; 984 } 985 986 /* sub-driver description */ 987 static const struct sd_desc sd_desc = { 988 .name = MODULE_NAME, 989 .config = sd_config, 990 .init = sd_init, 991 .init_controls = sd_init_controls, 992 .start = sd_start, 993 .stopN = sd_stopN, 994 .pkt_scan = sd_pkt_scan, 995 }; 996 997 /* -- module initialisation -- */ 998 #define BS(bridge, subtype) \ 999 .driver_info = (BRIDGE_ ## bridge << 8) \ 1000 | (subtype) 1001 static const struct usb_device_id device_table[] = { 1002 {USB_DEVICE(0x041e, 0x400b), BS(SPCA504C, 0)}, 1003 {USB_DEVICE(0x041e, 0x4012), BS(SPCA504C, 0)}, 1004 {USB_DEVICE(0x041e, 0x4013), BS(SPCA504C, 0)}, 1005 {USB_DEVICE(0x0458, 0x7006), BS(SPCA504B, 0)}, 1006 {USB_DEVICE(0x0461, 0x0821), BS(SPCA533, 0)}, 1007 {USB_DEVICE(0x046d, 0x0905), BS(SPCA533, LogitechClickSmart820)}, 1008 {USB_DEVICE(0x046d, 0x0960), BS(SPCA504C, LogitechClickSmart420)}, 1009 {USB_DEVICE(0x0471, 0x0322), BS(SPCA504B, 0)}, 1010 {USB_DEVICE(0x04a5, 0x3003), BS(SPCA504B, 0)}, 1011 {USB_DEVICE(0x04a5, 0x3008), BS(SPCA533, 0)}, 1012 {USB_DEVICE(0x04a5, 0x300a), BS(SPCA533, 0)}, 1013 {USB_DEVICE(0x04f1, 0x1001), BS(SPCA504B, 0)}, 1014 {USB_DEVICE(0x04fc, 0x500c), BS(SPCA504B, 0)}, 1015 {USB_DEVICE(0x04fc, 0x504a), BS(SPCA504, AiptekMiniPenCam13)}, 1016 {USB_DEVICE(0x04fc, 0x504b), BS(SPCA504B, 0)}, 1017 {USB_DEVICE(0x04fc, 0x5330), BS(SPCA533, 0)}, 1018 {USB_DEVICE(0x04fc, 0x5360), BS(SPCA536, 0)}, 1019 {USB_DEVICE(0x04fc, 0xffff), BS(SPCA504B, 0)}, 1020 {USB_DEVICE(0x052b, 0x1507), BS(SPCA533, MegapixV4)}, 1021 {USB_DEVICE(0x052b, 0x1513), BS(SPCA533, MegapixV4)}, 1022 {USB_DEVICE(0x052b, 0x1803), BS(SPCA533, MegaImageVI)}, 1023 {USB_DEVICE(0x0546, 0x3155), BS(SPCA533, 0)}, 1024 {USB_DEVICE(0x0546, 0x3191), BS(SPCA504B, 0)}, 1025 {USB_DEVICE(0x0546, 0x3273), BS(SPCA504B, 0)}, 1026 {USB_DEVICE(0x055f, 0xc211), BS(SPCA536, 0)}, 1027 {USB_DEVICE(0x055f, 0xc230), BS(SPCA533, 0)}, 1028 {USB_DEVICE(0x055f, 0xc232), BS(SPCA533, 0)}, 1029 {USB_DEVICE(0x055f, 0xc360), BS(SPCA536, 0)}, 1030 {USB_DEVICE(0x055f, 0xc420), BS(SPCA504, 0)}, 1031 {USB_DEVICE(0x055f, 0xc430), BS(SPCA533, 0)}, 1032 {USB_DEVICE(0x055f, 0xc440), BS(SPCA533, 0)}, 1033 {USB_DEVICE(0x055f, 0xc520), BS(SPCA504, 0)}, 1034 {USB_DEVICE(0x055f, 0xc530), BS(SPCA533, 0)}, 1035 {USB_DEVICE(0x055f, 0xc540), BS(SPCA533, 0)}, 1036 {USB_DEVICE(0x055f, 0xc630), BS(SPCA533, 0)}, 1037 {USB_DEVICE(0x055f, 0xc650), BS(SPCA533, 0)}, 1038 {USB_DEVICE(0x05da, 0x1018), BS(SPCA504B, 0)}, 1039 {USB_DEVICE(0x06d6, 0x0031), BS(SPCA533, 0)}, 1040 {USB_DEVICE(0x0733, 0x1311), BS(SPCA533, 0)}, 1041 {USB_DEVICE(0x0733, 0x1314), BS(SPCA533, 0)}, 1042 {USB_DEVICE(0x0733, 0x2211), BS(SPCA533, 0)}, 1043 {USB_DEVICE(0x0733, 0x2221), BS(SPCA533, 0)}, 1044 {USB_DEVICE(0x0733, 0x3261), BS(SPCA536, 0)}, 1045 {USB_DEVICE(0x0733, 0x3281), BS(SPCA536, 0)}, 1046 {USB_DEVICE(0x08ca, 0x0104), BS(SPCA533, 0)}, 1047 {USB_DEVICE(0x08ca, 0x0106), BS(SPCA533, 0)}, 1048 {USB_DEVICE(0x08ca, 0x2008), BS(SPCA504B, 0)}, 1049 {USB_DEVICE(0x08ca, 0x2010), BS(SPCA533, 0)}, 1050 {USB_DEVICE(0x08ca, 0x2016), BS(SPCA504B, 0)}, 1051 {USB_DEVICE(0x08ca, 0x2018), BS(SPCA504B, 0)}, 1052 {USB_DEVICE(0x08ca, 0x2020), BS(SPCA533, 0)}, 1053 {USB_DEVICE(0x08ca, 0x2022), BS(SPCA533, 0)}, 1054 {USB_DEVICE(0x08ca, 0x2024), BS(SPCA536, 0)}, 1055 {USB_DEVICE(0x08ca, 0x2028), BS(SPCA533, 0)}, 1056 {USB_DEVICE(0x08ca, 0x2040), BS(SPCA536, 0)}, 1057 {USB_DEVICE(0x08ca, 0x2042), BS(SPCA536, 0)}, 1058 {USB_DEVICE(0x08ca, 0x2050), BS(SPCA536, 0)}, 1059 {USB_DEVICE(0x08ca, 0x2060), BS(SPCA536, 0)}, 1060 {USB_DEVICE(0x0d64, 0x0303), BS(SPCA536, 0)}, 1061 {} 1062 }; 1063 MODULE_DEVICE_TABLE(usb, device_table); 1064 1065 /* -- device connect -- */ 1066 static int sd_probe(struct usb_interface *intf, 1067 const struct usb_device_id *id) 1068 { 1069 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd), 1070 THIS_MODULE); 1071 } 1072 1073 static struct usb_driver sd_driver = { 1074 .name = MODULE_NAME, 1075 .id_table = device_table, 1076 .probe = sd_probe, 1077 .disconnect = gspca_disconnect, 1078 #ifdef CONFIG_PM 1079 .suspend = gspca_suspend, 1080 .resume = gspca_resume, 1081 .reset_resume = gspca_resume, 1082 #endif 1083 }; 1084 1085 module_usb_driver(sd_driver); 1086