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 133 struct 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 */ 152 struct 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 */ 160 struct 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 179 struct 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 189 struct 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 200 struct s2255_fmt; /*forward declaration */ 201 struct s2255_dev; 202 203 /* 2255 video channel */ 204 struct 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 247 struct 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 270 static 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 275 struct s2255_fmt { 276 u32 fourcc; 277 int depth; 278 }; 279 280 /* buffer for one video frame */ 281 struct 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 */ 331 static unsigned long G_chnmap[MAX_CHANNELS] = {3, 2, 1, 0}; 332 333 static int debug; 334 335 static int s2255_start_readpipe(struct s2255_dev *dev); 336 static void s2255_stop_readpipe(struct s2255_dev *dev); 337 static int s2255_start_acquire(struct s2255_vc *vc); 338 static int s2255_stop_acquire(struct s2255_vc *vc); 339 static void s2255_fillbuff(struct s2255_vc *vc, struct s2255_buffer *buf, 340 int jpgsize); 341 static int s2255_set_mode(struct s2255_vc *vc, struct s2255_mode *mode); 342 static int s2255_board_shutdown(struct s2255_dev *dev); 343 static void s2255_fwload_start(struct s2255_dev *dev); 344 static void s2255_destroy(struct s2255_dev *dev); 345 static 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 357 static struct usb_driver s2255_driver; 358 359 /* start video number */ 360 static int video_nr = -1; /* /dev/videoN, -1 for autodetect */ 361 362 /* Enable jpeg capture. */ 363 static int jpeg_enable = 1; 364 365 module_param(debug, int, 0644); 366 MODULE_PARM_DESC(debug, "Debug level(0-100) default 0"); 367 module_param(video_nr, int, 0644); 368 MODULE_PARM_DESC(video_nr, "start video minor(-1 default autodetect)"); 369 module_param(jpeg_enable, int, 0644); 370 MODULE_PARM_DESC(jpeg_enable, "Jpeg enable(1-on 0-off) default 1"); 371 372 /* USB device table */ 373 #define USB_SENSORAY_VID 0x1943 374 static 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 }; 379 MODULE_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 */ 385 static 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 409 static 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 415 static 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 421 static 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 427 static 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 */ 438 static 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 460 static 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 */ 472 static 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 */ 492 static 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 543 static 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 569 static 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 */ 592 static 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 644 static 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 656 static 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 686 static 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 698 static int start_streaming(struct vb2_queue *vq, unsigned int count); 699 static void stop_streaming(struct vb2_queue *vq); 700 701 static 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 711 static 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 723 static 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 737 static 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 757 static 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 808 static 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 */ 886 static 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 899 static 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 963 static 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 */ 981 static 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 1031 static 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 1061 static 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 */ 1078 static 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 1094 static 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 1135 static 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 */ 1150 static 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 1184 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i) 1185 { 1186 *i = 0; 1187 return 0; 1188 } 1189 static 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 1196 static 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 1235 static 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 1246 static 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 1258 static 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 1295 static 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 1338 static const struct v4l2_frmsize_discrete ntsc_sizes[] = { 1339 { 640, 480 }, 1340 { 640, 240 }, 1341 { 320, 240 }, 1342 }; 1343 static const struct v4l2_frmsize_discrete pal_sizes[] = { 1344 { 704, 576 }, 1345 { 704, 288 }, 1346 { 352, 288 }, 1347 }; 1348 1349 static 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 1367 static 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 1402 static 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 1484 static 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 1508 static 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 1518 static 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 1546 static 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 1562 static 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 1570 static const struct v4l2_ctrl_ops s2255_ctrl_ops = { 1571 .s_ctrl = s2255_s_ctrl, 1572 }; 1573 1574 static 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 1584 static 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 */ 1690 static 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 1848 static 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 1868 static 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 */ 1905 static int s2255_get_fx2fw(struct s2255_dev *dev) 1906 { 1907 int fw; 1908 int ret; 1909 unsigned char transBuffer[64]; 1910 ret = s2255_vendor_req(dev, S2255_VR_FW, 0, 0, transBuffer, 2, 1911 S2255_VR_IN); 1912 if (ret < 0) 1913 dprintk(dev, 2, "get fw error: %x\n", ret); 1914 fw = transBuffer[0] + (transBuffer[1] << 8); 1915 dprintk(dev, 2, "Get FW %x %x\n", transBuffer[0], transBuffer[1]); 1916 return fw; 1917 } 1918 1919 /* 1920 * Create the system ring buffer to copy frames into from the 1921 * usb read pipe. 1922 */ 1923 static int s2255_create_sys_buffers(struct s2255_vc *vc) 1924 { 1925 unsigned long i; 1926 unsigned long reqsize; 1927 vc->buffer.dwFrames = SYS_FRAMES; 1928 /* always allocate maximum size(PAL) for system buffers */ 1929 reqsize = SYS_FRAMES_MAXSIZE; 1930 1931 if (reqsize > SYS_FRAMES_MAXSIZE) 1932 reqsize = SYS_FRAMES_MAXSIZE; 1933 1934 for (i = 0; i < SYS_FRAMES; i++) { 1935 /* allocate the frames */ 1936 vc->buffer.frame[i].lpvbits = vmalloc(reqsize); 1937 vc->buffer.frame[i].size = reqsize; 1938 if (vc->buffer.frame[i].lpvbits == NULL) { 1939 pr_info("out of memory. using less frames\n"); 1940 vc->buffer.dwFrames = i; 1941 break; 1942 } 1943 } 1944 1945 /* make sure internal states are set */ 1946 for (i = 0; i < SYS_FRAMES; i++) { 1947 vc->buffer.frame[i].ulState = 0; 1948 vc->buffer.frame[i].cur_size = 0; 1949 } 1950 1951 vc->cur_frame = 0; 1952 vc->last_frame = -1; 1953 return 0; 1954 } 1955 1956 static int s2255_release_sys_buffers(struct s2255_vc *vc) 1957 { 1958 unsigned long i; 1959 for (i = 0; i < SYS_FRAMES; i++) { 1960 vfree(vc->buffer.frame[i].lpvbits); 1961 vc->buffer.frame[i].lpvbits = NULL; 1962 } 1963 return 0; 1964 } 1965 1966 static int s2255_board_init(struct s2255_dev *dev) 1967 { 1968 struct s2255_mode mode_def = DEF_MODEI_NTSC_CONT; 1969 int fw_ver; 1970 int j; 1971 struct s2255_pipeinfo *pipe = &dev->pipe; 1972 dprintk(dev, 4, "board init: %p", dev); 1973 memset(pipe, 0, sizeof(*pipe)); 1974 pipe->dev = dev; 1975 pipe->cur_transfer_size = S2255_USB_XFER_SIZE; 1976 pipe->max_transfer_size = S2255_USB_XFER_SIZE; 1977 1978 pipe->transfer_buffer = kzalloc(pipe->max_transfer_size, 1979 GFP_KERNEL); 1980 if (pipe->transfer_buffer == NULL) { 1981 dprintk(dev, 1, "out of memory!\n"); 1982 return -ENOMEM; 1983 } 1984 /* query the firmware */ 1985 fw_ver = s2255_get_fx2fw(dev); 1986 1987 pr_info("s2255: usb firmware version %d.%d\n", 1988 (fw_ver >> 8) & 0xff, 1989 fw_ver & 0xff); 1990 1991 if (fw_ver < S2255_CUR_USB_FWVER) 1992 pr_info("s2255: newer USB firmware available\n"); 1993 1994 for (j = 0; j < MAX_CHANNELS; j++) { 1995 struct s2255_vc *vc = &dev->vc[j]; 1996 vc->mode = mode_def; 1997 if (dev->pid == 0x2257 && j > 1) 1998 vc->mode.color |= (1 << 16); 1999 vc->jpegqual = S2255_DEF_JPEG_QUAL; 2000 vc->width = LINE_SZ_4CIFS_NTSC; 2001 vc->height = NUM_LINES_4CIFS_NTSC * 2; 2002 vc->std = V4L2_STD_NTSC_M; 2003 vc->fmt = &formats[0]; 2004 vc->mode.restart = 1; 2005 vc->req_image_size = get_transfer_size(&mode_def); 2006 vc->frame_count = 0; 2007 /* create the system buffers */ 2008 s2255_create_sys_buffers(vc); 2009 } 2010 /* start read pipe */ 2011 s2255_start_readpipe(dev); 2012 dprintk(dev, 1, "%s: success\n", __func__); 2013 return 0; 2014 } 2015 2016 static int s2255_board_shutdown(struct s2255_dev *dev) 2017 { 2018 u32 i; 2019 dprintk(dev, 1, "%s: dev: %p", __func__, dev); 2020 2021 for (i = 0; i < MAX_CHANNELS; i++) { 2022 if (vb2_is_streaming(&dev->vc[i].vb_vidq)) 2023 s2255_stop_acquire(&dev->vc[i]); 2024 } 2025 s2255_stop_readpipe(dev); 2026 for (i = 0; i < MAX_CHANNELS; i++) 2027 s2255_release_sys_buffers(&dev->vc[i]); 2028 /* release transfer buffer */ 2029 kfree(dev->pipe.transfer_buffer); 2030 return 0; 2031 } 2032 2033 static void read_pipe_completion(struct urb *purb) 2034 { 2035 struct s2255_pipeinfo *pipe_info; 2036 struct s2255_dev *dev; 2037 int status; 2038 int pipe; 2039 pipe_info = purb->context; 2040 if (pipe_info == NULL) { 2041 dev_err(&purb->dev->dev, "no context!\n"); 2042 return; 2043 } 2044 dev = pipe_info->dev; 2045 if (dev == NULL) { 2046 dev_err(&purb->dev->dev, "no context!\n"); 2047 return; 2048 } 2049 status = purb->status; 2050 /* if shutting down, do not resubmit, exit immediately */ 2051 if (status == -ESHUTDOWN) { 2052 dprintk(dev, 2, "%s: err shutdown\n", __func__); 2053 pipe_info->err_count++; 2054 return; 2055 } 2056 2057 if (pipe_info->state == 0) { 2058 dprintk(dev, 2, "%s: exiting USB pipe", __func__); 2059 return; 2060 } 2061 2062 if (status == 0) 2063 s2255_read_video_callback(dev, pipe_info); 2064 else { 2065 pipe_info->err_count++; 2066 dprintk(dev, 1, "%s: failed URB %d\n", __func__, status); 2067 } 2068 2069 pipe = usb_rcvbulkpipe(dev->udev, dev->read_endpoint); 2070 /* reuse urb */ 2071 usb_fill_bulk_urb(pipe_info->stream_urb, dev->udev, 2072 pipe, 2073 pipe_info->transfer_buffer, 2074 pipe_info->cur_transfer_size, 2075 read_pipe_completion, pipe_info); 2076 2077 if (pipe_info->state != 0) { 2078 if (usb_submit_urb(pipe_info->stream_urb, GFP_ATOMIC)) 2079 dev_err(&dev->udev->dev, "error submitting urb\n"); 2080 } else { 2081 dprintk(dev, 2, "%s :complete state 0\n", __func__); 2082 } 2083 return; 2084 } 2085 2086 static int s2255_start_readpipe(struct s2255_dev *dev) 2087 { 2088 int pipe; 2089 int retval; 2090 struct s2255_pipeinfo *pipe_info = &dev->pipe; 2091 pipe = usb_rcvbulkpipe(dev->udev, dev->read_endpoint); 2092 dprintk(dev, 2, "%s: IN %d\n", __func__, dev->read_endpoint); 2093 pipe_info->state = 1; 2094 pipe_info->err_count = 0; 2095 pipe_info->stream_urb = usb_alloc_urb(0, GFP_KERNEL); 2096 if (!pipe_info->stream_urb) 2097 return -ENOMEM; 2098 /* transfer buffer allocated in board_init */ 2099 usb_fill_bulk_urb(pipe_info->stream_urb, dev->udev, 2100 pipe, 2101 pipe_info->transfer_buffer, 2102 pipe_info->cur_transfer_size, 2103 read_pipe_completion, pipe_info); 2104 retval = usb_submit_urb(pipe_info->stream_urb, GFP_KERNEL); 2105 if (retval) { 2106 pr_err("s2255: start read pipe failed\n"); 2107 return retval; 2108 } 2109 return 0; 2110 } 2111 2112 /* starts acquisition process */ 2113 static int s2255_start_acquire(struct s2255_vc *vc) 2114 { 2115 int res; 2116 unsigned long chn_rev; 2117 int j; 2118 struct s2255_dev *dev = to_s2255_dev(vc->vdev.v4l2_dev); 2119 __le32 *buffer = dev->cmdbuf; 2120 2121 mutex_lock(&dev->cmdlock); 2122 chn_rev = G_chnmap[vc->idx]; 2123 vc->last_frame = -1; 2124 vc->bad_payload = 0; 2125 vc->cur_frame = 0; 2126 for (j = 0; j < SYS_FRAMES; j++) { 2127 vc->buffer.frame[j].ulState = 0; 2128 vc->buffer.frame[j].cur_size = 0; 2129 } 2130 2131 /* send the start command */ 2132 buffer[0] = IN_DATA_TOKEN; 2133 buffer[1] = (__le32) cpu_to_le32(chn_rev); 2134 buffer[2] = CMD_START; 2135 res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512); 2136 if (res != 0) 2137 dev_err(&dev->udev->dev, "CMD_START error\n"); 2138 2139 dprintk(dev, 2, "start acquire exit[%d] %d\n", vc->idx, res); 2140 mutex_unlock(&dev->cmdlock); 2141 return res; 2142 } 2143 2144 static int s2255_stop_acquire(struct s2255_vc *vc) 2145 { 2146 int res; 2147 unsigned long chn_rev; 2148 struct s2255_dev *dev = to_s2255_dev(vc->vdev.v4l2_dev); 2149 __le32 *buffer = dev->cmdbuf; 2150 2151 mutex_lock(&dev->cmdlock); 2152 chn_rev = G_chnmap[vc->idx]; 2153 /* send the stop command */ 2154 buffer[0] = IN_DATA_TOKEN; 2155 buffer[1] = (__le32) cpu_to_le32(chn_rev); 2156 buffer[2] = CMD_STOP; 2157 2158 res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512); 2159 if (res != 0) 2160 dev_err(&dev->udev->dev, "CMD_STOP error\n"); 2161 2162 dprintk(dev, 4, "%s: chn %d, res %d\n", __func__, vc->idx, res); 2163 mutex_unlock(&dev->cmdlock); 2164 return res; 2165 } 2166 2167 static void s2255_stop_readpipe(struct s2255_dev *dev) 2168 { 2169 struct s2255_pipeinfo *pipe = &dev->pipe; 2170 2171 pipe->state = 0; 2172 if (pipe->stream_urb) { 2173 /* cancel urb */ 2174 usb_kill_urb(pipe->stream_urb); 2175 usb_free_urb(pipe->stream_urb); 2176 pipe->stream_urb = NULL; 2177 } 2178 dprintk(dev, 4, "%s", __func__); 2179 return; 2180 } 2181 2182 static void s2255_fwload_start(struct s2255_dev *dev) 2183 { 2184 s2255_reset_dsppower(dev); 2185 dev->fw_data->fw_size = dev->fw_data->fw->size; 2186 atomic_set(&dev->fw_data->fw_state, S2255_FW_NOTLOADED); 2187 memcpy(dev->fw_data->pfw_data, 2188 dev->fw_data->fw->data, CHUNK_SIZE); 2189 dev->fw_data->fw_loaded = CHUNK_SIZE; 2190 usb_fill_bulk_urb(dev->fw_data->fw_urb, dev->udev, 2191 usb_sndbulkpipe(dev->udev, 2), 2192 dev->fw_data->pfw_data, 2193 CHUNK_SIZE, s2255_fwchunk_complete, 2194 dev->fw_data); 2195 mod_timer(&dev->timer, jiffies + HZ); 2196 } 2197 2198 /* standard usb probe function */ 2199 static int s2255_probe(struct usb_interface *interface, 2200 const struct usb_device_id *id) 2201 { 2202 struct s2255_dev *dev = NULL; 2203 struct usb_host_interface *iface_desc; 2204 struct usb_endpoint_descriptor *endpoint; 2205 int i; 2206 int retval = -ENOMEM; 2207 __le32 *pdata; 2208 int fw_size; 2209 2210 /* allocate memory for our device state and initialize it to zero */ 2211 dev = kzalloc(sizeof(struct s2255_dev), GFP_KERNEL); 2212 if (dev == NULL) { 2213 s2255_dev_err(&interface->dev, "out of memory\n"); 2214 return -ENOMEM; 2215 } 2216 2217 dev->cmdbuf = kzalloc(S2255_CMDBUF_SIZE, GFP_KERNEL); 2218 if (dev->cmdbuf == NULL) { 2219 s2255_dev_err(&interface->dev, "out of memory\n"); 2220 goto errorFWDATA1; 2221 } 2222 2223 atomic_set(&dev->num_channels, 0); 2224 dev->pid = id->idProduct; 2225 dev->fw_data = kzalloc(sizeof(struct s2255_fw), GFP_KERNEL); 2226 if (!dev->fw_data) 2227 goto errorFWDATA1; 2228 mutex_init(&dev->lock); 2229 mutex_init(&dev->cmdlock); 2230 /* grab usb_device and save it */ 2231 dev->udev = usb_get_dev(interface_to_usbdev(interface)); 2232 if (dev->udev == NULL) { 2233 dev_err(&interface->dev, "null usb device\n"); 2234 retval = -ENODEV; 2235 goto errorUDEV; 2236 } 2237 dev_dbg(&interface->dev, "dev: %p, udev %p interface %p\n", 2238 dev, dev->udev, interface); 2239 dev->interface = interface; 2240 /* set up the endpoint information */ 2241 iface_desc = interface->cur_altsetting; 2242 dev_dbg(&interface->dev, "num EP: %d\n", 2243 iface_desc->desc.bNumEndpoints); 2244 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) { 2245 endpoint = &iface_desc->endpoint[i].desc; 2246 if (!dev->read_endpoint && usb_endpoint_is_bulk_in(endpoint)) { 2247 /* we found the bulk in endpoint */ 2248 dev->read_endpoint = endpoint->bEndpointAddress; 2249 } 2250 } 2251 2252 if (!dev->read_endpoint) { 2253 dev_err(&interface->dev, "Could not find bulk-in endpoint\n"); 2254 goto errorEP; 2255 } 2256 timer_setup(&dev->timer, s2255_timer, 0); 2257 init_waitqueue_head(&dev->fw_data->wait_fw); 2258 for (i = 0; i < MAX_CHANNELS; i++) { 2259 struct s2255_vc *vc = &dev->vc[i]; 2260 vc->idx = i; 2261 vc->dev = dev; 2262 init_waitqueue_head(&vc->wait_setmode); 2263 init_waitqueue_head(&vc->wait_vidstatus); 2264 spin_lock_init(&vc->qlock); 2265 mutex_init(&vc->vb_lock); 2266 } 2267 2268 dev->fw_data->fw_urb = usb_alloc_urb(0, GFP_KERNEL); 2269 if (!dev->fw_data->fw_urb) 2270 goto errorFWURB; 2271 2272 dev->fw_data->pfw_data = kzalloc(CHUNK_SIZE, GFP_KERNEL); 2273 if (!dev->fw_data->pfw_data) { 2274 dev_err(&interface->dev, "out of memory!\n"); 2275 goto errorFWDATA2; 2276 } 2277 /* load the first chunk */ 2278 if (request_firmware(&dev->fw_data->fw, 2279 FIRMWARE_FILE_NAME, &dev->udev->dev)) { 2280 dev_err(&interface->dev, "sensoray 2255 failed to get firmware\n"); 2281 goto errorREQFW; 2282 } 2283 /* check the firmware is valid */ 2284 fw_size = dev->fw_data->fw->size; 2285 pdata = (__le32 *) &dev->fw_data->fw->data[fw_size - 8]; 2286 2287 if (*pdata != S2255_FW_MARKER) { 2288 dev_err(&interface->dev, "Firmware invalid.\n"); 2289 retval = -ENODEV; 2290 goto errorFWMARKER; 2291 } else { 2292 /* make sure firmware is the latest */ 2293 __le32 *pRel; 2294 pRel = (__le32 *) &dev->fw_data->fw->data[fw_size - 4]; 2295 pr_info("s2255 dsp fw version %x\n", le32_to_cpu(*pRel)); 2296 dev->dsp_fw_ver = le32_to_cpu(*pRel); 2297 if (dev->dsp_fw_ver < S2255_CUR_DSP_FWVER) 2298 pr_info("s2255: f2255usb.bin out of date.\n"); 2299 if (dev->pid == 0x2257 && 2300 dev->dsp_fw_ver < S2255_MIN_DSP_COLORFILTER) 2301 pr_warn("2257 needs firmware %d or above.\n", 2302 S2255_MIN_DSP_COLORFILTER); 2303 } 2304 usb_reset_device(dev->udev); 2305 /* load 2255 board specific */ 2306 retval = s2255_board_init(dev); 2307 if (retval) 2308 goto errorBOARDINIT; 2309 s2255_fwload_start(dev); 2310 /* loads v4l specific */ 2311 retval = s2255_probe_v4l(dev); 2312 if (retval) 2313 goto errorBOARDINIT; 2314 dev_info(&interface->dev, "Sensoray 2255 detected\n"); 2315 return 0; 2316 errorBOARDINIT: 2317 s2255_board_shutdown(dev); 2318 errorFWMARKER: 2319 release_firmware(dev->fw_data->fw); 2320 errorREQFW: 2321 kfree(dev->fw_data->pfw_data); 2322 errorFWDATA2: 2323 usb_free_urb(dev->fw_data->fw_urb); 2324 errorFWURB: 2325 timer_shutdown_sync(&dev->timer); 2326 errorEP: 2327 usb_put_dev(dev->udev); 2328 errorUDEV: 2329 kfree(dev->fw_data); 2330 mutex_destroy(&dev->lock); 2331 errorFWDATA1: 2332 kfree(dev->cmdbuf); 2333 kfree(dev); 2334 pr_warn("Sensoray 2255 driver load failed: 0x%x\n", retval); 2335 return retval; 2336 } 2337 2338 /* disconnect routine. when board is removed physically or with rmmod */ 2339 static void s2255_disconnect(struct usb_interface *interface) 2340 { 2341 struct s2255_dev *dev = to_s2255_dev(usb_get_intfdata(interface)); 2342 int i; 2343 int channels = atomic_read(&dev->num_channels); 2344 mutex_lock(&dev->lock); 2345 v4l2_device_disconnect(&dev->v4l2_dev); 2346 mutex_unlock(&dev->lock); 2347 /*see comments in the uvc_driver.c usb disconnect function */ 2348 atomic_inc(&dev->num_channels); 2349 /* unregister each video device. */ 2350 for (i = 0; i < channels; i++) 2351 video_unregister_device(&dev->vc[i].vdev); 2352 /* wake up any of our timers */ 2353 atomic_set(&dev->fw_data->fw_state, S2255_FW_DISCONNECTING); 2354 wake_up(&dev->fw_data->wait_fw); 2355 for (i = 0; i < MAX_CHANNELS; i++) { 2356 dev->vc[i].setmode_ready = 1; 2357 wake_up(&dev->vc[i].wait_setmode); 2358 dev->vc[i].vidstatus_ready = 1; 2359 wake_up(&dev->vc[i].wait_vidstatus); 2360 } 2361 if (atomic_dec_and_test(&dev->num_channels)) 2362 s2255_destroy(dev); 2363 dev_info(&interface->dev, "%s\n", __func__); 2364 } 2365 2366 static struct usb_driver s2255_driver = { 2367 .name = S2255_DRIVER_NAME, 2368 .probe = s2255_probe, 2369 .disconnect = s2255_disconnect, 2370 .id_table = s2255_table, 2371 }; 2372 2373 module_usb_driver(s2255_driver); 2374 2375 MODULE_DESCRIPTION("Sensoray 2255 Video for Linux driver"); 2376 MODULE_AUTHOR("Dean Anderson (Sensoray Company Inc.)"); 2377 MODULE_LICENSE("GPL"); 2378 MODULE_VERSION(S2255_VERSION); 2379 MODULE_FIRMWARE(FIRMWARE_FILE_NAME); 2380