LXR linux/drivers/media/usb/gspca/dtcs033.c

   1/*
   2 * Subdriver for Scopium astro-camera (DTCS033, 0547:7303)
   3 *
   4 * Copyright (C) 2014 Robert Butora (robert.butora.fi@gmail.com)
   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
  17#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  18#define MODULE_NAME "dtcs033"
  19#include "gspca.h"
  20
  21MODULE_AUTHOR("Robert Butora <robert.butora.fi@gmail.com>");
  22MODULE_DESCRIPTION("Scopium DTCS033 astro-cam USB Camera Driver");
  23MODULE_LICENSE("GPL");
  24
  25struct dtcs033_usb_requests {
  26        u8 bRequestType;
  27        u8 bRequest;
  28        u16 wValue;
  29        u16 wIndex;
  30        u16 wLength;
  31};
  32
  33/* send a usb request */
  34static void reg_rw(struct gspca_dev *gspca_dev,
  35                u8 bRequestType, u8 bRequest,
  36                u16 wValue, u16 wIndex, u16 wLength)
  37{
  38        struct usb_device *udev = gspca_dev->dev;
  39        int ret;
  40
  41        if (gspca_dev->usb_err < 0)
  42                return;
  43
  44        ret = usb_control_msg(udev,
  45                usb_rcvctrlpipe(udev, 0),
  46                bRequest,
  47                bRequestType,
  48                wValue, wIndex,
  49                gspca_dev->usb_buf, wLength, 500);
  50
  51        if (ret < 0) {
  52                gspca_dev->usb_err = ret;
  53                pr_err("usb_control_msg error %d\n", ret);
  54        }
  55
  56        return;
  57}
  58/* send several usb in/out requests */
  59static int reg_reqs(struct gspca_dev *gspca_dev,
  60                    const struct dtcs033_usb_requests *preqs, int n_reqs)
  61{
  62        int i = 0;
  63        const struct dtcs033_usb_requests *preq;
  64
  65        while ((i < n_reqs) && (gspca_dev->usb_err >= 0)) {
  66
  67                preq = &preqs[i];
  68
  69                reg_rw(gspca_dev, preq->bRequestType, preq->bRequest,
  70                        preq->wValue, preq->wIndex, preq->wLength);
  71
  72                if (gspca_dev->usb_err < 0) {
  73
  74                        gspca_err(gspca_dev, "usb error request no: %d / %d\n",
  75                                  i, n_reqs);
  76                } else if (preq->bRequestType & USB_DIR_IN) {
  77
  78                        gspca_dbg(gspca_dev, D_STREAM,
  79                                  "USB IN (%d) returned[%d] %3ph %s",
  80                                  i,
  81                                  preq->wLength,
  82                                  gspca_dev->usb_buf,
  83                                  preq->wLength > 3 ? "...\n" : "\n");
  84                }
  85
  86                i++;
  87        }
  88        return gspca_dev->usb_err;
  89}
  90
  91/* -- subdriver interface implementation -- */
  92
  93#define DT_COLS (640)
  94static const struct v4l2_pix_format dtcs033_mode[] = {
  95        /* raw Bayer patterned output */
  96        {DT_COLS, 480, V4L2_PIX_FMT_GREY, V4L2_FIELD_NONE,
  97                .bytesperline = DT_COLS,
  98                .sizeimage = DT_COLS*480,
  99                .colorspace = V4L2_COLORSPACE_SRGB,
 100        },
 101        /* this mode will demosaic the Bayer pattern */
 102        {DT_COLS, 480, V4L2_PIX_FMT_SRGGB8, V4L2_FIELD_NONE,
 103                .bytesperline = DT_COLS,
 104                .sizeimage = DT_COLS*480,
 105                .colorspace = V4L2_COLORSPACE_SRGB,
 106        }
 107};
 108
 109/* config called at probe time */
 110static int sd_config(struct gspca_dev *gspca_dev,
 111                const struct usb_device_id *id)
 112{
 113        gspca_dev->cam.cam_mode = dtcs033_mode;
 114        gspca_dev->cam.nmodes = ARRAY_SIZE(dtcs033_mode);
 115
 116        gspca_dev->cam.bulk = 1;
 117        gspca_dev->cam.bulk_nurbs = 1;
 118        gspca_dev->cam.bulk_size = DT_COLS*512;
 119
 120        return 0;
 121}
 122
 123/* init called at probe and resume time */
 124static int sd_init(struct gspca_dev *gspca_dev)
 125{
 126        return 0;
 127}
 128
 129/* start stop the camera */
 130static int  dtcs033_start(struct gspca_dev *gspca_dev);
 131static void dtcs033_stopN(struct gspca_dev *gspca_dev);
 132
 133/* intercept camera image data */
 134static void dtcs033_pkt_scan(struct gspca_dev *gspca_dev,
 135                        u8 *data,  /* packet data */
 136                        int len)   /* packet data length */
 137{
 138        /* drop incomplete frames */
 139        if (len != DT_COLS*512) {
 140                gspca_dev->last_packet_type = DISCARD_PACKET;
 141                /* gspca.c: discard invalidates the whole frame. */
 142                return;
 143        }
 144
 145        /* forward complete frames */
 146        gspca_frame_add(gspca_dev, FIRST_PACKET, NULL, 0);
 147        gspca_frame_add(gspca_dev, INTER_PACKET,
 148                data + 16*DT_COLS,
 149                len  - 32*DT_COLS); /* skip first & last 16 lines */
 150        gspca_frame_add(gspca_dev, LAST_PACKET,  NULL, 0);
 151
 152        return;
 153}
 154
 155/* -- controls: exposure and gain -- */
 156
 157static void dtcs033_setexposure(struct gspca_dev *gspca_dev,
 158                        s32 expo, s32 gain)
 159{
 160        /* gain [dB] encoding */
 161        u16 sGain   = (u16)gain;
 162        u16 gainVal = 224+(sGain-14)*(768-224)/(33-14);
 163        u16 wIndex =  0x0100|(0x00FF&gainVal);
 164        u16 wValue = (0xFF00&gainVal)>>8;
 165
 166        /* exposure time [msec] encoding */
 167        u16 sXTime   = (u16)expo;
 168        u16 xtimeVal = (524*(150-(sXTime-1)))/150;
 169
 170        const u8 bRequestType =
 171                USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE;
 172        const u8 bRequest = 0x18;
 173
 174        reg_rw(gspca_dev,
 175                bRequestType, bRequest, wValue, wIndex, 0);
 176        if (gspca_dev->usb_err < 0)
 177                gspca_err(gspca_dev, "usb error in setexposure(gain) sequence\n");
 178
 179        reg_rw(gspca_dev,
 180                bRequestType, bRequest, (xtimeVal<<4), 0x6300, 0);
 181        if (gspca_dev->usb_err < 0)
 182                gspca_err(gspca_dev, "usb error in setexposure(time) sequence\n");
 183}
 184
 185/* specific webcam descriptor */
 186struct sd {
 187        struct gspca_dev gspca_dev;/* !! must be the first item */
 188
 189        /* exposure & gain controls */
 190        struct {
 191                struct v4l2_ctrl *exposure;
 192                struct v4l2_ctrl *gain;
 193        };
 194};
 195
 196static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
 197{
 198        struct gspca_dev *gspca_dev =
 199        container_of(ctrl->handler,
 200                struct gspca_dev, ctrl_handler);
 201        struct sd *sd = (struct sd *) gspca_dev;
 202
 203        gspca_dev->usb_err = 0;
 204
 205        if (!gspca_dev->streaming)
 206                return 0;
 207
 208        switch (ctrl->id) {
 209        case V4L2_CID_EXPOSURE:
 210                dtcs033_setexposure(gspca_dev,
 211                                ctrl->val, sd->gain->val);
 212                break;
 213        case V4L2_CID_GAIN:
 214                dtcs033_setexposure(gspca_dev,
 215                                sd->exposure->val, ctrl->val);
 216                break;
 217        }
 218        return gspca_dev->usb_err;
 219}
 220
 221static const struct v4l2_ctrl_ops sd_ctrl_ops = {
 222        .s_ctrl = sd_s_ctrl,
 223};
 224
 225static int dtcs033_init_controls(struct gspca_dev *gspca_dev)
 226{
 227        struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
 228        struct sd *sd = (struct sd *) gspca_dev;
 229
 230        gspca_dev->vdev.ctrl_handler = hdl;
 231        v4l2_ctrl_handler_init(hdl, 2);
 232        /*                               min max step default */
 233        sd->exposure = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 234                                V4L2_CID_EXPOSURE,
 235                                1,  150,  1,  75);/* [msec] */
 236        sd->gain     = v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
 237                                V4L2_CID_GAIN,
 238                                14,  33,  1,  24);/* [dB] */
 239        if (hdl->error) {
 240                gspca_err(gspca_dev, "Could not initialize controls: %d\n",
 241                          hdl->error);
 242                return hdl->error;
 243        }
 244
 245        v4l2_ctrl_cluster(2, &sd->exposure);
 246        return 0;
 247}
 248
 249/* sub-driver description */
 250static const struct sd_desc sd_desc = {
 251        .name     = MODULE_NAME,
 252        .config   = sd_config,
 253        .init     = sd_init,
 254        .start    = dtcs033_start,
 255        .stopN    = dtcs033_stopN,
 256        .pkt_scan = dtcs033_pkt_scan,
 257        .init_controls = dtcs033_init_controls,
 258};
 259
 260/* -- module initialisation -- */
 261
 262static const struct usb_device_id device_table[] = {
 263        {USB_DEVICE(0x0547, 0x7303)},
 264        {}
 265};
 266MODULE_DEVICE_TABLE(usb, device_table);
 267
 268/* device connect */
 269static int sd_probe(struct usb_interface *intf,
 270                        const struct usb_device_id *id)
 271{
 272        return gspca_dev_probe(intf, id,
 273                        &sd_desc, sizeof(struct sd),
 274                        THIS_MODULE);
 275}
 276
 277static struct usb_driver sd_driver = {
 278        .name       = MODULE_NAME,
 279        .id_table   = device_table,
 280        .probe      = sd_probe,
 281        .disconnect   = gspca_disconnect,
 282#ifdef CONFIG_PM
 283        .suspend      = gspca_suspend,
 284        .resume       = gspca_resume,
 285        .reset_resume = gspca_resume,
 286#endif
 287};
 288module_usb_driver(sd_driver);
 289
 290
 291/* ---------------------------------------------------------
 292 USB requests to start/stop the camera [USB 2.0 spec Ch.9].
 293
 294 bRequestType :
 295 0x40 =  USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 296 0xC0 =  USB_DIR_IN  | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 297*/
 298static const struct dtcs033_usb_requests dtcs033_start_reqs[] = {
 299/* -- bRequest,wValue,wIndex,wLength */
 300{ 0x40, 0x01, 0x0001, 0x000F, 0x0000 },
 301{ 0x40, 0x01, 0x0000, 0x000F, 0x0000 },
 302{ 0x40, 0x01, 0x0001, 0x000F, 0x0000 },
 303{ 0x40, 0x18, 0x0000, 0x7F00, 0x0000 },
 304{ 0x40, 0x18, 0x0000, 0x1001, 0x0000 },
 305{ 0x40, 0x18, 0x0000, 0x0004, 0x0000 },
 306{ 0x40, 0x18, 0x0000, 0x7F01, 0x0000 },
 307{ 0x40, 0x18, 0x30E0, 0x0009, 0x0000 },
 308{ 0x40, 0x18, 0x0500, 0x012C, 0x0000 },
 309{ 0x40, 0x18, 0x0380, 0x0200, 0x0000 },
 310{ 0x40, 0x18, 0x0000, 0x035C, 0x0000 },
 311{ 0x40, 0x18, 0x05C0, 0x0438, 0x0000 },
 312{ 0x40, 0x18, 0x0440, 0x0500, 0x0000 },
 313{ 0x40, 0x18, 0x0000, 0x0668, 0x0000 },
 314{ 0x40, 0x18, 0x0000, 0x0700, 0x0000 },
 315{ 0x40, 0x18, 0x0000, 0x0800, 0x0000 },
 316{ 0x40, 0x18, 0x0000, 0x0900, 0x0000 },
 317{ 0x40, 0x18, 0x0000, 0x0A00, 0x0000 },
 318{ 0x40, 0x18, 0x0000, 0x0B00, 0x0000 },
 319{ 0x40, 0x18, 0x30E0, 0x6009, 0x0000 },
 320{ 0x40, 0x18, 0x0500, 0x612C, 0x0000 },
 321{ 0x40, 0x18, 0x2090, 0x6274, 0x0000 },
 322{ 0x40, 0x18, 0x05C0, 0x6338, 0x0000 },
 323{ 0x40, 0x18, 0x0000, 0x6400, 0x0000 },
 324{ 0x40, 0x18, 0x05C0, 0x6538, 0x0000 },
 325{ 0x40, 0x18, 0x0000, 0x6600, 0x0000 },
 326{ 0x40, 0x18, 0x0680, 0x6744, 0x0000 },
 327{ 0x40, 0x18, 0x0000, 0x6800, 0x0000 },
 328{ 0x40, 0x18, 0x0000, 0x6900, 0x0000 },
 329{ 0x40, 0x18, 0x0000, 0x6A00, 0x0000 },
 330{ 0x40, 0x18, 0x0000, 0x6B00, 0x0000 },
 331{ 0x40, 0x18, 0x0000, 0x6C00, 0x0000 },
 332{ 0x40, 0x18, 0x0000, 0x6D00, 0x0000 },
 333{ 0x40, 0x18, 0x0000, 0x6E00, 0x0000 },
 334{ 0x40, 0x18, 0x0000, 0x808C, 0x0000 },
 335{ 0x40, 0x18, 0x0010, 0x8101, 0x0000 },
 336{ 0x40, 0x18, 0x30E0, 0x8200, 0x0000 },
 337{ 0x40, 0x18, 0x0810, 0x832C, 0x0000 },
 338{ 0x40, 0x18, 0x0680, 0x842B, 0x0000 },
 339{ 0x40, 0x18, 0x0000, 0x8500, 0x0000 },
 340{ 0x40, 0x18, 0x0000, 0x8600, 0x0000 },
 341{ 0x40, 0x18, 0x0280, 0x8715, 0x0000 },
 342{ 0x40, 0x18, 0x0000, 0x880C, 0x0000 },
 343{ 0x40, 0x18, 0x0010, 0x8901, 0x0000 },
 344{ 0x40, 0x18, 0x30E0, 0x8A00, 0x0000 },
 345{ 0x40, 0x18, 0x0810, 0x8B2C, 0x0000 },
 346{ 0x40, 0x18, 0x0680, 0x8C2B, 0x0000 },
 347{ 0x40, 0x18, 0x0000, 0x8D00, 0x0000 },
 348{ 0x40, 0x18, 0x0000, 0x8E00, 0x0000 },
 349{ 0x40, 0x18, 0x0280, 0x8F15, 0x0000 },
 350{ 0x40, 0x18, 0x0010, 0xD040, 0x0000 },
 351{ 0x40, 0x18, 0x0000, 0xD100, 0x0000 },
 352{ 0x40, 0x18, 0x00B0, 0xD20A, 0x0000 },
 353{ 0x40, 0x18, 0x0000, 0xD300, 0x0000 },
 354{ 0x40, 0x18, 0x30E2, 0xD40D, 0x0000 },
 355{ 0x40, 0x18, 0x0001, 0xD5C0, 0x0000 },
 356{ 0x40, 0x18, 0x00A0, 0xD60A, 0x0000 },
 357{ 0x40, 0x18, 0x0000, 0xD700, 0x0000 },
 358{ 0x40, 0x18, 0x0000, 0x7F00, 0x0000 },
 359{ 0x40, 0x18, 0x0000, 0x1501, 0x0000 },
 360{ 0x40, 0x18, 0x0001, 0x01FF, 0x0000 },
 361{ 0x40, 0x18, 0x0000, 0x0200, 0x0000 },
 362{ 0x40, 0x18, 0x0000, 0x0304, 0x0000 },
 363{ 0x40, 0x18, 0x0000, 0x1101, 0x0000 },
 364{ 0x40, 0x18, 0x0000, 0x1201, 0x0000 },
 365{ 0x40, 0x18, 0x0000, 0x1300, 0x0000 },
 366{ 0x40, 0x18, 0x0000, 0x1400, 0x0000 },
 367{ 0x40, 0x18, 0x0000, 0x1601, 0x0000 },
 368{ 0x40, 0x18, 0x0000, 0x1800, 0x0000 },
 369{ 0x40, 0x18, 0x0000, 0x1900, 0x0000 },
 370{ 0x40, 0x18, 0x0000, 0x1A00, 0x0000 },
 371{ 0x40, 0x18, 0x2000, 0x1B00, 0x0000 },
 372{ 0x40, 0x18, 0x0000, 0x1C00, 0x0000 },
 373{ 0x40, 0x18, 0x0000, 0x2100, 0x0000 },
 374{ 0x40, 0x18, 0x00C0, 0x228E, 0x0000 },
 375{ 0x40, 0x18, 0x0000, 0x3001, 0x0000 },
 376{ 0x40, 0x18, 0x0010, 0x3101, 0x0000 },
 377{ 0x40, 0x18, 0x0008, 0x3301, 0x0000 },
 378{ 0x40, 0x18, 0x0000, 0x3400, 0x0000 },
 379{ 0x40, 0x18, 0x0012, 0x3549, 0x0000 },
 380{ 0x40, 0x18, 0x0000, 0x3620, 0x0000 },
 381{ 0x40, 0x18, 0x0001, 0x3700, 0x0000 },
 382{ 0x40, 0x18, 0x0000, 0x4000, 0x0000 },
 383{ 0x40, 0x18, 0xFFFF, 0x41FF, 0x0000 },
 384{ 0x40, 0x18, 0xFFFF, 0x42FF, 0x0000 },
 385{ 0x40, 0x18, 0x0000, 0x500F, 0x0000 },
 386{ 0x40, 0x18, 0x2272, 0x5108, 0x0000 },
 387{ 0x40, 0x18, 0x2272, 0x5208, 0x0000 },
 388{ 0x40, 0x18, 0xFFFF, 0x53FF, 0x0000 },
 389{ 0x40, 0x18, 0xFFFF, 0x54FF, 0x0000 },
 390{ 0x40, 0x18, 0x0000, 0x6000, 0x0000 },
 391{ 0x40, 0x18, 0x0000, 0x6102, 0x0000 },
 392{ 0x40, 0x18, 0x0010, 0x6214, 0x0000 },
 393{ 0x40, 0x18, 0x0C80, 0x6300, 0x0000 },
 394{ 0x40, 0x18, 0x0000, 0x6401, 0x0000 },
 395{ 0x40, 0x18, 0x0680, 0x6551, 0x0000 },
 396{ 0x40, 0x18, 0xFFFF, 0x66FF, 0x0000 },
 397{ 0x40, 0x18, 0x0000, 0x6702, 0x0000 },
 398{ 0x40, 0x18, 0x0010, 0x6800, 0x0000 },
 399{ 0x40, 0x18, 0x0000, 0x6900, 0x0000 },
 400{ 0x40, 0x18, 0x0000, 0x6A00, 0x0000 },
 401{ 0x40, 0x18, 0x0000, 0x6B00, 0x0000 },
 402{ 0x40, 0x18, 0x0000, 0x6C00, 0x0000 },
 403{ 0x40, 0x18, 0x0000, 0x6D01, 0x0000 },
 404{ 0x40, 0x18, 0x0000, 0x6E00, 0x0000 },
 405{ 0x40, 0x18, 0x0000, 0x6F00, 0x0000 },
 406{ 0x40, 0x18, 0x0000, 0x7000, 0x0000 },
 407{ 0x40, 0x18, 0x0001, 0x7118, 0x0000 },
 408{ 0x40, 0x18, 0x0000, 0x2001, 0x0000 },
 409{ 0x40, 0x18, 0x0000, 0x1101, 0x0000 },
 410{ 0x40, 0x18, 0x0000, 0x1301, 0x0000 },
 411{ 0x40, 0x18, 0x0000, 0x1300, 0x0000 },
 412{ 0x40, 0x18, 0x0000, 0x1501, 0x0000 },
 413{ 0xC0, 0x11, 0x0000, 0x24C0, 0x0003 },
 414{ 0x40, 0x18, 0x0000, 0x3000, 0x0000 },
 415{ 0x40, 0x18, 0x0000, 0x3620, 0x0000 },
 416{ 0x40, 0x18, 0x0000, 0x1501, 0x0000 },
 417{ 0x40, 0x18, 0x0010, 0x6300, 0x0000 },
 418{ 0x40, 0x18, 0x0002, 0x01F0, 0x0000 },
 419{ 0x40, 0x01, 0x0003, 0x000F, 0x0000 }
 420};
 421
 422static const struct dtcs033_usb_requests dtcs033_stop_reqs[] = {
 423/* -- bRequest,wValue,wIndex,wLength */
 424{ 0x40, 0x01, 0x0001, 0x000F, 0x0000 },
 425{ 0x40, 0x01, 0x0000, 0x000F, 0x0000 },
 426{ 0x40, 0x18, 0x0000, 0x0003, 0x0000 }
 427};
 428static int dtcs033_start(struct gspca_dev *gspca_dev)
 429{
 430        return reg_reqs(gspca_dev, dtcs033_start_reqs,
 431                ARRAY_SIZE(dtcs033_start_reqs));
 432}
 433
 434static void dtcs033_stopN(struct gspca_dev *gspca_dev)
 435{
 436        reg_reqs(gspca_dev, dtcs033_stop_reqs,
 437                ARRAY_SIZE(dtcs033_stop_reqs));
 438        return;
 439}
 440