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