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