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