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