/drivers/media/video/zr364xx.c
C | 1723 lines | 1340 code | 250 blank | 133 comment | 189 complexity | 239f4611c7c906060549a62ad5e8fbb6 MD5 | raw file
1/* 2 * Zoran 364xx based USB webcam module version 0.73 3 * 4 * Allows you to use your USB webcam with V4L2 applications 5 * This is still in heavy developpement ! 6 * 7 * Copyright (C) 2004 Antoine Jacquet <royale@zerezo.com> 8 * http://royale.zerezo.com/zr364xx/ 9 * 10 * Heavily inspired by usb-skeleton.c, vicam.c, cpia.c and spca50x.c drivers 11 * V4L2 version inspired by meye.c driver 12 * 13 * Some video buffer code by Lamarque based on s2255drv.c and vivi.c drivers. 14 * 15 * This program is free software; you can redistribute it and/or modify 16 * it under the terms of the GNU General Public License as published by 17 * the Free Software Foundation; either version 2 of the License, or 18 * (at your option) any later version. 19 * 20 * This program is distributed in the hope that it will be useful, 21 * but WITHOUT ANY WARRANTY; without even the implied warranty of 22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 23 * GNU General Public License for more details. 24 * 25 * You should have received a copy of the GNU General Public License 26 * along with this program; if not, write to the Free Software 27 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 28 */ 29 30 31#include <linux/module.h> 32#include <linux/version.h> 33#include <linux/init.h> 34#include <linux/usb.h> 35#include <linux/vmalloc.h> 36#include <linux/slab.h> 37#include <linux/proc_fs.h> 38#include <linux/highmem.h> 39#include <media/v4l2-common.h> 40#include <media/v4l2-ioctl.h> 41#include <media/videobuf-vmalloc.h> 42 43 44/* Version Information */ 45#define DRIVER_VERSION "v0.73" 46#define ZR364XX_VERSION_CODE KERNEL_VERSION(0, 7, 3) 47#define DRIVER_AUTHOR "Antoine Jacquet, http://royale.zerezo.com/" 48#define DRIVER_DESC "Zoran 364xx" 49 50 51/* Camera */ 52#define FRAMES 1 53#define MAX_FRAME_SIZE 200000 54#define BUFFER_SIZE 0x1000 55#define CTRL_TIMEOUT 500 56 57#define ZR364XX_DEF_BUFS 4 58#define ZR364XX_READ_IDLE 0 59#define ZR364XX_READ_FRAME 1 60 61/* Debug macro */ 62#define DBG(fmt, args...) \ 63 do { \ 64 if (debug) { \ 65 printk(KERN_INFO KBUILD_MODNAME " " fmt, ##args); \ 66 } \ 67 } while (0) 68 69/*#define FULL_DEBUG 1*/ 70#ifdef FULL_DEBUG 71#define _DBG DBG 72#else 73#define _DBG(fmt, args...) 74#endif 75 76/* Init methods, need to find nicer names for these 77 * the exact names of the chipsets would be the best if someone finds it */ 78#define METHOD0 0 79#define METHOD1 1 80#define METHOD2 2 81#define METHOD3 3 82 83 84/* Module parameters */ 85static int debug; 86static int mode; 87 88 89/* Module parameters interface */ 90module_param(debug, int, 0644); 91MODULE_PARM_DESC(debug, "Debug level"); 92module_param(mode, int, 0644); 93MODULE_PARM_DESC(mode, "0 = 320x240, 1 = 160x120, 2 = 640x480"); 94 95 96/* Devices supported by this driver 97 * .driver_info contains the init method used by the camera */ 98static struct usb_device_id device_table[] = { 99 {USB_DEVICE(0x08ca, 0x0109), .driver_info = METHOD0 }, 100 {USB_DEVICE(0x041e, 0x4024), .driver_info = METHOD0 }, 101 {USB_DEVICE(0x0d64, 0x0108), .driver_info = METHOD0 }, 102 {USB_DEVICE(0x0546, 0x3187), .driver_info = METHOD0 }, 103 {USB_DEVICE(0x0d64, 0x3108), .driver_info = METHOD0 }, 104 {USB_DEVICE(0x0595, 0x4343), .driver_info = METHOD0 }, 105 {USB_DEVICE(0x0bb0, 0x500d), .driver_info = METHOD0 }, 106 {USB_DEVICE(0x0feb, 0x2004), .driver_info = METHOD0 }, 107 {USB_DEVICE(0x055f, 0xb500), .driver_info = METHOD0 }, 108 {USB_DEVICE(0x08ca, 0x2062), .driver_info = METHOD2 }, 109 {USB_DEVICE(0x052b, 0x1a18), .driver_info = METHOD1 }, 110 {USB_DEVICE(0x04c8, 0x0729), .driver_info = METHOD0 }, 111 {USB_DEVICE(0x04f2, 0xa208), .driver_info = METHOD0 }, 112 {USB_DEVICE(0x0784, 0x0040), .driver_info = METHOD1 }, 113 {USB_DEVICE(0x06d6, 0x0034), .driver_info = METHOD0 }, 114 {USB_DEVICE(0x0a17, 0x0062), .driver_info = METHOD2 }, 115 {USB_DEVICE(0x06d6, 0x003b), .driver_info = METHOD0 }, 116 {USB_DEVICE(0x0a17, 0x004e), .driver_info = METHOD2 }, 117 {USB_DEVICE(0x041e, 0x405d), .driver_info = METHOD2 }, 118 {USB_DEVICE(0x08ca, 0x2102), .driver_info = METHOD3 }, 119 {USB_DEVICE(0x06d6, 0x003d), .driver_info = METHOD0 }, 120 {} /* Terminating entry */ 121}; 122 123MODULE_DEVICE_TABLE(usb, device_table); 124 125struct zr364xx_mode { 126 u32 color; /* output video color format */ 127 u32 brightness; /* brightness */ 128}; 129 130/* frame structure */ 131struct zr364xx_framei { 132 unsigned long ulState; /* ulState:ZR364XX_READ_IDLE, 133 ZR364XX_READ_FRAME */ 134 void *lpvbits; /* image data */ 135 unsigned long cur_size; /* current data copied to it */ 136}; 137 138/* image buffer structure */ 139struct zr364xx_bufferi { 140 unsigned long dwFrames; /* number of frames in buffer */ 141 struct zr364xx_framei frame[FRAMES]; /* array of FRAME structures */ 142}; 143 144struct zr364xx_dmaqueue { 145 struct list_head active; 146 struct zr364xx_camera *cam; 147}; 148 149struct zr364xx_pipeinfo { 150 u32 transfer_size; 151 u8 *transfer_buffer; 152 u32 state; 153 void *stream_urb; 154 void *cam; /* back pointer to zr364xx_camera struct */ 155 u32 err_count; 156 u32 idx; 157}; 158 159struct zr364xx_fmt { 160 char *name; 161 u32 fourcc; 162 int depth; 163}; 164 165/* image formats. */ 166static const struct zr364xx_fmt formats[] = { 167 { 168 .name = "JPG", 169 .fourcc = V4L2_PIX_FMT_JPEG, 170 .depth = 24 171 } 172}; 173 174/* Camera stuff */ 175struct zr364xx_camera { 176 struct usb_device *udev; /* save off the usb device pointer */ 177 struct usb_interface *interface;/* the interface for this device */ 178 struct video_device *vdev; /* v4l video device */ 179 int nb; 180 struct zr364xx_bufferi buffer; 181 int skip; 182 int width; 183 int height; 184 int method; 185 struct mutex lock; 186 struct mutex open_lock; 187 int users; 188 189 spinlock_t slock; 190 struct zr364xx_dmaqueue vidq; 191 int resources; 192 int last_frame; 193 int cur_frame; 194 unsigned long frame_count; 195 int b_acquire; 196 struct zr364xx_pipeinfo pipe[1]; 197 198 u8 read_endpoint; 199 200 const struct zr364xx_fmt *fmt; 201 struct videobuf_queue vb_vidq; 202 enum v4l2_buf_type type; 203 struct zr364xx_mode mode; 204}; 205 206/* buffer for one video frame */ 207struct zr364xx_buffer { 208 /* common v4l buffer stuff -- must be first */ 209 struct videobuf_buffer vb; 210 const struct zr364xx_fmt *fmt; 211}; 212 213/* function used to send initialisation commands to the camera */ 214static int send_control_msg(struct usb_device *udev, u8 request, u16 value, 215 u16 index, unsigned char *cp, u16 size) 216{ 217 int status; 218 219 unsigned char *transfer_buffer = kmalloc(size, GFP_KERNEL); 220 if (!transfer_buffer) { 221 dev_err(&udev->dev, "kmalloc(%d) failed\n", size); 222 return -ENOMEM; 223 } 224 225 memcpy(transfer_buffer, cp, size); 226 227 status = usb_control_msg(udev, 228 usb_sndctrlpipe(udev, 0), 229 request, 230 USB_DIR_OUT | USB_TYPE_VENDOR | 231 USB_RECIP_DEVICE, value, index, 232 transfer_buffer, size, CTRL_TIMEOUT); 233 234 kfree(transfer_buffer); 235 236 if (status < 0) 237 dev_err(&udev->dev, 238 "Failed sending control message, error %d.\n", status); 239 240 return status; 241} 242 243 244/* Control messages sent to the camera to initialize it 245 * and launch the capture */ 246typedef struct { 247 unsigned int value; 248 unsigned int size; 249 unsigned char *bytes; 250} message; 251 252/* method 0 */ 253static unsigned char m0d1[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; 254static unsigned char m0d2[] = { 0, 0, 0, 0, 0, 0 }; 255static unsigned char m0d3[] = { 0, 0 }; 256static message m0[] = { 257 {0x1f30, 0, NULL}, 258 {0xd000, 0, NULL}, 259 {0x3370, sizeof(m0d1), m0d1}, 260 {0x2000, 0, NULL}, 261 {0x2f0f, 0, NULL}, 262 {0x2610, sizeof(m0d2), m0d2}, 263 {0xe107, 0, NULL}, 264 {0x2502, 0, NULL}, 265 {0x1f70, 0, NULL}, 266 {0xd000, 0, NULL}, 267 {0x9a01, sizeof(m0d3), m0d3}, 268 {-1, -1, NULL} 269}; 270 271/* method 1 */ 272static unsigned char m1d1[] = { 0xff, 0xff }; 273static unsigned char m1d2[] = { 0x00, 0x00 }; 274static message m1[] = { 275 {0x1f30, 0, NULL}, 276 {0xd000, 0, NULL}, 277 {0xf000, 0, NULL}, 278 {0x2000, 0, NULL}, 279 {0x2f0f, 0, NULL}, 280 {0x2650, 0, NULL}, 281 {0xe107, 0, NULL}, 282 {0x2502, sizeof(m1d1), m1d1}, 283 {0x1f70, 0, NULL}, 284 {0xd000, 0, NULL}, 285 {0xd000, 0, NULL}, 286 {0xd000, 0, NULL}, 287 {0x9a01, sizeof(m1d2), m1d2}, 288 {-1, -1, NULL} 289}; 290 291/* method 2 */ 292static unsigned char m2d1[] = { 0xff, 0xff }; 293static message m2[] = { 294 {0x1f30, 0, NULL}, 295 {0xf000, 0, NULL}, 296 {0x2000, 0, NULL}, 297 {0x2f0f, 0, NULL}, 298 {0x2650, 0, NULL}, 299 {0xe107, 0, NULL}, 300 {0x2502, sizeof(m2d1), m2d1}, 301 {0x1f70, 0, NULL}, 302 {-1, -1, NULL} 303}; 304 305/* init table */ 306static message *init[4] = { m0, m1, m2, m2 }; 307 308 309/* JPEG static data in header (Huffman table, etc) */ 310static unsigned char header1[] = { 311 0xFF, 0xD8, 312 /* 313 0xFF, 0xE0, 0x00, 0x10, 'J', 'F', 'I', 'F', 314 0x00, 0x01, 0x01, 0x00, 0x33, 0x8A, 0x00, 0x00, 0x33, 0x88, 315 */ 316 0xFF, 0xDB, 0x00, 0x84 317}; 318static unsigned char header2[] = { 319 0xFF, 0xC4, 0x00, 0x1F, 0x00, 0x00, 0x01, 0x05, 0x01, 0x01, 0x01, 320 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 321 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 322 0xFF, 0xC4, 0x00, 0xB5, 0x10, 0x00, 0x02, 0x01, 0x03, 0x03, 0x02, 323 0x04, 0x03, 0x05, 0x05, 0x04, 0x04, 0x00, 0x00, 0x01, 0x7D, 0x01, 324 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06, 325 0x13, 0x51, 0x61, 0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xA1, 326 0x08, 0x23, 0x42, 0xB1, 0xC1, 0x15, 0x52, 0xD1, 0xF0, 0x24, 0x33, 327 0x62, 0x72, 0x82, 0x09, 0x0A, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x25, 328 0x26, 0x27, 0x28, 0x29, 0x2A, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 329 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54, 330 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 331 0x68, 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 332 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 333 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 334 0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 335 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 336 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE1, 0xE2, 337 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF1, 0xF2, 0xF3, 338 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFF, 0xC4, 0x00, 0x1F, 339 0x01, 0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 340 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 341 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0xFF, 0xC4, 0x00, 0xB5, 342 0x11, 0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04, 0x07, 0x05, 343 0x04, 0x04, 0x00, 0x01, 0x02, 0x77, 0x00, 0x01, 0x02, 0x03, 0x11, 344 0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71, 345 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xA1, 0xB1, 0xC1, 346 0x09, 0x23, 0x33, 0x52, 0xF0, 0x15, 0x62, 0x72, 0xD1, 0x0A, 0x16, 347 0x24, 0x34, 0xE1, 0x25, 0xF1, 0x17, 0x18, 0x19, 0x1A, 0x26, 0x27, 348 0x28, 0x29, 0x2A, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43, 0x44, 349 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57, 350 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 351 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x82, 0x83, 0x84, 352 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96, 353 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8, 354 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA, 355 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3, 356 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE2, 0xE3, 0xE4, 0xE5, 357 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, 358 0xF8, 0xF9, 0xFA, 0xFF, 0xC0, 0x00, 0x11, 0x08, 0x00, 0xF0, 0x01, 359 0x40, 0x03, 0x01, 0x21, 0x00, 0x02, 0x11, 0x01, 0x03, 0x11, 0x01, 360 0xFF, 0xDA, 0x00, 0x0C, 0x03, 0x01, 0x00, 0x02, 0x11, 0x03, 0x11, 361 0x00, 0x3F, 0x00 362}; 363static unsigned char header3; 364 365/* ------------------------------------------------------------------ 366 Videobuf operations 367 ------------------------------------------------------------------*/ 368 369static int buffer_setup(struct videobuf_queue *vq, unsigned int *count, 370 unsigned int *size) 371{ 372 struct zr364xx_camera *cam = vq->priv_data; 373 374 *size = cam->width * cam->height * (cam->fmt->depth >> 3); 375 376 if (*count == 0) 377 *count = ZR364XX_DEF_BUFS; 378 379 if (*size * *count > ZR364XX_DEF_BUFS * 1024 * 1024) 380 *count = (ZR364XX_DEF_BUFS * 1024 * 1024) / *size; 381 382 return 0; 383} 384 385static void free_buffer(struct videobuf_queue *vq, struct zr364xx_buffer *buf) 386{ 387 _DBG("%s\n", __func__); 388 389 if (in_interrupt()) 390 BUG(); 391 392 videobuf_vmalloc_free(&buf->vb); 393 buf->vb.state = VIDEOBUF_NEEDS_INIT; 394} 395 396static int buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb, 397 enum v4l2_field field) 398{ 399 struct zr364xx_camera *cam = vq->priv_data; 400 struct zr364xx_buffer *buf = container_of(vb, struct zr364xx_buffer, 401 vb); 402 int rc; 403 404 DBG("%s, field=%d, fmt name = %s\n", __func__, field, cam->fmt != NULL ? 405 cam->fmt->name : ""); 406 if (cam->fmt == NULL) 407 return -EINVAL; 408 409 buf->vb.size = cam->width * cam->height * (cam->fmt->depth >> 3); 410 411 if (buf->vb.baddr != 0 && buf->vb.bsize < buf->vb.size) { 412 DBG("invalid buffer prepare\n"); 413 return -EINVAL; 414 } 415 416 buf->fmt = cam->fmt; 417 buf->vb.width = cam->width; 418 buf->vb.height = cam->height; 419 buf->vb.field = field; 420 421 if (buf->vb.state == VIDEOBUF_NEEDS_INIT) { 422 rc = videobuf_iolock(vq, &buf->vb, NULL); 423 if (rc < 0) 424 goto fail; 425 } 426 427 buf->vb.state = VIDEOBUF_PREPARED; 428 return 0; 429fail: 430 free_buffer(vq, buf); 431 return rc; 432} 433 434static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb) 435{ 436 struct zr364xx_buffer *buf = container_of(vb, struct zr364xx_buffer, 437 vb); 438 struct zr364xx_camera *cam = vq->priv_data; 439 440 _DBG("%s\n", __func__); 441 442 buf->vb.state = VIDEOBUF_QUEUED; 443 list_add_tail(&buf->vb.queue, &cam->vidq.active); 444} 445 446static void buffer_release(struct videobuf_queue *vq, 447 struct videobuf_buffer *vb) 448{ 449 struct zr364xx_buffer *buf = container_of(vb, struct zr364xx_buffer, 450 vb); 451 452 _DBG("%s\n", __func__); 453 free_buffer(vq, buf); 454} 455 456static struct videobuf_queue_ops zr364xx_video_qops = { 457 .buf_setup = buffer_setup, 458 .buf_prepare = buffer_prepare, 459 .buf_queue = buffer_queue, 460 .buf_release = buffer_release, 461}; 462 463/********************/ 464/* V4L2 integration */ 465/********************/ 466static int zr364xx_vidioc_streamon(struct file *file, void *priv, 467 enum v4l2_buf_type type); 468 469static ssize_t zr364xx_read(struct file *file, char __user *buf, size_t count, 470 loff_t * ppos) 471{ 472 struct zr364xx_camera *cam = video_drvdata(file); 473 474 _DBG("%s\n", __func__); 475 476 if (!buf) 477 return -EINVAL; 478 479 if (!count) 480 return -EINVAL; 481 482 if (cam->type == V4L2_BUF_TYPE_VIDEO_CAPTURE && 483 zr364xx_vidioc_streamon(file, cam, cam->type) == 0) { 484 DBG("%s: reading %d bytes at pos %d.\n", __func__, (int) count, 485 (int) *ppos); 486 487 /* NoMan Sux ! */ 488 return videobuf_read_one(&cam->vb_vidq, buf, count, ppos, 489 file->f_flags & O_NONBLOCK); 490 } 491 492 return 0; 493} 494 495/* video buffer vmalloc implementation based partly on VIVI driver which is 496 * Copyright (c) 2006 by 497 * Mauro Carvalho Chehab <mchehab--a.t--infradead.org> 498 * Ted Walther <ted--a.t--enumera.com> 499 * John Sokol <sokol--a.t--videotechnology.com> 500 * http://v4l.videotechnology.com/ 501 * 502 */ 503static void zr364xx_fillbuff(struct zr364xx_camera *cam, 504 struct zr364xx_buffer *buf, 505 int jpgsize) 506{ 507 int pos = 0; 508 struct timeval ts; 509 const char *tmpbuf; 510 char *vbuf = videobuf_to_vmalloc(&buf->vb); 511 unsigned long last_frame; 512 struct zr364xx_framei *frm; 513 514 if (!vbuf) 515 return; 516 517 last_frame = cam->last_frame; 518 if (last_frame != -1) { 519 frm = &cam->buffer.frame[last_frame]; 520 tmpbuf = (const char *)cam->buffer.frame[last_frame].lpvbits; 521 switch (buf->fmt->fourcc) { 522 case V4L2_PIX_FMT_JPEG: 523 buf->vb.size = jpgsize; 524 memcpy(vbuf, tmpbuf, buf->vb.size); 525 break; 526 default: 527 printk(KERN_DEBUG KBUILD_MODNAME ": unknown format?\n"); 528 } 529 cam->last_frame = -1; 530 } else { 531 printk(KERN_ERR KBUILD_MODNAME ": =======no frame\n"); 532 return; 533 } 534 DBG("%s: Buffer 0x%08lx size= %d\n", __func__, 535 (unsigned long)vbuf, pos); 536 /* tell v4l buffer was filled */ 537 538 buf->vb.field_count = cam->frame_count * 2; 539 do_gettimeofday(&ts); 540 buf->vb.ts = ts; 541 buf->vb.state = VIDEOBUF_DONE; 542} 543 544static int zr364xx_got_frame(struct zr364xx_camera *cam, int jpgsize) 545{ 546 struct zr364xx_dmaqueue *dma_q = &cam->vidq; 547 struct zr364xx_buffer *buf; 548 unsigned long flags = 0; 549 int rc = 0; 550 551 DBG("wakeup: %p\n", &dma_q); 552 spin_lock_irqsave(&cam->slock, flags); 553 554 if (list_empty(&dma_q->active)) { 555 DBG("No active queue to serve\n"); 556 rc = -1; 557 goto unlock; 558 } 559 buf = list_entry(dma_q->active.next, 560 struct zr364xx_buffer, vb.queue); 561 562 if (!waitqueue_active(&buf->vb.done)) { 563 /* no one active */ 564 rc = -1; 565 goto unlock; 566 } 567 list_del(&buf->vb.queue); 568 do_gettimeofday(&buf->vb.ts); 569 DBG("[%p/%d] wakeup\n", buf, buf->vb.i); 570 zr364xx_fillbuff(cam, buf, jpgsize); 571 wake_up(&buf->vb.done); 572 DBG("wakeup [buf/i] [%p/%d]\n", buf, buf->vb.i); 573unlock: 574 spin_unlock_irqrestore(&cam->slock, flags); 575 return 0; 576} 577 578/* this function moves the usb stream read pipe data 579 * into the system buffers. 580 * returns 0 on success, EAGAIN if more data to process (call this 581 * function again). 582 */ 583static int zr364xx_read_video_callback(struct zr364xx_camera *cam, 584 struct zr364xx_pipeinfo *pipe_info, 585 struct urb *purb) 586{ 587 unsigned char *pdest; 588 unsigned char *psrc; 589 s32 idx = -1; 590 struct zr364xx_framei *frm; 591 int i = 0; 592 unsigned char *ptr = NULL; 593 594 _DBG("buffer to user\n"); 595 idx = cam->cur_frame; 596 frm = &cam->buffer.frame[idx]; 597 598 /* swap bytes if camera needs it */ 599 if (cam->method == METHOD0) { 600 u16 *buf = (u16 *)pipe_info->transfer_buffer; 601 for (i = 0; i < purb->actual_length/2; i++) 602 swab16s(buf + i); 603 } 604 605 /* search done. now find out if should be acquiring */ 606 if (!cam->b_acquire) { 607 /* we found a frame, but this channel is turned off */ 608 frm->ulState = ZR364XX_READ_IDLE; 609 return -EINVAL; 610 } 611 612 psrc = (u8 *)pipe_info->transfer_buffer; 613 ptr = pdest = frm->lpvbits; 614 615 if (frm->ulState == ZR364XX_READ_IDLE) { 616 frm->ulState = ZR364XX_READ_FRAME; 617 frm->cur_size = 0; 618 619 _DBG("jpeg header, "); 620 memcpy(ptr, header1, sizeof(header1)); 621 ptr += sizeof(header1); 622 header3 = 0; 623 memcpy(ptr, &header3, 1); 624 ptr++; 625 memcpy(ptr, psrc, 64); 626 ptr += 64; 627 header3 = 1; 628 memcpy(ptr, &header3, 1); 629 ptr++; 630 memcpy(ptr, psrc + 64, 64); 631 ptr += 64; 632 memcpy(ptr, header2, sizeof(header2)); 633 ptr += sizeof(header2); 634 memcpy(ptr, psrc + 128, 635 purb->actual_length - 128); 636 ptr += purb->actual_length - 128; 637 _DBG("header : %d %d %d %d %d %d %d %d %d\n", 638 psrc[0], psrc[1], psrc[2], 639 psrc[3], psrc[4], psrc[5], 640 psrc[6], psrc[7], psrc[8]); 641 frm->cur_size = ptr - pdest; 642 } else { 643 if (frm->cur_size + purb->actual_length > MAX_FRAME_SIZE) { 644 dev_info(&cam->udev->dev, 645 "%s: buffer (%d bytes) too small to hold " 646 "frame data. Discarding frame data.\n", 647 __func__, MAX_FRAME_SIZE); 648 } else { 649 pdest += frm->cur_size; 650 memcpy(pdest, psrc, purb->actual_length); 651 frm->cur_size += purb->actual_length; 652 } 653 } 654 /*_DBG("cur_size %lu urb size %d\n", frm->cur_size, 655 purb->actual_length);*/ 656 657 if (purb->actual_length < pipe_info->transfer_size) { 658 _DBG("****************Buffer[%d]full*************\n", idx); 659 cam->last_frame = cam->cur_frame; 660 cam->cur_frame++; 661 /* end of system frame ring buffer, start at zero */ 662 if (cam->cur_frame == cam->buffer.dwFrames) 663 cam->cur_frame = 0; 664 665 /* frame ready */ 666 /* go back to find the JPEG EOI marker */ 667 ptr = pdest = frm->lpvbits; 668 ptr += frm->cur_size - 2; 669 while (ptr > pdest) { 670 if (*ptr == 0xFF && *(ptr + 1) == 0xD9 671 && *(ptr + 2) == 0xFF) 672 break; 673 ptr--; 674 } 675 if (ptr == pdest) 676 DBG("No EOI marker\n"); 677 678 /* Sometimes there is junk data in the middle of the picture, 679 * we want to skip this bogus frames */ 680 while (ptr > pdest) { 681 if (*ptr == 0xFF && *(ptr + 1) == 0xFF 682 && *(ptr + 2) == 0xFF) 683 break; 684 ptr--; 685 } 686 if (ptr != pdest) { 687 DBG("Bogus frame ? %d\n", ++(cam->nb)); 688 } else if (cam->b_acquire) { 689 /* we skip the 2 first frames which are usually buggy */ 690 if (cam->skip) 691 cam->skip--; 692 else { 693 _DBG("jpeg(%lu): %d %d %d %d %d %d %d %d\n", 694 frm->cur_size, 695 pdest[0], pdest[1], pdest[2], pdest[3], 696 pdest[4], pdest[5], pdest[6], pdest[7]); 697 698 zr364xx_got_frame(cam, frm->cur_size); 699 } 700 } 701 cam->frame_count++; 702 frm->ulState = ZR364XX_READ_IDLE; 703 frm->cur_size = 0; 704 } 705 /* done successfully */ 706 return 0; 707} 708 709static int res_get(struct zr364xx_camera *cam) 710{ 711 /* is it free? */ 712 mutex_lock(&cam->lock); 713 if (cam->resources) { 714 /* no, someone else uses it */ 715 mutex_unlock(&cam->lock); 716 return 0; 717 } 718 /* it's free, grab it */ 719 cam->resources = 1; 720 _DBG("res: get\n"); 721 mutex_unlock(&cam->lock); 722 return 1; 723} 724 725static inline int res_check(struct zr364xx_camera *cam) 726{ 727 return cam->resources; 728} 729 730static void res_free(struct zr364xx_camera *cam) 731{ 732 mutex_lock(&cam->lock); 733 cam->resources = 0; 734 mutex_unlock(&cam->lock); 735 _DBG("res: put\n"); 736} 737 738static int zr364xx_vidioc_querycap(struct file *file, void *priv, 739 struct v4l2_capability *cap) 740{ 741 struct zr364xx_camera *cam = video_drvdata(file); 742 743 strlcpy(cap->driver, DRIVER_DESC, sizeof(cap->driver)); 744 strlcpy(cap->card, cam->udev->product, sizeof(cap->card)); 745 strlcpy(cap->bus_info, dev_name(&cam->udev->dev), 746 sizeof(cap->bus_info)); 747 cap->version = ZR364XX_VERSION_CODE; 748 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | 749 V4L2_CAP_READWRITE | 750 V4L2_CAP_STREAMING; 751 752 return 0; 753} 754 755static int zr364xx_vidioc_enum_input(struct file *file, void *priv, 756 struct v4l2_input *i) 757{ 758 if (i->index != 0) 759 return -EINVAL; 760 strcpy(i->name, DRIVER_DESC " Camera"); 761 i->type = V4L2_INPUT_TYPE_CAMERA; 762 return 0; 763} 764 765static int zr364xx_vidioc_g_input(struct file *file, void *priv, 766 unsigned int *i) 767{ 768 *i = 0; 769 return 0; 770} 771 772static int zr364xx_vidioc_s_input(struct file *file, void *priv, 773 unsigned int i) 774{ 775 if (i != 0) 776 return -EINVAL; 777 return 0; 778} 779 780static int zr364xx_vidioc_queryctrl(struct file *file, void *priv, 781 struct v4l2_queryctrl *c) 782{ 783 struct zr364xx_camera *cam; 784 785 if (file == NULL) 786 return -ENODEV; 787 cam = video_drvdata(file); 788 789 switch (c->id) { 790 case V4L2_CID_BRIGHTNESS: 791 c->type = V4L2_CTRL_TYPE_INTEGER; 792 strcpy(c->name, "Brightness"); 793 c->minimum = 0; 794 c->maximum = 127; 795 c->step = 1; 796 c->default_value = cam->mode.brightness; 797 c->flags = 0; 798 break; 799 default: 800 return -EINVAL; 801 } 802 return 0; 803} 804 805static int zr364xx_vidioc_s_ctrl(struct file *file, void *priv, 806 struct v4l2_control *c) 807{ 808 struct zr364xx_camera *cam; 809 int temp; 810 811 if (file == NULL) 812 return -ENODEV; 813 cam = video_drvdata(file); 814 815 switch (c->id) { 816 case V4L2_CID_BRIGHTNESS: 817 cam->mode.brightness = c->value; 818 /* hardware brightness */ 819 mutex_lock(&cam->lock); 820 send_control_msg(cam->udev, 1, 0x2001, 0, NULL, 0); 821 temp = (0x60 << 8) + 127 - cam->mode.brightness; 822 send_control_msg(cam->udev, 1, temp, 0, NULL, 0); 823 mutex_unlock(&cam->lock); 824 break; 825 default: 826 return -EINVAL; 827 } 828 829 return 0; 830} 831 832static int zr364xx_vidioc_g_ctrl(struct file *file, void *priv, 833 struct v4l2_control *c) 834{ 835 struct zr364xx_camera *cam; 836 837 if (file == NULL) 838 return -ENODEV; 839 cam = video_drvdata(file); 840 841 switch (c->id) { 842 case V4L2_CID_BRIGHTNESS: 843 c->value = cam->mode.brightness; 844 break; 845 default: 846 return -EINVAL; 847 } 848 return 0; 849} 850 851static int zr364xx_vidioc_enum_fmt_vid_cap(struct file *file, 852 void *priv, struct v4l2_fmtdesc *f) 853{ 854 if (f->index > 0) 855 return -EINVAL; 856 f->flags = V4L2_FMT_FLAG_COMPRESSED; 857 strcpy(f->description, formats[0].name); 858 f->pixelformat = formats[0].fourcc; 859 return 0; 860} 861 862static char *decode_fourcc(__u32 pixelformat, char *buf) 863{ 864 buf[0] = pixelformat & 0xff; 865 buf[1] = (pixelformat >> 8) & 0xff; 866 buf[2] = (pixelformat >> 16) & 0xff; 867 buf[3] = (pixelformat >> 24) & 0xff; 868 buf[4] = '\0'; 869 return buf; 870} 871 872static int zr364xx_vidioc_try_fmt_vid_cap(struct file *file, void *priv, 873 struct v4l2_format *f) 874{ 875 struct zr364xx_camera *cam = video_drvdata(file); 876 char pixelformat_name[5]; 877 878 if (cam == NULL) 879 return -ENODEV; 880 881 if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_JPEG) { 882 DBG("%s: unsupported pixelformat V4L2_PIX_FMT_%s\n", __func__, 883 decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name)); 884 return -EINVAL; 885 } 886 887 if (!(f->fmt.pix.width == 160 && f->fmt.pix.height == 120) && 888 !(f->fmt.pix.width == 640 && f->fmt.pix.height == 480)) { 889 f->fmt.pix.width = 320; 890 f->fmt.pix.height = 240; 891 } 892 893 f->fmt.pix.field = V4L2_FIELD_NONE; 894 f->fmt.pix.bytesperline = f->fmt.pix.width * 2; 895 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline; 896 f->fmt.pix.colorspace = 0; 897 f->fmt.pix.priv = 0; 898 DBG("%s: V4L2_PIX_FMT_%s (%d) ok!\n", __func__, 899 decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name), 900 f->fmt.pix.field); 901 return 0; 902} 903 904static int zr364xx_vidioc_g_fmt_vid_cap(struct file *file, void *priv, 905 struct v4l2_format *f) 906{ 907 struct zr364xx_camera *cam; 908 909 if (file == NULL) 910 return -ENODEV; 911 cam = video_drvdata(file); 912 913 f->fmt.pix.pixelformat = formats[0].fourcc; 914 f->fmt.pix.field = V4L2_FIELD_NONE; 915 f->fmt.pix.width = cam->width; 916 f->fmt.pix.height = cam->height; 917 f->fmt.pix.bytesperline = f->fmt.pix.width * 2; 918 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline; 919 f->fmt.pix.colorspace = 0; 920 f->fmt.pix.priv = 0; 921 return 0; 922} 923 924static int zr364xx_vidioc_s_fmt_vid_cap(struct file *file, void *priv, 925 struct v4l2_format *f) 926{ 927 struct zr364xx_camera *cam = video_drvdata(file); 928 struct videobuf_queue *q = &cam->vb_vidq; 929 char pixelformat_name[5]; 930 int ret = zr364xx_vidioc_try_fmt_vid_cap(file, cam, f); 931 int i; 932 933 if (ret < 0) 934 return ret; 935 936 mutex_lock(&q->vb_lock); 937 938 if (videobuf_queue_is_busy(&cam->vb_vidq)) { 939 DBG("%s queue busy\n", __func__); 940 ret = -EBUSY; 941 goto out; 942 } 943 944 if (res_check(cam)) { 945 DBG("%s can't change format after started\n", __func__); 946 ret = -EBUSY; 947 goto out; 948 } 949 950 cam->width = f->fmt.pix.width; 951 cam->height = f->fmt.pix.height; 952 dev_info(&cam->udev->dev, "%s: %dx%d mode selected\n", __func__, 953 cam->width, cam->height); 954 f->fmt.pix.bytesperline = f->fmt.pix.width * 2; 955 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline; 956 f->fmt.pix.colorspace = 0; 957 f->fmt.pix.priv = 0; 958 cam->vb_vidq.field = f->fmt.pix.field; 959 cam->mode.color = V4L2_PIX_FMT_JPEG; 960 961 if (f->fmt.pix.width == 160 && f->fmt.pix.height == 120) 962 mode = 1; 963 else if (f->fmt.pix.width == 640 && f->fmt.pix.height == 480) 964 mode = 2; 965 else 966 mode = 0; 967 968 m0d1[0] = mode; 969 m1[2].value = 0xf000 + mode; 970 m2[1].value = 0xf000 + mode; 971 972 /* special case for METHOD3, the modes are different */ 973 if (cam->method == METHOD3) { 974 switch (mode) { 975 case 1: 976 m2[1].value = 0xf000 + 4; 977 break; 978 case 2: 979 m2[1].value = 0xf000 + 0; 980 break; 981 default: 982 m2[1].value = 0xf000 + 1; 983 break; 984 } 985 } 986 987 header2[437] = cam->height / 256; 988 header2[438] = cam->height % 256; 989 header2[439] = cam->width / 256; 990 header2[440] = cam->width % 256; 991 992 for (i = 0; init[cam->method][i].size != -1; i++) { 993 ret = 994 send_control_msg(cam->udev, 1, init[cam->method][i].value, 995 0, init[cam->method][i].bytes, 996 init[cam->method][i].size); 997 if (ret < 0) { 998 dev_err(&cam->udev->dev, 999 "error during resolution change sequence: %d\n", i); 1000 goto out; 1001 } 1002 } 1003 1004 /* Added some delay here, since opening/closing the camera quickly, 1005 * like Ekiga does during its startup, can crash the webcam 1006 */ 1007 mdelay(100); 1008 cam->skip = 2; 1009 ret = 0; 1010 1011out: 1012 mutex_unlock(&q->vb_lock); 1013 1014 DBG("%s: V4L2_PIX_FMT_%s (%d) ok!\n", __func__, 1015 decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name), 1016 f->fmt.pix.field); 1017 return ret; 1018} 1019 1020static int zr364xx_vidioc_reqbufs(struct file *file, void *priv, 1021 struct v4l2_requestbuffers *p) 1022{ 1023 int rc; 1024 struct zr364xx_camera *cam = video_drvdata(file); 1025 rc = videobuf_reqbufs(&cam->vb_vidq, p); 1026 return rc; 1027} 1028 1029static int zr364xx_vidioc_querybuf(struct file *file, 1030 void *priv, 1031 struct v4l2_buffer *p) 1032{ 1033 int rc; 1034 struct zr364xx_camera *cam = video_drvdata(file); 1035 rc = videobuf_querybuf(&cam->vb_vidq, p); 1036 return rc; 1037} 1038 1039static int zr364xx_vidioc_qbuf(struct file *file, 1040 void *priv, 1041 struct v4l2_buffer *p) 1042{ 1043 int rc; 1044 struct zr364xx_camera *cam = video_drvdata(file); 1045 _DBG("%s\n", __func__); 1046 rc = videobuf_qbuf(&cam->vb_vidq, p); 1047 return rc; 1048} 1049 1050static int zr364xx_vidioc_dqbuf(struct file *file, 1051 void *priv, 1052 struct v4l2_buffer *p) 1053{ 1054 int rc; 1055 struct zr364xx_camera *cam = video_drvdata(file); 1056 _DBG("%s\n", __func__); 1057 rc = videobuf_dqbuf(&cam->vb_vidq, p, file->f_flags & O_NONBLOCK); 1058 return rc; 1059} 1060 1061static void read_pipe_completion(struct urb *purb) 1062{ 1063 struct zr364xx_pipeinfo *pipe_info; 1064 struct zr364xx_camera *cam; 1065 int pipe; 1066 1067 pipe_info = purb->context; 1068 _DBG("%s %p, status %d\n", __func__, purb, purb->status); 1069 if (pipe_info == NULL) { 1070 printk(KERN_ERR KBUILD_MODNAME ": no context!\n"); 1071 return; 1072 } 1073 1074 cam = pipe_info->cam; 1075 if (cam == NULL) { 1076 printk(KERN_ERR KBUILD_MODNAME ": no context!\n"); 1077 return; 1078 } 1079 1080 /* if shutting down, do not resubmit, exit immediately */ 1081 if (purb->status == -ESHUTDOWN) { 1082 DBG("%s, err shutdown\n", __func__); 1083 pipe_info->err_count++; 1084 return; 1085 } 1086 1087 if (pipe_info->state == 0) { 1088 DBG("exiting USB pipe\n"); 1089 return; 1090 } 1091 1092 if (purb->actual_length < 0 || 1093 purb->actual_length > pipe_info->transfer_size) { 1094 dev_err(&cam->udev->dev, "wrong number of bytes\n"); 1095 return; 1096 } 1097 1098 if (purb->status == 0) 1099 zr364xx_read_video_callback(cam, pipe_info, purb); 1100 else { 1101 pipe_info->err_count++; 1102 DBG("%s: failed URB %d\n", __func__, purb->status); 1103 } 1104 1105 pipe = usb_rcvbulkpipe(cam->udev, cam->read_endpoint); 1106 1107 /* reuse urb */ 1108 usb_fill_bulk_urb(pipe_info->stream_urb, cam->udev, 1109 pipe, 1110 pipe_info->transfer_buffer, 1111 pipe_info->transfer_size, 1112 read_pipe_completion, pipe_info); 1113 1114 if (pipe_info->state != 0) { 1115 purb->status = usb_submit_urb(pipe_info->stream_urb, 1116 GFP_ATOMIC); 1117 1118 if (purb->status) 1119 dev_err(&cam->udev->dev, 1120 "error submitting urb (error=%i)\n", 1121 purb->status); 1122 } else 1123 DBG("read pipe complete state 0\n"); 1124} 1125 1126static int zr364xx_start_readpipe(struct zr364xx_camera *cam) 1127{ 1128 int pipe; 1129 int retval; 1130 struct zr364xx_pipeinfo *pipe_info = cam->pipe; 1131 pipe = usb_rcvbulkpipe(cam->udev, cam->read_endpoint); 1132 DBG("%s: start pipe IN x%x\n", __func__, cam->read_endpoint); 1133 1134 pipe_info->state = 1; 1135 pipe_info->err_count = 0; 1136 pipe_info->stream_urb = usb_alloc_urb(0, GFP_KERNEL); 1137 if (!pipe_info->stream_urb) { 1138 dev_err(&cam->udev->dev, "ReadStream: Unable to alloc URB\n"); 1139 return -ENOMEM; 1140 } 1141 /* transfer buffer allocated in board_init */ 1142 usb_fill_bulk_urb(pipe_info->stream_urb, cam->udev, 1143 pipe, 1144 pipe_info->transfer_buffer, 1145 pipe_info->transfer_size, 1146 read_pipe_completion, pipe_info); 1147 1148 DBG("submitting URB %p\n", pipe_info->stream_urb); 1149 retval = usb_submit_urb(pipe_info->stream_urb, GFP_KERNEL); 1150 if (retval) { 1151 printk(KERN_ERR KBUILD_MODNAME ": start read pipe failed\n"); 1152 return retval; 1153 } 1154 1155 return 0; 1156} 1157 1158static void zr364xx_stop_readpipe(struct zr364xx_camera *cam) 1159{ 1160 struct zr364xx_pipeinfo *pipe_info; 1161 1162 if (cam == NULL) { 1163 printk(KERN_ERR KBUILD_MODNAME ": invalid device\n"); 1164 return; 1165 } 1166 DBG("stop read pipe\n"); 1167 pipe_info = cam->pipe; 1168 if (pipe_info) { 1169 if (pipe_info->state != 0) 1170 pipe_info->state = 0; 1171 1172 if (pipe_info->stream_urb) { 1173 /* cancel urb */ 1174 usb_kill_urb(pipe_info->stream_urb); 1175 usb_free_urb(pipe_info->stream_urb); 1176 pipe_info->stream_urb = NULL; 1177 } 1178 } 1179 return; 1180} 1181 1182/* starts acquisition process */ 1183static int zr364xx_start_acquire(struct zr364xx_camera *cam) 1184{ 1185 int j; 1186 1187 DBG("start acquire\n"); 1188 1189 cam->last_frame = -1; 1190 cam->cur_frame = 0; 1191 for (j = 0; j < FRAMES; j++) { 1192 cam->buffer.frame[j].ulState = ZR364XX_READ_IDLE; 1193 cam->buffer.frame[j].cur_size = 0; 1194 } 1195 cam->b_acquire = 1; 1196 return 0; 1197} 1198 1199static inline int zr364xx_stop_acquire(struct zr364xx_camera *cam) 1200{ 1201 cam->b_acquire = 0; 1202 return 0; 1203} 1204 1205static int zr364xx_vidioc_streamon(struct file *file, void *priv, 1206 enum v4l2_buf_type type) 1207{ 1208 struct zr364xx_camera *cam = video_drvdata(file); 1209 int j; 1210 int res; 1211 1212 DBG("%s\n", __func__); 1213 1214 if (cam->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) { 1215 dev_err(&cam->udev->dev, "invalid fh type0\n"); 1216 return -EINVAL; 1217 } 1218 if (cam->type != type) { 1219 dev_err(&cam->udev->dev, "invalid fh type1\n"); 1220 return -EINVAL; 1221 } 1222 1223 if (!res_get(cam)) { 1224 dev_err(&cam->udev->dev, "stream busy\n"); 1225 return -EBUSY; 1226 } 1227 1228 cam->last_frame = -1; 1229 cam->cur_frame = 0; 1230 cam->frame_count = 0; 1231 for (j = 0; j < FRAMES; j++) { 1232 cam->buffer.frame[j].ulState = ZR364XX_READ_IDLE; 1233 cam->buffer.frame[j].cur_size = 0; 1234 } 1235 res = videobuf_streamon(&cam->vb_vidq); 1236 if (res == 0) { 1237 zr364xx_start_acquire(cam); 1238 } else { 1239 res_free(cam); 1240 } 1241 return res; 1242} 1243 1244static int zr364xx_vidioc_streamoff(struct file *file, void *priv, 1245 enum v4l2_buf_type type) 1246{ 1247 int res; 1248 struct zr364xx_camera *cam = video_drvdata(file); 1249 1250 DBG("%s\n", __func__); 1251 if (cam->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) { 1252 dev_err(&cam->udev->dev, "invalid fh type0\n"); 1253 return -EINVAL; 1254 } 1255 if (cam->type != type) { 1256 dev_err(&cam->udev->dev, "invalid fh type1\n"); 1257 return -EINVAL; 1258 } 1259 zr364xx_stop_acquire(cam); 1260 res = videobuf_streamoff(&cam->vb_vidq); 1261 if (res < 0) 1262 return res; 1263 res_free(cam); 1264 return 0; 1265} 1266 1267 1268/* open the camera */ 1269static int zr364xx_open(struct file *file) 1270{ 1271 struct video_device *vdev = video_devdata(file); 1272 struct zr364xx_camera *cam = video_drvdata(file); 1273 struct usb_device *udev = cam->udev; 1274 int i, err; 1275 1276 DBG("%s\n", __func__); 1277 1278 mutex_lock(&cam->open_lock); 1279 1280 if (cam->users) { 1281 err = -EBUSY; 1282 goto out; 1283 } 1284 1285 for (i = 0; init[cam->method][i].size != -1; i++) { 1286 err = 1287 send_control_msg(udev, 1, init[cam->method][i].value, 1288 0, init[cam->method][i].bytes, 1289 init[cam->method][i].size); 1290 if (err < 0) { 1291 dev_err(&cam->udev->dev, 1292 "error during open sequence: %d\n", i); 1293 goto out; 1294 } 1295 } 1296 1297 cam->skip = 2; 1298 cam->users++; 1299 file->private_data = vdev; 1300 cam->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1301 cam->fmt = formats; 1302 1303 videobuf_queue_vmalloc_init(&cam->vb_vidq, &zr364xx_video_qops, 1304 NULL, &cam->slock, 1305 cam->type, 1306 V4L2_FIELD_NONE, 1307 sizeof(struct zr364xx_buffer), cam); 1308 1309 /* Added some delay here, since opening/closing the camera quickly, 1310 * like Ekiga does during its startup, can crash the webcam 1311 */ 1312 mdelay(100); 1313 err = 0; 1314 1315out: 1316 mutex_unlock(&cam->open_lock); 1317 DBG("%s: %d\n", __func__, err); 1318 return err; 1319} 1320 1321static void zr364xx_destroy(struct zr364xx_camera *cam) 1322{ 1323 unsigned long i; 1324 1325 if (!cam) { 1326 printk(KERN_ERR KBUILD_MODNAME ", %s: no device\n", __func__); 1327 return; 1328 } 1329 mutex_lock(&cam->open_lock); 1330 if (cam->vdev) 1331 video_unregister_device(cam->vdev); 1332 cam->vdev = NULL; 1333 1334 /* stops the read pipe if it is running */ 1335 if (cam->b_acquire) 1336 zr364xx_stop_acquire(cam); 1337 1338 zr364xx_stop_readpipe(cam); 1339 1340 /* release sys buffers */ 1341 for (i = 0; i < FRAMES; i++) { 1342 if (cam->buffer.frame[i].lpvbits) { 1343 DBG("vfree %p\n", cam->buffer.frame[i].lpvbits); 1344 vfree(cam->buffer.frame[i].lpvbits); 1345 } 1346 cam->buffer.frame[i].lpvbits = NULL; 1347 } 1348 1349 /* release transfer buffer */ 1350 kfree(cam->pipe->transfer_buffer); 1351 cam->pipe->transfer_buffer = NULL; 1352 mutex_unlock(&cam->open_lock); 1353 kfree(cam); 1354 cam = NULL; 1355} 1356 1357/* release the camera */ 1358static int zr364xx_release(struct file *file) 1359{ 1360 struct zr364xx_camera *cam; 1361 struct usb_device *udev; 1362 int i, err; 1363 1364 DBG("%s\n", __func__); 1365 cam = video_drvdata(file); 1366 1367 if (!cam) 1368 return -ENODEV; 1369 1370 mutex_lock(&cam->open_lock); 1371 udev = cam->udev; 1372 1373 /* turn off stream */ 1374 if (res_check(cam)) { 1375 if (cam->b_acquire) 1376 zr364xx_stop_acquire(cam); 1377 videobuf_streamoff(&cam->vb_vidq); 1378 res_free(cam); 1379 } 1380 1381 cam->users--; 1382 file->private_data = NULL; 1383 1384 for (i = 0; i < 2; i++) { 1385 err = 1386 send_control_msg(udev, 1, init[cam->method][i].value, 1387 0, init[cam->method][i].bytes, 1388 init[cam->method][i].size); 1389 if (err < 0) { 1390 dev_err(&udev->dev, "error during release sequence\n"); 1391 goto out; 1392 } 1393 } 1394 1395 /* Added some delay here, since opening/closing the camera quickly, 1396 * like Ekiga does during its startup, can crash the webcam 1397 */ 1398 mdelay(100); 1399 err = 0; 1400 1401out: 1402 mutex_unlock(&cam->open_lock); 1403 1404 return err; 1405} 1406 1407 1408static int zr364xx_mmap(struct file *file, struct vm_area_struct *vma) 1409{ 1410 struct zr364xx_camera *cam = video_drvdata(file); 1411 int ret; 1412 1413 if (cam == NULL) { 1414 DBG("%s: cam == NULL\n", __func__); 1415 return -ENODEV; 1416 } 1417 DBG("mmap called, vma=0x%08lx\n", (unsigned long)vma); 1418 1419 ret = videobuf_mmap_mapper(&cam->vb_vidq, vma); 1420 1421 DBG("vma start=0x%08lx, size=%ld, ret=%d\n", 1422 (unsigned long)vma->vm_start, 1423 (unsigned long)vma->vm_end - (unsigned long)vma->vm_start, ret); 1424 return ret; 1425} 1426 1427static unsigned int zr364xx_poll(struct file *file, 1428 struct poll_table_struct *wait) 1429{ 1430 struct zr364xx_camera *cam = video_drvdata(file); 1431 struct videobuf_queue *q = &cam->vb_vidq; 1432 _DBG("%s\n", __func__); 1433 1434 if (cam->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 1435 return POLLERR; 1436 1437 return videobuf_poll_stream(file, q, wait); 1438} 1439 1440static const struct v4l2_file_operations zr364xx_fops = { 1441 .owner = THIS_MODULE, 1442 .open = zr364xx_open, 1443 .release = zr364xx_release, 1444 .read = zr364xx_read, 1445 .mmap = zr364xx_mmap, 1446 .ioctl = video_ioctl2, 1447 .poll = zr364xx_poll, 1448}; 1449 1450static const struct v4l2_ioctl_ops zr364xx_ioctl_ops = { 1451 .vidioc_querycap = zr364xx_vidioc_querycap, 1452 .vidioc_enum_fmt_vid_cap = zr364xx_vidioc_enum_fmt_vid_cap, 1453 .vidioc_try_fmt_vid_cap = zr364xx_vidioc_try_fmt_vid_cap, 1454 .vidioc_s_fmt_vid_cap = zr364xx_vidioc_s_fmt_vid_cap, 1455 .vidioc_g_fmt_vid_cap = zr364xx_vidioc_g_fmt_vid_cap, 1456 .vidioc_enum_input = zr364xx_vidioc_enum_input, 1457 .vidioc_g_input = zr364xx_vidioc_g_input, 1458 .vidioc_s_input = zr364xx_vidioc_s_input, 1459 .vidioc_streamon = zr364xx_vidioc_streamon, 1460 .vidioc_streamoff = zr364xx_vidioc_streamoff, 1461 .vidioc_queryctrl = zr364xx_vidioc_queryctrl, 1462 .vidioc_g_ctrl = zr364xx_vidioc_g_ctrl, 1463 .vidioc_s_ctrl = zr364xx_vidioc_s_ctrl, 1464 .vidioc_reqbufs = zr364xx_vidioc_reqbufs, 1465 .vidioc_querybuf = zr364xx_vidioc_querybuf, 1466 .vidioc_qbuf = zr364xx_vidioc_qbuf, 1467 .vidioc_dqbuf = zr364xx_vidioc_dqbuf, 1468}; 1469 1470static struct video_device zr364xx_template = { 1471 .name = DRIVER_DESC, 1472 .fops = &zr364xx_fops, 1473 .ioctl_ops = &zr364xx_ioctl_ops, 1474 .release = video_device_release, 1475}; 1476 1477 1478 1479/*******************/ 1480/* USB integration */ 1481/*******************/ 1482static int zr364xx_board_init(struct zr364xx_camera *cam) 1483{ 1484 struct zr364xx_pipeinfo *pipe = cam->pipe; 1485 unsigned long i; 1486 1487 DBG("board init: %p\n", cam); 1488 memset(pipe, 0, sizeof(*pipe)); 1489 pipe->cam = cam; 1490 pipe->transfer_size = BUFFER_SIZE; 1491 1492 pipe->transfer_buffer = kzalloc(pipe->transfer_size, 1493 GFP_KERNEL); 1494 if (pipe->transfer_buffer == NULL) { 1495 DBG("out of memory!\n"); 1496 return -ENOMEM; 1497 } 1498 1499 cam->b_acquire = 0; 1500 cam->frame_count = 0; 1501 1502 /*** start create system buffers ***/ 1503 for (i = 0; i < FRAMES; i++) { 1504 /* always allocate maximum size for system buffers */ 1505 cam->buffer.frame[i].lpvbits = vmalloc(MAX_FRAME_SIZE); 1506 1507 DBG("valloc %p, idx %lu, pdata %p\n", 1508 &cam->buffer.frame[i], i, 1509 cam->buffer.frame[i].lpvbits); 1510 if (cam->buffer.frame[i].lpvbits == NULL) { 1511 printk(KERN_INFO KBUILD_MODNAME ": out of memory. " 1512 "Using less frames\n"); 1513 break; 1514 } 1515 } 1516 1517 if (i == 0) { 1518 printk(KERN_INFO KBUILD_MODNAME ": out of memory. Aborting\n"); 1519 kfree(cam->pipe->transfer_buffer); 1520 cam->pipe->transfer_buffer = NULL; 1521 return -ENOMEM; 1522 } else 1523 cam->buffer.dwFrames = i; 1524 1525 /* make sure internal states are set */ 1526 for (i = 0; i < FRAMES; i++) { 1527 cam->buffer.frame[i].ulState = ZR364XX_READ_IDLE; 1528 cam->buffer.frame[i].cur_size = 0; 1529 } 1530 1531 cam->cur_frame = 0; 1532 cam->last_frame = -1; 1533 /*** end create system buffers ***/ 1534 1535 /* start read pipe */ 1536 zr364xx_start_readpipe(cam); 1537 DBG(": board initialized\n"); 1538 return 0; 1539} 1540 1541static int zr364xx_probe(struct usb_interface *intf, 1542 const struct usb_device_id *id) 1543{ 1544 struct usb_device *udev = interface_to_usbdev(intf); 1545 struct zr364xx_camera *cam = NULL; 1546 struct usb_host_interface *iface_desc; 1547 struct usb_endpoint_descriptor *endpoint; 1548 int err; 1549 int i; 1550 1551 DBG("probing...\n"); 1552 1553 dev_info(&intf->dev, DRIVER_DESC " compatible webcam plugged\n"); 1554 dev_info(&intf->dev, "model %04x:%04x detected\n", 1555 le16_to_cpu(udev->descriptor.idVendor), 1556 le16_to_cpu(udev->descriptor.idProduct)); 1557 1558 cam = kzalloc(sizeof(struct zr364xx_camera), GFP_KERNEL); 1559 if (cam == NULL) { 1560 dev_err(&udev->dev, "cam: out of memory !\n"); 1561 return -ENOMEM; 1562 } 1563 /* save the init method used by this camera */ 1564 cam->method = id->driver_info; 1565 1566 cam->vdev = video_device_alloc(); 1567 if (cam->vdev == NULL) { 1568 dev_err(&udev->dev, "cam->vdev: out of memory !\n"); 1569 kfree(cam); 1570 cam = NULL; 1571 return -ENOMEM; 1572 } 1573 memcpy(cam->vdev, &zr364xx_template, sizeof(zr364xx_template)); 1574 cam->vdev->parent = &intf->dev; 1575 video_set_drvdata(cam->vdev, cam); 1576 if (debug) 1577 cam->vdev->debug = V4L2_DEBUG_IOCTL | V4L2_DEBUG_IOCTL_ARG; 1578 1579 cam->udev = udev; 1580 1581 switch (mode) { 1582 case 1: 1583 dev_info(&udev->dev, "160x120 mode selected\n"); 1584 cam->width = 160; 1585 cam->height = 120; 1586 break; 1587 case 2: 1588 dev_info(&udev->dev, "640x480 mode selected\n"); 1589 cam->width = 640; 1590 cam->height = 480; 1591 break; 1592 default: 1593 dev_info(&udev->dev, "320x240 mode selected\n"); 1594 cam->width = 320; 1595 cam->height = 240; 1596 break; 1597 } 1598 1599 m0d1[0] = mode; 1600 m1[2].value = 0xf000 + mode; 1601 m2[1].value = 0xf000 + mode; 1602 1603 /* special case for METHOD3, the modes are different */ 1604 if (cam->method == METHOD3) { 1605 switch (mode) { 1606 case 1: 1607 m2[1].value = 0xf000 + 4; 1608 break; 1609 case 2: 1610 m2[1].value = 0xf000 + 0; 1611 break; 1612 default: 1613 m2[1].value = 0xf000 + 1; 1614 break; 1615 } 1616 } 1617 1618 header2[437] = cam->height / 256; 1619 header2[438] = cam->height % 256; 1620 header2[439] = cam->width / 256; 1621 header2[440] = cam->width % 256; 1622 1623 cam->users = 0; 1624 cam->nb = 0; 1625 cam->mode.brightness = 64; 1626 mutex_init(&cam->lock); 1627 mutex_init(&cam->open_lock); 1628 1629 DBG("dev: %p, udev %p interface %p\n", cam, cam->udev, intf); 1630 1631 /* set up the endpoint information */ 1632 iface_desc = intf->cur_altsetting; 1633 DBG("num endpoints %d\n", iface_desc->desc.bNumEndpoints); 1634 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) { 1635 endpoint = &iface_desc->endpoint[i].desc; 1636 if (!cam->read_endpoint && usb_endpoint_is_bulk_in(endpoint)) { 1637 /* we found the bulk in endpoint */ 1638 cam->read_endpoint = endpoint->bEndpointAddress; 1639 } 1640 } 1641 1642 if (!cam->read_endpoint) { 1643 dev_err(&intf->dev, "Could not find bulk-in endpoint\n"); 1644 return -ENOMEM; 1645 } 1646 1647 /* v4l */ 1648 INIT_LIST_HEAD(&cam->vidq.active); 1649 cam->vidq.cam = cam; 1650 err = video_register_device(cam->vdev, VFL_TYPE_GRABBER, -1); 1651 if (err) { 1652 dev_err(&udev->dev, "video_register_device failed\n"); 1653 video_device_release(cam->vdev); 1654 kfree(cam); 1655 cam = NULL; 1656 return err; 1657 } 1658 1659 usb_set_intfdata(intf, cam); 1660 1661 /* load zr364xx board specific */ 1662 err = zr364xx_board_init(cam); 1663 if (err) { 1664 spin_lock_init(&cam->slock); 1665 return err; 1666 } 1667 1668 spin_lock_init(&cam->slock); 1669 1670 dev_info(&udev->dev, DRIVER_DESC " controlling device %s\n", 1671 video_device_node_name(cam->vdev)); 1672 return 0; 1673} 1674 1675 1676static void zr364xx_disconnect(struct usb_interface *intf) 1677{ 1678 struct zr364xx_camera *cam = usb_get_intfdata(intf); 1679 videobuf_mmap_free(&cam->vb_vidq); 1680 usb_set_intfdata(intf, NULL); 1681 dev_info(&intf->dev, DRIVER_DESC " webcam unplugged\n"); 1682 zr364xx_destroy(cam); 1683} 1684 1685 1686 1687/**********************/ 1688/* Module integration */ 1689/**********************/ 1690 1691static struct usb_driver zr364xx_driver = { 1692 .name = "zr364xx", 1693 .probe = zr364xx_probe, 1694 .disconnect = zr364xx_disconnect, 1695 .id_table = device_table 1696}; 1697 1698 1699static int __init zr364xx_init(void) 1700{ 1701 int retval; 1702 retval = usb_register(&zr364xx_driver); 1703 if (retval) 1704 printk(KERN_ERR KBUILD_MODNAME ": usb_register failed!\n"); 1705 else 1706 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n"); 1707 return retval; 1708} 1709 1710 1711static void __exit zr364xx_exit(void) 1712{ 1713 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC " module unloaded\n"); 1714 usb_deregister(&zr364xx_driver); 1715} 1716 1717 1718module_init(zr364xx_init); 1719module_exit(zr364xx_exit); 1720 1721MODULE_AUTHOR(DRIVER_AUTHOR); 1722MODULE_DESCRIPTION(DRIVER_DESC); 1723MODULE_LICENSE("GPL");