usb/gspca/pac207.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Pixart PAC207BCA library
0004  *
0005  * Copyright (C) 2008 Hans de Goede <hdegoede@redhat.com>
0006  * Copyright (C) 2005 Thomas Kaiser thomas@kaiser-linux.li
0007  * Copyleft (C) 2005 Michel Xhaard mxhaard@magic.fr
0008  *
0009  * V4L2 by Jean-Francois Moine <http://moinejf.free.fr>
0010  */
0011
0012 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0013
0014 #define MODULE_NAME "pac207"
0015
0016 #include <linux/input.h>
0017 #include "gspca.h"
0018 /* Include pac common sof detection functions */
0019 #include "pac_common.h"
0020
0021 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
0022 MODULE_DESCRIPTION("Pixart PAC207");
0023 MODULE_LICENSE("GPL");
0024
0025 #define PAC207_CTRL_TIMEOUT     100  /* ms */
0026
0027 #define PAC207_BRIGHTNESS_MIN       0
0028 #define PAC207_BRIGHTNESS_MAX       255
0029 #define PAC207_BRIGHTNESS_DEFAULT   46
0030 #define PAC207_BRIGHTNESS_REG       0x08
0031
0032 #define PAC207_EXPOSURE_MIN     3
0033 #define PAC207_EXPOSURE_MAX     90 /* 1 sec expo time / 1 fps */
0034 #define PAC207_EXPOSURE_DEFAULT     5 /* power on default: 3 */
0035 #define PAC207_EXPOSURE_REG     0x02
0036
0037 #define PAC207_GAIN_MIN         0
0038 #define PAC207_GAIN_MAX         31
0039 #define PAC207_GAIN_DEFAULT     7 /* power on default: 9 */
0040 #define PAC207_GAIN_REG         0x0e
0041
0042 #define PAC207_AUTOGAIN_DEADZONE    30
0043
0044 /* global parameters */
0045 static int led_invert;
0046 module_param(led_invert, int, 0644);
0047 MODULE_PARM_DESC(led_invert, "Invert led");
0048
0049 /* specific webcam descriptor */
0050 struct sd {
0051     struct gspca_dev gspca_dev;     /* !! must be the first item */
0052
0053     struct v4l2_ctrl *brightness;
0054
0055     u8 mode;
0056     u8 sof_read;
0057     u8 header_read;
0058     u8 autogain_ignore_frames;
0059
0060     atomic_t avg_lum;
0061 };
0062
0063 static const struct v4l2_pix_format sif_mode[] = {
0064     {176, 144, V4L2_PIX_FMT_PAC207, V4L2_FIELD_NONE,
0065         .bytesperline = 176,
0066         .sizeimage = (176 + 2) * 144,
0067             /* uncompressed, add 2 bytes / line for line header */
0068         .colorspace = V4L2_COLORSPACE_SRGB,
0069         .priv = 1},
0070     {352, 288, V4L2_PIX_FMT_PAC207, V4L2_FIELD_NONE,
0071         .bytesperline = 352,
0072             /* compressed, but only when needed (not compressed
0073                when the framerate is low) */
0074         .sizeimage = (352 + 2) * 288,
0075         .colorspace = V4L2_COLORSPACE_SRGB,
0076         .priv = 0},
0077 };
0078
0079 static const __u8 pac207_sensor_init[][8] = {
0080     {0x10, 0x12, 0x0d, 0x12, 0x0c, 0x01, 0x29, 0x84},
0081     {0x49, 0x64, 0x64, 0x64, 0x04, 0x10, 0xf0, 0x30},
0082     {0x00, 0x00, 0x00, 0x70, 0xa0, 0xf8, 0x00, 0x00},
0083     {0x32, 0x00, 0x96, 0x00, 0xa2, 0x02, 0xaf, 0x00},
0084 };
0085
0086 static void pac207_write_regs(struct gspca_dev *gspca_dev, u16 index,
0087     const u8 *buffer, u16 length)
0088 {
0089     struct usb_device *udev = gspca_dev->dev;
0090     int err;
0091
0092     if (gspca_dev->usb_err < 0)
0093         return;
0094
0095     memcpy(gspca_dev->usb_buf, buffer, length);
0096
0097     err = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x01,
0098             USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
0099             0x00, index,
0100             gspca_dev->usb_buf, length, PAC207_CTRL_TIMEOUT);
0101     if (err < 0) {
0102         pr_err("Failed to write registers to index 0x%04X, error %d\n",
0103                index, err);
0104         gspca_dev->usb_err = err;
0105     }
0106 }
0107
0108 static void pac207_write_reg(struct gspca_dev *gspca_dev, u16 index, u16 value)
0109 {
0110     struct usb_device *udev = gspca_dev->dev;
0111     int err;
0112
0113     if (gspca_dev->usb_err < 0)
0114         return;
0115
0116     err = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), 0x00,
0117             USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
0118             value, index, NULL, 0, PAC207_CTRL_TIMEOUT);
0119     if (err) {
0120         pr_err("Failed to write a register (index 0x%04X, value 0x%02X, error %d)\n",
0121                index, value, err);
0122         gspca_dev->usb_err = err;
0123     }
0124 }
0125
0126 static int pac207_read_reg(struct gspca_dev *gspca_dev, u16 index)
0127 {
0128     struct usb_device *udev = gspca_dev->dev;
0129     int res;
0130
0131     if (gspca_dev->usb_err < 0)
0132         return 0;
0133
0134     res = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), 0x00,
0135             USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,
0136             0x00, index,
0137             gspca_dev->usb_buf, 1, PAC207_CTRL_TIMEOUT);
0138     if (res < 0) {
0139         pr_err("Failed to read a register (index 0x%04X, error %d)\n",
0140                index, res);
0141         gspca_dev->usb_err = res;
0142         return 0;
0143     }
0144
0145     return gspca_dev->usb_buf[0];
0146 }
0147
0148 /* this function is called at probe time */
0149 static int sd_config(struct gspca_dev *gspca_dev,
0150             const struct usb_device_id *id)
0151 {
0152     struct cam *cam;
0153     u8 idreg[2];
0154
0155     idreg[0] = pac207_read_reg(gspca_dev, 0x0000);
0156     idreg[1] = pac207_read_reg(gspca_dev, 0x0001);
0157     idreg[0] = ((idreg[0] & 0x0f) << 4) | ((idreg[1] & 0xf0) >> 4);
0158     idreg[1] = idreg[1] & 0x0f;
0159     gspca_dbg(gspca_dev, D_PROBE, "Pixart Sensor ID 0x%02X Chips ID 0x%02X\n",
0160           idreg[0], idreg[1]);
0161
0162     if (idreg[0] != 0x27) {
0163         gspca_dbg(gspca_dev, D_PROBE, "Error invalid sensor ID!\n");
0164         return -ENODEV;
0165     }
0166
0167     gspca_dbg(gspca_dev, D_PROBE,
0168           "Pixart PAC207BCA Image Processor and Control Chip detected (vid/pid 0x%04X:0x%04X)\n",
0169           id->idVendor, id->idProduct);
0170
0171     cam = &gspca_dev->cam;
0172     cam->cam_mode = sif_mode;
0173     cam->nmodes = ARRAY_SIZE(sif_mode);
0174
0175     return 0;
0176 }
0177
0178 /* this function is called at probe and resume time */
0179 static int sd_init(struct gspca_dev *gspca_dev)
0180 {
0181     u8 mode;
0182
0183     /* mode: Image Format (Bit 0), LED (1), Compr. test mode (2) */
0184     if (led_invert)
0185         mode = 0x02;
0186     else
0187         mode = 0x00;
0188     pac207_write_reg(gspca_dev, 0x41, mode);
0189     pac207_write_reg(gspca_dev, 0x0f, 0x00); /* Power Control */
0190
0191     return gspca_dev->usb_err;
0192 }
0193
0194 static void setcontrol(struct gspca_dev *gspca_dev, u16 reg, u16 val)
0195 {
0196     pac207_write_reg(gspca_dev, reg, val);
0197     pac207_write_reg(gspca_dev, 0x13, 0x01);    /* Bit 0, auto clear */
0198     pac207_write_reg(gspca_dev, 0x1c, 0x01);    /* not documented */
0199 }
0200
0201 static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
0202 {
0203     struct gspca_dev *gspca_dev =
0204         container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
0205     struct sd *sd = (struct sd *)gspca_dev;
0206
0207     gspca_dev->usb_err = 0;
0208
0209     if (ctrl->id == V4L2_CID_AUTOGAIN && ctrl->is_new && ctrl->val) {
0210         /* when switching to autogain set defaults to make sure
0211            we are on a valid point of the autogain gain /
0212            exposure knee graph, and give this change time to
0213            take effect before doing autogain. */
0214         gspca_dev->exposure->val    = PAC207_EXPOSURE_DEFAULT;
0215         gspca_dev->gain->val        = PAC207_GAIN_DEFAULT;
0216         sd->autogain_ignore_frames  = PAC_AUTOGAIN_IGNORE_FRAMES;
0217     }
0218
0219     if (!gspca_dev->streaming)
0220         return 0;
0221
0222     switch (ctrl->id) {
0223     case V4L2_CID_BRIGHTNESS:
0224         setcontrol(gspca_dev, PAC207_BRIGHTNESS_REG, ctrl->val);
0225         break;
0226     case V4L2_CID_AUTOGAIN:
0227         if (gspca_dev->exposure->is_new || (ctrl->is_new && ctrl->val))
0228             setcontrol(gspca_dev, PAC207_EXPOSURE_REG,
0229                    gspca_dev->exposure->val);
0230         if (gspca_dev->gain->is_new || (ctrl->is_new && ctrl->val))
0231             setcontrol(gspca_dev, PAC207_GAIN_REG,
0232                    gspca_dev->gain->val);
0233         break;
0234     default:
0235         return -EINVAL;
0236     }
0237     return gspca_dev->usb_err;
0238 }
0239
0240 static const struct v4l2_ctrl_ops sd_ctrl_ops = {
0241     .s_ctrl = sd_s_ctrl,
0242 };
0243
0244 /* this function is called at probe time */
0245 static int sd_init_controls(struct gspca_dev *gspca_dev)
0246 {
0247     struct sd *sd = (struct sd *) gspca_dev;
0248     struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
0249
0250     gspca_dev->vdev.ctrl_handler = hdl;
0251     v4l2_ctrl_handler_init(hdl, 4);
0252
0253     sd->brightness = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
0254                 V4L2_CID_BRIGHTNESS,
0255                 PAC207_BRIGHTNESS_MIN, PAC207_BRIGHTNESS_MAX,
0256                 1, PAC207_BRIGHTNESS_DEFAULT);
0257     gspca_dev->autogain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
0258                 V4L2_CID_AUTOGAIN, 0, 1, 1, 1);
0259     gspca_dev->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
0260                 V4L2_CID_EXPOSURE,
0261                 PAC207_EXPOSURE_MIN, PAC207_EXPOSURE_MAX,
0262                 1, PAC207_EXPOSURE_DEFAULT);
0263     gspca_dev->gain = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
0264                 V4L2_CID_GAIN,
0265                 PAC207_GAIN_MIN, PAC207_GAIN_MAX,
0266                 1, PAC207_GAIN_DEFAULT);
0267     if (hdl->error) {
0268         pr_err("Could not initialize controls\n");
0269         return hdl->error;
0270     }
0271     v4l2_ctrl_auto_cluster(3, &gspca_dev->autogain, 0, false);
0272     return 0;
0273 }
0274
0275 /* -- start the camera -- */
0276 static int sd_start(struct gspca_dev *gspca_dev)
0277 {
0278     struct sd *sd = (struct sd *) gspca_dev;
0279     __u8 mode;
0280
0281     pac207_write_reg(gspca_dev, 0x0f, 0x10); /* Power control (Bit 6-0) */
0282     pac207_write_regs(gspca_dev, 0x0002, pac207_sensor_init[0], 8);
0283     pac207_write_regs(gspca_dev, 0x000a, pac207_sensor_init[1], 8);
0284     pac207_write_regs(gspca_dev, 0x0012, pac207_sensor_init[2], 8);
0285     pac207_write_regs(gspca_dev, 0x0042, pac207_sensor_init[3], 8);
0286
0287     /* Compression Balance */
0288     if (gspca_dev->pixfmt.width == 176)
0289         pac207_write_reg(gspca_dev, 0x4a, 0xff);
0290     else
0291         pac207_write_reg(gspca_dev, 0x4a, 0x30);
0292     pac207_write_reg(gspca_dev, 0x4b, 0x00); /* Sram test value */
0293     pac207_write_reg(gspca_dev, 0x08, v4l2_ctrl_g_ctrl(sd->brightness));
0294
0295     /* PGA global gain (Bit 4-0) */
0296     pac207_write_reg(gspca_dev, 0x0e,
0297         v4l2_ctrl_g_ctrl(gspca_dev->gain));
0298     pac207_write_reg(gspca_dev, 0x02,
0299         v4l2_ctrl_g_ctrl(gspca_dev->exposure)); /* PXCK = 12MHz /n */
0300
0301     /* mode: Image Format (Bit 0), LED (1), Compr. test mode (2) */
0302     if (led_invert)
0303         mode = 0x00;
0304     else
0305         mode = 0x02;
0306     if (gspca_dev->pixfmt.width == 176) {   /* 176x144 */
0307         mode |= 0x01;
0308         gspca_dbg(gspca_dev, D_STREAM, "pac207_start mode 176x144\n");
0309     } else {                /* 352x288 */
0310         gspca_dbg(gspca_dev, D_STREAM, "pac207_start mode 352x288\n");
0311     }
0312     pac207_write_reg(gspca_dev, 0x41, mode);
0313
0314     pac207_write_reg(gspca_dev, 0x13, 0x01); /* Bit 0, auto clear */
0315     pac207_write_reg(gspca_dev, 0x1c, 0x01); /* not documented */
0316     msleep(10);
0317     pac207_write_reg(gspca_dev, 0x40, 0x01); /* Start ISO pipe */
0318
0319     sd->sof_read = 0;
0320     sd->autogain_ignore_frames = 0;
0321     atomic_set(&sd->avg_lum, -1);
0322     return gspca_dev->usb_err;
0323 }
0324
0325 static void sd_stopN(struct gspca_dev *gspca_dev)
0326 {
0327     u8 mode;
0328
0329     /* mode: Image Format (Bit 0), LED (1), Compr. test mode (2) */
0330     if (led_invert)
0331         mode = 0x02;
0332     else
0333         mode = 0x00;
0334     pac207_write_reg(gspca_dev, 0x40, 0x00); /* Stop ISO pipe */
0335     pac207_write_reg(gspca_dev, 0x41, mode); /* Turn off LED */
0336     pac207_write_reg(gspca_dev, 0x0f, 0x00); /* Power Control */
0337 }
0338
0339
0340 static void pac207_do_auto_gain(struct gspca_dev *gspca_dev)
0341 {
0342     struct sd *sd = (struct sd *) gspca_dev;
0343     int avg_lum = atomic_read(&sd->avg_lum);
0344
0345     if (avg_lum == -1)
0346         return;
0347
0348     if (sd->autogain_ignore_frames > 0)
0349         sd->autogain_ignore_frames--;
0350     else if (gspca_coarse_grained_expo_autogain(gspca_dev, avg_lum,
0351             90, PAC207_AUTOGAIN_DEADZONE))
0352         sd->autogain_ignore_frames = PAC_AUTOGAIN_IGNORE_FRAMES;
0353 }
0354
0355 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
0356             u8 *data,
0357             int len)
0358 {
0359     struct sd *sd = (struct sd *) gspca_dev;
0360     unsigned char *sof;
0361
0362     sof = pac_find_sof(gspca_dev, &sd->sof_read, data, len);
0363     if (sof) {
0364         int n;
0365
0366         /* finish decoding current frame */
0367         n = sof - data;
0368         if (n > sizeof pac_sof_marker)
0369             n -= sizeof pac_sof_marker;
0370         else
0371             n = 0;
0372         gspca_frame_add(gspca_dev, LAST_PACKET,
0373                 data, n);
0374         sd->header_read = 0;
0375         gspca_frame_add(gspca_dev, FIRST_PACKET, NULL, 0);
0376         len -= sof - data;
0377         data = sof;
0378     }
0379     if (sd->header_read < 11) {
0380         int needed;
0381
0382         /* get average lumination from frame header (byte 5) */
0383         if (sd->header_read < 5) {
0384             needed = 5 - sd->header_read;
0385             if (len >= needed)
0386                 atomic_set(&sd->avg_lum, data[needed - 1]);
0387         }
0388         /* skip the rest of the header */
0389         needed = 11 - sd->header_read;
0390         if (len <= needed) {
0391             sd->header_read += len;
0392             return;
0393         }
0394         data += needed;
0395         len -= needed;
0396         sd->header_read = 11;
0397     }
0398
0399     gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
0400 }
0401
0402 #if IS_ENABLED(CONFIG_INPUT)
0403 static int sd_int_pkt_scan(struct gspca_dev *gspca_dev,
0404             u8 *data,       /* interrupt packet data */
0405             int len)        /* interrupt packet length */
0406 {
0407     int ret = -EINVAL;
0408
0409     if (len == 2 && data[0] == 0x5a && data[1] == 0x5a) {
0410         input_report_key(gspca_dev->input_dev, KEY_CAMERA, 1);
0411         input_sync(gspca_dev->input_dev);
0412         input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
0413         input_sync(gspca_dev->input_dev);
0414         ret = 0;
0415     }
0416
0417     return ret;
0418 }
0419 #endif
0420
0421 /* sub-driver description */
0422 static const struct sd_desc sd_desc = {
0423     .name = MODULE_NAME,
0424     .config = sd_config,
0425     .init = sd_init,
0426     .init_controls = sd_init_controls,
0427     .start = sd_start,
0428     .stopN = sd_stopN,
0429     .dq_callback = pac207_do_auto_gain,
0430     .pkt_scan = sd_pkt_scan,
0431 #if IS_ENABLED(CONFIG_INPUT)
0432     .int_pkt_scan = sd_int_pkt_scan,
0433 #endif
0434 };
0435
0436 /* -- module initialisation -- */
0437 static const struct usb_device_id device_table[] = {
0438     {USB_DEVICE(0x041e, 0x4028)},
0439     {USB_DEVICE(0x093a, 0x2460)},
0440     {USB_DEVICE(0x093a, 0x2461)},
0441     {USB_DEVICE(0x093a, 0x2463)},
0442     {USB_DEVICE(0x093a, 0x2464)},
0443     {USB_DEVICE(0x093a, 0x2468)},
0444     {USB_DEVICE(0x093a, 0x2470)},
0445     {USB_DEVICE(0x093a, 0x2471)},
0446     {USB_DEVICE(0x093a, 0x2472)},
0447     {USB_DEVICE(0x093a, 0x2474)},
0448     {USB_DEVICE(0x093a, 0x2476)},
0449     {USB_DEVICE(0x145f, 0x013a)},
0450     {USB_DEVICE(0x2001, 0xf115)},
0451     {}
0452 };
0453 MODULE_DEVICE_TABLE(usb, device_table);
0454
0455 /* -- device connect -- */
0456 static int sd_probe(struct usb_interface *intf,
0457             const struct usb_device_id *id)
0458 {
0459     return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
0460                 THIS_MODULE);
0461 }
0462
0463 static struct usb_driver sd_driver = {
0464     .name = MODULE_NAME,
0465     .id_table = device_table,
0466     .probe = sd_probe,
0467     .disconnect = gspca_disconnect,
0468 #ifdef CONFIG_PM
0469     .suspend = gspca_suspend,
0470     .resume = gspca_resume,
0471     .reset_resume = gspca_resume,
0472 #endif
0473 };
0474
0475 module_usb_driver(sd_driver);