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