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 field = f->fmt.pix.field; 771 772 dprintk(vc->dev, 50, "%s NTSC: %d suggested width: %d, height: %d\n", 773 __func__, is_ntsc, f->fmt.pix.width, f->fmt.pix.height); 774 if (is_ntsc) { 775 /* NTSC */ 776 if (f->fmt.pix.height >= NUM_LINES_1CIFS_NTSC * 2) { 777 f->fmt.pix.height = NUM_LINES_1CIFS_NTSC * 2; 778 field = V4L2_FIELD_INTERLACED; 779 } else { 780 f->fmt.pix.height = NUM_LINES_1CIFS_NTSC; 781 field = V4L2_FIELD_TOP; 782 } 783 if (f->fmt.pix.width >= LINE_SZ_4CIFS_NTSC) 784 f->fmt.pix.width = LINE_SZ_4CIFS_NTSC; 785 else 786 f->fmt.pix.width = LINE_SZ_1CIFS_NTSC; 787 } else { 788 /* PAL */ 789 if (f->fmt.pix.height >= NUM_LINES_1CIFS_PAL * 2) { 790 f->fmt.pix.height = NUM_LINES_1CIFS_PAL * 2; 791 field = V4L2_FIELD_INTERLACED; 792 } else { 793 f->fmt.pix.height = NUM_LINES_1CIFS_PAL; 794 field = V4L2_FIELD_TOP; 795 } 796 if (f->fmt.pix.width >= LINE_SZ_4CIFS_PAL) 797 f->fmt.pix.width = LINE_SZ_4CIFS_PAL; 798 else 799 f->fmt.pix.width = LINE_SZ_1CIFS_PAL; 800 } 801 f->fmt.pix.field = field; 802 f->fmt.pix.bytesperline = (f->fmt.pix.width * fmt->depth) >> 3; 803 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline; 804 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M; 805 dprintk(vc->dev, 50, "%s: set width %d height %d field %d\n", __func__, 806 f->fmt.pix.width, f->fmt.pix.height, f->fmt.pix.field); 807 return 0; 808 } 809 810 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv, 811 struct v4l2_format *f) 812 { 813 struct s2255_vc *vc = video_drvdata(file); 814 const struct s2255_fmt *fmt; 815 struct vb2_queue *q = &vc->vb_vidq; 816 struct s2255_mode mode; 817 int ret; 818 819 ret = vidioc_try_fmt_vid_cap(file, vc, f); 820 821 if (ret < 0) 822 return ret; 823 824 fmt = format_by_fourcc(f->fmt.pix.pixelformat); 825 826 if (fmt == NULL) 827 return -EINVAL; 828 829 if (vb2_is_busy(q)) { 830 dprintk(vc->dev, 1, "queue busy\n"); 831 return -EBUSY; 832 } 833 834 mode = vc->mode; 835 vc->fmt = fmt; 836 vc->width = f->fmt.pix.width; 837 vc->height = f->fmt.pix.height; 838 vc->field = f->fmt.pix.field; 839 if (vc->width > norm_minw(vc)) { 840 if (vc->height > norm_minh(vc)) { 841 if (vc->cap_parm.capturemode & 842 V4L2_MODE_HIGHQUALITY) 843 mode.scale = SCALE_4CIFSI; 844 else 845 mode.scale = SCALE_4CIFS; 846 } else 847 mode.scale = SCALE_2CIFS; 848 849 } else { 850 mode.scale = SCALE_1CIFS; 851 } 852 /* color mode */ 853 switch (vc->fmt->fourcc) { 854 case V4L2_PIX_FMT_GREY: 855 mode.color &= ~MASK_COLOR; 856 mode.color |= COLOR_Y8; 857 break; 858 case V4L2_PIX_FMT_JPEG: 859 case V4L2_PIX_FMT_MJPEG: 860 mode.color &= ~MASK_COLOR; 861 mode.color |= COLOR_JPG; 862 mode.color |= (vc->jpegqual << 8); 863 break; 864 case V4L2_PIX_FMT_YUV422P: 865 mode.color &= ~MASK_COLOR; 866 mode.color |= COLOR_YUVPL; 867 break; 868 case V4L2_PIX_FMT_YUYV: 869 case V4L2_PIX_FMT_UYVY: 870 default: 871 mode.color &= ~MASK_COLOR; 872 mode.color |= COLOR_YUVPK; 873 break; 874 } 875 if ((mode.color & MASK_COLOR) != (vc->mode.color & MASK_COLOR)) 876 mode.restart = 1; 877 else if (mode.scale != vc->mode.scale) 878 mode.restart = 1; 879 else if (mode.format != vc->mode.format) 880 mode.restart = 1; 881 vc->mode = mode; 882 (void) s2255_set_mode(vc, &mode); 883 return 0; 884 } 885 886 887 /* write to the configuration pipe, synchronously */ 888 static int s2255_write_config(struct usb_device *udev, unsigned char *pbuf, 889 int size) 890 { 891 int pipe; 892 int done; 893 long retval = -1; 894 if (udev) { 895 pipe = usb_sndbulkpipe(udev, S2255_CONFIG_EP); 896 retval = usb_bulk_msg(udev, pipe, pbuf, size, &done, 500); 897 } 898 return retval; 899 } 900 901 static u32 get_transfer_size(struct s2255_mode *mode) 902 { 903 int linesPerFrame = LINE_SZ_DEF; 904 int pixelsPerLine = NUM_LINES_DEF; 905 u32 outImageSize; 906 u32 usbInSize; 907 unsigned int mask_mult; 908 909 if (mode == NULL) 910 return 0; 911 912 if (mode->format == FORMAT_NTSC) { 913 switch (mode->scale) { 914 case SCALE_4CIFS: 915 case SCALE_4CIFSI: 916 linesPerFrame = NUM_LINES_4CIFS_NTSC * 2; 917 pixelsPerLine = LINE_SZ_4CIFS_NTSC; 918 break; 919 case SCALE_2CIFS: 920 linesPerFrame = NUM_LINES_2CIFS_NTSC; 921 pixelsPerLine = LINE_SZ_2CIFS_NTSC; 922 break; 923 case SCALE_1CIFS: 924 linesPerFrame = NUM_LINES_1CIFS_NTSC; 925 pixelsPerLine = LINE_SZ_1CIFS_NTSC; 926 break; 927 default: 928 break; 929 } 930 } else if (mode->format == FORMAT_PAL) { 931 switch (mode->scale) { 932 case SCALE_4CIFS: 933 case SCALE_4CIFSI: 934 linesPerFrame = NUM_LINES_4CIFS_PAL * 2; 935 pixelsPerLine = LINE_SZ_4CIFS_PAL; 936 break; 937 case SCALE_2CIFS: 938 linesPerFrame = NUM_LINES_2CIFS_PAL; 939 pixelsPerLine = LINE_SZ_2CIFS_PAL; 940 break; 941 case SCALE_1CIFS: 942 linesPerFrame = NUM_LINES_1CIFS_PAL; 943 pixelsPerLine = LINE_SZ_1CIFS_PAL; 944 break; 945 default: 946 break; 947 } 948 } 949 outImageSize = linesPerFrame * pixelsPerLine; 950 if ((mode->color & MASK_COLOR) != COLOR_Y8) { 951 /* 2 bytes/pixel if not monochrome */ 952 outImageSize *= 2; 953 } 954 955 /* total bytes to send including prefix and 4K padding; 956 must be a multiple of USB_READ_SIZE */ 957 usbInSize = outImageSize + PREFIX_SIZE; /* always send prefix */ 958 mask_mult = 0xffffffffUL - DEF_USB_BLOCK + 1; 959 /* if size not a multiple of USB_READ_SIZE */ 960 if (usbInSize & ~mask_mult) 961 usbInSize = (usbInSize & mask_mult) + (DEF_USB_BLOCK); 962 return usbInSize; 963 } 964 965 static void s2255_print_cfg(struct s2255_dev *sdev, struct s2255_mode *mode) 966 { 967 struct device *dev = &sdev->udev->dev; 968 dev_info(dev, "------------------------------------------------\n"); 969 dev_info(dev, "format: %d\nscale %d\n", mode->format, mode->scale); 970 dev_info(dev, "fdec: %d\ncolor %d\n", mode->fdec, mode->color); 971 dev_info(dev, "bright: 0x%x\n", mode->bright); 972 dev_info(dev, "------------------------------------------------\n"); 973 } 974 975 /* 976 * set mode is the function which controls the DSP. 977 * the restart parameter in struct s2255_mode should be set whenever 978 * the image size could change via color format, video system or image 979 * size. 980 * When the restart parameter is set, we sleep for ONE frame to allow the 981 * DSP time to get the new frame 982 */ 983 static int s2255_set_mode(struct s2255_vc *vc, 984 struct s2255_mode *mode) 985 { 986 int res; 987 unsigned long chn_rev; 988 struct s2255_dev *dev = to_s2255_dev(vc->vdev.v4l2_dev); 989 int i; 990 __le32 *buffer = dev->cmdbuf; 991 992 mutex_lock(&dev->cmdlock); 993 chn_rev = G_chnmap[vc->idx]; 994 dprintk(dev, 3, "%s channel: %d\n", __func__, vc->idx); 995 /* if JPEG, set the quality */ 996 if ((mode->color & MASK_COLOR) == COLOR_JPG) { 997 mode->color &= ~MASK_COLOR; 998 mode->color |= COLOR_JPG; 999 mode->color &= ~MASK_JPG_QUALITY; 1000 mode->color |= (vc->jpegqual << 8); 1001 } 1002 /* save the mode */ 1003 vc->mode = *mode; 1004 vc->req_image_size = get_transfer_size(mode); 1005 dprintk(dev, 1, "%s: reqsize %ld\n", __func__, vc->req_image_size); 1006 /* set the mode */ 1007 buffer[0] = IN_DATA_TOKEN; 1008 buffer[1] = (__le32) cpu_to_le32(chn_rev); 1009 buffer[2] = CMD_SET_MODE; 1010 for (i = 0; i < sizeof(struct s2255_mode) / sizeof(u32); i++) 1011 buffer[3 + i] = cpu_to_le32(((u32 *)&vc->mode)[i]); 1012 vc->setmode_ready = 0; 1013 res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512); 1014 if (debug) 1015 s2255_print_cfg(dev, mode); 1016 /* wait at least 3 frames before continuing */ 1017 if (mode->restart) { 1018 wait_event_timeout(vc->wait_setmode, 1019 (vc->setmode_ready != 0), 1020 msecs_to_jiffies(S2255_SETMODE_TIMEOUT)); 1021 if (vc->setmode_ready != 1) { 1022 dprintk(dev, 0, "s2255: no set mode response\n"); 1023 res = -EFAULT; 1024 } 1025 } 1026 /* clear the restart flag */ 1027 vc->mode.restart = 0; 1028 dprintk(dev, 1, "%s chn %d, result: %d\n", __func__, vc->idx, res); 1029 mutex_unlock(&dev->cmdlock); 1030 return res; 1031 } 1032 1033 static int s2255_cmd_status(struct s2255_vc *vc, u32 *pstatus) 1034 { 1035 int res; 1036 u32 chn_rev; 1037 struct s2255_dev *dev = to_s2255_dev(vc->vdev.v4l2_dev); 1038 __le32 *buffer = dev->cmdbuf; 1039 1040 mutex_lock(&dev->cmdlock); 1041 chn_rev = G_chnmap[vc->idx]; 1042 dprintk(dev, 4, "%s chan %d\n", __func__, vc->idx); 1043 /* form the get vid status command */ 1044 buffer[0] = IN_DATA_TOKEN; 1045 buffer[1] = (__le32) cpu_to_le32(chn_rev); 1046 buffer[2] = CMD_STATUS; 1047 *pstatus = 0; 1048 vc->vidstatus_ready = 0; 1049 res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512); 1050 wait_event_timeout(vc->wait_vidstatus, 1051 (vc->vidstatus_ready != 0), 1052 msecs_to_jiffies(S2255_VIDSTATUS_TIMEOUT)); 1053 if (vc->vidstatus_ready != 1) { 1054 dprintk(dev, 0, "s2255: no vidstatus response\n"); 1055 res = -EFAULT; 1056 } 1057 *pstatus = vc->vidstatus; 1058 dprintk(dev, 4, "%s, vid status %d\n", __func__, *pstatus); 1059 mutex_unlock(&dev->cmdlock); 1060 return res; 1061 } 1062 1063 static int start_streaming(struct vb2_queue *vq, unsigned int count) 1064 { 1065 struct s2255_vc *vc = vb2_get_drv_priv(vq); 1066 int j; 1067 1068 vc->last_frame = -1; 1069 vc->bad_payload = 0; 1070 vc->cur_frame = 0; 1071 vc->frame_count = 0; 1072 for (j = 0; j < SYS_FRAMES; j++) { 1073 vc->buffer.frame[j].ulState = S2255_READ_IDLE; 1074 vc->buffer.frame[j].cur_size = 0; 1075 } 1076 return s2255_start_acquire(vc); 1077 } 1078 1079 /* abort streaming and wait for last buffer */ 1080 static void stop_streaming(struct vb2_queue *vq) 1081 { 1082 struct s2255_vc *vc = vb2_get_drv_priv(vq); 1083 struct s2255_buffer *buf, *node; 1084 unsigned long flags; 1085 (void) s2255_stop_acquire(vc); 1086 spin_lock_irqsave(&vc->qlock, flags); 1087 list_for_each_entry_safe(buf, node, &vc->buf_list, list) { 1088 list_del(&buf->list); 1089 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR); 1090 dprintk(vc->dev, 2, "[%p/%d] done\n", 1091 buf, buf->vb.vb2_buf.index); 1092 } 1093 spin_unlock_irqrestore(&vc->qlock, flags); 1094 } 1095 1096 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id i) 1097 { 1098 struct s2255_vc *vc = video_drvdata(file); 1099 struct s2255_mode mode; 1100 struct vb2_queue *q = &vc->vb_vidq; 1101 1102 /* 1103 * Changing the standard implies a format change, which is not allowed 1104 * while buffers for use with streaming have already been allocated. 1105 */ 1106 if (vb2_is_busy(q)) 1107 return -EBUSY; 1108 1109 mode = vc->mode; 1110 if (i & V4L2_STD_525_60) { 1111 dprintk(vc->dev, 4, "%s 60 Hz\n", __func__); 1112 /* if changing format, reset frame decimation/intervals */ 1113 if (mode.format != FORMAT_NTSC) { 1114 mode.restart = 1; 1115 mode.format = FORMAT_NTSC; 1116 mode.fdec = FDEC_1; 1117 vc->width = LINE_SZ_4CIFS_NTSC; 1118 vc->height = NUM_LINES_4CIFS_NTSC * 2; 1119 } 1120 } else if (i & V4L2_STD_625_50) { 1121 dprintk(vc->dev, 4, "%s 50 Hz\n", __func__); 1122 if (mode.format != FORMAT_PAL) { 1123 mode.restart = 1; 1124 mode.format = FORMAT_PAL; 1125 mode.fdec = FDEC_1; 1126 vc->width = LINE_SZ_4CIFS_PAL; 1127 vc->height = NUM_LINES_4CIFS_PAL * 2; 1128 } 1129 } else 1130 return -EINVAL; 1131 vc->std = i; 1132 if (mode.restart) 1133 s2255_set_mode(vc, &mode); 1134 return 0; 1135 } 1136 1137 static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *i) 1138 { 1139 struct s2255_vc *vc = video_drvdata(file); 1140 1141 *i = vc->std; 1142 return 0; 1143 } 1144 1145 /* Sensoray 2255 is a multiple channel capture device. 1146 It does not have a "crossbar" of inputs. 1147 We use one V4L device per channel. The user must 1148 be aware that certain combinations are not allowed. 1149 For instance, you cannot do full FPS on more than 2 channels(2 videodevs) 1150 at once in color(you can do full fps on 4 channels with greyscale. 1151 */ 1152 static int vidioc_enum_input(struct file *file, void *priv, 1153 struct v4l2_input *inp) 1154 { 1155 struct s2255_vc *vc = video_drvdata(file); 1156 struct s2255_dev *dev = vc->dev; 1157 u32 status = 0; 1158 1159 if (inp->index != 0) 1160 return -EINVAL; 1161 inp->type = V4L2_INPUT_TYPE_CAMERA; 1162 inp->std = S2255_NORMS; 1163 inp->status = 0; 1164 if (dev->dsp_fw_ver >= S2255_MIN_DSP_STATUS) { 1165 int rc; 1166 rc = s2255_cmd_status(vc, &status); 1167 dprintk(dev, 4, "s2255_cmd_status rc: %d status %x\n", 1168 rc, status); 1169 if (rc == 0) 1170 inp->status = (status & 0x01) ? 0 1171 : V4L2_IN_ST_NO_SIGNAL; 1172 } 1173 switch (dev->pid) { 1174 case 0x2255: 1175 default: 1176 strscpy(inp->name, "Composite", sizeof(inp->name)); 1177 break; 1178 case 0x2257: 1179 strscpy(inp->name, (vc->idx < 2) ? "Composite" : "S-Video", 1180 sizeof(inp->name)); 1181 break; 1182 } 1183 return 0; 1184 } 1185 1186 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i) 1187 { 1188 *i = 0; 1189 return 0; 1190 } 1191 static int vidioc_s_input(struct file *file, void *priv, unsigned int i) 1192 { 1193 if (i > 0) 1194 return -EINVAL; 1195 return 0; 1196 } 1197 1198 static int s2255_s_ctrl(struct v4l2_ctrl *ctrl) 1199 { 1200 struct s2255_vc *vc = 1201 container_of(ctrl->handler, struct s2255_vc, hdl); 1202 struct s2255_mode mode; 1203 mode = vc->mode; 1204 /* update the mode to the corresponding value */ 1205 switch (ctrl->id) { 1206 case V4L2_CID_BRIGHTNESS: 1207 mode.bright = ctrl->val; 1208 break; 1209 case V4L2_CID_CONTRAST: 1210 mode.contrast = ctrl->val; 1211 break; 1212 case V4L2_CID_HUE: 1213 mode.hue = ctrl->val; 1214 break; 1215 case V4L2_CID_SATURATION: 1216 mode.saturation = ctrl->val; 1217 break; 1218 case V4L2_CID_S2255_COLORFILTER: 1219 mode.color &= ~MASK_INPUT_TYPE; 1220 mode.color |= !ctrl->val << 16; 1221 break; 1222 case V4L2_CID_JPEG_COMPRESSION_QUALITY: 1223 vc->jpegqual = ctrl->val; 1224 return 0; 1225 default: 1226 return -EINVAL; 1227 } 1228 mode.restart = 0; 1229 /* set mode here. Note: stream does not need restarted. 1230 some V4L programs restart stream unnecessarily 1231 after a s_crtl. 1232 */ 1233 s2255_set_mode(vc, &mode); 1234 return 0; 1235 } 1236 1237 static int vidioc_g_jpegcomp(struct file *file, void *priv, 1238 struct v4l2_jpegcompression *jc) 1239 { 1240 struct s2255_vc *vc = video_drvdata(file); 1241 1242 memset(jc, 0, sizeof(*jc)); 1243 jc->quality = vc->jpegqual; 1244 dprintk(vc->dev, 2, "%s: quality %d\n", __func__, jc->quality); 1245 return 0; 1246 } 1247 1248 static int vidioc_s_jpegcomp(struct file *file, void *priv, 1249 const struct v4l2_jpegcompression *jc) 1250 { 1251 struct s2255_vc *vc = video_drvdata(file); 1252 1253 if (jc->quality < 0 || jc->quality > 100) 1254 return -EINVAL; 1255 v4l2_ctrl_s_ctrl(vc->jpegqual_ctrl, jc->quality); 1256 dprintk(vc->dev, 2, "%s: quality %d\n", __func__, jc->quality); 1257 return 0; 1258 } 1259 1260 static int vidioc_g_parm(struct file *file, void *priv, 1261 struct v4l2_streamparm *sp) 1262 { 1263 __u32 def_num, def_dem; 1264 struct s2255_vc *vc = video_drvdata(file); 1265 1266 if (sp->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 1267 return -EINVAL; 1268 sp->parm.capture.capability = V4L2_CAP_TIMEPERFRAME; 1269 sp->parm.capture.capturemode = vc->cap_parm.capturemode; 1270 sp->parm.capture.readbuffers = S2255_MIN_BUFS; 1271 def_num = (vc->mode.format == FORMAT_NTSC) ? 1001 : 1000; 1272 def_dem = (vc->mode.format == FORMAT_NTSC) ? 30000 : 25000; 1273 sp->parm.capture.timeperframe.denominator = def_dem; 1274 switch (vc->mode.fdec) { 1275 default: 1276 case FDEC_1: 1277 sp->parm.capture.timeperframe.numerator = def_num; 1278 break; 1279 case FDEC_2: 1280 sp->parm.capture.timeperframe.numerator = def_num * 2; 1281 break; 1282 case FDEC_3: 1283 sp->parm.capture.timeperframe.numerator = def_num * 3; 1284 break; 1285 case FDEC_5: 1286 sp->parm.capture.timeperframe.numerator = def_num * 5; 1287 break; 1288 } 1289 dprintk(vc->dev, 4, "%s capture mode, %d timeperframe %d/%d\n", 1290 __func__, 1291 sp->parm.capture.capturemode, 1292 sp->parm.capture.timeperframe.numerator, 1293 sp->parm.capture.timeperframe.denominator); 1294 return 0; 1295 } 1296 1297 static int vidioc_s_parm(struct file *file, void *priv, 1298 struct v4l2_streamparm *sp) 1299 { 1300 struct s2255_vc *vc = video_drvdata(file); 1301 struct s2255_mode mode; 1302 int fdec = FDEC_1; 1303 __u32 def_num, def_dem; 1304 if (sp->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 1305 return -EINVAL; 1306 mode = vc->mode; 1307 /* high quality capture mode requires a stream restart */ 1308 if ((vc->cap_parm.capturemode != sp->parm.capture.capturemode) 1309 && vb2_is_streaming(&vc->vb_vidq)) 1310 return -EBUSY; 1311 def_num = (mode.format == FORMAT_NTSC) ? 1001 : 1000; 1312 def_dem = (mode.format == FORMAT_NTSC) ? 30000 : 25000; 1313 if (def_dem != sp->parm.capture.timeperframe.denominator) 1314 sp->parm.capture.timeperframe.numerator = def_num; 1315 else if (sp->parm.capture.timeperframe.numerator <= def_num) 1316 sp->parm.capture.timeperframe.numerator = def_num; 1317 else if (sp->parm.capture.timeperframe.numerator <= (def_num * 2)) { 1318 sp->parm.capture.timeperframe.numerator = def_num * 2; 1319 fdec = FDEC_2; 1320 } else if (sp->parm.capture.timeperframe.numerator <= (def_num * 3)) { 1321 sp->parm.capture.timeperframe.numerator = def_num * 3; 1322 fdec = FDEC_3; 1323 } else { 1324 sp->parm.capture.timeperframe.numerator = def_num * 5; 1325 fdec = FDEC_5; 1326 } 1327 mode.fdec = fdec; 1328 sp->parm.capture.timeperframe.denominator = def_dem; 1329 sp->parm.capture.readbuffers = S2255_MIN_BUFS; 1330 s2255_set_mode(vc, &mode); 1331 dprintk(vc->dev, 4, "%s capture mode, %d timeperframe %d/%d, fdec %d\n", 1332 __func__, 1333 sp->parm.capture.capturemode, 1334 sp->parm.capture.timeperframe.numerator, 1335 sp->parm.capture.timeperframe.denominator, fdec); 1336 return 0; 1337 } 1338 1339 #define NUM_SIZE_ENUMS 3 1340 static const struct v4l2_frmsize_discrete ntsc_sizes[] = { 1341 { 640, 480 }, 1342 { 640, 240 }, 1343 { 320, 240 }, 1344 }; 1345 static const struct v4l2_frmsize_discrete pal_sizes[] = { 1346 { 704, 576 }, 1347 { 704, 288 }, 1348 { 352, 288 }, 1349 }; 1350 1351 static int vidioc_enum_framesizes(struct file *file, void *priv, 1352 struct v4l2_frmsizeenum *fe) 1353 { 1354 struct s2255_vc *vc = video_drvdata(file); 1355 int is_ntsc = vc->std & V4L2_STD_525_60; 1356 const struct s2255_fmt *fmt; 1357 1358 if (fe->index >= NUM_SIZE_ENUMS) 1359 return -EINVAL; 1360 1361 fmt = format_by_fourcc(fe->pixel_format); 1362 if (fmt == NULL) 1363 return -EINVAL; 1364 fe->type = V4L2_FRMSIZE_TYPE_DISCRETE; 1365 fe->discrete = is_ntsc ? ntsc_sizes[fe->index] : pal_sizes[fe->index]; 1366 return 0; 1367 } 1368 1369 static int vidioc_enum_frameintervals(struct file *file, void *priv, 1370 struct v4l2_frmivalenum *fe) 1371 { 1372 struct s2255_vc *vc = video_drvdata(file); 1373 const struct s2255_fmt *fmt; 1374 const struct v4l2_frmsize_discrete *sizes; 1375 int is_ntsc = vc->std & V4L2_STD_525_60; 1376 #define NUM_FRAME_ENUMS 4 1377 int frm_dec[NUM_FRAME_ENUMS] = {1, 2, 3, 5}; 1378 int i; 1379 1380 if (fe->index >= NUM_FRAME_ENUMS) 1381 return -EINVAL; 1382 1383 fmt = format_by_fourcc(fe->pixel_format); 1384 if (fmt == NULL) 1385 return -EINVAL; 1386 1387 sizes = is_ntsc ? ntsc_sizes : pal_sizes; 1388 for (i = 0; i < NUM_SIZE_ENUMS; i++, sizes++) 1389 if (fe->width == sizes->width && 1390 fe->height == sizes->height) 1391 break; 1392 if (i == NUM_SIZE_ENUMS) 1393 return -EINVAL; 1394 1395 fe->type = V4L2_FRMIVAL_TYPE_DISCRETE; 1396 fe->discrete.denominator = is_ntsc ? 30000 : 25000; 1397 fe->discrete.numerator = (is_ntsc ? 1001 : 1000) * frm_dec[fe->index]; 1398 dprintk(vc->dev, 4, "%s discrete %d/%d\n", __func__, 1399 fe->discrete.numerator, 1400 fe->discrete.denominator); 1401 return 0; 1402 } 1403 1404 static int s2255_open(struct file *file) 1405 { 1406 struct s2255_vc *vc = video_drvdata(file); 1407 struct s2255_dev *dev = vc->dev; 1408 int state; 1409 int rc = 0; 1410 1411 rc = v4l2_fh_open(file); 1412 if (rc != 0) 1413 return rc; 1414 1415 dprintk(dev, 1, "s2255: %s\n", __func__); 1416 state = atomic_read(&dev->fw_data->fw_state); 1417 switch (state) { 1418 case S2255_FW_DISCONNECTING: 1419 return -ENODEV; 1420 case S2255_FW_FAILED: 1421 s2255_dev_err(&dev->udev->dev, 1422 "firmware load failed. retrying.\n"); 1423 s2255_fwload_start(dev); 1424 wait_event_timeout(dev->fw_data->wait_fw, 1425 ((atomic_read(&dev->fw_data->fw_state) 1426 == S2255_FW_SUCCESS) || 1427 (atomic_read(&dev->fw_data->fw_state) 1428 == S2255_FW_DISCONNECTING)), 1429 msecs_to_jiffies(S2255_LOAD_TIMEOUT)); 1430 /* state may have changed, re-read */ 1431 state = atomic_read(&dev->fw_data->fw_state); 1432 break; 1433 case S2255_FW_NOTLOADED: 1434 case S2255_FW_LOADED_DSPWAIT: 1435 /* give S2255_LOAD_TIMEOUT time for firmware to load in case 1436 driver loaded and then device immediately opened */ 1437 pr_info("%s waiting for firmware load\n", __func__); 1438 wait_event_timeout(dev->fw_data->wait_fw, 1439 ((atomic_read(&dev->fw_data->fw_state) 1440 == S2255_FW_SUCCESS) || 1441 (atomic_read(&dev->fw_data->fw_state) 1442 == S2255_FW_DISCONNECTING)), 1443 msecs_to_jiffies(S2255_LOAD_TIMEOUT)); 1444 /* state may have changed, re-read */ 1445 state = atomic_read(&dev->fw_data->fw_state); 1446 break; 1447 case S2255_FW_SUCCESS: 1448 default: 1449 break; 1450 } 1451 /* state may have changed in above switch statement */ 1452 switch (state) { 1453 case S2255_FW_SUCCESS: 1454 break; 1455 case S2255_FW_FAILED: 1456 pr_info("2255 firmware load failed.\n"); 1457 return -ENODEV; 1458 case S2255_FW_DISCONNECTING: 1459 pr_info("%s: disconnecting\n", __func__); 1460 return -ENODEV; 1461 case S2255_FW_LOADED_DSPWAIT: 1462 case S2255_FW_NOTLOADED: 1463 pr_info("%s: firmware not loaded, please retry\n", 1464 __func__); 1465 /* 1466 * Timeout on firmware load means device unusable. 1467 * Set firmware failure state. 1468 * On next s2255_open the firmware will be reloaded. 1469 */ 1470 atomic_set(&dev->fw_data->fw_state, 1471 S2255_FW_FAILED); 1472 return -EAGAIN; 1473 default: 1474 pr_info("%s: unknown state\n", __func__); 1475 return -EFAULT; 1476 } 1477 if (!vc->configured) { 1478 /* configure channel to default state */ 1479 vc->fmt = &formats[0]; 1480 s2255_set_mode(vc, &vc->mode); 1481 vc->configured = 1; 1482 } 1483 return 0; 1484 } 1485 1486 static void s2255_destroy(struct s2255_dev *dev) 1487 { 1488 dprintk(dev, 1, "%s", __func__); 1489 /* board shutdown stops the read pipe if it is running */ 1490 s2255_board_shutdown(dev); 1491 /* make sure firmware still not trying to load */ 1492 del_timer_sync(&dev->timer); /* only started in .probe and .open */ 1493 if (dev->fw_data->fw_urb) { 1494 usb_kill_urb(dev->fw_data->fw_urb); 1495 usb_free_urb(dev->fw_data->fw_urb); 1496 dev->fw_data->fw_urb = NULL; 1497 } 1498 release_firmware(dev->fw_data->fw); 1499 kfree(dev->fw_data->pfw_data); 1500 kfree(dev->fw_data); 1501 /* reset the DSP so firmware can be reloaded next time */ 1502 s2255_reset_dsppower(dev); 1503 mutex_destroy(&dev->lock); 1504 usb_put_dev(dev->udev); 1505 v4l2_device_unregister(&dev->v4l2_dev); 1506 kfree(dev->cmdbuf); 1507 kfree(dev); 1508 } 1509 1510 static const struct v4l2_file_operations s2255_fops_v4l = { 1511 .owner = THIS_MODULE, 1512 .open = s2255_open, 1513 .release = vb2_fop_release, 1514 .poll = vb2_fop_poll, 1515 .unlocked_ioctl = video_ioctl2, /* V4L2 ioctl handler */ 1516 .mmap = vb2_fop_mmap, 1517 .read = vb2_fop_read, 1518 }; 1519 1520 static const struct v4l2_ioctl_ops s2255_ioctl_ops = { 1521 .vidioc_querycap = vidioc_querycap, 1522 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap, 1523 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap, 1524 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap, 1525 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap, 1526 .vidioc_reqbufs = vb2_ioctl_reqbufs, 1527 .vidioc_querybuf = vb2_ioctl_querybuf, 1528 .vidioc_qbuf = vb2_ioctl_qbuf, 1529 .vidioc_dqbuf = vb2_ioctl_dqbuf, 1530 .vidioc_s_std = vidioc_s_std, 1531 .vidioc_g_std = vidioc_g_std, 1532 .vidioc_enum_input = vidioc_enum_input, 1533 .vidioc_g_input = vidioc_g_input, 1534 .vidioc_s_input = vidioc_s_input, 1535 .vidioc_streamon = vb2_ioctl_streamon, 1536 .vidioc_streamoff = vb2_ioctl_streamoff, 1537 .vidioc_s_jpegcomp = vidioc_s_jpegcomp, 1538 .vidioc_g_jpegcomp = vidioc_g_jpegcomp, 1539 .vidioc_s_parm = vidioc_s_parm, 1540 .vidioc_g_parm = vidioc_g_parm, 1541 .vidioc_enum_framesizes = vidioc_enum_framesizes, 1542 .vidioc_enum_frameintervals = vidioc_enum_frameintervals, 1543 .vidioc_log_status = v4l2_ctrl_log_status, 1544 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event, 1545 .vidioc_unsubscribe_event = v4l2_event_unsubscribe, 1546 }; 1547 1548 static void s2255_video_device_release(struct video_device *vdev) 1549 { 1550 struct s2255_dev *dev = to_s2255_dev(vdev->v4l2_dev); 1551 struct s2255_vc *vc = 1552 container_of(vdev, struct s2255_vc, vdev); 1553 1554 dprintk(dev, 4, "%s, chnls: %d\n", __func__, 1555 atomic_read(&dev->num_channels)); 1556 1557 v4l2_ctrl_handler_free(&vc->hdl); 1558 1559 if (atomic_dec_and_test(&dev->num_channels)) 1560 s2255_destroy(dev); 1561 return; 1562 } 1563 1564 static const struct video_device template = { 1565 .name = "s2255v", 1566 .fops = &s2255_fops_v4l, 1567 .ioctl_ops = &s2255_ioctl_ops, 1568 .release = s2255_video_device_release, 1569 .tvnorms = S2255_NORMS, 1570 }; 1571 1572 static const struct v4l2_ctrl_ops s2255_ctrl_ops = { 1573 .s_ctrl = s2255_s_ctrl, 1574 }; 1575 1576 static const struct v4l2_ctrl_config color_filter_ctrl = { 1577 .ops = &s2255_ctrl_ops, 1578 .name = "Color Filter", 1579 .id = V4L2_CID_S2255_COLORFILTER, 1580 .type = V4L2_CTRL_TYPE_BOOLEAN, 1581 .max = 1, 1582 .step = 1, 1583 .def = 1, 1584 }; 1585 1586 static int s2255_probe_v4l(struct s2255_dev *dev) 1587 { 1588 int ret; 1589 int i; 1590 int cur_nr = video_nr; 1591 struct s2255_vc *vc; 1592 struct vb2_queue *q; 1593 1594 ret = v4l2_device_register(&dev->interface->dev, &dev->v4l2_dev); 1595 if (ret) 1596 return ret; 1597 /* initialize all video 4 linux */ 1598 /* register 4 video devices */ 1599 for (i = 0; i < MAX_CHANNELS; i++) { 1600 vc = &dev->vc[i]; 1601 INIT_LIST_HEAD(&vc->buf_list); 1602 1603 v4l2_ctrl_handler_init(&vc->hdl, 6); 1604 v4l2_ctrl_new_std(&vc->hdl, &s2255_ctrl_ops, 1605 V4L2_CID_BRIGHTNESS, -127, 127, 1, DEF_BRIGHT); 1606 v4l2_ctrl_new_std(&vc->hdl, &s2255_ctrl_ops, 1607 V4L2_CID_CONTRAST, 0, 255, 1, DEF_CONTRAST); 1608 v4l2_ctrl_new_std(&vc->hdl, &s2255_ctrl_ops, 1609 V4L2_CID_SATURATION, 0, 255, 1, DEF_SATURATION); 1610 v4l2_ctrl_new_std(&vc->hdl, &s2255_ctrl_ops, 1611 V4L2_CID_HUE, 0, 255, 1, DEF_HUE); 1612 vc->jpegqual_ctrl = v4l2_ctrl_new_std(&vc->hdl, 1613 &s2255_ctrl_ops, 1614 V4L2_CID_JPEG_COMPRESSION_QUALITY, 1615 0, 100, 1, S2255_DEF_JPEG_QUAL); 1616 if (dev->dsp_fw_ver >= S2255_MIN_DSP_COLORFILTER && 1617 (dev->pid != 0x2257 || vc->idx <= 1)) 1618 v4l2_ctrl_new_custom(&vc->hdl, &color_filter_ctrl, 1619 NULL); 1620 if (vc->hdl.error) { 1621 ret = vc->hdl.error; 1622 v4l2_ctrl_handler_free(&vc->hdl); 1623 dev_err(&dev->udev->dev, "couldn't register control\n"); 1624 break; 1625 } 1626 q = &vc->vb_vidq; 1627 q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1628 q->io_modes = VB2_MMAP | VB2_READ | VB2_USERPTR; 1629 q->drv_priv = vc; 1630 q->lock = &vc->vb_lock; 1631 q->buf_struct_size = sizeof(struct s2255_buffer); 1632 q->mem_ops = &vb2_vmalloc_memops; 1633 q->ops = &s2255_video_qops; 1634 q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC; 1635 ret = vb2_queue_init(q); 1636 if (ret != 0) { 1637 dev_err(&dev->udev->dev, 1638 "%s vb2_queue_init 0x%x\n", __func__, ret); 1639 break; 1640 } 1641 /* register video devices */ 1642 vc->vdev = template; 1643 vc->vdev.queue = q; 1644 vc->vdev.ctrl_handler = &vc->hdl; 1645 vc->vdev.lock = &dev->lock; 1646 vc->vdev.v4l2_dev = &dev->v4l2_dev; 1647 vc->vdev.device_caps = V4L2_CAP_VIDEO_CAPTURE | 1648 V4L2_CAP_STREAMING | V4L2_CAP_READWRITE; 1649 video_set_drvdata(&vc->vdev, vc); 1650 if (video_nr == -1) 1651 ret = video_register_device(&vc->vdev, 1652 VFL_TYPE_GRABBER, 1653 video_nr); 1654 else 1655 ret = video_register_device(&vc->vdev, 1656 VFL_TYPE_GRABBER, 1657 cur_nr + i); 1658 1659 if (ret) { 1660 dev_err(&dev->udev->dev, 1661 "failed to register video device!\n"); 1662 break; 1663 } 1664 atomic_inc(&dev->num_channels); 1665 v4l2_info(&dev->v4l2_dev, "V4L2 device registered as %s\n", 1666 video_device_node_name(&vc->vdev)); 1667 1668 } 1669 pr_info("Sensoray 2255 V4L driver Revision: %s\n", 1670 S2255_VERSION); 1671 /* if no channels registered, return error and probe will fail*/ 1672 if (atomic_read(&dev->num_channels) == 0) { 1673 v4l2_device_unregister(&dev->v4l2_dev); 1674 return ret; 1675 } 1676 if (atomic_read(&dev->num_channels) != MAX_CHANNELS) 1677 pr_warn("s2255: Not all channels available.\n"); 1678 return 0; 1679 } 1680 1681 /* this function moves the usb stream read pipe data 1682 * into the system buffers. 1683 * returns 0 on success, EAGAIN if more data to process( call this 1684 * function again). 1685 * 1686 * Received frame structure: 1687 * bytes 0-3: marker : 0x2255DA4AL (S2255_MARKER_FRAME) 1688 * bytes 4-7: channel: 0-3 1689 * bytes 8-11: payload size: size of the frame 1690 * bytes 12-payloadsize+12: frame data 1691 */ 1692 static int save_frame(struct s2255_dev *dev, struct s2255_pipeinfo *pipe_info) 1693 { 1694 char *pdest; 1695 u32 offset = 0; 1696 int bframe = 0; 1697 char *psrc; 1698 unsigned long copy_size; 1699 unsigned long size; 1700 s32 idx = -1; 1701 struct s2255_framei *frm; 1702 unsigned char *pdata; 1703 struct s2255_vc *vc; 1704 dprintk(dev, 100, "buffer to user\n"); 1705 vc = &dev->vc[dev->cc]; 1706 idx = vc->cur_frame; 1707 frm = &vc->buffer.frame[idx]; 1708 if (frm->ulState == S2255_READ_IDLE) { 1709 int jj; 1710 unsigned int cc; 1711 __le32 *pdword; /*data from dsp is little endian */ 1712 int payload; 1713 /* search for marker codes */ 1714 pdata = (unsigned char *)pipe_info->transfer_buffer; 1715 pdword = (__le32 *)pdata; 1716 for (jj = 0; jj < (pipe_info->cur_transfer_size - 12); jj++) { 1717 switch (*pdword) { 1718 case S2255_MARKER_FRAME: 1719 dprintk(dev, 4, "marker @ offset: %d [%x %x]\n", 1720 jj, pdata[0], pdata[1]); 1721 offset = jj + PREFIX_SIZE; 1722 bframe = 1; 1723 cc = le32_to_cpu(pdword[1]); 1724 if (cc >= MAX_CHANNELS) { 1725 dprintk(dev, 0, 1726 "bad channel\n"); 1727 return -EINVAL; 1728 } 1729 /* reverse it */ 1730 dev->cc = G_chnmap[cc]; 1731 vc = &dev->vc[dev->cc]; 1732 payload = le32_to_cpu(pdword[3]); 1733 if (payload > vc->req_image_size) { 1734 vc->bad_payload++; 1735 /* discard the bad frame */ 1736 return -EINVAL; 1737 } 1738 vc->pkt_size = payload; 1739 vc->jpg_size = le32_to_cpu(pdword[4]); 1740 break; 1741 case S2255_MARKER_RESPONSE: 1742 1743 pdata += DEF_USB_BLOCK; 1744 jj += DEF_USB_BLOCK; 1745 if (le32_to_cpu(pdword[1]) >= MAX_CHANNELS) 1746 break; 1747 cc = G_chnmap[le32_to_cpu(pdword[1])]; 1748 if (cc >= MAX_CHANNELS) 1749 break; 1750 vc = &dev->vc[cc]; 1751 switch (pdword[2]) { 1752 case S2255_RESPONSE_SETMODE: 1753 /* check if channel valid */ 1754 /* set mode ready */ 1755 vc->setmode_ready = 1; 1756 wake_up(&vc->wait_setmode); 1757 dprintk(dev, 5, "setmode rdy %d\n", cc); 1758 break; 1759 case S2255_RESPONSE_FW: 1760 dev->chn_ready |= (1 << cc); 1761 if ((dev->chn_ready & 0x0f) != 0x0f) 1762 break; 1763 /* all channels ready */ 1764 pr_info("s2255: fw loaded\n"); 1765 atomic_set(&dev->fw_data->fw_state, 1766 S2255_FW_SUCCESS); 1767 wake_up(&dev->fw_data->wait_fw); 1768 break; 1769 case S2255_RESPONSE_STATUS: 1770 vc->vidstatus = le32_to_cpu(pdword[3]); 1771 vc->vidstatus_ready = 1; 1772 wake_up(&vc->wait_vidstatus); 1773 dprintk(dev, 5, "vstat %x chan %d\n", 1774 le32_to_cpu(pdword[3]), cc); 1775 break; 1776 default: 1777 pr_info("s2255 unknown resp\n"); 1778 } 1779 pdata++; 1780 break; 1781 default: 1782 pdata++; 1783 break; 1784 } 1785 if (bframe) 1786 break; 1787 } /* for */ 1788 if (!bframe) 1789 return -EINVAL; 1790 } 1791 vc = &dev->vc[dev->cc]; 1792 idx = vc->cur_frame; 1793 frm = &vc->buffer.frame[idx]; 1794 /* search done. now find out if should be acquiring on this channel */ 1795 if (!vb2_is_streaming(&vc->vb_vidq)) { 1796 /* we found a frame, but this channel is turned off */ 1797 frm->ulState = S2255_READ_IDLE; 1798 return -EINVAL; 1799 } 1800 1801 if (frm->ulState == S2255_READ_IDLE) { 1802 frm->ulState = S2255_READ_FRAME; 1803 frm->cur_size = 0; 1804 } 1805 1806 /* skip the marker 512 bytes (and offset if out of sync) */ 1807 psrc = (u8 *)pipe_info->transfer_buffer + offset; 1808 1809 1810 if (frm->lpvbits == NULL) { 1811 dprintk(dev, 1, "s2255 frame buffer == NULL.%p %p %d %d", 1812 frm, dev, dev->cc, idx); 1813 return -ENOMEM; 1814 } 1815 1816 pdest = frm->lpvbits + frm->cur_size; 1817 1818 copy_size = (pipe_info->cur_transfer_size - offset); 1819 1820 size = vc->pkt_size - PREFIX_SIZE; 1821 1822 /* sanity check on pdest */ 1823 if ((copy_size + frm->cur_size) < vc->req_image_size) 1824 memcpy(pdest, psrc, copy_size); 1825 1826 frm->cur_size += copy_size; 1827 dprintk(dev, 4, "cur_size: %lu, size: %lu\n", frm->cur_size, size); 1828 1829 if (frm->cur_size >= size) { 1830 dprintk(dev, 2, "******[%d]Buffer[%d]full*******\n", 1831 dev->cc, idx); 1832 vc->last_frame = vc->cur_frame; 1833 vc->cur_frame++; 1834 /* end of system frame ring buffer, start at zero */ 1835 if ((vc->cur_frame == SYS_FRAMES) || 1836 (vc->cur_frame == vc->buffer.dwFrames)) 1837 vc->cur_frame = 0; 1838 /* frame ready */ 1839 if (vb2_is_streaming(&vc->vb_vidq)) 1840 s2255_got_frame(vc, vc->jpg_size); 1841 vc->frame_count++; 1842 frm->ulState = S2255_READ_IDLE; 1843 frm->cur_size = 0; 1844 1845 } 1846 /* done successfully */ 1847 return 0; 1848 } 1849 1850 static void s2255_read_video_callback(struct s2255_dev *dev, 1851 struct s2255_pipeinfo *pipe_info) 1852 { 1853 int res; 1854 dprintk(dev, 50, "callback read video\n"); 1855 1856 if (dev->cc >= MAX_CHANNELS) { 1857 dev->cc = 0; 1858 dev_err(&dev->udev->dev, "invalid channel\n"); 1859 return; 1860 } 1861 /* otherwise copy to the system buffers */ 1862 res = save_frame(dev, pipe_info); 1863 if (res != 0) 1864 dprintk(dev, 4, "s2255: read callback failed\n"); 1865 1866 dprintk(dev, 50, "callback read video done\n"); 1867 return; 1868 } 1869 1870 static long s2255_vendor_req(struct s2255_dev *dev, unsigned char Request, 1871 u16 Index, u16 Value, void *TransferBuffer, 1872 s32 TransferBufferLength, int bOut) 1873 { 1874 int r; 1875 unsigned char *buf; 1876 1877 buf = kmalloc(TransferBufferLength, GFP_KERNEL); 1878 if (!buf) 1879 return -ENOMEM; 1880 1881 if (!bOut) { 1882 r = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0), 1883 Request, 1884 USB_TYPE_VENDOR | USB_RECIP_DEVICE | 1885 USB_DIR_IN, 1886 Value, Index, buf, 1887 TransferBufferLength, HZ * 5); 1888 1889 if (r >= 0) 1890 memcpy(TransferBuffer, buf, TransferBufferLength); 1891 } else { 1892 memcpy(buf, TransferBuffer, TransferBufferLength); 1893 r = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0), 1894 Request, USB_TYPE_VENDOR | USB_RECIP_DEVICE, 1895 Value, Index, buf, 1896 TransferBufferLength, HZ * 5); 1897 } 1898 kfree(buf); 1899 return r; 1900 } 1901 1902 /* 1903 * retrieve FX2 firmware version. future use. 1904 * @param dev pointer to device extension 1905 * @return -1 for fail, else returns firmware version as an int(16 bits) 1906 */ 1907 static int s2255_get_fx2fw(struct s2255_dev *dev) 1908 { 1909 int fw; 1910 int ret; 1911 unsigned char transBuffer[64]; 1912 ret = s2255_vendor_req(dev, S2255_VR_FW, 0, 0, transBuffer, 2, 1913 S2255_VR_IN); 1914 if (ret < 0) 1915 dprintk(dev, 2, "get fw error: %x\n", ret); 1916 fw = transBuffer[0] + (transBuffer[1] << 8); 1917 dprintk(dev, 2, "Get FW %x %x\n", transBuffer[0], transBuffer[1]); 1918 return fw; 1919 } 1920 1921 /* 1922 * Create the system ring buffer to copy frames into from the 1923 * usb read pipe. 1924 */ 1925 static int s2255_create_sys_buffers(struct s2255_vc *vc) 1926 { 1927 unsigned long i; 1928 unsigned long reqsize; 1929 vc->buffer.dwFrames = SYS_FRAMES; 1930 /* always allocate maximum size(PAL) for system buffers */ 1931 reqsize = SYS_FRAMES_MAXSIZE; 1932 1933 if (reqsize > SYS_FRAMES_MAXSIZE) 1934 reqsize = SYS_FRAMES_MAXSIZE; 1935 1936 for (i = 0; i < SYS_FRAMES; i++) { 1937 /* allocate the frames */ 1938 vc->buffer.frame[i].lpvbits = vmalloc(reqsize); 1939 vc->buffer.frame[i].size = reqsize; 1940 if (vc->buffer.frame[i].lpvbits == NULL) { 1941 pr_info("out of memory. using less frames\n"); 1942 vc->buffer.dwFrames = i; 1943 break; 1944 } 1945 } 1946 1947 /* make sure internal states are set */ 1948 for (i = 0; i < SYS_FRAMES; i++) { 1949 vc->buffer.frame[i].ulState = 0; 1950 vc->buffer.frame[i].cur_size = 0; 1951 } 1952 1953 vc->cur_frame = 0; 1954 vc->last_frame = -1; 1955 return 0; 1956 } 1957 1958 static int s2255_release_sys_buffers(struct s2255_vc *vc) 1959 { 1960 unsigned long i; 1961 for (i = 0; i < SYS_FRAMES; i++) { 1962 vfree(vc->buffer.frame[i].lpvbits); 1963 vc->buffer.frame[i].lpvbits = NULL; 1964 } 1965 return 0; 1966 } 1967 1968 static int s2255_board_init(struct s2255_dev *dev) 1969 { 1970 struct s2255_mode mode_def = DEF_MODEI_NTSC_CONT; 1971 int fw_ver; 1972 int j; 1973 struct s2255_pipeinfo *pipe = &dev->pipe; 1974 dprintk(dev, 4, "board init: %p", dev); 1975 memset(pipe, 0, sizeof(*pipe)); 1976 pipe->dev = dev; 1977 pipe->cur_transfer_size = S2255_USB_XFER_SIZE; 1978 pipe->max_transfer_size = S2255_USB_XFER_SIZE; 1979 1980 pipe->transfer_buffer = kzalloc(pipe->max_transfer_size, 1981 GFP_KERNEL); 1982 if (pipe->transfer_buffer == NULL) { 1983 dprintk(dev, 1, "out of memory!\n"); 1984 return -ENOMEM; 1985 } 1986 /* query the firmware */ 1987 fw_ver = s2255_get_fx2fw(dev); 1988 1989 pr_info("s2255: usb firmware version %d.%d\n", 1990 (fw_ver >> 8) & 0xff, 1991 fw_ver & 0xff); 1992 1993 if (fw_ver < S2255_CUR_USB_FWVER) 1994 pr_info("s2255: newer USB firmware available\n"); 1995 1996 for (j = 0; j < MAX_CHANNELS; j++) { 1997 struct s2255_vc *vc = &dev->vc[j]; 1998 vc->mode = mode_def; 1999 if (dev->pid == 0x2257 && j > 1) 2000 vc->mode.color |= (1 << 16); 2001 vc->jpegqual = S2255_DEF_JPEG_QUAL; 2002 vc->width = LINE_SZ_4CIFS_NTSC; 2003 vc->height = NUM_LINES_4CIFS_NTSC * 2; 2004 vc->std = V4L2_STD_NTSC_M; 2005 vc->fmt = &formats[0]; 2006 vc->mode.restart = 1; 2007 vc->req_image_size = get_transfer_size(&mode_def); 2008 vc->frame_count = 0; 2009 /* create the system buffers */ 2010 s2255_create_sys_buffers(vc); 2011 } 2012 /* start read pipe */ 2013 s2255_start_readpipe(dev); 2014 dprintk(dev, 1, "%s: success\n", __func__); 2015 return 0; 2016 } 2017 2018 static int s2255_board_shutdown(struct s2255_dev *dev) 2019 { 2020 u32 i; 2021 dprintk(dev, 1, "%s: dev: %p", __func__, dev); 2022 2023 for (i = 0; i < MAX_CHANNELS; i++) { 2024 if (vb2_is_streaming(&dev->vc[i].vb_vidq)) 2025 s2255_stop_acquire(&dev->vc[i]); 2026 } 2027 s2255_stop_readpipe(dev); 2028 for (i = 0; i < MAX_CHANNELS; i++) 2029 s2255_release_sys_buffers(&dev->vc[i]); 2030 /* release transfer buffer */ 2031 kfree(dev->pipe.transfer_buffer); 2032 return 0; 2033 } 2034 2035 static void read_pipe_completion(struct urb *purb) 2036 { 2037 struct s2255_pipeinfo *pipe_info; 2038 struct s2255_dev *dev; 2039 int status; 2040 int pipe; 2041 pipe_info = purb->context; 2042 if (pipe_info == NULL) { 2043 dev_err(&purb->dev->dev, "no context!\n"); 2044 return; 2045 } 2046 dev = pipe_info->dev; 2047 if (dev == NULL) { 2048 dev_err(&purb->dev->dev, "no context!\n"); 2049 return; 2050 } 2051 status = purb->status; 2052 /* if shutting down, do not resubmit, exit immediately */ 2053 if (status == -ESHUTDOWN) { 2054 dprintk(dev, 2, "%s: err shutdown\n", __func__); 2055 pipe_info->err_count++; 2056 return; 2057 } 2058 2059 if (pipe_info->state == 0) { 2060 dprintk(dev, 2, "%s: exiting USB pipe", __func__); 2061 return; 2062 } 2063 2064 if (status == 0) 2065 s2255_read_video_callback(dev, pipe_info); 2066 else { 2067 pipe_info->err_count++; 2068 dprintk(dev, 1, "%s: failed URB %d\n", __func__, status); 2069 } 2070 2071 pipe = usb_rcvbulkpipe(dev->udev, dev->read_endpoint); 2072 /* reuse urb */ 2073 usb_fill_bulk_urb(pipe_info->stream_urb, dev->udev, 2074 pipe, 2075 pipe_info->transfer_buffer, 2076 pipe_info->cur_transfer_size, 2077 read_pipe_completion, pipe_info); 2078 2079 if (pipe_info->state != 0) { 2080 if (usb_submit_urb(pipe_info->stream_urb, GFP_ATOMIC)) 2081 dev_err(&dev->udev->dev, "error submitting urb\n"); 2082 } else { 2083 dprintk(dev, 2, "%s :complete state 0\n", __func__); 2084 } 2085 return; 2086 } 2087 2088 static int s2255_start_readpipe(struct s2255_dev *dev) 2089 { 2090 int pipe; 2091 int retval; 2092 struct s2255_pipeinfo *pipe_info = &dev->pipe; 2093 pipe = usb_rcvbulkpipe(dev->udev, dev->read_endpoint); 2094 dprintk(dev, 2, "%s: IN %d\n", __func__, dev->read_endpoint); 2095 pipe_info->state = 1; 2096 pipe_info->err_count = 0; 2097 pipe_info->stream_urb = usb_alloc_urb(0, GFP_KERNEL); 2098 if (!pipe_info->stream_urb) 2099 return -ENOMEM; 2100 /* transfer buffer allocated in board_init */ 2101 usb_fill_bulk_urb(pipe_info->stream_urb, dev->udev, 2102 pipe, 2103 pipe_info->transfer_buffer, 2104 pipe_info->cur_transfer_size, 2105 read_pipe_completion, pipe_info); 2106 retval = usb_submit_urb(pipe_info->stream_urb, GFP_KERNEL); 2107 if (retval) { 2108 pr_err("s2255: start read pipe failed\n"); 2109 return retval; 2110 } 2111 return 0; 2112 } 2113 2114 /* starts acquisition process */ 2115 static int s2255_start_acquire(struct s2255_vc *vc) 2116 { 2117 int res; 2118 unsigned long chn_rev; 2119 int j; 2120 struct s2255_dev *dev = to_s2255_dev(vc->vdev.v4l2_dev); 2121 __le32 *buffer = dev->cmdbuf; 2122 2123 mutex_lock(&dev->cmdlock); 2124 chn_rev = G_chnmap[vc->idx]; 2125 vc->last_frame = -1; 2126 vc->bad_payload = 0; 2127 vc->cur_frame = 0; 2128 for (j = 0; j < SYS_FRAMES; j++) { 2129 vc->buffer.frame[j].ulState = 0; 2130 vc->buffer.frame[j].cur_size = 0; 2131 } 2132 2133 /* send the start command */ 2134 buffer[0] = IN_DATA_TOKEN; 2135 buffer[1] = (__le32) cpu_to_le32(chn_rev); 2136 buffer[2] = CMD_START; 2137 res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512); 2138 if (res != 0) 2139 dev_err(&dev->udev->dev, "CMD_START error\n"); 2140 2141 dprintk(dev, 2, "start acquire exit[%d] %d\n", vc->idx, res); 2142 mutex_unlock(&dev->cmdlock); 2143 return res; 2144 } 2145 2146 static int s2255_stop_acquire(struct s2255_vc *vc) 2147 { 2148 int res; 2149 unsigned long chn_rev; 2150 struct s2255_dev *dev = to_s2255_dev(vc->vdev.v4l2_dev); 2151 __le32 *buffer = dev->cmdbuf; 2152 2153 mutex_lock(&dev->cmdlock); 2154 chn_rev = G_chnmap[vc->idx]; 2155 /* send the stop command */ 2156 buffer[0] = IN_DATA_TOKEN; 2157 buffer[1] = (__le32) cpu_to_le32(chn_rev); 2158 buffer[2] = CMD_STOP; 2159 2160 res = s2255_write_config(dev->udev, (unsigned char *)buffer, 512); 2161 if (res != 0) 2162 dev_err(&dev->udev->dev, "CMD_STOP error\n"); 2163 2164 dprintk(dev, 4, "%s: chn %d, res %d\n", __func__, vc->idx, res); 2165 mutex_unlock(&dev->cmdlock); 2166 return res; 2167 } 2168 2169 static void s2255_stop_readpipe(struct s2255_dev *dev) 2170 { 2171 struct s2255_pipeinfo *pipe = &dev->pipe; 2172 2173 pipe->state = 0; 2174 if (pipe->stream_urb) { 2175 /* cancel urb */ 2176 usb_kill_urb(pipe->stream_urb); 2177 usb_free_urb(pipe->stream_urb); 2178 pipe->stream_urb = NULL; 2179 } 2180 dprintk(dev, 4, "%s", __func__); 2181 return; 2182 } 2183 2184 static void s2255_fwload_start(struct s2255_dev *dev) 2185 { 2186 s2255_reset_dsppower(dev); 2187 dev->fw_data->fw_size = dev->fw_data->fw->size; 2188 atomic_set(&dev->fw_data->fw_state, S2255_FW_NOTLOADED); 2189 memcpy(dev->fw_data->pfw_data, 2190 dev->fw_data->fw->data, CHUNK_SIZE); 2191 dev->fw_data->fw_loaded = CHUNK_SIZE; 2192 usb_fill_bulk_urb(dev->fw_data->fw_urb, dev->udev, 2193 usb_sndbulkpipe(dev->udev, 2), 2194 dev->fw_data->pfw_data, 2195 CHUNK_SIZE, s2255_fwchunk_complete, 2196 dev->fw_data); 2197 mod_timer(&dev->timer, jiffies + HZ); 2198 } 2199 2200 /* standard usb probe function */ 2201 static int s2255_probe(struct usb_interface *interface, 2202 const struct usb_device_id *id) 2203 { 2204 struct s2255_dev *dev = NULL; 2205 struct usb_host_interface *iface_desc; 2206 struct usb_endpoint_descriptor *endpoint; 2207 int i; 2208 int retval = -ENOMEM; 2209 __le32 *pdata; 2210 int fw_size; 2211 2212 /* allocate memory for our device state and initialize it to zero */ 2213 dev = kzalloc(sizeof(struct s2255_dev), GFP_KERNEL); 2214 if (dev == NULL) { 2215 s2255_dev_err(&interface->dev, "out of memory\n"); 2216 return -ENOMEM; 2217 } 2218 2219 dev->cmdbuf = kzalloc(S2255_CMDBUF_SIZE, GFP_KERNEL); 2220 if (dev->cmdbuf == NULL) { 2221 s2255_dev_err(&interface->dev, "out of memory\n"); 2222 goto errorFWDATA1; 2223 } 2224 2225 atomic_set(&dev->num_channels, 0); 2226 dev->pid = id->idProduct; 2227 dev->fw_data = kzalloc(sizeof(struct s2255_fw), GFP_KERNEL); 2228 if (!dev->fw_data) 2229 goto errorFWDATA1; 2230 mutex_init(&dev->lock); 2231 mutex_init(&dev->cmdlock); 2232 /* grab usb_device and save it */ 2233 dev->udev = usb_get_dev(interface_to_usbdev(interface)); 2234 if (dev->udev == NULL) { 2235 dev_err(&interface->dev, "null usb device\n"); 2236 retval = -ENODEV; 2237 goto errorUDEV; 2238 } 2239 dev_dbg(&interface->dev, "dev: %p, udev %p interface %p\n", 2240 dev, dev->udev, interface); 2241 dev->interface = interface; 2242 /* set up the endpoint information */ 2243 iface_desc = interface->cur_altsetting; 2244 dev_dbg(&interface->dev, "num EP: %d\n", 2245 iface_desc->desc.bNumEndpoints); 2246 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) { 2247 endpoint = &iface_desc->endpoint[i].desc; 2248 if (!dev->read_endpoint && usb_endpoint_is_bulk_in(endpoint)) { 2249 /* we found the bulk in endpoint */ 2250 dev->read_endpoint = endpoint->bEndpointAddress; 2251 } 2252 } 2253 2254 if (!dev->read_endpoint) { 2255 dev_err(&interface->dev, "Could not find bulk-in endpoint\n"); 2256 goto errorEP; 2257 } 2258 timer_setup(&dev->timer, s2255_timer, 0); 2259 init_waitqueue_head(&dev->fw_data->wait_fw); 2260 for (i = 0; i < MAX_CHANNELS; i++) { 2261 struct s2255_vc *vc = &dev->vc[i]; 2262 vc->idx = i; 2263 vc->dev = dev; 2264 init_waitqueue_head(&vc->wait_setmode); 2265 init_waitqueue_head(&vc->wait_vidstatus); 2266 spin_lock_init(&vc->qlock); 2267 mutex_init(&vc->vb_lock); 2268 } 2269 2270 dev->fw_data->fw_urb = usb_alloc_urb(0, GFP_KERNEL); 2271 if (!dev->fw_data->fw_urb) 2272 goto errorFWURB; 2273 2274 dev->fw_data->pfw_data = kzalloc(CHUNK_SIZE, GFP_KERNEL); 2275 if (!dev->fw_data->pfw_data) { 2276 dev_err(&interface->dev, "out of memory!\n"); 2277 goto errorFWDATA2; 2278 } 2279 /* load the first chunk */ 2280 if (request_firmware(&dev->fw_data->fw, 2281 FIRMWARE_FILE_NAME, &dev->udev->dev)) { 2282 dev_err(&interface->dev, "sensoray 2255 failed to get firmware\n"); 2283 goto errorREQFW; 2284 } 2285 /* check the firmware is valid */ 2286 fw_size = dev->fw_data->fw->size; 2287 pdata = (__le32 *) &dev->fw_data->fw->data[fw_size - 8]; 2288 2289 if (*pdata != S2255_FW_MARKER) { 2290 dev_err(&interface->dev, "Firmware invalid.\n"); 2291 retval = -ENODEV; 2292 goto errorFWMARKER; 2293 } else { 2294 /* make sure firmware is the latest */ 2295 __le32 *pRel; 2296 pRel = (__le32 *) &dev->fw_data->fw->data[fw_size - 4]; 2297 pr_info("s2255 dsp fw version %x\n", le32_to_cpu(*pRel)); 2298 dev->dsp_fw_ver = le32_to_cpu(*pRel); 2299 if (dev->dsp_fw_ver < S2255_CUR_DSP_FWVER) 2300 pr_info("s2255: f2255usb.bin out of date.\n"); 2301 if (dev->pid == 0x2257 && 2302 dev->dsp_fw_ver < S2255_MIN_DSP_COLORFILTER) 2303 pr_warn("2257 needs firmware %d or above.\n", 2304 S2255_MIN_DSP_COLORFILTER); 2305 } 2306 usb_reset_device(dev->udev); 2307 /* load 2255 board specific */ 2308 retval = s2255_board_init(dev); 2309 if (retval) 2310 goto errorBOARDINIT; 2311 s2255_fwload_start(dev); 2312 /* loads v4l specific */ 2313 retval = s2255_probe_v4l(dev); 2314 if (retval) 2315 goto errorBOARDINIT; 2316 dev_info(&interface->dev, "Sensoray 2255 detected\n"); 2317 return 0; 2318 errorBOARDINIT: 2319 s2255_board_shutdown(dev); 2320 errorFWMARKER: 2321 release_firmware(dev->fw_data->fw); 2322 errorREQFW: 2323 kfree(dev->fw_data->pfw_data); 2324 errorFWDATA2: 2325 usb_free_urb(dev->fw_data->fw_urb); 2326 errorFWURB: 2327 del_timer_sync(&dev->timer); 2328 errorEP: 2329 usb_put_dev(dev->udev); 2330 errorUDEV: 2331 kfree(dev->fw_data); 2332 mutex_destroy(&dev->lock); 2333 errorFWDATA1: 2334 kfree(dev->cmdbuf); 2335 kfree(dev); 2336 pr_warn("Sensoray 2255 driver load failed: 0x%x\n", retval); 2337 return retval; 2338 } 2339 2340 /* disconnect routine. when board is removed physically or with rmmod */ 2341 static void s2255_disconnect(struct usb_interface *interface) 2342 { 2343 struct s2255_dev *dev = to_s2255_dev(usb_get_intfdata(interface)); 2344 int i; 2345 int channels = atomic_read(&dev->num_channels); 2346 mutex_lock(&dev->lock); 2347 v4l2_device_disconnect(&dev->v4l2_dev); 2348 mutex_unlock(&dev->lock); 2349 /*see comments in the uvc_driver.c usb disconnect function */ 2350 atomic_inc(&dev->num_channels); 2351 /* unregister each video device. */ 2352 for (i = 0; i < channels; i++) 2353 video_unregister_device(&dev->vc[i].vdev); 2354 /* wake up any of our timers */ 2355 atomic_set(&dev->fw_data->fw_state, S2255_FW_DISCONNECTING); 2356 wake_up(&dev->fw_data->wait_fw); 2357 for (i = 0; i < MAX_CHANNELS; i++) { 2358 dev->vc[i].setmode_ready = 1; 2359 wake_up(&dev->vc[i].wait_setmode); 2360 dev->vc[i].vidstatus_ready = 1; 2361 wake_up(&dev->vc[i].wait_vidstatus); 2362 } 2363 if (atomic_dec_and_test(&dev->num_channels)) 2364 s2255_destroy(dev); 2365 dev_info(&interface->dev, "%s\n", __func__); 2366 } 2367 2368 static struct usb_driver s2255_driver = { 2369 .name = S2255_DRIVER_NAME, 2370 .probe = s2255_probe, 2371 .disconnect = s2255_disconnect, 2372 .id_table = s2255_table, 2373 }; 2374 2375 module_usb_driver(s2255_driver); 2376 2377 MODULE_DESCRIPTION("Sensoray 2255 Video for Linux driver"); 2378 MODULE_AUTHOR("Dean Anderson (Sensoray Company Inc.)"); 2379 MODULE_LICENSE("GPL"); 2380 MODULE_VERSION(S2255_VERSION); 2381 MODULE_FIRMWARE(FIRMWARE_FILE_NAME); 2382