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