root/drivers/media/usb/gspca/t613.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. reg_r
  2. reg_w
  3. reg_w_buf
  4. reg_w_ixbuf
  5. om6802_sensor_init
  6. sd_config
  7. setbrightness
  8. setcontrast
  9. setcolors
  10. setgamma
  11. setawb_n_RGB
  12. setsharpness
  13. setfreq
  14. sd_init
  15. setmirror
  16. seteffect
  17. poll_sensor
  18. sd_start
  19. sd_stopN
  20. sd_pkt_scan
  21. sd_g_volatile_ctrl
  22. sd_s_ctrl
  23. sd_init_controls
  24. sd_probe

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

/* [<][>][^][v][top][bottom][index][help] */