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