drivers/media/usb/s2255/s2255drv.c

   1 /*
   2  *  s2255drv.c - a driver for the Sensoray 2255 USB video capture device
   3  *
   4  *   Copyright (C) 2007-2014 by Sensoray Company Inc.
   5  *                              Dean Anderson
   6  *
   7  * Some video buffer code based on vivi driver:
   8  *
   9  * Sensoray 2255 device supports 4 simultaneous channels.
  10  * The channels are not "crossbar" inputs, they are physically
  11  * attached to separate video decoders.
  12  *
  13  * Because of USB2.0 bandwidth limitations. There is only a
  14  * certain amount of data which may be transferred at one time.
  15  *
  16  * Example maximum bandwidth utilization:
  17  *
  18  * -full size, color mode YUYV or YUV422P: 2 channels at once
  19  * -full or half size Grey scale: all 4 channels at once
  20  * -half size, color mode YUYV or YUV422P: all 4 channels at once
  21  * -full size, color mode YUYV or YUV422P 1/2 frame rate: all 4 channels
  22  *  at once.
  23  *
  24  * This program is free software; you can redistribute it and/or modify
  25  * it under the terms of the GNU General Public License as published by
  26  * the Free Software Foundation; either version 2 of the License, or
  27  * (at your option) any later version.
  28  *
  29  * This program is distributed in the hope that it will be useful,
  30  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  31  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  32  * GNU General Public License for more details.
  33  *
  34  * You should have received a copy of the GNU General Public License
  35  * along with this program; if not, write to the Free Software
  36  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  37  */
  38
  39 #include <linux/module.h>
  40 #include <linux/firmware.h>
  41 #include <linux/kernel.h>
  42 #include <linux/mutex.h>
  43 #include <linux/slab.h>
  44 #include <linux/videodev2.h>
  45 #include <linux/mm.h>
  46 #include <linux/vmalloc.h>
  47 #include <linux/usb.h>
  48 #include <media/videobuf2-v4l2.h>
  49 #include <media/videobuf2-vmalloc.h>
  50 #include <media/v4l2-common.h>
  51 #include <media/v4l2-device.h>
  52 #include <media/v4l2-ioctl.h>
  53 #include <media/v4l2-ctrls.h>
  54 #include <media/v4l2-event.h>
  55
  56 #define S2255_VERSION           "1.25.1"
  57 #define FIRMWARE_FILE_NAME "f2255usb.bin"
  58
  59 /* default JPEG quality */
  60 #define S2255_DEF_JPEG_QUAL     50
  61 /* vendor request in */
  62 #define S2255_VR_IN             0
  63 /* vendor request out */
  64 #define S2255_VR_OUT            1
  65 /* firmware query */
  66 #define S2255_VR_FW             0x30
  67 /* USB endpoint number for configuring the device */
  68 #define S2255_CONFIG_EP         2
  69 /* maximum time for DSP to start responding after last FW word loaded(ms) */
  70 #define S2255_DSP_BOOTTIME      800
  71 /* maximum time to wait for firmware to load (ms) */
  72 #define S2255_LOAD_TIMEOUT      (5000 + S2255_DSP_BOOTTIME)
  73 #define S2255_MIN_BUFS          2
  74 #define S2255_SETMODE_TIMEOUT   500
  75 #define S2255_VIDSTATUS_TIMEOUT 350
  76 #define S2255_MARKER_FRAME      cpu_to_le32(0x2255DA4AL)
  77 #define S2255_MARKER_RESPONSE   cpu_to_le32(0x2255ACACL)
  78 #define S2255_RESPONSE_SETMODE  cpu_to_le32(0x01)
  79 #define S2255_RESPONSE_FW       cpu_to_le32(0x10)
  80 #define S2255_RESPONSE_STATUS   cpu_to_le32(0x20)
  81 #define S2255_USB_XFER_SIZE     (16 * 1024)
  82 #define MAX_CHANNELS            4
  83 #define SYS_FRAMES              4
  84 /* maximum size is PAL full size plus room for the marker header(s) */
  85 #define SYS_FRAMES_MAXSIZE      (720*288*2*2 + 4096)
  86 #define DEF_USB_BLOCK           S2255_USB_XFER_SIZE
  87 #define LINE_SZ_4CIFS_NTSC      640
  88 #define LINE_SZ_2CIFS_NTSC      640
  89 #define LINE_SZ_1CIFS_NTSC      320
  90 #define LINE_SZ_4CIFS_PAL       704
  91 #define LINE_SZ_2CIFS_PAL       704
  92 #define LINE_SZ_1CIFS_PAL       352
  93 #define NUM_LINES_4CIFS_NTSC    240
  94 #define NUM_LINES_2CIFS_NTSC    240
  95 #define NUM_LINES_1CIFS_NTSC    240
  96 #define NUM_LINES_4CIFS_PAL     288
  97 #define NUM_LINES_2CIFS_PAL     288
  98 #define NUM_LINES_1CIFS_PAL     288
  99 #define LINE_SZ_DEF             640
 100 #define NUM_LINES_DEF           240
 101
 102
 103 /* predefined settings */
 104 #define FORMAT_NTSC     1
 105 #define FORMAT_PAL      2
 106
 107 #define SCALE_4CIFS     1       /* 640x480(NTSC) or 704x576(PAL) */
 108 #define SCALE_2CIFS     2       /* 640x240(NTSC) or 704x288(PAL) */
 109 #define SCALE_1CIFS     3       /* 320x240(NTSC) or 352x288(PAL) */
 110 /* SCALE_4CIFSI is the 2 fields interpolated into one */
 111 #define SCALE_4CIFSI    4       /* 640x480(NTSC) or 704x576(PAL) high quality */
 112
 113 #define COLOR_YUVPL     1       /* YUV planar */
 114 #define COLOR_YUVPK     2       /* YUV packed */
 115 #define COLOR_Y8        4       /* monochrome */
 116 #define COLOR_JPG       5       /* JPEG */
 117
 118 #define MASK_COLOR       0x000000ff
 119 #define MASK_JPG_QUALITY 0x0000ff00
 120 #define MASK_INPUT_TYPE  0x000f0000
 121 /* frame decimation. */
 122 #define FDEC_1          1       /* capture every frame. default */
 123 #define FDEC_2          2       /* capture every 2nd frame */
 124 #define FDEC_3          3       /* capture every 3rd frame */
 125 #define FDEC_5          5       /* capture every 5th frame */
 126
 127 /*-------------------------------------------------------
 128  * Default mode parameters.
 129  *-------------------------------------------------------*/
 130 #define DEF_SCALE       SCALE_4CIFS
 131 #define DEF_COLOR       COLOR_YUVPL
 132 #define DEF_FDEC        FDEC_1
 133 #define DEF_BRIGHT      0
 134 #define DEF_CONTRAST    0x5c
 135 #define DEF_SATURATION  0x80
 136 #define DEF_HUE         0
 137
 138 /* usb config commands */
 139 #define IN_DATA_TOKEN   cpu_to_le32(0x2255c0de)
 140 #define CMD_2255        0xc2255000
 141 #define CMD_SET_MODE    cpu_to_le32((CMD_2255 | 0x10))
 142 #define CMD_START       cpu_to_le32((CMD_2255 | 0x20))
 143 #define CMD_STOP        cpu_to_le32((CMD_2255 | 0x30))
 144 #define CMD_STATUS      cpu_to_le32((CMD_2255 | 0x40))
 145
 146 struct s2255_mode {
 147         u32 format;     /* input video format (NTSC, PAL) */
 148         u32 scale;      /* output video scale */
 149         u32 color;      /* output video color format */
 150         u32 fdec;       /* frame decimation */
 151         u32 bright;     /* brightness */
 152         u32 contrast;   /* contrast */
 153         u32 saturation; /* saturation */
 154         u32 hue;        /* hue (NTSC only)*/
 155         u32 single;     /* capture 1 frame at a time (!=0), continuously (==0)*/
 156         u32 usb_block;  /* block size. should be 4096 of DEF_USB_BLOCK */
 157         u32 restart;    /* if DSP requires restart */
 158 };
 159
 160
 161 #define S2255_READ_IDLE         0
 162 #define S2255_READ_FRAME        1
 163
 164 /* frame structure */
 165 struct s2255_framei {
 166         unsigned long size;
 167         unsigned long ulState;  /* ulState:S2255_READ_IDLE, S2255_READ_FRAME*/
 168         void *lpvbits;          /* image data */
 169         unsigned long cur_size; /* current data copied to it */
 170 };
 171
 172 /* image buffer structure */
 173 struct s2255_bufferi {
 174         unsigned long dwFrames;                 /* number of frames in buffer */
 175         struct s2255_framei frame[SYS_FRAMES];  /* array of FRAME structures */
 176 };
 177
 178 #define DEF_MODEI_NTSC_CONT     {FORMAT_NTSC, DEF_SCALE, DEF_COLOR,     \
 179                         DEF_FDEC, DEF_BRIGHT, DEF_CONTRAST, DEF_SATURATION, \
 180                         DEF_HUE, 0, DEF_USB_BLOCK, 0}
 181
 182 /* for firmware loading, fw_state */
 183 #define S2255_FW_NOTLOADED      0
 184 #define S2255_FW_LOADED_DSPWAIT 1
 185 #define S2255_FW_SUCCESS        2
 186 #define S2255_FW_FAILED         3
 187 #define S2255_FW_DISCONNECTING  4
 188 #define S2255_FW_MARKER         cpu_to_le32(0x22552f2f)
 189 /* 2255 read states */
 190 #define S2255_READ_IDLE         0
 191 #define S2255_READ_FRAME        1
 192 struct s2255_fw {
 193         int                   fw_loaded;
 194         int                   fw_size;
 195         struct urb            *fw_urb;
 196         atomic_t              fw_state;
 197         void                  *pfw_data;
 198         wait_queue_head_t     wait_fw;
 199         const struct firmware *fw;
 200 };
 201
 202 struct s2255_pipeinfo {
 203         u32 max_transfer_size;
 204         u32 cur_transfer_size;
 205         u8 *transfer_buffer;
 206         u32 state;
 207         void *stream_urb;
 208         void *dev;      /* back pointer to s2255_dev struct*/
 209         u32 err_count;
 210         u32 idx;
 211 };
 212
 213 struct s2255_fmt; /*forward declaration */
 214 struct s2255_dev;
 215
 216 /* 2255 video channel */
 217 struct s2255_vc {
 218         struct s2255_dev        *dev;
 219         struct video_device     vdev;
 220         struct v4l2_ctrl_handler hdl;
 221         struct v4l2_ctrl        *jpegqual_ctrl;
 222         int                     resources;
 223         struct list_head        buf_list;
 224         struct s2255_bufferi    buffer;
 225         struct s2255_mode       mode;
 226         v4l2_std_id             std;
 227         /* jpeg compression */
 228         unsigned                jpegqual;
 229         /* capture parameters (for high quality mode full size) */
 230         struct v4l2_captureparm cap_parm;
 231         int                     cur_frame;
 232         int                     last_frame;
 233         /* allocated image size */
 234         unsigned long           req_image_size;
 235         /* received packet size */
 236         unsigned long           pkt_size;
 237         int                     bad_payload;
 238         unsigned long           frame_count;
 239         /* if JPEG image */
 240         int                     jpg_size;
 241         /* if channel configured to default state */
 242         int                     configured;
 243         wait_queue_head_t       wait_setmode;
 244         int                     setmode_ready;
 245         /* video status items */
 246         int                     vidstatus;
 247         wait_queue_head_t       wait_vidstatus;
 248         int                     vidstatus_ready;
 249         unsigned int            width;
 250         unsigned int            height;
 251         enum v4l2_field         field;
 252         const struct s2255_fmt  *fmt;
 253         int idx; /* channel number on device, 0-3 */
 254         struct vb2_queue vb_vidq;
 255         struct mutex vb_lock; /* streaming lock */
 256         spinlock_t qlock;
 257 };
 258
 259
 260 struct s2255_dev {
 261         struct s2255_vc         vc[MAX_CHANNELS];
 262         struct v4l2_device      v4l2_dev;
 263         atomic_t                num_channels;
 264         int                     frames;
 265         struct mutex            lock;   /* channels[].vdev.lock */
 266         struct mutex            cmdlock; /* protects cmdbuf */
 267         struct usb_device       *udev;
 268         struct usb_interface    *interface;
 269         u8                      read_endpoint;
 270         struct timer_list       timer;
 271         struct s2255_fw *fw_data;
 272         struct s2255_pipeinfo   pipe;
 273         u32                     cc;     /* current channel */
 274         int                     frame_ready;
 275         int                     chn_ready;
 276         /* dsp firmware version (f2255usb.bin) */
 277         int                     dsp_fw_ver;
 278         u16                     pid; /* product id */
 279 #define S2255_CMDBUF_SIZE 512
 280         __le32                  *cmdbuf;
 281 };
 282
 283 static inline struct s2255_dev *to_s2255_dev(struct v4l2_device *v4l2_dev)
 284 {
 285         return container_of(v4l2_dev, struct s2255_dev, v4l2_dev);
 286 }
 287
 288 struct s2255_fmt {
 289         char *name;
 290         u32 fourcc;
 291         int depth;
 292 };
 293
 294 /* buffer for one video frame */
 295 struct s2255_buffer {
 296         /* common v4l buffer stuff -- must be first */
 297         struct vb2_v4l2_buffer vb;
 298         struct list_head list;
 299 };
 300
 301
 302 /* current cypress EEPROM firmware version */
 303 #define S2255_CUR_USB_FWVER     ((3 << 8) | 12)
 304 /* current DSP FW version */
 305 #define S2255_CUR_DSP_FWVER     10104
 306 /* Need DSP version 5+ for video status feature */
 307 #define S2255_MIN_DSP_STATUS      5
 308 #define S2255_MIN_DSP_COLORFILTER 8
 309 #define S2255_NORMS             (V4L2_STD_ALL)
 310
 311 /* private V4L2 controls */
 312
 313 /*
 314  * The following chart displays how COLORFILTER should be set
 315  *  =========================================================
 316  *  =     fourcc              =     COLORFILTER             =
 317  *  =                         ===============================
 318  *  =                         =   0             =    1      =
 319  *  =========================================================
 320  *  =  V4L2_PIX_FMT_GREY(Y8)  = monochrome from = monochrome=
 321  *  =                         = s-video or      = composite =
 322  *  =                         = B/W camera      = input     =
 323  *  =========================================================
 324  *  =    other                = color, svideo   = color,    =
 325  *  =                         =                 = composite =
 326  *  =========================================================
 327  *
 328  * Notes:
 329  *   channels 0-3 on 2255 are composite
 330  *   channels 0-1 on 2257 are composite, 2-3 are s-video
 331  * If COLORFILTER is 0 with a composite color camera connected,
 332  * the output will appear monochrome but hatching
 333  * will occur.
 334  * COLORFILTER is different from "color killer" and "color effects"
 335  * for reasons above.
 336  */
 337 #define S2255_V4L2_YC_ON  1
 338 #define S2255_V4L2_YC_OFF 0
 339 #define V4L2_CID_S2255_COLORFILTER (V4L2_CID_USER_S2255_BASE + 0)
 340
 341 /* frame prefix size (sent once every frame) */
 342 #define PREFIX_SIZE             512
 343
 344 /* Channels on box are in reverse order */
 345 static unsigned long G_chnmap[MAX_CHANNELS] = {3, 2, 1, 0};
 346
 347 static int debug;
 348
 349 static int s2255_start_readpipe(struct s2255_dev *dev);
 350 static void s2255_stop_readpipe(struct s2255_dev *dev);
 351 static int s2255_start_acquire(struct s2255_vc *vc);
 352 static int s2255_stop_acquire(struct s2255_vc *vc);
 353 static void s2255_fillbuff(struct s2255_vc *vc, struct s2255_buffer *buf,
 354                            int jpgsize);
 355 static int s2255_set_mode(struct s2255_vc *vc, struct s2255_mode *mode);
 356 static int s2255_board_shutdown(struct s2255_dev *dev);
 357 static void s2255_fwload_start(struct s2255_dev *dev, int reset);
 358 static void s2255_destroy(struct s2255_dev *dev);
 359 static long s2255_vendor_req(struct s2255_dev *dev, unsigned char req,
 360                              u16 index, u16 value, void *buf,
 361                              s32 buf_len, int bOut);
 362
 363 /* dev_err macro with driver name */
 364 #define S2255_DRIVER_NAME "s2255"
 365 #define s2255_dev_err(dev, fmt, arg...)                                 \
 366                 dev_err(dev, S2255_DRIVER_NAME " - " fmt, ##arg)
 367
 368 #define dprintk(dev, level, fmt, arg...) \
 369         v4l2_dbg(level, debug, &dev->v4l2_dev, fmt, ## arg)
 370
 371 static struct usb_driver s2255_driver;
 372
 373 /* start video number */
 374 static int video_nr = -1;       /* /dev/videoN, -1 for autodetect */
 375
 376 /* Enable jpeg capture. */
 377 static int jpeg_enable = 1;
 378
 379 module_param(debug, int, 0644);
 380 MODULE_PARM_DESC(debug, "Debug level(0-100) default 0");
 381 module_param(video_nr, int, 0644);
 382 MODULE_PARM_DESC(video_nr, "start video minor(-1 default autodetect)");
 383 module_param(jpeg_enable, int, 0644);
 384 MODULE_PARM_DESC(jpeg_enable, "Jpeg enable(1-on 0-off) default 1");
 385
 386 /* USB device table */
 387 #define USB_SENSORAY_VID        0x1943
 388 static struct usb_device_id s2255_table[] = {
 389         {USB_DEVICE(USB_SENSORAY_VID, 0x2255)},
 390         {USB_DEVICE(USB_SENSORAY_VID, 0x2257)}, /*same family as 2255*/
 391         { }                     /* Terminating entry */
 392 };
 393 MODULE_DEVICE_TABLE(usb, s2255_table);
 394
 395 #define BUFFER_TIMEOUT msecs_to_jiffies(400)
 396
 397 /* image formats.  */
 398 /* JPEG formats must be defined last to support jpeg_enable parameter */
 399 static const struct s2255_fmt formats[] = {
 400         {
 401                 .name = "4:2:2, packed, YUYV",
 402                 .fourcc = V4L2_PIX_FMT_YUYV,
 403                 .depth = 16
 404
 405         }, {
 406                 .name = "4:2:2, packed, UYVY",
 407                 .fourcc = V4L2_PIX_FMT_UYVY,
 408                 .depth = 16
 409         }, {
 410                 .name = "4:2:2, planar, YUV422P",
 411                 .fourcc = V4L2_PIX_FMT_YUV422P,
 412                 .depth = 16
 413
 414         }, {
 415                 .name = "8bpp GREY",
 416                 .fourcc = V4L2_PIX_FMT_GREY,
 417                 .depth = 8
 418         }, {
 419                 .name = "JPG",
 420                 .fourcc = V4L2_PIX_FMT_JPEG,
 421                 .depth = 24
 422         }, {
 423                 .name = "MJPG",
 424                 .fourcc = V4L2_PIX_FMT_MJPEG,
 425                 .depth = 24
 426         }
 427 };
 428
 429 static int norm_maxw(struct s2255_vc *vc)
 430 {
 431         return (vc->std & V4L2_STD_525_60) ?
 432             LINE_SZ_4CIFS_NTSC : LINE_SZ_4CIFS_PAL;
 433 }
 434
 435 static int norm_maxh(struct s2255_vc *vc)
 436 {
 437         return (vc->std & V4L2_STD_525_60) ?
 438             (NUM_LINES_1CIFS_NTSC * 2) : (NUM_LINES_1CIFS_PAL * 2);
 439 }
 440
 441 static int norm_minw(struct s2255_vc *vc)
 442 {
 443         return (vc->std & V4L2_STD_525_60) ?
 444             LINE_SZ_1CIFS_NTSC : LINE_SZ_1CIFS_PAL;
 445 }
 446
 447 static int norm_minh(struct s2255_vc *vc)
 448 {
 449         return (vc->std & V4L2_STD_525_60) ?
 450             (NUM_LINES_1CIFS_NTSC) : (NUM_LINES_1CIFS_PAL);
 451 }
 452
 453
 454 /*
 455  * TODO: fixme: move YUV reordering to hardware
 456  * converts 2255 planar format to yuyv or uyvy
 457  */
 458 static void planar422p_to_yuv_packed(const unsigned char *in,
 459                                      unsigned char *out,
 460                                      int width, int height,
 461                                      int fmt)
 462 {
 463         unsigned char *pY;
 464         unsigned char *pCb;
 465         unsigned char *pCr;
 466         unsigned long size = height * width;
 467         unsigned int i;
 468         pY = (unsigned char *)in;
 469         pCr = (unsigned char *)in + height * width;
 470         pCb = (unsigned char *)in + height * width + (height * width / 2);
 471         for (i = 0; i < size * 2; i += 4) {
 472                 out[i] = (fmt == V4L2_PIX_FMT_YUYV) ? *pY++ : *pCr++;
 473                 out[i + 1] = (fmt == V4L2_PIX_FMT_YUYV) ? *pCr++ : *pY++;
 474                 out[i + 2] = (fmt == V4L2_PIX_FMT_YUYV) ? *pY++ : *pCb++;
 475                 out[i + 3] = (fmt == V4L2_PIX_FMT_YUYV) ? *pCb++ : *pY++;
 476         }
 477         return;
 478 }
 479
 480 static void s2255_reset_dsppower(struct s2255_dev *dev)
 481 {
 482         s2255_vendor_req(dev, 0x40, 0x0000, 0x0001, NULL, 0, 1);
 483         msleep(20);
 484         s2255_vendor_req(dev, 0x50, 0x0000, 0x0000, NULL, 0, 1);
 485         msleep(600);
 486         s2255_vendor_req(dev, 0x10, 0x0000, 0x0000, NULL, 0, 1);
 487         return;
 488 }
 489
 490 /* kickstarts the firmware loading. from probe
 491  */
 492 static void s2255_timer(unsigned long user_data)
 493 {
 494         struct s2255_fw *data = (struct s2255_fw *)user_data;
 495         if (usb_submit_urb(data->fw_urb, GFP_ATOMIC) < 0) {
 496                 pr_err("s2255: can't submit urb\n");
 497                 atomic_set(&data->fw_state, S2255_FW_FAILED);
 498                 /* wake up anything waiting for the firmware */
 499                 wake_up(&data->wait_fw);
 500                 return;
 501         }
 502 }
 503
 504
 505 /* this loads the firmware asynchronously.
 506    Originally this was done synchronously in probe.
 507    But it is better to load it asynchronously here than block
 508    inside the probe function. Blocking inside probe affects boot time.
 509    FW loading is triggered by the timer in the probe function
 510 */
 511 static void s2255_fwchunk_complete(struct urb *urb)
 512 {
 513         struct s2255_fw *data = urb->context;
 514         struct usb_device *udev = urb->dev;
 515         int len;
 516         if (urb->status) {
 517                 dev_err(&udev->dev, "URB failed with status %d\n", urb->status);
 518                 atomic_set(&data->fw_state, S2255_FW_FAILED);
 519                 /* wake up anything waiting for the firmware */
 520                 wake_up(&data->wait_fw);
 521                 return;
 522         }
 523         if (data->fw_urb == NULL) {
 524                 s2255_dev_err(&udev->dev, "disconnected\n");
 525                 atomic_set(&data->fw_state, S2255_FW_FAILED);
 526                 /* wake up anything waiting for the firmware */
 527                 wake_up(&data->wait_fw);
 528                 return;
 529         }
 530 #define CHUNK_SIZE 512
 531         /* all USB transfers must be done with continuous kernel memory.
 532            can't allocate more than 128k in current linux kernel, so
 533            upload the firmware in chunks
 534          */
 535         if (data->fw_loaded < data->fw_size) {
 536                 len = (data->fw_loaded + CHUNK_SIZE) > data->fw_size ?
 537                     data->fw_size % CHUNK_SIZE : CHUNK_SIZE;
 538
 539                 if (len < CHUNK_SIZE)
 540                         memset(data->pfw_data, 0, CHUNK_SIZE);
 541
 542                 memcpy(data->pfw_data,
 543                        (char *) data->fw->data + data->fw_loaded, len);
 544
 545                 usb_fill_bulk_urb(data->fw_urb, udev, usb_sndbulkpipe(udev, 2),
 546                                   data->pfw_data, CHUNK_SIZE,
 547                                   s2255_fwchunk_complete, data);
 548                 if (usb_submit_urb(data->fw_urb, GFP_ATOMIC) < 0) {
 549                         dev_err(&udev->dev, "failed submit URB\n");
 550                         atomic_set(&data->fw_state, S2255_FW_FAILED);
 551                         /* wake up anything waiting for the firmware */
 552                         wake_up(&data->wait_fw);
 553                         return;
 554                 }
 555                 data->fw_loaded += len;
 556         } else
 557                 atomic_set(&data->fw_state, S2255_FW_LOADED_DSPWAIT);
 558         return;
 559
 560 }
 561
 562 static void s2255_got_frame(struct s2255_vc *vc, int jpgsize)
 563 {
 564         struct s2255_buffer *buf;
 565         struct s2255_dev *dev = to_s2255_dev(vc->vdev.v4l2_dev);
 566         unsigned long flags = 0;
 567
 568         spin_lock_irqsave(&vc->qlock, flags);
 569         if (list_empty(&vc->buf_list)) {
 570                 dprintk(dev, 1, "No active queue to serve\n");
 571                 spin_unlock_irqrestore(&vc->qlock, flags);
 572                 return;
 573         }
 574         buf = list_entry(vc->buf_list.next,
 575                          struct s2255_buffer, list);
 576         list_del(&buf->list);
 577         v4l2_get_timestamp(&buf->vb.timestamp);
 578         buf->vb.field = vc->field;
 579         buf->vb.sequence = vc->frame_count;
 580         spin_unlock_irqrestore(&vc->qlock, flags);
 581
 582         s2255_fillbuff(vc, buf, jpgsize);
 583         /* tell v4l buffer was filled */
 584         vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_DONE);
 585         dprintk(dev, 2, "%s: [buf] [%p]\n", __func__, buf);
 586 }
 587
 588 static const struct s2255_fmt *format_by_fourcc(int fourcc)
 589 {
 590         unsigned int i;
 591         for (i = 0; i < ARRAY_SIZE(formats); i++) {
 592                 if (-1 == formats[i].fourcc)
 593                         continue;
 594                 if (!jpeg_enable && ((formats[i].fourcc == V4L2_PIX_FMT_JPEG) ||
 595                                      (formats[i].fourcc == V4L2_PIX_FMT_MJPEG)))
 596                         continue;
 597                 if (formats[i].fourcc == fourcc)
 598                         return formats + i;
 599         }
 600         return NULL;
 601 }
 602
 603 /* video buffer vmalloc implementation based partly on VIVI driver which is
 604  *          Copyright (c) 2006 by
 605  *                  Mauro Carvalho Chehab <mchehab--a.t--infradead.org>
 606  *                  Ted Walther <ted--a.t--enumera.com>
 607  *                  John Sokol <sokol--a.t--videotechnology.com>
 608  *                  http://v4l.videotechnology.com/
 609  *
 610  */
 611 static void s2255_fillbuff(struct s2255_vc *vc,
 612                            struct s2255_buffer *buf, int jpgsize)
 613 {
 614         int pos = 0;
 615         const char *tmpbuf;
 616         char *vbuf = vb2_plane_vaddr(&buf->vb.vb2_buf, 0);
 617         unsigned long last_frame;
 618         struct s2255_dev *dev = vc->dev;
 619
 620         if (!vbuf)
 621                 return;
 622         last_frame = vc->last_frame;
 623         if (last_frame != -1) {
 624                 tmpbuf =
 625                     (const char *)vc->buffer.frame[last_frame].lpvbits;
 626                 switch (vc->fmt->fourcc) {
 627                 case V4L2_PIX_FMT_YUYV:
 628                 case V4L2_PIX_FMT_UYVY:
 629                         planar422p_to_yuv_packed((const unsigned char *)tmpbuf,
 630                                                  vbuf, vc->width,
 631                                                  vc->height,
 632                                                  vc->fmt->fourcc);
 633                         break;
 634                 case V4L2_PIX_FMT_GREY:
 635                         memcpy(vbuf, tmpbuf, vc->width * vc->height);
 636                         break;
 637                 case V4L2_PIX_FMT_JPEG:
 638                 case V4L2_PIX_FMT_MJPEG:
 639                         vb2_set_plane_payload(&buf->vb.vb2_buf, 0, jpgsize);
 640                         memcpy(vbuf, tmpbuf, jpgsize);
 641                         break;
 642                 case V4L2_PIX_FMT_YUV422P:
 643                         memcpy(vbuf, tmpbuf,
 644                                vc->width * vc->height * 2);
 645                         break;
 646                 default:
 647                         pr_info("s2255: unknown format?\n");
 648                 }
 649                 vc->last_frame = -1;
 650         } else {
 651                 pr_err("s2255: =======no frame\n");
 652                 return;
 653         }
 654         dprintk(dev, 2, "s2255fill at : Buffer 0x%08lx size= %d\n",
 655                 (unsigned long)vbuf, pos);
 656 }
 657
 658
 659 /* ------------------------------------------------------------------
 660    Videobuf operations
 661    ------------------------------------------------------------------*/
 662
 663 static int queue_setup(struct vb2_queue *vq, const void *parg,
 664                        unsigned int *nbuffers, unsigned int *nplanes,
 665                        unsigned int sizes[], void *alloc_ctxs[])
 666 {
 667         struct s2255_vc *vc = vb2_get_drv_priv(vq);
 668         if (*nbuffers < S2255_MIN_BUFS)
 669                 *nbuffers = S2255_MIN_BUFS;
 670         *nplanes = 1;
 671         sizes[0] = vc->width * vc->height * (vc->fmt->depth >> 3);
 672         return 0;
 673 }
 674
 675 static int buffer_prepare(struct vb2_buffer *vb)
 676 {
 677         struct s2255_vc *vc = vb2_get_drv_priv(vb->vb2_queue);
 678         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
 679         struct s2255_buffer *buf = container_of(vbuf, struct s2255_buffer, vb);
 680         int w = vc->width;
 681         int h = vc->height;
 682         unsigned long size;
 683
 684         dprintk(vc->dev, 4, "%s\n", __func__);
 685         if (vc->fmt == NULL)
 686                 return -EINVAL;
 687
 688         if ((w < norm_minw(vc)) ||
 689             (w > norm_maxw(vc)) ||
 690             (h < norm_minh(vc)) ||
 691             (h > norm_maxh(vc))) {
 692                 dprintk(vc->dev, 4, "invalid buffer prepare\n");
 693                 return -EINVAL;
 694         }
 695         size = w * h * (vc->fmt->depth >> 3);
 696         if (vb2_plane_size(vb, 0) < size) {
 697                 dprintk(vc->dev, 4, "invalid buffer prepare\n");
 698                 return -EINVAL;
 699         }
 700
 701         vb2_set_plane_payload(&buf->vb.vb2_buf, 0, size);
 702         return 0;
 703 }
 704
 705 static void buffer_queue(struct vb2_buffer *vb)
 706 {
 707         struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
 708         struct s2255_buffer *buf = container_of(vbuf, struct s2255_buffer, vb);
 709         struct s2255_vc *vc = vb2_get_drv_priv(vb->vb2_queue);
 710         unsigned long flags = 0;
 711         dprintk(vc->dev, 1, "%s\n", __func__);
 712         spin_lock_irqsave(&vc->qlock, flags);
 713         list_add_tail(&buf->list, &vc->buf_list);
 714         spin_unlock_irqrestore(&vc->qlock, flags);
 715 }
 716
 717 static int start_streaming(struct vb2_queue *vq, unsigned int count);
 718 static void stop_streaming(struct vb2_queue *vq);
 719
 720 static struct vb2_ops s2255_video_qops = {
 721         .queue_setup = queue_setup,
 722         .buf_prepare = buffer_prepare,
 723         .buf_queue = buffer_queue,
 724         .start_streaming = start_streaming,
 725         .stop_streaming = stop_streaming,
 726         .wait_prepare = vb2_ops_wait_prepare,
 727         .wait_finish = vb2_ops_wait_finish,
 728 };
 729
 730 static int vidioc_querycap(struct file *file, void *priv,
 731                            struct v4l2_capability *cap)
 732 {
 733         struct s2255_vc *vc = video_drvdata(file);
 734         struct s2255_dev *dev = vc->dev;
 735
 736         strlcpy(cap->driver, "s2255", sizeof(cap->driver));
 737         strlcpy(cap->card, "s2255", sizeof(cap->card));
 738         usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
 739         cap->device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_STREAMING |
 740                 V4L2_CAP_READWRITE;
 741         cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
 742         return 0;
 743 }
 744
 745 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
 746                                struct v4l2_fmtdesc *f)
 747 {
 748         int index = f->index;
 749
 750         if (index >= ARRAY_SIZE(formats))
 751                 return -EINVAL;
 752         if (!jpeg_enable && ((formats[index].fourcc == V4L2_PIX_FMT_JPEG) ||
 753                         (formats[index].fourcc == V4L2_PIX_FMT_MJPEG)))
 754                 return -EINVAL;
 755         strlcpy(f->description, formats[index].name, sizeof(f->description));
 756         f->pixelformat = formats[index].fourcc;
 757         return 0;
 758 }
 759
 760 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
 761                             struct v4l2_format *f)
 762 {
 763         struct s2255_vc *vc = video_drvdata(file);
 764         int is_ntsc = vc->std & V4L2_STD_525_60;
 765
 766         f->fmt.pix.width = vc->width;
 767         f->fmt.pix.height = vc->height;
 768         if (f->fmt.pix.height >=
 769             (is_ntsc ? NUM_LINES_1CIFS_NTSC : NUM_LINES_1CIFS_PAL) * 2)
 770                 f->fmt.pix.field = V4L2_FIELD_INTERLACED;
 771         else
 772                 f->fmt.pix.field = V4L2_FIELD_TOP;
 773         f->fmt.pix.pixelformat = vc->fmt->fourcc;
 774         f->fmt.pix.bytesperline = f->fmt.pix.width * (vc->fmt->depth >> 3);
 775         f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
 776         f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
 777         f->fmt.pix.priv = 0;
 778         return 0;
 779 }
 780
 781 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
 782                               struct v4l2_format *f)
 783 {
 784         const struct s2255_fmt *fmt;
 785         enum v4l2_field field;
 786         struct s2255_vc *vc = video_drvdata(file);
 787         int is_ntsc = vc->std & V4L2_STD_525_60;
 788
 789         fmt = format_by_fourcc(f->fmt.pix.pixelformat);
 790
 791         if (fmt == NULL)
 792                 return -EINVAL;
 793
 794         field = f->fmt.pix.field;
 795
 796         dprintk(vc->dev, 50, "%s NTSC: %d suggested width: %d, height: %d\n",
 797                 __func__, is_ntsc, f->fmt.pix.width, f->fmt.pix.height);
 798         if (is_ntsc) {
 799                 /* NTSC */
 800                 if (f->fmt.pix.height >= NUM_LINES_1CIFS_NTSC * 2) {
 801                         f->fmt.pix.height = NUM_LINES_1CIFS_NTSC * 2;
 802                         field = V4L2_FIELD_INTERLACED;
 803                 } else {
 804                         f->fmt.pix.height = NUM_LINES_1CIFS_NTSC;
 805                         field = V4L2_FIELD_TOP;
 806                 }
 807                 if (f->fmt.pix.width >= LINE_SZ_4CIFS_NTSC)
 808                         f->fmt.pix.width = LINE_SZ_4CIFS_NTSC;
 809                 else if (f->fmt.pix.width >= LINE_SZ_2CIFS_NTSC)
 810                         f->fmt.pix.width = LINE_SZ_2CIFS_NTSC;
 811                 else if (f->fmt.pix.width >= LINE_SZ_1CIFS_NTSC)
 812                         f->fmt.pix.width = LINE_SZ_1CIFS_NTSC;
 813                 else
 814                         f->fmt.pix.width = LINE_SZ_1CIFS_NTSC;
 815         } else {
 816                 /* PAL */
 817                 if (f->fmt.pix.height >= NUM_LINES_1CIFS_PAL * 2) {
 818                         f->fmt.pix.height = NUM_LINES_1CIFS_PAL * 2;
 819                         field = V4L2_FIELD_INTERLACED;
 820                 } else {
 821                         f->fmt.pix.height = NUM_LINES_1CIFS_PAL;
 822                         field = V4L2_FIELD_TOP;
 823                 }
 824                 if (f->fmt.pix.width >= LINE_SZ_4CIFS_PAL)
 825                         f->fmt.pix.width = LINE_SZ_4CIFS_PAL;
 826                 else if (f->fmt.pix.width >= LINE_SZ_2CIFS_PAL)
 827                         f->fmt.pix.width = LINE_SZ_2CIFS_PAL;
 828                 else if (f->fmt.pix.width >= LINE_SZ_1CIFS_PAL)
 829                         f->fmt.pix.width = LINE_SZ_1CIFS_PAL;
 830                 else
 831                         f->fmt.pix.width = LINE_SZ_1CIFS_PAL;
 832         }
 833         f->fmt.pix.field = field;
 834         f->fmt.pix.bytesperline = (f->fmt.pix.width * fmt->depth) >> 3;
 835         f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
 836         f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
 837         f->fmt.pix.priv = 0;
 838         dprintk(vc->dev, 50, "%s: set width %d height %d field %d\n", __func__,
 839                 f->fmt.pix.width, f->fmt.pix.height, f->fmt.pix.field);
 840         return 0;
 841 }
 842
 843 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
 844                             struct v4l2_format *f)
 845 {
 846         struct s2255_vc *vc = video_drvdata(file);
 847         const struct s2255_fmt *fmt;
 848         struct vb2_queue *q = &vc->vb_vidq;
 849         struct s2255_mode mode;
 850         int ret;
 851
 852         ret = vidioc_try_fmt_vid_cap(file, vc, f);
 853
 854         if (ret < 0)
 855                 return ret;
 856
 857         fmt = format_by_fourcc(f->fmt.pix.pixelformat);
 858
 859         if (fmt == NULL)
 860                 return -EINVAL;
 861
 862         if (vb2_is_busy(q)) {
 863                 dprintk(vc->dev, 1, "queue busy\n");
 864                 return -EBUSY;
 865         }
 866
 867         mode = vc->mode;
 868         vc->fmt = fmt;
 869         vc->width = f->fmt.pix.width;
 870         vc->height = f->fmt.pix.height;
 871         vc->field = f->fmt.pix.field;
 872         if (vc->width > norm_minw(vc)) {
 873                 if (vc->height > norm_minh(vc)) {
 874                         if (vc->cap_parm.capturemode &
 875                             V4L2_MODE_HIGHQUALITY)
 876                                 mode.scale = SCALE_4CIFSI;
 877                         else
 878                                 mode.scale = SCALE_4CIFS;
 879                 } else
 880                         mode.scale = SCALE_2CIFS;
 881
 882         } else {
 883                 mode.scale = SCALE_1CIFS;
 884         }
 885         /* color mode */
 886         switch (vc->fmt->fourcc) {
 887         case V4L2_PIX_FMT_GREY:
 888                 mode.color &= ~MASK_COLOR;
 889                 mode.color |= COLOR_Y8;
 890                 break;
 891         case V4L2_PIX_FMT_JPEG:
 892         case V4L2_PIX_FMT_MJPEG:
 893                 mode.color &= ~MASK_COLOR;
 894                 mode.color |= COLOR_JPG;
 895                 mode.color |= (vc->jpegqual << 8);
 896                 break;
 897         case V4L2_PIX_FMT_YUV422P:
 898                 mode.color &= ~MASK_COLOR;
 899                 mode.color |= COLOR_YUVPL;
 900                 break;
 901         case V4L2_PIX_FMT_YUYV:
 902         case V4L2_PIX_FMT_UYVY:
 903         default:
 904                 mode.color &= ~MASK_COLOR;
 905                 mode.color |= COLOR_YUVPK;
 906                 break;
 907         }
 908         if ((mode.color & MASK_COLOR) != (vc->mode.color & MASK_COLOR))
 909                 mode.restart = 1;
 910         else if (mode.scale != vc->mode.scale)
 911                 mode.restart = 1;
 912         else if (mode.format != vc->mode.format)
 913                 mode.restart = 1;
 914         vc->mode = mode;
 915         (void) s2255_set_mode(vc, &mode);
 916         return 0;
 917 }
 918
 919
 920 /* write to the configuration pipe, synchronously */
 921 static int s2255_write_config(struct usb_device *udev, unsigned char *pbuf,
 922                               int size)
 923 {
 924         int pipe;
 925         int done;
 926         long retval = -1;
 927         if (udev) {
 928                 pipe = usb_sndbulkpipe(udev, S2255_CONFIG_EP);
 929                 retval = usb_bulk_msg(udev, pipe, pbuf, size, &done, 500);
 930         }
 931         return retval;
 932 }
 933
 934 static u32 get_transfer_size(struct s2255_mode *mode)
 935 {
 936         int linesPerFrame = LINE_SZ_DEF;
 937         int pixelsPerLine = NUM_LINES_DEF;
 938         u32 outImageSize;
 939         u32 usbInSize;
 940         unsigned int mask_mult;
 941
 942         if (mode == NULL)
 943                 return 0;
 944
 945         if (mode->format == FORMAT_NTSC) {
 946                 switch (mode->scale) {
 947                 case SCALE_4CIFS:
 948                 case SCALE_4CIFSI:
 949                         linesPerFrame = NUM_LINES_4CIFS_NTSC * 2;
 950                         pixelsPerLine = LINE_SZ_4CIFS_NTSC;
 951                         break;
 952                 case SCALE_2CIFS:
 953                         linesPerFrame = NUM_LINES_2CIFS_NTSC;
 954                         pixelsPerLine = LINE_SZ_2CIFS_NTSC;
 955                         break;
 956                 case SCALE_1CIFS:
 957                         linesPerFrame = NUM_LINES_1CIFS_NTSC;
 958                         pixelsPerLine = LINE_SZ_1CIFS_NTSC;
 959                         break;
 960                 default:
 961                         break;
 962                 }
 963         } else if (mode->format == FORMAT_PAL) {
 964                 switch (mode->scale) {
 965                 case SCALE_4CIFS:
 966                 case SCALE_4CIFSI:
 967                         linesPerFrame = NUM_LINES_4CIFS_PAL * 2;
 968                         pixelsPerLine = LINE_SZ_4CIFS_PAL;
 969                         break;
 970                 case SCALE_2CIFS:
 971                         linesPerFrame = NUM_LINES_2CIFS_PAL;
 972                         pixelsPerLine = LINE_SZ_2CIFS_PAL;
 973                         break;
 974                 case SCALE_1CIFS:
 975                         linesPerFrame = NUM_LINES_1CIFS_PAL;
 976                         pixelsPerLine = LINE_SZ_1CIFS_PAL;
 977                         break;
 978                 default:
 979                         break;
 980                 }
 981         }
 982         outImageSize = linesPerFrame * pixelsPerLine;
 983         if ((mode->color & MASK_COLOR) != COLOR_Y8) {
 984                 /* 2 bytes/pixel if not monochrome */
 985                 outImageSize *= 2;
 986         }
 987
 988         /* total bytes to send including prefix and 4K padding;
 989            must be a multiple of USB_READ_SIZE */
 990         usbInSize = outImageSize + PREFIX_SIZE; /* always send prefix */
 991         mask_mult = 0xffffffffUL - DEF_USB_BLOCK + 1;
 992         /* if size not a multiple of USB_READ_SIZE */
 993         if (usbInSize & ~mask_mult)
 994                 usbInSize = (usbInSize & mask_mult) + (DEF_USB_BLOCK);
 995         return usbInSize;
 996 }
 997
 998 static void s2255_print_cfg(struct s2255_dev *sdev, struct s2255_mode *mode)
 999 {
1000         struct device *dev = &sdev->udev->dev;
1001         dev_info(dev, "------------------------------------------------\n");
1002         dev_info(dev, "format: %d\nscale %d\n", mode->format, mode->scale);
1003         dev_info(dev, "fdec: %d\ncolor %d\n", mode->fdec, mode->color);
1004         dev_info(dev, "bright: 0x%x\n", mode->bright);
1005         dev_info(dev, "------------------------------------------------\n");
1006 }
1007
1008 /*
1009  * set mode is the function which controls the DSP.
1010  * the restart parameter in struct s2255_mode should be set whenever
1011  * the image size could change via color format, video system or image
1012  * size.
1013  * When the restart parameter is set, we sleep for ONE frame to allow the
1014  * DSP time to get the new frame
1015  */
1016 static int s2255_set_mode(struct s2255_vc *vc,
1017                           struct s2255_mode *mode)
1018 {
1019         int res;
1020         unsigned long chn_rev;
1021         struct s2255_dev *dev = to_s2255_dev(vc->vdev.v4l2_dev);
1022         int i;
1023         __le32 *buffer = dev->cmdbuf;
1024
1025         mutex_lock(&dev->cmdlock);
1026         chn_rev = G_chnmap[vc->idx];
1027         dprintk(dev, 3, "%s channel: %d\n", __func__, vc->idx);
1028         /* if JPEG, set the quality */
1029         if ((mode->color & MASK_COLOR) == COLOR_JPG) {
1030                 mode->color &= ~MASK_COLOR;
1031                 mode->color |= COLOR_JPG;
1032                 mode->color &= ~MASK_JPG_QUALITY;
1033                 mode->color |= (vc->jpegqual << 8);
1034         }
1035         /* save the mode */
1036         vc->mode = *mode;
1037         vc->req_image_size = get_transfer_size(mode);
1038         dprintk(dev, 1, "%s: reqsize %ld\n", __func__, vc->req_image_size);
1039         /* set the mode */
1040         buffer[0] = IN_DATA_TOKEN;
1041         buffer[1] = (__le32) cpu_to_le32(chn_rev);
1042         buffer[2] = CMD_SET_MODE;
1043         for (i = 0; i < sizeof(struct s2255_mode) / sizeof(u32); i++)
1044                 buffer[3 + i] = cpu_to_le32(((u32 *)&vc->mode)[i]);
1045         vc->setmode_ready = 0;
1046         res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
1047         if (debug)
1048                 s2255_print_cfg(dev, mode);
1049         /* wait at least 3 frames before continuing */
1050         if (mode->restart) {
1051                 wait_event_timeout(vc->wait_setmode,
1052                                    (vc->setmode_ready != 0),
1053                                    msecs_to_jiffies(S2255_SETMODE_TIMEOUT));
1054                 if (vc->setmode_ready != 1) {
1055                         dprintk(dev, 0, "s2255: no set mode response\n");
1056                         res = -EFAULT;
1057                 }
1058         }
1059         /* clear the restart flag */
1060         vc->mode.restart = 0;
1061         dprintk(dev, 1, "%s chn %d, result: %d\n", __func__, vc->idx, res);
1062         mutex_unlock(&dev->cmdlock);
1063         return res;
1064 }
1065
1066 static int s2255_cmd_status(struct s2255_vc *vc, u32 *pstatus)
1067 {
1068         int res;
1069         u32 chn_rev;
1070         struct s2255_dev *dev = to_s2255_dev(vc->vdev.v4l2_dev);
1071         __le32 *buffer = dev->cmdbuf;
1072
1073         mutex_lock(&dev->cmdlock);
1074         chn_rev = G_chnmap[vc->idx];
1075         dprintk(dev, 4, "%s chan %d\n", __func__, vc->idx);
1076         /* form the get vid status command */
1077         buffer[0] = IN_DATA_TOKEN;
1078         buffer[1] = (__le32) cpu_to_le32(chn_rev);
1079         buffer[2] = CMD_STATUS;
1080         *pstatus = 0;
1081         vc->vidstatus_ready = 0;
1082         res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
1083         wait_event_timeout(vc->wait_vidstatus,
1084                            (vc->vidstatus_ready != 0),
1085                            msecs_to_jiffies(S2255_VIDSTATUS_TIMEOUT));
1086         if (vc->vidstatus_ready != 1) {
1087                 dprintk(dev, 0, "s2255: no vidstatus response\n");
1088                 res = -EFAULT;
1089         }
1090         *pstatus = vc->vidstatus;
1091         dprintk(dev, 4, "%s, vid status %d\n", __func__, *pstatus);
1092         mutex_unlock(&dev->cmdlock);
1093         return res;
1094 }
1095
1096 static int start_streaming(struct vb2_queue *vq, unsigned int count)
1097 {
1098         struct s2255_vc *vc = vb2_get_drv_priv(vq);
1099         int j;
1100
1101         vc->last_frame = -1;
1102         vc->bad_payload = 0;
1103         vc->cur_frame = 0;
1104         vc->frame_count = 0;
1105         for (j = 0; j < SYS_FRAMES; j++) {
1106                 vc->buffer.frame[j].ulState = S2255_READ_IDLE;
1107                 vc->buffer.frame[j].cur_size = 0;
1108         }
1109         return s2255_start_acquire(vc);
1110 }
1111
1112 /* abort streaming and wait for last buffer */
1113 static void stop_streaming(struct vb2_queue *vq)
1114 {
1115         struct s2255_vc *vc = vb2_get_drv_priv(vq);
1116         struct s2255_buffer *buf, *node;
1117         unsigned long flags;
1118         (void) s2255_stop_acquire(vc);
1119         spin_lock_irqsave(&vc->qlock, flags);
1120         list_for_each_entry_safe(buf, node, &vc->buf_list, list) {
1121                 list_del(&buf->list);
1122                 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
1123                 dprintk(vc->dev, 2, "[%p/%d] done\n",
1124                         buf, buf->vb.vb2_buf.index);
1125         }
1126         spin_unlock_irqrestore(&vc->qlock, flags);
1127 }
1128
1129 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id i)
1130 {
1131         struct s2255_vc *vc = video_drvdata(file);
1132         struct s2255_mode mode;
1133         struct vb2_queue *q = &vc->vb_vidq;
1134
1135         /*
1136          * Changing the standard implies a format change, which is not allowed
1137          * while buffers for use with streaming have already been allocated.
1138          */
1139         if (vb2_is_busy(q))
1140                 return -EBUSY;
1141
1142         mode = vc->mode;
1143         if (i & V4L2_STD_525_60) {
1144                 dprintk(vc->dev, 4, "%s 60 Hz\n", __func__);
1145                 /* if changing format, reset frame decimation/intervals */
1146                 if (mode.format != FORMAT_NTSC) {
1147                         mode.restart = 1;
1148                         mode.format = FORMAT_NTSC;
1149                         mode.fdec = FDEC_1;
1150                         vc->width = LINE_SZ_4CIFS_NTSC;
1151                         vc->height = NUM_LINES_4CIFS_NTSC * 2;
1152                 }
1153         } else if (i & V4L2_STD_625_50) {
1154                 dprintk(vc->dev, 4, "%s 50 Hz\n", __func__);
1155                 if (mode.format != FORMAT_PAL) {
1156                         mode.restart = 1;
1157                         mode.format = FORMAT_PAL;
1158                         mode.fdec = FDEC_1;
1159                         vc->width = LINE_SZ_4CIFS_PAL;
1160                         vc->height = NUM_LINES_4CIFS_PAL * 2;
1161                 }
1162         } else
1163                 return -EINVAL;
1164         vc->std = i;
1165         if (mode.restart)
1166                 s2255_set_mode(vc, &mode);
1167         return 0;
1168 }
1169
1170 static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *i)
1171 {
1172         struct s2255_vc *vc = video_drvdata(file);
1173
1174         *i = vc->std;
1175         return 0;
1176 }
1177
1178 /* Sensoray 2255 is a multiple channel capture device.
1179    It does not have a "crossbar" of inputs.
1180    We use one V4L device per channel. The user must
1181    be aware that certain combinations are not allowed.
1182    For instance, you cannot do full FPS on more than 2 channels(2 videodevs)
1183    at once in color(you can do full fps on 4 channels with greyscale.
1184 */
1185 static int vidioc_enum_input(struct file *file, void *priv,
1186                              struct v4l2_input *inp)
1187 {
1188         struct s2255_vc *vc = video_drvdata(file);
1189         struct s2255_dev *dev = vc->dev;
1190         u32 status = 0;
1191
1192         if (inp->index != 0)
1193                 return -EINVAL;
1194         inp->type = V4L2_INPUT_TYPE_CAMERA;
1195         inp->std = S2255_NORMS;
1196         inp->status = 0;
1197         if (dev->dsp_fw_ver >= S2255_MIN_DSP_STATUS) {
1198                 int rc;
1199                 rc = s2255_cmd_status(vc, &status);
1200                 dprintk(dev, 4, "s2255_cmd_status rc: %d status %x\n",
1201                         rc, status);
1202                 if (rc == 0)
1203                         inp->status =  (status & 0x01) ? 0
1204                                 : V4L2_IN_ST_NO_SIGNAL;
1205         }
1206         switch (dev->pid) {
1207         case 0x2255:
1208         default:
1209                 strlcpy(inp->name, "Composite", sizeof(inp->name));
1210                 break;
1211         case 0x2257:
1212                 strlcpy(inp->name, (vc->idx < 2) ? "Composite" : "S-Video",
1213                         sizeof(inp->name));
1214                 break;
1215         }
1216         return 0;
1217 }
1218
1219 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1220 {
1221         *i = 0;
1222         return 0;
1223 }
1224 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1225 {
1226         if (i > 0)
1227                 return -EINVAL;
1228         return 0;
1229 }
1230
1231 static int s2255_s_ctrl(struct v4l2_ctrl *ctrl)
1232 {
1233         struct s2255_vc *vc =
1234                 container_of(ctrl->handler, struct s2255_vc, hdl);
1235         struct s2255_mode mode;
1236         mode = vc->mode;
1237         /* update the mode to the corresponding value */
1238         switch (ctrl->id) {
1239         case V4L2_CID_BRIGHTNESS:
1240                 mode.bright = ctrl->val;
1241                 break;
1242         case V4L2_CID_CONTRAST:
1243                 mode.contrast = ctrl->val;
1244                 break;
1245         case V4L2_CID_HUE:
1246                 mode.hue = ctrl->val;
1247                 break;
1248         case V4L2_CID_SATURATION:
1249                 mode.saturation = ctrl->val;
1250                 break;
1251         case V4L2_CID_S2255_COLORFILTER:
1252                 mode.color &= ~MASK_INPUT_TYPE;
1253                 mode.color |= !ctrl->val << 16;
1254                 break;
1255         case V4L2_CID_JPEG_COMPRESSION_QUALITY:
1256                 vc->jpegqual = ctrl->val;
1257                 return 0;
1258         default:
1259                 return -EINVAL;
1260         }
1261         mode.restart = 0;
1262         /* set mode here.  Note: stream does not need restarted.
1263            some V4L programs restart stream unnecessarily
1264            after a s_crtl.
1265         */
1266         s2255_set_mode(vc, &mode);
1267         return 0;
1268 }
1269
1270 static int vidioc_g_jpegcomp(struct file *file, void *priv,
1271                          struct v4l2_jpegcompression *jc)
1272 {
1273         struct s2255_vc *vc = video_drvdata(file);
1274
1275         memset(jc, 0, sizeof(*jc));
1276         jc->quality = vc->jpegqual;
1277         dprintk(vc->dev, 2, "%s: quality %d\n", __func__, jc->quality);
1278         return 0;
1279 }
1280
1281 static int vidioc_s_jpegcomp(struct file *file, void *priv,
1282                          const struct v4l2_jpegcompression *jc)
1283 {
1284         struct s2255_vc *vc = video_drvdata(file);
1285
1286         if (jc->quality < 0 || jc->quality > 100)
1287                 return -EINVAL;
1288         v4l2_ctrl_s_ctrl(vc->jpegqual_ctrl, jc->quality);
1289         dprintk(vc->dev, 2, "%s: quality %d\n", __func__, jc->quality);
1290         return 0;
1291 }
1292
1293 static int vidioc_g_parm(struct file *file, void *priv,
1294                          struct v4l2_streamparm *sp)
1295 {
1296         __u32 def_num, def_dem;
1297         struct s2255_vc *vc = video_drvdata(file);
1298
1299         if (sp->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1300                 return -EINVAL;
1301         sp->parm.capture.capability = V4L2_CAP_TIMEPERFRAME;
1302         sp->parm.capture.capturemode = vc->cap_parm.capturemode;
1303         sp->parm.capture.readbuffers = S2255_MIN_BUFS;
1304         def_num = (vc->mode.format == FORMAT_NTSC) ? 1001 : 1000;
1305         def_dem = (vc->mode.format == FORMAT_NTSC) ? 30000 : 25000;
1306         sp->parm.capture.timeperframe.denominator = def_dem;
1307         switch (vc->mode.fdec) {
1308         default:
1309         case FDEC_1:
1310                 sp->parm.capture.timeperframe.numerator = def_num;
1311                 break;
1312         case FDEC_2:
1313                 sp->parm.capture.timeperframe.numerator = def_num * 2;
1314                 break;
1315         case FDEC_3:
1316                 sp->parm.capture.timeperframe.numerator = def_num * 3;
1317                 break;
1318         case FDEC_5:
1319                 sp->parm.capture.timeperframe.numerator = def_num * 5;
1320                 break;
1321         }
1322         dprintk(vc->dev, 4, "%s capture mode, %d timeperframe %d/%d\n",
1323                 __func__,
1324                 sp->parm.capture.capturemode,
1325                 sp->parm.capture.timeperframe.numerator,
1326                 sp->parm.capture.timeperframe.denominator);
1327         return 0;
1328 }
1329
1330 static int vidioc_s_parm(struct file *file, void *priv,
1331                          struct v4l2_streamparm *sp)
1332 {
1333         struct s2255_vc *vc = video_drvdata(file);
1334         struct s2255_mode mode;
1335         int fdec = FDEC_1;
1336         __u32 def_num, def_dem;
1337         if (sp->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1338                 return -EINVAL;
1339         mode = vc->mode;
1340         /* high quality capture mode requires a stream restart */
1341         if ((vc->cap_parm.capturemode != sp->parm.capture.capturemode)
1342             && vb2_is_streaming(&vc->vb_vidq))
1343                 return -EBUSY;
1344         def_num = (mode.format == FORMAT_NTSC) ? 1001 : 1000;
1345         def_dem = (mode.format == FORMAT_NTSC) ? 30000 : 25000;
1346         if (def_dem != sp->parm.capture.timeperframe.denominator)
1347                 sp->parm.capture.timeperframe.numerator = def_num;
1348         else if (sp->parm.capture.timeperframe.numerator <= def_num)
1349                 sp->parm.capture.timeperframe.numerator = def_num;
1350         else if (sp->parm.capture.timeperframe.numerator <= (def_num * 2)) {
1351                 sp->parm.capture.timeperframe.numerator = def_num * 2;
1352                 fdec = FDEC_2;
1353         } else if (sp->parm.capture.timeperframe.numerator <= (def_num * 3)) {
1354                 sp->parm.capture.timeperframe.numerator = def_num * 3;
1355                 fdec = FDEC_3;
1356         } else {
1357                 sp->parm.capture.timeperframe.numerator = def_num * 5;
1358                 fdec = FDEC_5;
1359         }
1360         mode.fdec = fdec;
1361         sp->parm.capture.timeperframe.denominator = def_dem;
1362         sp->parm.capture.readbuffers = S2255_MIN_BUFS;
1363         s2255_set_mode(vc, &mode);
1364         dprintk(vc->dev, 4, "%s capture mode, %d timeperframe %d/%d, fdec %d\n",
1365                 __func__,
1366                 sp->parm.capture.capturemode,
1367                 sp->parm.capture.timeperframe.numerator,
1368                 sp->parm.capture.timeperframe.denominator, fdec);
1369         return 0;
1370 }
1371
1372 #define NUM_SIZE_ENUMS 3
1373 static const struct v4l2_frmsize_discrete ntsc_sizes[] = {
1374         { 640, 480 },
1375         { 640, 240 },
1376         { 320, 240 },
1377 };
1378 static const struct v4l2_frmsize_discrete pal_sizes[] = {
1379         { 704, 576 },
1380         { 704, 288 },
1381         { 352, 288 },
1382 };
1383
1384 static int vidioc_enum_framesizes(struct file *file, void *priv,
1385                             struct v4l2_frmsizeenum *fe)
1386 {
1387         struct s2255_vc *vc = video_drvdata(file);
1388         int is_ntsc = vc->std & V4L2_STD_525_60;
1389         const struct s2255_fmt *fmt;
1390
1391         if (fe->index >= NUM_SIZE_ENUMS)
1392                 return -EINVAL;
1393
1394         fmt = format_by_fourcc(fe->pixel_format);
1395         if (fmt == NULL)
1396                 return -EINVAL;
1397         fe->type = V4L2_FRMSIZE_TYPE_DISCRETE;
1398         fe->discrete = is_ntsc ?  ntsc_sizes[fe->index] : pal_sizes[fe->index];
1399         return 0;
1400 }
1401
1402 static int vidioc_enum_frameintervals(struct file *file, void *priv,
1403                             struct v4l2_frmivalenum *fe)
1404 {
1405         struct s2255_vc *vc = video_drvdata(file);
1406         const struct s2255_fmt *fmt;
1407         const struct v4l2_frmsize_discrete *sizes;
1408         int is_ntsc = vc->std & V4L2_STD_525_60;
1409 #define NUM_FRAME_ENUMS 4
1410         int frm_dec[NUM_FRAME_ENUMS] = {1, 2, 3, 5};
1411         int i;
1412
1413         if (fe->index >= NUM_FRAME_ENUMS)
1414                 return -EINVAL;
1415
1416         fmt = format_by_fourcc(fe->pixel_format);
1417         if (fmt == NULL)
1418                 return -EINVAL;
1419
1420         sizes = is_ntsc ? ntsc_sizes : pal_sizes;
1421         for (i = 0; i < NUM_SIZE_ENUMS; i++, sizes++)
1422                 if (fe->width == sizes->width &&
1423                     fe->height == sizes->height)
1424                         break;
1425         if (i == NUM_SIZE_ENUMS)
1426                 return -EINVAL;
1427
1428         fe->type = V4L2_FRMIVAL_TYPE_DISCRETE;
1429         fe->discrete.denominator = is_ntsc ? 30000 : 25000;
1430         fe->discrete.numerator = (is_ntsc ? 1001 : 1000) * frm_dec[fe->index];
1431         dprintk(vc->dev, 4, "%s discrete %d/%d\n", __func__,
1432                 fe->discrete.numerator,
1433                 fe->discrete.denominator);
1434         return 0;
1435 }
1436
1437 static int s2255_open(struct file *file)
1438 {
1439         struct s2255_vc *vc = video_drvdata(file);
1440         struct s2255_dev *dev = vc->dev;
1441         int state;
1442         int rc = 0;
1443
1444         rc = v4l2_fh_open(file);
1445         if (rc != 0)
1446                 return rc;
1447
1448         dprintk(dev, 1, "s2255: %s\n", __func__);
1449         state = atomic_read(&dev->fw_data->fw_state);
1450         switch (state) {
1451         case S2255_FW_DISCONNECTING:
1452                 return -ENODEV;
1453         case S2255_FW_FAILED:
1454                 s2255_dev_err(&dev->udev->dev,
1455                         "firmware load failed. retrying.\n");
1456                 s2255_fwload_start(dev, 1);
1457                 wait_event_timeout(dev->fw_data->wait_fw,
1458                                    ((atomic_read(&dev->fw_data->fw_state)
1459                                      == S2255_FW_SUCCESS) ||
1460                                     (atomic_read(&dev->fw_data->fw_state)
1461                                      == S2255_FW_DISCONNECTING)),
1462                                    msecs_to_jiffies(S2255_LOAD_TIMEOUT));
1463                 /* state may have changed, re-read */
1464                 state = atomic_read(&dev->fw_data->fw_state);
1465                 break;
1466         case S2255_FW_NOTLOADED:
1467         case S2255_FW_LOADED_DSPWAIT:
1468                 /* give S2255_LOAD_TIMEOUT time for firmware to load in case
1469                    driver loaded and then device immediately opened */
1470                 pr_info("%s waiting for firmware load\n", __func__);
1471                 wait_event_timeout(dev->fw_data->wait_fw,
1472                                    ((atomic_read(&dev->fw_data->fw_state)
1473                                      == S2255_FW_SUCCESS) ||
1474                                     (atomic_read(&dev->fw_data->fw_state)
1475                                      == S2255_FW_DISCONNECTING)),
1476                                    msecs_to_jiffies(S2255_LOAD_TIMEOUT));
1477                 /* state may have changed, re-read */
1478                 state = atomic_read(&dev->fw_data->fw_state);
1479                 break;
1480         case S2255_FW_SUCCESS:
1481         default:
1482                 break;
1483         }
1484         /* state may have changed in above switch statement */
1485         switch (state) {
1486         case S2255_FW_SUCCESS:
1487                 break;
1488         case S2255_FW_FAILED:
1489                 pr_info("2255 firmware load failed.\n");
1490                 return -ENODEV;
1491         case S2255_FW_DISCONNECTING:
1492                 pr_info("%s: disconnecting\n", __func__);
1493                 return -ENODEV;
1494         case S2255_FW_LOADED_DSPWAIT:
1495         case S2255_FW_NOTLOADED:
1496                 pr_info("%s: firmware not loaded, please retry\n",
1497                         __func__);
1498                 /*
1499                  * Timeout on firmware load means device unusable.
1500                  * Set firmware failure state.
1501                  * On next s2255_open the firmware will be reloaded.
1502                  */
1503                 atomic_set(&dev->fw_data->fw_state,
1504                            S2255_FW_FAILED);
1505                 return -EAGAIN;
1506         default:
1507                 pr_info("%s: unknown state\n", __func__);
1508                 return -EFAULT;
1509         }
1510         if (!vc->configured) {
1511                 /* configure channel to default state */
1512                 vc->fmt = &formats[0];
1513                 s2255_set_mode(vc, &vc->mode);
1514                 vc->configured = 1;
1515         }
1516         return 0;
1517 }
1518
1519 static void s2255_destroy(struct s2255_dev *dev)
1520 {
1521         dprintk(dev, 1, "%s", __func__);
1522         /* board shutdown stops the read pipe if it is running */
1523         s2255_board_shutdown(dev);
1524         /* make sure firmware still not trying to load */
1525         del_timer_sync(&dev->timer);  /* only started in .probe and .open */
1526         if (dev->fw_data->fw_urb) {
1527                 usb_kill_urb(dev->fw_data->fw_urb);
1528                 usb_free_urb(dev->fw_data->fw_urb);
1529                 dev->fw_data->fw_urb = NULL;
1530         }
1531         release_firmware(dev->fw_data->fw);
1532         kfree(dev->fw_data->pfw_data);
1533         kfree(dev->fw_data);
1534         /* reset the DSP so firmware can be reloaded next time */
1535         s2255_reset_dsppower(dev);
1536         mutex_destroy(&dev->lock);
1537         usb_put_dev(dev->udev);
1538         v4l2_device_unregister(&dev->v4l2_dev);
1539         kfree(dev->cmdbuf);
1540         kfree(dev);
1541 }
1542
1543 static const struct v4l2_file_operations s2255_fops_v4l = {
1544         .owner = THIS_MODULE,
1545         .open = s2255_open,
1546         .release = vb2_fop_release,
1547         .poll = vb2_fop_poll,
1548         .unlocked_ioctl = video_ioctl2, /* V4L2 ioctl handler */
1549         .mmap = vb2_fop_mmap,
1550         .read = vb2_fop_read,
1551 };
1552
1553 static const struct v4l2_ioctl_ops s2255_ioctl_ops = {
1554         .vidioc_querycap = vidioc_querycap,
1555         .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1556         .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1557         .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1558         .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1559         .vidioc_reqbufs = vb2_ioctl_reqbufs,
1560         .vidioc_querybuf = vb2_ioctl_querybuf,
1561         .vidioc_qbuf = vb2_ioctl_qbuf,
1562         .vidioc_dqbuf = vb2_ioctl_dqbuf,
1563         .vidioc_s_std = vidioc_s_std,
1564         .vidioc_g_std = vidioc_g_std,
1565         .vidioc_enum_input = vidioc_enum_input,
1566         .vidioc_g_input = vidioc_g_input,
1567         .vidioc_s_input = vidioc_s_input,
1568         .vidioc_streamon = vb2_ioctl_streamon,
1569         .vidioc_streamoff = vb2_ioctl_streamoff,
1570         .vidioc_s_jpegcomp = vidioc_s_jpegcomp,
1571         .vidioc_g_jpegcomp = vidioc_g_jpegcomp,
1572         .vidioc_s_parm = vidioc_s_parm,
1573         .vidioc_g_parm = vidioc_g_parm,
1574         .vidioc_enum_framesizes = vidioc_enum_framesizes,
1575         .vidioc_enum_frameintervals = vidioc_enum_frameintervals,
1576         .vidioc_log_status  = v4l2_ctrl_log_status,
1577         .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1578         .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
1579 };
1580
1581 static void s2255_video_device_release(struct video_device *vdev)
1582 {
1583         struct s2255_dev *dev = to_s2255_dev(vdev->v4l2_dev);
1584         struct s2255_vc *vc =
1585                 container_of(vdev, struct s2255_vc, vdev);
1586
1587         dprintk(dev, 4, "%s, chnls: %d\n", __func__,
1588                 atomic_read(&dev->num_channels));
1589
1590         v4l2_ctrl_handler_free(&vc->hdl);
1591
1592         if (atomic_dec_and_test(&dev->num_channels))
1593                 s2255_destroy(dev);
1594         return;
1595 }
1596
1597 static struct video_device template = {
1598         .name = "s2255v",
1599         .fops = &s2255_fops_v4l,
1600         .ioctl_ops = &s2255_ioctl_ops,
1601         .release = s2255_video_device_release,
1602         .tvnorms = S2255_NORMS,
1603 };
1604
1605 static const struct v4l2_ctrl_ops s2255_ctrl_ops = {
1606         .s_ctrl = s2255_s_ctrl,
1607 };
1608
1609 static const struct v4l2_ctrl_config color_filter_ctrl = {
1610         .ops = &s2255_ctrl_ops,
1611         .name = "Color Filter",
1612         .id = V4L2_CID_S2255_COLORFILTER,
1613         .type = V4L2_CTRL_TYPE_BOOLEAN,
1614         .max = 1,
1615         .step = 1,
1616         .def = 1,
1617 };
1618
1619 static int s2255_probe_v4l(struct s2255_dev *dev)
1620 {
1621         int ret;
1622         int i;
1623         int cur_nr = video_nr;
1624         struct s2255_vc *vc;
1625         struct vb2_queue *q;
1626
1627         ret = v4l2_device_register(&dev->interface->dev, &dev->v4l2_dev);
1628         if (ret)
1629                 return ret;
1630         /* initialize all video 4 linux */
1631         /* register 4 video devices */
1632         for (i = 0; i < MAX_CHANNELS; i++) {
1633                 vc = &dev->vc[i];
1634                 INIT_LIST_HEAD(&vc->buf_list);
1635
1636                 v4l2_ctrl_handler_init(&vc->hdl, 6);
1637                 v4l2_ctrl_new_std(&vc->hdl, &s2255_ctrl_ops,
1638                                 V4L2_CID_BRIGHTNESS, -127, 127, 1, DEF_BRIGHT);
1639                 v4l2_ctrl_new_std(&vc->hdl, &s2255_ctrl_ops,
1640                                 V4L2_CID_CONTRAST, 0, 255, 1, DEF_CONTRAST);
1641                 v4l2_ctrl_new_std(&vc->hdl, &s2255_ctrl_ops,
1642                                 V4L2_CID_SATURATION, 0, 255, 1, DEF_SATURATION);
1643                 v4l2_ctrl_new_std(&vc->hdl, &s2255_ctrl_ops,
1644                                 V4L2_CID_HUE, 0, 255, 1, DEF_HUE);
1645                 vc->jpegqual_ctrl = v4l2_ctrl_new_std(&vc->hdl,
1646                                 &s2255_ctrl_ops,
1647                                 V4L2_CID_JPEG_COMPRESSION_QUALITY,
1648                                 0, 100, 1, S2255_DEF_JPEG_QUAL);
1649                 if (dev->dsp_fw_ver >= S2255_MIN_DSP_COLORFILTER &&
1650                     (dev->pid != 0x2257 || vc->idx <= 1))
1651                         v4l2_ctrl_new_custom(&vc->hdl, &color_filter_ctrl,
1652                                              NULL);
1653                 if (vc->hdl.error) {
1654                         ret = vc->hdl.error;
1655                         v4l2_ctrl_handler_free(&vc->hdl);
1656                         dev_err(&dev->udev->dev, "couldn't register control\n");
1657                         break;
1658                 }
1659                 q = &vc->vb_vidq;
1660                 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
1661                 q->io_modes = VB2_MMAP | VB2_READ | VB2_USERPTR;
1662                 q->drv_priv = vc;
1663                 q->lock = &vc->vb_lock;
1664                 q->buf_struct_size = sizeof(struct s2255_buffer);
1665                 q->mem_ops = &vb2_vmalloc_memops;
1666                 q->ops = &s2255_video_qops;
1667                 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
1668                 ret = vb2_queue_init(q);
1669                 if (ret != 0) {
1670                         dev_err(&dev->udev->dev,
1671                                 "%s vb2_queue_init 0x%x\n", __func__, ret);
1672                         break;
1673                 }
1674                 /* register video devices */
1675                 vc->vdev = template;
1676                 vc->vdev.queue = q;
1677                 vc->vdev.ctrl_handler = &vc->hdl;
1678                 vc->vdev.lock = &dev->lock;
1679                 vc->vdev.v4l2_dev = &dev->v4l2_dev;
1680                 video_set_drvdata(&vc->vdev, vc);
1681                 if (video_nr == -1)
1682                         ret = video_register_device(&vc->vdev,
1683                                                     VFL_TYPE_GRABBER,
1684                                                     video_nr);
1685                 else
1686                         ret = video_register_device(&vc->vdev,
1687                                                     VFL_TYPE_GRABBER,
1688                                                     cur_nr + i);
1689
1690                 if (ret) {
1691                         dev_err(&dev->udev->dev,
1692                                 "failed to register video device!\n");
1693                         break;
1694                 }
1695                 atomic_inc(&dev->num_channels);
1696                 v4l2_info(&dev->v4l2_dev, "V4L2 device registered as %s\n",
1697                           video_device_node_name(&vc->vdev));
1698
1699         }
1700         pr_info("Sensoray 2255 V4L driver Revision: %s\n",
1701                 S2255_VERSION);
1702         /* if no channels registered, return error and probe will fail*/
1703         if (atomic_read(&dev->num_channels) == 0) {
1704                 v4l2_device_unregister(&dev->v4l2_dev);
1705                 return ret;
1706         }
1707         if (atomic_read(&dev->num_channels) != MAX_CHANNELS)
1708                 pr_warn("s2255: Not all channels available.\n");
1709         return 0;
1710 }
1711
1712 /* this function moves the usb stream read pipe data
1713  * into the system buffers.
1714  * returns 0 on success, EAGAIN if more data to process( call this
1715  * function again).
1716  *
1717  * Received frame structure:
1718  * bytes 0-3:  marker : 0x2255DA4AL (S2255_MARKER_FRAME)
1719  * bytes 4-7:  channel: 0-3
1720  * bytes 8-11: payload size:  size of the frame
1721  * bytes 12-payloadsize+12:  frame data
1722  */
1723 static int save_frame(struct s2255_dev *dev, struct s2255_pipeinfo *pipe_info)
1724 {
1725         char *pdest;
1726         u32 offset = 0;
1727         int bframe = 0;
1728         char *psrc;
1729         unsigned long copy_size;
1730         unsigned long size;
1731         s32 idx = -1;
1732         struct s2255_framei *frm;
1733         unsigned char *pdata;
1734         struct s2255_vc *vc;
1735         dprintk(dev, 100, "buffer to user\n");
1736         vc = &dev->vc[dev->cc];
1737         idx = vc->cur_frame;
1738         frm = &vc->buffer.frame[idx];
1739         if (frm->ulState == S2255_READ_IDLE) {
1740                 int jj;
1741                 unsigned int cc;
1742                 __le32 *pdword; /*data from dsp is little endian */
1743                 int payload;
1744                 /* search for marker codes */
1745                 pdata = (unsigned char *)pipe_info->transfer_buffer;
1746                 pdword = (__le32 *)pdata;
1747                 for (jj = 0; jj < (pipe_info->cur_transfer_size - 12); jj++) {
1748                         switch (*pdword) {
1749                         case S2255_MARKER_FRAME:
1750                                 dprintk(dev, 4, "marker @ offset: %d [%x %x]\n",
1751                                         jj, pdata[0], pdata[1]);
1752                                 offset = jj + PREFIX_SIZE;
1753                                 bframe = 1;
1754                                 cc = le32_to_cpu(pdword[1]);
1755                                 if (cc >= MAX_CHANNELS) {
1756                                         dprintk(dev, 0,
1757                                                 "bad channel\n");
1758                                         return -EINVAL;
1759                                 }
1760                                 /* reverse it */
1761                                 dev->cc = G_chnmap[cc];
1762                                 vc = &dev->vc[dev->cc];
1763                                 payload =  le32_to_cpu(pdword[3]);
1764                                 if (payload > vc->req_image_size) {
1765                                         vc->bad_payload++;
1766                                         /* discard the bad frame */
1767                                         return -EINVAL;
1768                                 }
1769                                 vc->pkt_size = payload;
1770                                 vc->jpg_size = le32_to_cpu(pdword[4]);
1771                                 break;
1772                         case S2255_MARKER_RESPONSE:
1773
1774                                 pdata += DEF_USB_BLOCK;
1775                                 jj += DEF_USB_BLOCK;
1776                                 if (le32_to_cpu(pdword[1]) >= MAX_CHANNELS)
1777                                         break;
1778                                 cc = G_chnmap[le32_to_cpu(pdword[1])];
1779                                 if (cc >= MAX_CHANNELS)
1780                                         break;
1781                                 vc = &dev->vc[cc];
1782                                 switch (pdword[2]) {
1783                                 case S2255_RESPONSE_SETMODE:
1784                                         /* check if channel valid */
1785                                         /* set mode ready */
1786                                         vc->setmode_ready = 1;
1787                                         wake_up(&vc->wait_setmode);
1788                                         dprintk(dev, 5, "setmode rdy %d\n", cc);
1789                                         break;
1790                                 case S2255_RESPONSE_FW:
1791                                         dev->chn_ready |= (1 << cc);
1792                                         if ((dev->chn_ready & 0x0f) != 0x0f)
1793                                                 break;
1794                                         /* all channels ready */
1795                                         pr_info("s2255: fw loaded\n");
1796                                         atomic_set(&dev->fw_data->fw_state,
1797                                                    S2255_FW_SUCCESS);
1798                                         wake_up(&dev->fw_data->wait_fw);
1799                                         break;
1800                                 case S2255_RESPONSE_STATUS:
1801                                         vc->vidstatus = le32_to_cpu(pdword[3]);
1802                                         vc->vidstatus_ready = 1;
1803                                         wake_up(&vc->wait_vidstatus);
1804                                         dprintk(dev, 5, "vstat %x chan %d\n",
1805                                                 le32_to_cpu(pdword[3]), cc);
1806                                         break;
1807                                 default:
1808                                         pr_info("s2255 unknown resp\n");
1809                                 }
1810                         default:
1811                                 pdata++;
1812                                 break;
1813                         }
1814                         if (bframe)
1815                                 break;
1816                 } /* for */
1817                 if (!bframe)
1818                         return -EINVAL;
1819         }
1820         vc = &dev->vc[dev->cc];
1821         idx = vc->cur_frame;
1822         frm = &vc->buffer.frame[idx];
1823         /* search done.  now find out if should be acquiring on this channel */
1824         if (!vb2_is_streaming(&vc->vb_vidq)) {
1825                 /* we found a frame, but this channel is turned off */
1826                 frm->ulState = S2255_READ_IDLE;
1827                 return -EINVAL;
1828         }
1829
1830         if (frm->ulState == S2255_READ_IDLE) {
1831                 frm->ulState = S2255_READ_FRAME;
1832                 frm->cur_size = 0;
1833         }
1834
1835         /* skip the marker 512 bytes (and offset if out of sync) */
1836         psrc = (u8 *)pipe_info->transfer_buffer + offset;
1837
1838
1839         if (frm->lpvbits == NULL) {
1840                 dprintk(dev, 1, "s2255 frame buffer == NULL.%p %p %d %d",
1841                         frm, dev, dev->cc, idx);
1842                 return -ENOMEM;
1843         }
1844
1845         pdest = frm->lpvbits + frm->cur_size;
1846
1847         copy_size = (pipe_info->cur_transfer_size - offset);
1848
1849         size = vc->pkt_size - PREFIX_SIZE;
1850
1851         /* sanity check on pdest */
1852         if ((copy_size + frm->cur_size) < vc->req_image_size)
1853                 memcpy(pdest, psrc, copy_size);
1854
1855         frm->cur_size += copy_size;
1856         dprintk(dev, 4, "cur_size: %lu, size: %lu\n", frm->cur_size, size);
1857
1858         if (frm->cur_size >= size) {
1859                 dprintk(dev, 2, "******[%d]Buffer[%d]full*******\n",
1860                         dev->cc, idx);
1861                 vc->last_frame = vc->cur_frame;
1862                 vc->cur_frame++;
1863                 /* end of system frame ring buffer, start at zero */
1864                 if ((vc->cur_frame == SYS_FRAMES) ||
1865                     (vc->cur_frame == vc->buffer.dwFrames))
1866                         vc->cur_frame = 0;
1867                 /* frame ready */
1868                 if (vb2_is_streaming(&vc->vb_vidq))
1869                         s2255_got_frame(vc, vc->jpg_size);
1870                 vc->frame_count++;
1871                 frm->ulState = S2255_READ_IDLE;
1872                 frm->cur_size = 0;
1873
1874         }
1875         /* done successfully */
1876         return 0;
1877 }
1878
1879 static void s2255_read_video_callback(struct s2255_dev *dev,
1880                                       struct s2255_pipeinfo *pipe_info)
1881 {
1882         int res;
1883         dprintk(dev, 50, "callback read video\n");
1884
1885         if (dev->cc >= MAX_CHANNELS) {
1886                 dev->cc = 0;
1887                 dev_err(&dev->udev->dev, "invalid channel\n");
1888                 return;
1889         }
1890         /* otherwise copy to the system buffers */
1891         res = save_frame(dev, pipe_info);
1892         if (res != 0)
1893                 dprintk(dev, 4, "s2255: read callback failed\n");
1894
1895         dprintk(dev, 50, "callback read video done\n");
1896         return;
1897 }
1898
1899 static long s2255_vendor_req(struct s2255_dev *dev, unsigned char Request,
1900                              u16 Index, u16 Value, void *TransferBuffer,
1901                              s32 TransferBufferLength, int bOut)
1902 {
1903         int r;
1904         if (!bOut) {
1905                 r = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0),
1906                                     Request,
1907                                     USB_TYPE_VENDOR | USB_RECIP_DEVICE |
1908                                     USB_DIR_IN,
1909                                     Value, Index, TransferBuffer,
1910                                     TransferBufferLength, HZ * 5);
1911         } else {
1912                 r = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0),
1913                                     Request, USB_TYPE_VENDOR | USB_RECIP_DEVICE,
1914                                     Value, Index, TransferBuffer,
1915                                     TransferBufferLength, HZ * 5);
1916         }
1917         return r;
1918 }
1919
1920 /*
1921  * retrieve FX2 firmware version. future use.
1922  * @param dev pointer to device extension
1923  * @return -1 for fail, else returns firmware version as an int(16 bits)
1924  */
1925 static int s2255_get_fx2fw(struct s2255_dev *dev)
1926 {
1927         int fw;
1928         int ret;
1929         unsigned char transBuffer[64];
1930         ret = s2255_vendor_req(dev, S2255_VR_FW, 0, 0, transBuffer, 2,
1931                                S2255_VR_IN);
1932         if (ret < 0)
1933                 dprintk(dev, 2, "get fw error: %x\n", ret);
1934         fw = transBuffer[0] + (transBuffer[1] << 8);
1935         dprintk(dev, 2, "Get FW %x %x\n", transBuffer[0], transBuffer[1]);
1936         return fw;
1937 }
1938
1939 /*
1940  * Create the system ring buffer to copy frames into from the
1941  * usb read pipe.
1942  */
1943 static int s2255_create_sys_buffers(struct s2255_vc *vc)
1944 {
1945         unsigned long i;
1946         unsigned long reqsize;
1947         vc->buffer.dwFrames = SYS_FRAMES;
1948         /* always allocate maximum size(PAL) for system buffers */
1949         reqsize = SYS_FRAMES_MAXSIZE;
1950
1951         if (reqsize > SYS_FRAMES_MAXSIZE)
1952                 reqsize = SYS_FRAMES_MAXSIZE;
1953
1954         for (i = 0; i < SYS_FRAMES; i++) {
1955                 /* allocate the frames */
1956                 vc->buffer.frame[i].lpvbits = vmalloc(reqsize);
1957                 vc->buffer.frame[i].size = reqsize;
1958                 if (vc->buffer.frame[i].lpvbits == NULL) {
1959                         pr_info("out of memory.  using less frames\n");
1960                         vc->buffer.dwFrames = i;
1961                         break;
1962                 }
1963         }
1964
1965         /* make sure internal states are set */
1966         for (i = 0; i < SYS_FRAMES; i++) {
1967                 vc->buffer.frame[i].ulState = 0;
1968                 vc->buffer.frame[i].cur_size = 0;
1969         }
1970
1971         vc->cur_frame = 0;
1972         vc->last_frame = -1;
1973         return 0;
1974 }
1975
1976 static int s2255_release_sys_buffers(struct s2255_vc *vc)
1977 {
1978         unsigned long i;
1979         for (i = 0; i < SYS_FRAMES; i++) {
1980                 vfree(vc->buffer.frame[i].lpvbits);
1981                 vc->buffer.frame[i].lpvbits = NULL;
1982         }
1983         return 0;
1984 }
1985
1986 static int s2255_board_init(struct s2255_dev *dev)
1987 {
1988         struct s2255_mode mode_def = DEF_MODEI_NTSC_CONT;
1989         int fw_ver;
1990         int j;
1991         struct s2255_pipeinfo *pipe = &dev->pipe;
1992         dprintk(dev, 4, "board init: %p", dev);
1993         memset(pipe, 0, sizeof(*pipe));
1994         pipe->dev = dev;
1995         pipe->cur_transfer_size = S2255_USB_XFER_SIZE;
1996         pipe->max_transfer_size = S2255_USB_XFER_SIZE;
1997
1998         pipe->transfer_buffer = kzalloc(pipe->max_transfer_size,
1999                                         GFP_KERNEL);
2000         if (pipe->transfer_buffer == NULL) {
2001                 dprintk(dev, 1, "out of memory!\n");
2002                 return -ENOMEM;
2003         }
2004         /* query the firmware */
2005         fw_ver = s2255_get_fx2fw(dev);
2006
2007         pr_info("s2255: usb firmware version %d.%d\n",
2008                 (fw_ver >> 8) & 0xff,
2009                 fw_ver & 0xff);
2010
2011         if (fw_ver < S2255_CUR_USB_FWVER)
2012                 pr_info("s2255: newer USB firmware available\n");
2013
2014         for (j = 0; j < MAX_CHANNELS; j++) {
2015                 struct s2255_vc *vc = &dev->vc[j];
2016                 vc->mode = mode_def;
2017                 if (dev->pid == 0x2257 && j > 1)
2018                         vc->mode.color |= (1 << 16);
2019                 vc->jpegqual = S2255_DEF_JPEG_QUAL;
2020                 vc->width = LINE_SZ_4CIFS_NTSC;
2021                 vc->height = NUM_LINES_4CIFS_NTSC * 2;
2022                 vc->std = V4L2_STD_NTSC_M;
2023                 vc->fmt = &formats[0];
2024                 vc->mode.restart = 1;
2025                 vc->req_image_size = get_transfer_size(&mode_def);
2026                 vc->frame_count = 0;
2027                 /* create the system buffers */
2028                 s2255_create_sys_buffers(vc);
2029         }
2030         /* start read pipe */
2031         s2255_start_readpipe(dev);
2032         dprintk(dev, 1, "%s: success\n", __func__);
2033         return 0;
2034 }
2035
2036 static int s2255_board_shutdown(struct s2255_dev *dev)
2037 {
2038         u32 i;
2039         dprintk(dev, 1, "%s: dev: %p", __func__,  dev);
2040
2041         for (i = 0; i < MAX_CHANNELS; i++) {
2042                 if (vb2_is_streaming(&dev->vc[i].vb_vidq))
2043                         s2255_stop_acquire(&dev->vc[i]);
2044         }
2045         s2255_stop_readpipe(dev);
2046         for (i = 0; i < MAX_CHANNELS; i++)
2047                 s2255_release_sys_buffers(&dev->vc[i]);
2048         /* release transfer buffer */
2049         kfree(dev->pipe.transfer_buffer);
2050         return 0;
2051 }
2052
2053 static void read_pipe_completion(struct urb *purb)
2054 {
2055         struct s2255_pipeinfo *pipe_info;
2056         struct s2255_dev *dev;
2057         int status;
2058         int pipe;
2059         pipe_info = purb->context;
2060         if (pipe_info == NULL) {
2061                 dev_err(&purb->dev->dev, "no context!\n");
2062                 return;
2063         }
2064         dev = pipe_info->dev;
2065         if (dev == NULL) {
2066                 dev_err(&purb->dev->dev, "no context!\n");
2067                 return;
2068         }
2069         status = purb->status;
2070         /* if shutting down, do not resubmit, exit immediately */
2071         if (status == -ESHUTDOWN) {
2072                 dprintk(dev, 2, "%s: err shutdown\n", __func__);
2073                 pipe_info->err_count++;
2074                 return;
2075         }
2076
2077         if (pipe_info->state == 0) {
2078                 dprintk(dev, 2, "%s: exiting USB pipe", __func__);
2079                 return;
2080         }
2081
2082         if (status == 0)
2083                 s2255_read_video_callback(dev, pipe_info);
2084         else {
2085                 pipe_info->err_count++;
2086                 dprintk(dev, 1, "%s: failed URB %d\n", __func__, status);
2087         }
2088
2089         pipe = usb_rcvbulkpipe(dev->udev, dev->read_endpoint);
2090         /* reuse urb */
2091         usb_fill_bulk_urb(pipe_info->stream_urb, dev->udev,
2092                           pipe,
2093                           pipe_info->transfer_buffer,
2094                           pipe_info->cur_transfer_size,
2095                           read_pipe_completion, pipe_info);
2096
2097         if (pipe_info->state != 0) {
2098                 if (usb_submit_urb(pipe_info->stream_urb, GFP_ATOMIC))
2099                         dev_err(&dev->udev->dev, "error submitting urb\n");
2100         } else {
2101                 dprintk(dev, 2, "%s :complete state 0\n", __func__);
2102         }
2103         return;
2104 }
2105
2106 static int s2255_start_readpipe(struct s2255_dev *dev)
2107 {
2108         int pipe;
2109         int retval;
2110         struct s2255_pipeinfo *pipe_info = &dev->pipe;
2111         pipe = usb_rcvbulkpipe(dev->udev, dev->read_endpoint);
2112         dprintk(dev, 2, "%s: IN %d\n", __func__, dev->read_endpoint);
2113         pipe_info->state = 1;
2114         pipe_info->err_count = 0;
2115         pipe_info->stream_urb = usb_alloc_urb(0, GFP_KERNEL);
2116         if (!pipe_info->stream_urb) {
2117                 dev_err(&dev->udev->dev,
2118                         "ReadStream: Unable to alloc URB\n");
2119                 return -ENOMEM;
2120         }
2121         /* transfer buffer allocated in board_init */
2122         usb_fill_bulk_urb(pipe_info->stream_urb, dev->udev,
2123                           pipe,
2124                           pipe_info->transfer_buffer,
2125                           pipe_info->cur_transfer_size,
2126                           read_pipe_completion, pipe_info);
2127         retval = usb_submit_urb(pipe_info->stream_urb, GFP_KERNEL);
2128         if (retval) {
2129                 pr_err("s2255: start read pipe failed\n");
2130                 return retval;
2131         }
2132         return 0;
2133 }
2134
2135 /* starts acquisition process */
2136 static int s2255_start_acquire(struct s2255_vc *vc)
2137 {
2138         int res;
2139         unsigned long chn_rev;
2140         int j;
2141         struct s2255_dev *dev = to_s2255_dev(vc->vdev.v4l2_dev);
2142         __le32 *buffer = dev->cmdbuf;
2143
2144         mutex_lock(&dev->cmdlock);
2145         chn_rev = G_chnmap[vc->idx];
2146         vc->last_frame = -1;
2147         vc->bad_payload = 0;
2148         vc->cur_frame = 0;
2149         for (j = 0; j < SYS_FRAMES; j++) {
2150                 vc->buffer.frame[j].ulState = 0;
2151                 vc->buffer.frame[j].cur_size = 0;
2152         }
2153
2154         /* send the start command */
2155         buffer[0] = IN_DATA_TOKEN;
2156         buffer[1] = (__le32) cpu_to_le32(chn_rev);
2157         buffer[2] = CMD_START;
2158         res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
2159         if (res != 0)
2160                 dev_err(&dev->udev->dev, "CMD_START error\n");
2161
2162         dprintk(dev, 2, "start acquire exit[%d] %d\n", vc->idx, res);
2163         mutex_unlock(&dev->cmdlock);
2164         return res;
2165 }
2166
2167 static int s2255_stop_acquire(struct s2255_vc *vc)
2168 {
2169         int res;
2170         unsigned long chn_rev;
2171         struct s2255_dev *dev = to_s2255_dev(vc->vdev.v4l2_dev);
2172         __le32 *buffer = dev->cmdbuf;
2173
2174         mutex_lock(&dev->cmdlock);
2175         chn_rev = G_chnmap[vc->idx];
2176         /* send the stop command */
2177         buffer[0] = IN_DATA_TOKEN;
2178         buffer[1] = (__le32) cpu_to_le32(chn_rev);
2179         buffer[2] = CMD_STOP;
2180
2181         res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512);
2182         if (res != 0)
2183                 dev_err(&dev->udev->dev, "CMD_STOP error\n");
2184
2185         dprintk(dev, 4, "%s: chn %d, res %d\n", __func__, vc->idx, res);
2186         mutex_unlock(&dev->cmdlock);
2187         return res;
2188 }
2189
2190 static void s2255_stop_readpipe(struct s2255_dev *dev)
2191 {
2192         struct s2255_pipeinfo *pipe = &dev->pipe;
2193
2194         pipe->state = 0;
2195         if (pipe->stream_urb) {
2196                 /* cancel urb */
2197                 usb_kill_urb(pipe->stream_urb);
2198                 usb_free_urb(pipe->stream_urb);
2199                 pipe->stream_urb = NULL;
2200         }
2201         dprintk(dev, 4, "%s", __func__);
2202         return;
2203 }
2204
2205 static void s2255_fwload_start(struct s2255_dev *dev, int reset)
2206 {
2207         if (reset)
2208                 s2255_reset_dsppower(dev);
2209         dev->fw_data->fw_size = dev->fw_data->fw->size;
2210         atomic_set(&dev->fw_data->fw_state, S2255_FW_NOTLOADED);
2211         memcpy(dev->fw_data->pfw_data,
2212                dev->fw_data->fw->data, CHUNK_SIZE);
2213         dev->fw_data->fw_loaded = CHUNK_SIZE;
2214         usb_fill_bulk_urb(dev->fw_data->fw_urb, dev->udev,
2215                           usb_sndbulkpipe(dev->udev, 2),
2216                           dev->fw_data->pfw_data,
2217                           CHUNK_SIZE, s2255_fwchunk_complete,
2218                           dev->fw_data);
2219         mod_timer(&dev->timer, jiffies + HZ);
2220 }
2221
2222 /* standard usb probe function */
2223 static int s2255_probe(struct usb_interface *interface,
2224                        const struct usb_device_id *id)
2225 {
2226         struct s2255_dev *dev = NULL;
2227         struct usb_host_interface *iface_desc;
2228         struct usb_endpoint_descriptor *endpoint;
2229         int i;
2230         int retval = -ENOMEM;
2231         __le32 *pdata;
2232         int fw_size;
2233
2234         /* allocate memory for our device state and initialize it to zero */
2235         dev = kzalloc(sizeof(struct s2255_dev), GFP_KERNEL);
2236         if (dev == NULL) {
2237                 s2255_dev_err(&interface->dev, "out of memory\n");
2238                 return -ENOMEM;
2239         }
2240
2241         dev->cmdbuf = kzalloc(S2255_CMDBUF_SIZE, GFP_KERNEL);
2242         if (dev->cmdbuf == NULL) {
2243                 s2255_dev_err(&interface->dev, "out of memory\n");
2244                 goto errorFWDATA1;
2245         }
2246
2247         atomic_set(&dev->num_channels, 0);
2248         dev->pid = id->idProduct;
2249         dev->fw_data = kzalloc(sizeof(struct s2255_fw), GFP_KERNEL);
2250         if (!dev->fw_data)
2251                 goto errorFWDATA1;
2252         mutex_init(&dev->lock);
2253         mutex_init(&dev->cmdlock);
2254         /* grab usb_device and save it */
2255         dev->udev = usb_get_dev(interface_to_usbdev(interface));
2256         if (dev->udev == NULL) {
2257                 dev_err(&interface->dev, "null usb device\n");
2258                 retval = -ENODEV;
2259                 goto errorUDEV;
2260         }
2261         dev_dbg(&interface->dev, "dev: %p, udev %p interface %p\n",
2262                 dev, dev->udev, interface);
2263         dev->interface = interface;
2264         /* set up the endpoint information  */
2265         iface_desc = interface->cur_altsetting;
2266         dev_dbg(&interface->dev, "num EP: %d\n",
2267                 iface_desc->desc.bNumEndpoints);
2268         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
2269                 endpoint = &iface_desc->endpoint[i].desc;
2270                 if (!dev->read_endpoint && usb_endpoint_is_bulk_in(endpoint)) {
2271                         /* we found the bulk in endpoint */
2272                         dev->read_endpoint = endpoint->bEndpointAddress;
2273                 }
2274         }
2275
2276         if (!dev->read_endpoint) {
2277                 dev_err(&interface->dev, "Could not find bulk-in endpoint\n");
2278                 goto errorEP;
2279         }
2280         setup_timer(&dev->timer, s2255_timer, (unsigned long)dev->fw_data);
2281         init_waitqueue_head(&dev->fw_data->wait_fw);
2282         for (i = 0; i < MAX_CHANNELS; i++) {
2283                 struct s2255_vc *vc = &dev->vc[i];
2284                 vc->idx = i;
2285                 vc->dev = dev;
2286                 init_waitqueue_head(&vc->wait_setmode);
2287                 init_waitqueue_head(&vc->wait_vidstatus);
2288                 spin_lock_init(&vc->qlock);
2289                 mutex_init(&vc->vb_lock);
2290         }
2291
2292         dev->fw_data->fw_urb = usb_alloc_urb(0, GFP_KERNEL);
2293         if (!dev->fw_data->fw_urb) {
2294                 dev_err(&interface->dev, "out of memory!\n");
2295                 goto errorFWURB;
2296         }
2297
2298         dev->fw_data->pfw_data = kzalloc(CHUNK_SIZE, GFP_KERNEL);
2299         if (!dev->fw_data->pfw_data) {
2300                 dev_err(&interface->dev, "out of memory!\n");
2301                 goto errorFWDATA2;
2302         }
2303         /* load the first chunk */
2304         if (request_firmware(&dev->fw_data->fw,
2305                              FIRMWARE_FILE_NAME, &dev->udev->dev)) {
2306                 dev_err(&interface->dev, "sensoray 2255 failed to get firmware\n");
2307                 goto errorREQFW;
2308         }
2309         /* check the firmware is valid */
2310         fw_size = dev->fw_data->fw->size;
2311         pdata = (__le32 *) &dev->fw_data->fw->data[fw_size - 8];
2312
2313         if (*pdata != S2255_FW_MARKER) {
2314                 dev_err(&interface->dev, "Firmware invalid.\n");
2315                 retval = -ENODEV;
2316                 goto errorFWMARKER;
2317         } else {
2318                 /* make sure firmware is the latest */
2319                 __le32 *pRel;
2320                 pRel = (__le32 *) &dev->fw_data->fw->data[fw_size - 4];
2321                 pr_info("s2255 dsp fw version %x\n", le32_to_cpu(*pRel));
2322                 dev->dsp_fw_ver = le32_to_cpu(*pRel);
2323                 if (dev->dsp_fw_ver < S2255_CUR_DSP_FWVER)
2324                         pr_info("s2255: f2255usb.bin out of date.\n");
2325                 if (dev->pid == 0x2257 &&
2326                                 dev->dsp_fw_ver < S2255_MIN_DSP_COLORFILTER)
2327                         pr_warn("2257 needs firmware %d or above.\n",
2328                                 S2255_MIN_DSP_COLORFILTER);
2329         }
2330         usb_reset_device(dev->udev);
2331         /* load 2255 board specific */
2332         retval = s2255_board_init(dev);
2333         if (retval)
2334                 goto errorBOARDINIT;
2335         s2255_fwload_start(dev, 0);
2336         /* loads v4l specific */
2337         retval = s2255_probe_v4l(dev);
2338         if (retval)
2339                 goto errorBOARDINIT;
2340         dev_info(&interface->dev, "Sensoray 2255 detected\n");
2341         return 0;
2342 errorBOARDINIT:
2343         s2255_board_shutdown(dev);
2344 errorFWMARKER:
2345         release_firmware(dev->fw_data->fw);
2346 errorREQFW:
2347         kfree(dev->fw_data->pfw_data);
2348 errorFWDATA2:
2349         usb_free_urb(dev->fw_data->fw_urb);
2350 errorFWURB:
2351         del_timer_sync(&dev->timer);
2352 errorEP:
2353         usb_put_dev(dev->udev);
2354 errorUDEV:
2355         kfree(dev->fw_data);
2356         mutex_destroy(&dev->lock);
2357 errorFWDATA1:
2358         kfree(dev->cmdbuf);
2359         kfree(dev);
2360         pr_warn("Sensoray 2255 driver load failed: 0x%x\n", retval);
2361         return retval;
2362 }
2363
2364 /* disconnect routine. when board is removed physically or with rmmod */
2365 static void s2255_disconnect(struct usb_interface *interface)
2366 {
2367         struct s2255_dev *dev = to_s2255_dev(usb_get_intfdata(interface));
2368         int i;
2369         int channels = atomic_read(&dev->num_channels);
2370         mutex_lock(&dev->lock);
2371         v4l2_device_disconnect(&dev->v4l2_dev);
2372         mutex_unlock(&dev->lock);
2373         /*see comments in the uvc_driver.c usb disconnect function */
2374         atomic_inc(&dev->num_channels);
2375         /* unregister each video device. */
2376         for (i = 0; i < channels; i++)
2377                 video_unregister_device(&dev->vc[i].vdev);
2378         /* wake up any of our timers */
2379         atomic_set(&dev->fw_data->fw_state, S2255_FW_DISCONNECTING);
2380         wake_up(&dev->fw_data->wait_fw);
2381         for (i = 0; i < MAX_CHANNELS; i++) {
2382                 dev->vc[i].setmode_ready = 1;
2383                 wake_up(&dev->vc[i].wait_setmode);
2384                 dev->vc[i].vidstatus_ready = 1;
2385                 wake_up(&dev->vc[i].wait_vidstatus);
2386         }
2387         if (atomic_dec_and_test(&dev->num_channels))
2388                 s2255_destroy(dev);
2389         dev_info(&interface->dev, "%s\n", __func__);
2390 }
2391
2392 static struct usb_driver s2255_driver = {
2393         .name = S2255_DRIVER_NAME,
2394         .probe = s2255_probe,
2395         .disconnect = s2255_disconnect,
2396         .id_table = s2255_table,
2397 };
2398
2399 module_usb_driver(s2255_driver);
2400
2401 MODULE_DESCRIPTION("Sensoray 2255 Video for Linux driver");
2402 MODULE_AUTHOR("Dean Anderson (Sensoray Company Inc.)");
2403 MODULE_LICENSE("GPL");
2404 MODULE_VERSION(S2255_VERSION);
2405 MODULE_FIRMWARE(FIRMWARE_FILE_NAME);