projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'for-next' of git://git.samba.org/sfrench/cifs-2.6
[deliverable/linux.git] / drivers / media / video / zr364xx.c
CommitLineData
b7eee616 1/*
ccbf035a 2 * Zoran 364xx based USB webcam module version 0.73
b7eee616
AJ		 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 *
ccbf035a
LVS		 13 * Some video buffer code by Lamarque based on s2255drv.c and vivi.c drivers.
14 *
b7eee616
AJ		 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
b7eee616
AJ		 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>
2575f84a 37#include <linux/highmem.h>
b7eee616 38#include <media/v4l2-common.h>
35ea11ff 39#include <media/v4l2-ioctl.h>
a906f62f 40#include <media/v4l2-device.h>
1fc21a19 41#include <media/v4l2-ctrls.h>
5d317abe
HV		 42#include <media/v4l2-fh.h>
43#include <media/v4l2-event.h>
ccbf035a 44#include <media/videobuf-vmalloc.h>
b7eee616
AJ		 45
46
47/* Version Information */
1990d50b 48#define DRIVER_VERSION "0.7.4"
b7eee616
AJ		 49#define DRIVER_AUTHOR "Antoine Jacquet, http://royale.zerezo.com/"
50#define DRIVER_DESC "Zoran 364xx"
51
52
53/* Camera */
ccbf035a 54#define FRAMES 1
8c5f32ac 55#define MAX_FRAME_SIZE 200000
b7eee616
AJ		 56#define BUFFER_SIZE 0x1000
57#define CTRL_TIMEOUT 500
58
ccbf035a
LVS		 59#define ZR364XX_DEF_BUFS 4
60#define ZR364XX_READ_IDLE 0
61#define ZR364XX_READ_FRAME 1
b7eee616
AJ		 62
63/* Debug macro */
ccbf035a
LVS		 64#define DBG(fmt, args...) \
65 do { \
66 if (debug) { \
67 printk(KERN_INFO KBUILD_MODNAME " " fmt, ##args); \
68 } \
69 } while (0)
b7eee616 70
76594c53
LVS		 71/*#define FULL_DEBUG 1*/
72#ifdef FULL_DEBUG
73#define _DBG DBG
74#else
75#define _DBG(fmt, args...)
76#endif
77
b7eee616
AJ		 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
08135ba2 83#define METHOD3 3
b7eee616
AJ		 84
85
86/* Module parameters */
ff699e6b
DSL		 87static int debug;
88static int mode;
b7eee616
AJ		 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 },
bebeaea0 117 {USB_DEVICE(0x06d6, 0x003b), .driver_info = METHOD0 },
71c04475 118 {USB_DEVICE(0x0a17, 0x004e), .driver_info = METHOD2 },
c0e0aff9 119 {USB_DEVICE(0x041e, 0x405d), .driver_info = METHOD2 },
08135ba2 120 {USB_DEVICE(0x08ca, 0x2102), .driver_info = METHOD3 },
9018f6c3 121 {USB_DEVICE(0x06d6, 0x003d), .driver_info = METHOD0 },
b7eee616
AJ		 122 {} /* Terminating entry */
123};
124
125MODULE_DEVICE_TABLE(usb, device_table);
126
ccbf035a
LVS		 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};
b7eee616
AJ		 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 */
a906f62f 175 struct v4l2_device v4l2_dev;
1fc21a19 176 struct v4l2_ctrl_handler ctrl_handler;
2b99251f 177 struct video_device vdev; /* v4l video device */
a065729d 178 struct v4l2_fh *owner; /* owns the streaming */
b7eee616 179 int nb;
ccbf035a 180 struct zr364xx_bufferi buffer;
b7eee616 181 int skip;
b7eee616
AJ		 182 int width;
183 int height;
184 int method;
185 struct mutex lock;
ccbf035a
LVS		 186
187 spinlock_t slock;
188 struct zr364xx_dmaqueue vidq;
ccbf035a
LVS		 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;
587a5765 199 bool was_streaming;
b7eee616
AJ		 200};
201
ccbf035a
LVS		 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};
b7eee616
AJ		 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) {
a482f327 217 dev_err(&udev->dev, "kmalloc(%d) failed\n", size);
b7eee616
AJ		 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);
b7eee616
AJ		 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 */
08135ba2 297static message *init[4] = { m0, m1, m2, m2 };
b7eee616
AJ		 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
ccbf035a
LVS		 356/* ------------------------------------------------------------------
357 Videobuf operations
358 ------------------------------------------------------------------*/
b7eee616 359
ccbf035a
LVS		 360static int buffer_setup(struct videobuf_queue *vq, unsigned int *count,
361 unsigned int *size)
362{
363 struct zr364xx_camera *cam = vq->priv_data;
b7eee616 364
ccbf035a 365 *size = cam->width * cam->height * (cam->fmt->depth >> 3);
b7eee616 366
ccbf035a
LVS		 367 if (*count == 0)
368 *count = ZR364XX_DEF_BUFS;
b7eee616 369
dab7e310
AB		 370 if (*size * *count > ZR364XX_DEF_BUFS * 1024 * 1024)
371 *count = (ZR364XX_DEF_BUFS * 1024 * 1024) / *size;
b7eee616 372
ccbf035a
LVS		 373 return 0;
374}
b7eee616 375
ccbf035a
LVS		 376static void free_buffer(struct videobuf_queue *vq, struct zr364xx_buffer *buf)
377{
76594c53 378 _DBG("%s\n", __func__);
b7eee616 379
ccbf035a
LVS		 380 if (in_interrupt())
381 BUG();
b7eee616 382
ccbf035a
LVS		 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;
b7eee616 405 }
ccbf035a
LVS		 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;
b7eee616
AJ		 416 }
417
ccbf035a
LVS		 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
76594c53 431 _DBG("%s\n", __func__);
b7eee616 432
ccbf035a
LVS		 433 buf->vb.state = VIDEOBUF_QUEUED;
434 list_add_tail(&buf->vb.queue, &cam->vidq.active);
b7eee616
AJ		 435}
436
ccbf035a
LVS		 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
76594c53 443 _DBG("%s\n", __func__);
ccbf035a
LVS		 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);
b7eee616 459
ccbf035a 460static ssize_t zr364xx_read(struct file *file, char __user *buf, size_t count,
b7eee616
AJ		 461 loff_t * ppos)
462{
ccbf035a 463 struct zr364xx_camera *cam = video_drvdata(file);
a906f62f 464 int err = 0;
b7eee616 465
76594c53 466 _DBG("%s\n", __func__);
b7eee616
AJ		 467
468 if (!buf)
469 return -EINVAL;
470
471 if (!count)
472 return -EINVAL;
473
a906f62f
HV		 474 if (mutex_lock_interruptible(&cam->lock))
475 return -ERESTARTSYS;
476
a065729d
HV		 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);
ccbf035a
LVS		 482
483 /* NoMan Sux ! */
a906f62f 484 err = videobuf_read_one(&cam->vb_vidq, buf, count, ppos,
ccbf035a
LVS		 485 file->f_flags & O_NONBLOCK);
486 }
a906f62f
HV		 487 mutex_unlock(&cam->lock);
488 return err;
ccbf035a
LVS		 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 struct timeval ts;
505 const char *tmpbuf;
506 char *vbuf = videobuf_to_vmalloc(&buf->vb);
507 unsigned long last_frame;
ccbf035a
LVS		 508
509 if (!vbuf)
510 return;
511
512 last_frame = cam->last_frame;
513 if (last_frame != -1) {
ccbf035a
LVS		 514 tmpbuf = (const char *)cam->buffer.frame[last_frame].lpvbits;
515 switch (buf->fmt->fourcc) {
516 case V4L2_PIX_FMT_JPEG:
517 buf->vb.size = jpgsize;
518 memcpy(vbuf, tmpbuf, buf->vb.size);
519 break;
520 default:
521 printk(KERN_DEBUG KBUILD_MODNAME ": unknown format?\n");
522 }
523 cam->last_frame = -1;
524 } else {
525 printk(KERN_ERR KBUILD_MODNAME ": =======no frame\n");
526 return;
527 }
528 DBG("%s: Buffer 0x%08lx size= %d\n", __func__,
529 (unsigned long)vbuf, pos);
530 /* tell v4l buffer was filled */
531
532 buf->vb.field_count = cam->frame_count * 2;
533 do_gettimeofday(&ts);
534 buf->vb.ts = ts;
535 buf->vb.state = VIDEOBUF_DONE;
536}
537
538static int zr364xx_got_frame(struct zr364xx_camera *cam, int jpgsize)
539{
540 struct zr364xx_dmaqueue *dma_q = &cam->vidq;
541 struct zr364xx_buffer *buf;
542 unsigned long flags = 0;
543 int rc = 0;
544
545 DBG("wakeup: %p\n", &dma_q);
546 spin_lock_irqsave(&cam->slock, flags);
547
548 if (list_empty(&dma_q->active)) {
549 DBG("No active queue to serve\n");
550 rc = -1;
551 goto unlock;
552 }
553 buf = list_entry(dma_q->active.next,
554 struct zr364xx_buffer, vb.queue);
555
556 if (!waitqueue_active(&buf->vb.done)) {
557 /* no one active */
558 rc = -1;
559 goto unlock;
560 }
561 list_del(&buf->vb.queue);
562 do_gettimeofday(&buf->vb.ts);
563 DBG("[%p/%d] wakeup\n", buf, buf->vb.i);
564 zr364xx_fillbuff(cam, buf, jpgsize);
565 wake_up(&buf->vb.done);
566 DBG("wakeup [buf/i] [%p/%d]\n", buf, buf->vb.i);
567unlock:
568 spin_unlock_irqrestore(&cam->slock, flags);
3053814c 569 return rc;
ccbf035a
LVS		 570}
571
572/* this function moves the usb stream read pipe data
573 * into the system buffers.
574 * returns 0 on success, EAGAIN if more data to process (call this
575 * function again).
576 */
577static int zr364xx_read_video_callback(struct zr364xx_camera *cam,
578 struct zr364xx_pipeinfo *pipe_info,
579 struct urb *purb)
580{
581 unsigned char *pdest;
582 unsigned char *psrc;
583 s32 idx = -1;
584 struct zr364xx_framei *frm;
585 int i = 0;
586 unsigned char *ptr = NULL;
587
76594c53 588 _DBG("buffer to user\n");
ccbf035a
LVS		 589 idx = cam->cur_frame;
590 frm = &cam->buffer.frame[idx];
591
592 /* swap bytes if camera needs it */
593 if (cam->method == METHOD0) {
594 u16 *buf = (u16 *)pipe_info->transfer_buffer;
595 for (i = 0; i < purb->actual_length/2; i++)
596 swab16s(buf + i);
597 }
598
599 /* search done. now find out if should be acquiring */
600 if (!cam->b_acquire) {
601 /* we found a frame, but this channel is turned off */
602 frm->ulState = ZR364XX_READ_IDLE;
603 return -EINVAL;
604 }
605
ccbf035a
LVS		 606 psrc = (u8 *)pipe_info->transfer_buffer;
607 ptr = pdest = frm->lpvbits;
608
609 if (frm->ulState == ZR364XX_READ_IDLE) {
610 frm->ulState = ZR364XX_READ_FRAME;
611 frm->cur_size = 0;
612
76594c53 613 _DBG("jpeg header, ");
ccbf035a
LVS		 614 memcpy(ptr, header1, sizeof(header1));
615 ptr += sizeof(header1);
616 header3 = 0;
617 memcpy(ptr, &header3, 1);
618 ptr++;
619 memcpy(ptr, psrc, 64);
620 ptr += 64;
621 header3 = 1;
622 memcpy(ptr, &header3, 1);
623 ptr++;
624 memcpy(ptr, psrc + 64, 64);
625 ptr += 64;
626 memcpy(ptr, header2, sizeof(header2));
627 ptr += sizeof(header2);
628 memcpy(ptr, psrc + 128,
629 purb->actual_length - 128);
630 ptr += purb->actual_length - 128;
76594c53 631 _DBG("header : %d %d %d %d %d %d %d %d %d\n",
ccbf035a
LVS		 632 psrc[0], psrc[1], psrc[2],
633 psrc[3], psrc[4], psrc[5],
634 psrc[6], psrc[7], psrc[8]);
635 frm->cur_size = ptr - pdest;
636 } else {
76594c53
LVS		 637 if (frm->cur_size + purb->actual_length > MAX_FRAME_SIZE) {
638 dev_info(&cam->udev->dev,
639 "%s: buffer (%d bytes) too small to hold "
640 "frame data. Discarding frame data.\n",
641 __func__, MAX_FRAME_SIZE);
642 } else {
643 pdest += frm->cur_size;
644 memcpy(pdest, psrc, purb->actual_length);
645 frm->cur_size += purb->actual_length;
646 }
ccbf035a 647 }
76594c53 648 /*_DBG("cur_size %lu urb size %d\n", frm->cur_size,
ccbf035a
LVS		 649 purb->actual_length);*/
650
651 if (purb->actual_length < pipe_info->transfer_size) {
76594c53 652 _DBG("****************Buffer[%d]full*************\n", idx);
ccbf035a
LVS		 653 cam->last_frame = cam->cur_frame;
654 cam->cur_frame++;
655 /* end of system frame ring buffer, start at zero */
656 if (cam->cur_frame == cam->buffer.dwFrames)
657 cam->cur_frame = 0;
658
659 /* frame ready */
660 /* go back to find the JPEG EOI marker */
661 ptr = pdest = frm->lpvbits;
662 ptr += frm->cur_size - 2;
663 while (ptr > pdest) {
664 if (*ptr == 0xFF && *(ptr + 1) == 0xD9
665 && *(ptr + 2) == 0xFF)
666 break;
667 ptr--;
668 }
669 if (ptr == pdest)
670 DBG("No EOI marker\n");
671
672 /* Sometimes there is junk data in the middle of the picture,
673 * we want to skip this bogus frames */
674 while (ptr > pdest) {
675 if (*ptr == 0xFF && *(ptr + 1) == 0xFF
676 && *(ptr + 2) == 0xFF)
677 break;
678 ptr--;
679 }
680 if (ptr != pdest) {
681 DBG("Bogus frame ? %d\n", ++(cam->nb));
682 } else if (cam->b_acquire) {
683 /* we skip the 2 first frames which are usually buggy */
684 if (cam->skip)
685 cam->skip--;
686 else {
76594c53 687 _DBG("jpeg(%lu): %d %d %d %d %d %d %d %d\n",
ccbf035a
LVS		 688 frm->cur_size,
689 pdest[0], pdest[1], pdest[2], pdest[3],
690 pdest[4], pdest[5], pdest[6], pdest[7]);
691
692 zr364xx_got_frame(cam, frm->cur_size);
693 }
694 }
695 cam->frame_count++;
696 frm->ulState = ZR364XX_READ_IDLE;
697 frm->cur_size = 0;
698 }
699 /* done successfully */
700 return 0;
701}
702
b7eee616
AJ		 703static int zr364xx_vidioc_querycap(struct file *file, void *priv,
704 struct v4l2_capability *cap)
705{
ccbf035a
LVS		 706 struct zr364xx_camera *cam = video_drvdata(file);
707
708 strlcpy(cap->driver, DRIVER_DESC, sizeof(cap->driver));
709 strlcpy(cap->card, cam->udev->product, sizeof(cap->card));
710 strlcpy(cap->bus_info, dev_name(&cam->udev->dev),
711 sizeof(cap->bus_info));
df462902 712 cap->device_caps = V4L2_CAP_VIDEO_CAPTURE |
ccbf035a
LVS		 713 V4L2_CAP_READWRITE |
714 V4L2_CAP_STREAMING;
df462902 715 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
ccbf035a 716
b7eee616
AJ		 717 return 0;
718}
719
720static int zr364xx_vidioc_enum_input(struct file *file, void *priv,
721 struct v4l2_input *i)
722{
723 if (i->index != 0)
724 return -EINVAL;
b7eee616
AJ		 725 strcpy(i->name, DRIVER_DESC " Camera");
726 i->type = V4L2_INPUT_TYPE_CAMERA;
727 return 0;
728}
729
730static int zr364xx_vidioc_g_input(struct file *file, void *priv,
731 unsigned int *i)
732{
733 *i = 0;
734 return 0;
735}
736
737static int zr364xx_vidioc_s_input(struct file *file, void *priv,
738 unsigned int i)
739{
740 if (i != 0)
741 return -EINVAL;
742 return 0;
743}
744
1fc21a19 745static int zr364xx_s_ctrl(struct v4l2_ctrl *ctrl)
b7eee616 746{
1fc21a19
HV		 747 struct zr364xx_camera *cam =
748 container_of(ctrl->handler, struct zr364xx_camera, ctrl_handler);
ccbf035a 749 int temp;
b7eee616 750
1fc21a19 751 switch (ctrl->id) {
b7eee616 752 case V4L2_CID_BRIGHTNESS:
ccbf035a 753 /* hardware brightness */
ccbf035a 754 send_control_msg(cam->udev, 1, 0x2001, 0, NULL, 0);
1fc21a19 755 temp = (0x60 << 8) + 127 - ctrl->val;
ccbf035a 756 send_control_msg(cam->udev, 1, temp, 0, NULL, 0);
b7eee616
AJ		 757 break;
758 default:
759 return -EINVAL;
760 }
ccbf035a 761
b7eee616
AJ		 762 return 0;
763}
764
78b526a4 765static int zr364xx_vidioc_enum_fmt_vid_cap(struct file *file,
b7eee616
AJ		 766 void *priv, struct v4l2_fmtdesc *f)
767{
768 if (f->index > 0)
769 return -EINVAL;
b7eee616 770 f->flags = V4L2_FMT_FLAG_COMPRESSED;
ccbf035a
LVS		 771 strcpy(f->description, formats[0].name);
772 f->pixelformat = formats[0].fourcc;
b7eee616
AJ		 773 return 0;
774}
775
ccbf035a
LVS		 776static char *decode_fourcc(__u32 pixelformat, char *buf)
777{
778 buf[0] = pixelformat & 0xff;
779 buf[1] = (pixelformat >> 8) & 0xff;
780 buf[2] = (pixelformat >> 16) & 0xff;
781 buf[3] = (pixelformat >> 24) & 0xff;
782 buf[4] = '\0';
783 return buf;
784}
785
78b526a4 786static int zr364xx_vidioc_try_fmt_vid_cap(struct file *file, void *priv,
b7eee616
AJ		 787 struct v4l2_format *f)
788{
ccbf035a
LVS		 789 struct zr364xx_camera *cam = video_drvdata(file);
790 char pixelformat_name[5];
b7eee616 791
ccbf035a 792 if (cam == NULL)
b7eee616 793 return -ENODEV;
b7eee616 794
ccbf035a
LVS		 795 if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_JPEG) {
796 DBG("%s: unsupported pixelformat V4L2_PIX_FMT_%s\n", __func__,
797 decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name));
b7eee616 798 return -EINVAL;
ccbf035a
LVS		 799 }
800
8c5f32ac
LVS		 801 if (!(f->fmt.pix.width == 160 && f->fmt.pix.height == 120) &&
802 !(f->fmt.pix.width == 640 && f->fmt.pix.height == 480)) {
803 f->fmt.pix.width = 320;
804 f->fmt.pix.height = 240;
805 }
806
b7eee616 807 f->fmt.pix.field = V4L2_FIELD_NONE;
b7eee616
AJ		 808 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
809 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
df462902 810 f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
b7eee616 811 f->fmt.pix.priv = 0;
ccbf035a
LVS		 812 DBG("%s: V4L2_PIX_FMT_%s (%d) ok!\n", __func__,
813 decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name),
814 f->fmt.pix.field);
b7eee616
AJ		 815 return 0;
816}
817
78b526a4 818static int zr364xx_vidioc_g_fmt_vid_cap(struct file *file, void *priv,
b7eee616
AJ		 819 struct v4l2_format *f)
820{
b7eee616
AJ		 821 struct zr364xx_camera *cam;
822
ccbf035a 823 if (file == NULL)
b7eee616 824 return -ENODEV;
ccbf035a 825 cam = video_drvdata(file);
b7eee616 826
ccbf035a 827 f->fmt.pix.pixelformat = formats[0].fourcc;
b7eee616
AJ		 828 f->fmt.pix.field = V4L2_FIELD_NONE;
829 f->fmt.pix.width = cam->width;
830 f->fmt.pix.height = cam->height;
831 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
832 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
df462902 833 f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
b7eee616
AJ		 834 f->fmt.pix.priv = 0;
835 return 0;
836}
837
78b526a4 838static int zr364xx_vidioc_s_fmt_vid_cap(struct file *file, void *priv,
b7eee616
AJ		 839 struct v4l2_format *f)
840{
ccbf035a
LVS		 841 struct zr364xx_camera *cam = video_drvdata(file);
842 struct videobuf_queue *q = &cam->vb_vidq;
843 char pixelformat_name[5];
844 int ret = zr364xx_vidioc_try_fmt_vid_cap(file, cam, f);
8c5f32ac 845 int i;
b7eee616 846
ccbf035a
LVS		 847 if (ret < 0)
848 return ret;
849
850 mutex_lock(&q->vb_lock);
851
852 if (videobuf_queue_is_busy(&cam->vb_vidq)) {
853 DBG("%s queue busy\n", __func__);
854 ret = -EBUSY;
855 goto out;
856 }
b7eee616 857
a065729d 858 if (cam->owner) {
8c5f32ac
LVS		 859 DBG("%s can't change format after started\n", __func__);
860 ret = -EBUSY;
861 goto out;
862 }
863
864 cam->width = f->fmt.pix.width;
865 cam->height = f->fmt.pix.height;
a065729d 866 DBG("%s: %dx%d mode selected\n", __func__,
8c5f32ac 867 cam->width, cam->height);
b7eee616
AJ		 868 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
869 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
df462902 870 f->fmt.pix.colorspace = V4L2_COLORSPACE_JPEG;
b7eee616 871 f->fmt.pix.priv = 0;
ccbf035a 872 cam->vb_vidq.field = f->fmt.pix.field;
8c5f32ac
LVS		 873
874 if (f->fmt.pix.width == 160 && f->fmt.pix.height == 120)
875 mode = 1;
876 else if (f->fmt.pix.width == 640 && f->fmt.pix.height == 480)
877 mode = 2;
878 else
879 mode = 0;
880
881 m0d1[0] = mode;
882 m1[2].value = 0xf000 + mode;
883 m2[1].value = 0xf000 + mode;
08135ba2
AJ		 884
885 /* special case for METHOD3, the modes are different */
886 if (cam->method == METHOD3) {
887 switch (mode) {
888 case 1:
889 m2[1].value = 0xf000 + 4;
890 break;
891 case 2:
892 m2[1].value = 0xf000 + 0;
893 break;
894 default:
895 m2[1].value = 0xf000 + 1;
896 break;
897 }
898 }
899
8c5f32ac
LVS		 900 header2[437] = cam->height / 256;
901 header2[438] = cam->height % 256;
902 header2[439] = cam->width / 256;
903 header2[440] = cam->width % 256;
904
905 for (i = 0; init[cam->method][i].size != -1; i++) {
906 ret =
907 send_control_msg(cam->udev, 1, init[cam->method][i].value,
908 0, init[cam->method][i].bytes,
909 init[cam->method][i].size);
910 if (ret < 0) {
911 dev_err(&cam->udev->dev,
912 "error during resolution change sequence: %d\n", i);
913 goto out;
914 }
915 }
916
917 /* Added some delay here, since opening/closing the camera quickly,
918 * like Ekiga does during its startup, can crash the webcam
919 */
920 mdelay(100);
921 cam->skip = 2;
ccbf035a
LVS		 922 ret = 0;
923
924out:
925 mutex_unlock(&q->vb_lock);
926
927 DBG("%s: V4L2_PIX_FMT_%s (%d) ok!\n", __func__,
928 decode_fourcc(f->fmt.pix.pixelformat, pixelformat_name),
929 f->fmt.pix.field);
930 return ret;
931}
932
933static int zr364xx_vidioc_reqbufs(struct file *file, void *priv,
934 struct v4l2_requestbuffers *p)
935{
ccbf035a 936 struct zr364xx_camera *cam = video_drvdata(file);
a065729d
HV		 937
938 if (cam->owner && cam->owner != priv)
939 return -EBUSY;
940 return videobuf_reqbufs(&cam->vb_vidq, p);
ccbf035a
LVS		 941}
942
943static int zr364xx_vidioc_querybuf(struct file *file,
944 void *priv,
945 struct v4l2_buffer *p)
946{
947 int rc;
948 struct zr364xx_camera *cam = video_drvdata(file);
949 rc = videobuf_querybuf(&cam->vb_vidq, p);
950 return rc;
951}
952
953static int zr364xx_vidioc_qbuf(struct file *file,
954 void *priv,
955 struct v4l2_buffer *p)
956{
957 int rc;
958 struct zr364xx_camera *cam = video_drvdata(file);
76594c53 959 _DBG("%s\n", __func__);
a065729d
HV		 960 if (cam->owner && cam->owner != priv)
961 return -EBUSY;
ccbf035a
LVS		 962 rc = videobuf_qbuf(&cam->vb_vidq, p);
963 return rc;
964}
965
966static int zr364xx_vidioc_dqbuf(struct file *file,
967 void *priv,
968 struct v4l2_buffer *p)
969{
970 int rc;
971 struct zr364xx_camera *cam = video_drvdata(file);
76594c53 972 _DBG("%s\n", __func__);
a065729d
HV		 973 if (cam->owner && cam->owner != priv)
974 return -EBUSY;
ccbf035a
LVS		 975 rc = videobuf_dqbuf(&cam->vb_vidq, p, file->f_flags & O_NONBLOCK);
976 return rc;
977}
978
979static void read_pipe_completion(struct urb *purb)
980{
981 struct zr364xx_pipeinfo *pipe_info;
982 struct zr364xx_camera *cam;
983 int pipe;
984
985 pipe_info = purb->context;
76594c53 986 _DBG("%s %p, status %d\n", __func__, purb, purb->status);
ccbf035a
LVS		 987 if (pipe_info == NULL) {
988 printk(KERN_ERR KBUILD_MODNAME ": no context!\n");
989 return;
990 }
991
992 cam = pipe_info->cam;
993 if (cam == NULL) {
994 printk(KERN_ERR KBUILD_MODNAME ": no context!\n");
995 return;
996 }
997
998 /* if shutting down, do not resubmit, exit immediately */
999 if (purb->status == -ESHUTDOWN) {
1000 DBG("%s, err shutdown\n", __func__);
1001 pipe_info->err_count++;
1002 return;
1003 }
1004
1005 if (pipe_info->state == 0) {
1006 DBG("exiting USB pipe\n");
1007 return;
1008 }
1009
1010 if (purb->actual_length < 0 ||
1011 purb->actual_length > pipe_info->transfer_size) {
1012 dev_err(&cam->udev->dev, "wrong number of bytes\n");
1013 return;
1014 }
1015
1016 if (purb->status == 0)
1017 zr364xx_read_video_callback(cam, pipe_info, purb);
1018 else {
1019 pipe_info->err_count++;
1020 DBG("%s: failed URB %d\n", __func__, purb->status);
1021 }
1022
1023 pipe = usb_rcvbulkpipe(cam->udev, cam->read_endpoint);
1024
1025 /* reuse urb */
1026 usb_fill_bulk_urb(pipe_info->stream_urb, cam->udev,
1027 pipe,
1028 pipe_info->transfer_buffer,
1029 pipe_info->transfer_size,
1030 read_pipe_completion, pipe_info);
1031
1032 if (pipe_info->state != 0) {
1033 purb->status = usb_submit_urb(pipe_info->stream_urb,
1034 GFP_ATOMIC);
1035
1036 if (purb->status)
1037 dev_err(&cam->udev->dev,
1038 "error submitting urb (error=%i)\n",
1039 purb->status);
1040 } else
1041 DBG("read pipe complete state 0\n");
1042}
1043
1044static int zr364xx_start_readpipe(struct zr364xx_camera *cam)
1045{
1046 int pipe;
1047 int retval;
1048 struct zr364xx_pipeinfo *pipe_info = cam->pipe;
1049 pipe = usb_rcvbulkpipe(cam->udev, cam->read_endpoint);
1050 DBG("%s: start pipe IN x%x\n", __func__, cam->read_endpoint);
1051
1052 pipe_info->state = 1;
1053 pipe_info->err_count = 0;
1054 pipe_info->stream_urb = usb_alloc_urb(0, GFP_KERNEL);
1055 if (!pipe_info->stream_urb) {
1056 dev_err(&cam->udev->dev, "ReadStream: Unable to alloc URB\n");
1057 return -ENOMEM;
1058 }
1059 /* transfer buffer allocated in board_init */
1060 usb_fill_bulk_urb(pipe_info->stream_urb, cam->udev,
1061 pipe,
1062 pipe_info->transfer_buffer,
1063 pipe_info->transfer_size,
1064 read_pipe_completion, pipe_info);
1065
1066 DBG("submitting URB %p\n", pipe_info->stream_urb);
1067 retval = usb_submit_urb(pipe_info->stream_urb, GFP_KERNEL);
1068 if (retval) {
1069 printk(KERN_ERR KBUILD_MODNAME ": start read pipe failed\n");
1070 return retval;
1071 }
1072
1073 return 0;
1074}
1075
1076static void zr364xx_stop_readpipe(struct zr364xx_camera *cam)
1077{
1078 struct zr364xx_pipeinfo *pipe_info;
1079
1080 if (cam == NULL) {
1081 printk(KERN_ERR KBUILD_MODNAME ": invalid device\n");
1082 return;
1083 }
1084 DBG("stop read pipe\n");
1085 pipe_info = cam->pipe;
1086 if (pipe_info) {
1087 if (pipe_info->state != 0)
1088 pipe_info->state = 0;
1089
1090 if (pipe_info->stream_urb) {
1091 /* cancel urb */
1092 usb_kill_urb(pipe_info->stream_urb);
1093 usb_free_urb(pipe_info->stream_urb);
1094 pipe_info->stream_urb = NULL;
1095 }
1096 }
ccbf035a
LVS		 1097 return;
1098}
1099
1100/* starts acquisition process */
1101static int zr364xx_start_acquire(struct zr364xx_camera *cam)
1102{
1103 int j;
1104
1105 DBG("start acquire\n");
1106
1107 cam->last_frame = -1;
1108 cam->cur_frame = 0;
1109 for (j = 0; j < FRAMES; j++) {
1110 cam->buffer.frame[j].ulState = ZR364XX_READ_IDLE;
1111 cam->buffer.frame[j].cur_size = 0;
1112 }
8c5f32ac 1113 cam->b_acquire = 1;
ccbf035a
LVS		 1114 return 0;
1115}
1116
1117static inline int zr364xx_stop_acquire(struct zr364xx_camera *cam)
1118{
1119 cam->b_acquire = 0;
b7eee616
AJ		 1120 return 0;
1121}
1122
587a5765 1123static int zr364xx_prepare(struct zr364xx_camera *cam)
b7eee616 1124{
ccbf035a 1125 int res;
587a5765 1126 int i, j;
a065729d
HV		 1127
1128 for (i = 0; init[cam->method][i].size != -1; i++) {
1129 res = send_control_msg(cam->udev, 1, init[cam->method][i].value,
1130 0, init[cam->method][i].bytes,
1131 init[cam->method][i].size);
1132 if (res < 0) {
1133 dev_err(&cam->udev->dev,
1134 "error during open sequence: %d\n", i);
1135 return res;
1136 }
ccbf035a
LVS		 1137 }
1138
a065729d 1139 cam->skip = 2;
ccbf035a
LVS		 1140 cam->last_frame = -1;
1141 cam->cur_frame = 0;
1142 cam->frame_count = 0;
1143 for (j = 0; j < FRAMES; j++) {
1144 cam->buffer.frame[j].ulState = ZR364XX_READ_IDLE;
1145 cam->buffer.frame[j].cur_size = 0;
1146 }
587a5765
HV		 1147 v4l2_ctrl_handler_setup(&cam->ctrl_handler);
1148 return 0;
1149}
1150
1151static int zr364xx_vidioc_streamon(struct file *file, void *priv,
1152 enum v4l2_buf_type type)
1153{
1154 struct zr364xx_camera *cam = video_drvdata(file);
1155 int res;
1156
1157 DBG("%s\n", __func__);
1158
1159 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1160 return -EINVAL;
1161
1162 if (cam->owner && cam->owner != priv)
1163 return -EBUSY;
1164
1165 res = zr364xx_prepare(cam);
1166 if (res)
1167 return res;
ccbf035a
LVS		 1168 res = videobuf_streamon(&cam->vb_vidq);
1169 if (res == 0) {
1170 zr364xx_start_acquire(cam);
a065729d 1171 cam->owner = file->private_data;
ccbf035a 1172 }
ccbf035a 1173 return res;
b7eee616
AJ		 1174}
1175
1176static int zr364xx_vidioc_streamoff(struct file *file, void *priv,
1177 enum v4l2_buf_type type)
1178{
ccbf035a
LVS		 1179 struct zr364xx_camera *cam = video_drvdata(file);
1180
1181 DBG("%s\n", __func__);
5d317abe 1182 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
ccbf035a 1183 return -EINVAL;
a065729d
HV		 1184 if (cam->owner && cam->owner != priv)
1185 return -EBUSY;
ccbf035a 1186 zr364xx_stop_acquire(cam);
a065729d 1187 return videobuf_streamoff(&cam->vb_vidq);
b7eee616
AJ		 1188}
1189
1190
1191/* open the camera */
bec43661 1192static int zr364xx_open(struct file *file)
b7eee616 1193{
ccbf035a 1194 struct zr364xx_camera *cam = video_drvdata(file);
a065729d 1195 int err;
b7eee616 1196
ccbf035a 1197 DBG("%s\n", __func__);
b7eee616 1198
a906f62f
HV		 1199 if (mutex_lock_interruptible(&cam->lock))
1200 return -ERESTARTSYS;
69025c93 1201
5d317abe
HV		 1202 err = v4l2_fh_open(file);
1203 if (err)
1204 goto out;
1205
b7eee616
AJ		 1206 /* Added some delay here, since opening/closing the camera quickly,
1207 * like Ekiga does during its startup, can crash the webcam
1208 */
1209 mdelay(100);
69025c93 1210 err = 0;
b7eee616 1211
69025c93 1212out:
a906f62f 1213 mutex_unlock(&cam->lock);
ccbf035a 1214 DBG("%s: %d\n", __func__, err);
69025c93 1215 return err;
b7eee616
AJ		 1216}
1217
a906f62f 1218static void zr364xx_release(struct v4l2_device *v4l2_dev)
ccbf035a 1219{
a906f62f
HV		 1220 struct zr364xx_camera *cam =
1221 container_of(v4l2_dev, struct zr364xx_camera, v4l2_dev);
ccbf035a
LVS		 1222 unsigned long i;
1223
a906f62f 1224 v4l2_device_unregister(&cam->v4l2_dev);
ccbf035a 1225
a906f62f 1226 videobuf_mmap_free(&cam->vb_vidq);
ccbf035a
LVS		 1227
1228 /* release sys buffers */
1229 for (i = 0; i < FRAMES; i++) {
1230 if (cam->buffer.frame[i].lpvbits) {
1231 DBG("vfree %p\n", cam->buffer.frame[i].lpvbits);
1232 vfree(cam->buffer.frame[i].lpvbits);
1233 }
1234 cam->buffer.frame[i].lpvbits = NULL;
1235 }
1236
1fc21a19 1237 v4l2_ctrl_handler_free(&cam->ctrl_handler);
ccbf035a
LVS		 1238 /* release transfer buffer */
1239 kfree(cam->pipe->transfer_buffer);
ccbf035a 1240 kfree(cam);
ccbf035a 1241}
b7eee616
AJ		 1242
1243/* release the camera */
a906f62f 1244static int zr364xx_close(struct file *file)
b7eee616 1245{
b7eee616
AJ		 1246 struct zr364xx_camera *cam;
1247 struct usb_device *udev;
a906f62f 1248 int i;
b7eee616 1249
ccbf035a
LVS		 1250 DBG("%s\n", __func__);
1251 cam = video_drvdata(file);
b7eee616 1252
a906f62f 1253 mutex_lock(&cam->lock);
b7eee616
AJ		 1254 udev = cam->udev;
1255
a065729d
HV		 1256 if (file->private_data == cam->owner) {
1257 /* turn off stream */
ccbf035a
LVS		 1258 if (cam->b_acquire)
1259 zr364xx_stop_acquire(cam);
1260 videobuf_streamoff(&cam->vb_vidq);
33d27a45 1261
a065729d
HV		 1262 for (i = 0; i < 2; i++) {
1263 send_control_msg(udev, 1, init[cam->method][i].value,
1264 0, init[cam->method][i].bytes,
1265 init[cam->method][i].size);
1266 }
1267 cam->owner = NULL;
b7eee616
AJ		 1268 }
1269
b7eee616
AJ		 1270 /* Added some delay here, since opening/closing the camera quickly,
1271 * like Ekiga does during its startup, can crash the webcam
1272 */
1273 mdelay(100);
a906f62f 1274 mutex_unlock(&cam->lock);
5d317abe 1275 return v4l2_fh_release(file);
b7eee616
AJ		 1276}
1277
1278
1279static int zr364xx_mmap(struct file *file, struct vm_area_struct *vma)
1280{
ccbf035a
LVS		 1281 struct zr364xx_camera *cam = video_drvdata(file);
1282 int ret;
b7eee616 1283
ccbf035a
LVS		 1284 if (cam == NULL) {
1285 DBG("%s: cam == NULL\n", __func__);
b7eee616 1286 return -ENODEV;
b7eee616 1287 }
ccbf035a 1288 DBG("mmap called, vma=0x%08lx\n", (unsigned long)vma);
b7eee616 1289
ccbf035a
LVS		 1290 ret = videobuf_mmap_mapper(&cam->vb_vidq, vma);
1291
1292 DBG("vma start=0x%08lx, size=%ld, ret=%d\n",
1293 (unsigned long)vma->vm_start,
1294 (unsigned long)vma->vm_end - (unsigned long)vma->vm_start, ret);
1295 return ret;
b7eee616
AJ		 1296}
1297
ccbf035a
LVS		 1298static unsigned int zr364xx_poll(struct file *file,
1299 struct poll_table_struct *wait)
1300{
1301 struct zr364xx_camera *cam = video_drvdata(file);
1302 struct videobuf_queue *q = &cam->vb_vidq;
5d317abe 1303 unsigned res = v4l2_ctrl_poll(file, wait);
ccbf035a 1304
5d317abe 1305 _DBG("%s\n", __func__);
ccbf035a 1306
5d317abe 1307 return res | videobuf_poll_stream(file, q, wait);
ccbf035a 1308}
b7eee616 1309
1fc21a19
HV		 1310static const struct v4l2_ctrl_ops zr364xx_ctrl_ops = {
1311 .s_ctrl = zr364xx_s_ctrl,
1312};
1313
bec43661 1314static const struct v4l2_file_operations zr364xx_fops = {
b7eee616
AJ		 1315 .owner = THIS_MODULE,
1316 .open = zr364xx_open,
a906f62f 1317 .release = zr364xx_close,
b7eee616
AJ		 1318 .read = zr364xx_read,
1319 .mmap = zr364xx_mmap,
a906f62f 1320 .unlocked_ioctl = video_ioctl2,
ccbf035a 1321 .poll = zr364xx_poll,
b7eee616
AJ		 1322};
1323
a399810c 1324static const struct v4l2_ioctl_ops zr364xx_ioctl_ops = {
b7eee616 1325 .vidioc_querycap = zr364xx_vidioc_querycap,
78b526a4
HV		 1326 .vidioc_enum_fmt_vid_cap = zr364xx_vidioc_enum_fmt_vid_cap,
1327 .vidioc_try_fmt_vid_cap = zr364xx_vidioc_try_fmt_vid_cap,
1328 .vidioc_s_fmt_vid_cap = zr364xx_vidioc_s_fmt_vid_cap,
1329 .vidioc_g_fmt_vid_cap = zr364xx_vidioc_g_fmt_vid_cap,
b7eee616
AJ		 1330 .vidioc_enum_input = zr364xx_vidioc_enum_input,
1331 .vidioc_g_input = zr364xx_vidioc_g_input,
1332 .vidioc_s_input = zr364xx_vidioc_s_input,
1333 .vidioc_streamon = zr364xx_vidioc_streamon,
1334 .vidioc_streamoff = zr364xx_vidioc_streamoff,
ccbf035a
LVS		 1335 .vidioc_reqbufs = zr364xx_vidioc_reqbufs,
1336 .vidioc_querybuf = zr364xx_vidioc_querybuf,
1337 .vidioc_qbuf = zr364xx_vidioc_qbuf,
1338 .vidioc_dqbuf = zr364xx_vidioc_dqbuf,
5d317abe
HV		 1339 .vidioc_log_status = v4l2_ctrl_log_status,
1340 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
1341 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
b7eee616
AJ		 1342};
1343
a399810c 1344static struct video_device zr364xx_template = {
a399810c 1345 .name = DRIVER_DESC,
a399810c
HV		 1346 .fops = &zr364xx_fops,
1347 .ioctl_ops = &zr364xx_ioctl_ops,
2b99251f 1348 .release = video_device_release_empty,
a399810c
HV		 1349};
1350
b7eee616
AJ		 1351
1352
1353/*******************/
1354/* USB integration */
1355/*******************/
ccbf035a
LVS		 1356static int zr364xx_board_init(struct zr364xx_camera *cam)
1357{
1358 struct zr364xx_pipeinfo *pipe = cam->pipe;
1359 unsigned long i;
1360
1361 DBG("board init: %p\n", cam);
1362 memset(pipe, 0, sizeof(*pipe));
1363 pipe->cam = cam;
1364 pipe->transfer_size = BUFFER_SIZE;
1365
1366 pipe->transfer_buffer = kzalloc(pipe->transfer_size,
1367 GFP_KERNEL);
1368 if (pipe->transfer_buffer == NULL) {
1369 DBG("out of memory!\n");
1370 return -ENOMEM;
1371 }
1372
1373 cam->b_acquire = 0;
1374 cam->frame_count = 0;
1375
1376 /*** start create system buffers ***/
1377 for (i = 0; i < FRAMES; i++) {
1378 /* always allocate maximum size for system buffers */
1379 cam->buffer.frame[i].lpvbits = vmalloc(MAX_FRAME_SIZE);
1380
1381 DBG("valloc %p, idx %lu, pdata %p\n",
1382 &cam->buffer.frame[i], i,
1383 cam->buffer.frame[i].lpvbits);
1384 if (cam->buffer.frame[i].lpvbits == NULL) {
1385 printk(KERN_INFO KBUILD_MODNAME ": out of memory. "
1386 "Using less frames\n");
1387 break;
1388 }
1389 }
1390
1391 if (i == 0) {
1392 printk(KERN_INFO KBUILD_MODNAME ": out of memory. Aborting\n");
1393 kfree(cam->pipe->transfer_buffer);
1394 cam->pipe->transfer_buffer = NULL;
1395 return -ENOMEM;
1396 } else
1397 cam->buffer.dwFrames = i;
1398
1399 /* make sure internal states are set */
1400 for (i = 0; i < FRAMES; i++) {
1401 cam->buffer.frame[i].ulState = ZR364XX_READ_IDLE;
1402 cam->buffer.frame[i].cur_size = 0;
1403 }
1404
1405 cam->cur_frame = 0;
1406 cam->last_frame = -1;
1407 /*** end create system buffers ***/
1408
1409 /* start read pipe */
1410 zr364xx_start_readpipe(cam);
1411 DBG(": board initialized\n");
1412 return 0;
1413}
b7eee616
AJ		 1414
1415static int zr364xx_probe(struct usb_interface *intf,
1416 const struct usb_device_id *id)
1417{
1418 struct usb_device *udev = interface_to_usbdev(intf);
1419 struct zr364xx_camera *cam = NULL;
ccbf035a
LVS		 1420 struct usb_host_interface *iface_desc;
1421 struct usb_endpoint_descriptor *endpoint;
1fc21a19 1422 struct v4l2_ctrl_handler *hdl;
783aa8fa 1423 int err;
ccbf035a 1424 int i;
b7eee616 1425
ccbf035a 1426 DBG("probing...\n");
b7eee616 1427
a482f327
GKH		 1428 dev_info(&intf->dev, DRIVER_DESC " compatible webcam plugged\n");
1429 dev_info(&intf->dev, "model %04x:%04x detected\n",
1430 le16_to_cpu(udev->descriptor.idVendor),
1431 le16_to_cpu(udev->descriptor.idProduct));
b7eee616 1432
783aa8fa
AM		 1433 cam = kzalloc(sizeof(struct zr364xx_camera), GFP_KERNEL);
1434 if (cam == NULL) {
a482f327 1435 dev_err(&udev->dev, "cam: out of memory !\n");
783aa8fa 1436 return -ENOMEM;
b7eee616 1437 }
a906f62f
HV		 1438
1439 cam->v4l2_dev.release = zr364xx_release;
1440 err = v4l2_device_register(&intf->dev, &cam->v4l2_dev);
1441 if (err < 0) {
1442 dev_err(&udev->dev, "couldn't register v4l2_device\n");
1443 kfree(cam);
1444 return err;
1445 }
1fc21a19
HV		 1446 hdl = &cam->ctrl_handler;
1447 v4l2_ctrl_handler_init(hdl, 1);
1448 v4l2_ctrl_new_std(hdl, &zr364xx_ctrl_ops,
1449 V4L2_CID_BRIGHTNESS, 0, 127, 1, 64);
1450 if (hdl->error) {
1451 err = hdl->error;
1452 dev_err(&udev->dev, "couldn't register control\n");
1453 goto fail;
1454 }
b7eee616
AJ		 1455 /* save the init method used by this camera */
1456 cam->method = id->driver_info;
a906f62f 1457 mutex_init(&cam->lock);
2b99251f 1458 cam->vdev = zr364xx_template;
a906f62f
HV		 1459 cam->vdev.lock = &cam->lock;
1460 cam->vdev.v4l2_dev = &cam->v4l2_dev;
1fc21a19 1461 cam->vdev.ctrl_handler = &cam->ctrl_handler;
a065729d 1462 set_bit(V4L2_FL_USE_FH_PRIO, &cam->vdev.flags);
2b99251f 1463 video_set_drvdata(&cam->vdev, cam);
b7eee616 1464 if (debug)
2b99251f 1465 cam->vdev.debug = V4L2_DEBUG_IOCTL | V4L2_DEBUG_IOCTL_ARG;
b7eee616
AJ		 1466
1467 cam->udev = udev;
1468
b7eee616
AJ		 1469 switch (mode) {
1470 case 1:
a482f327 1471 dev_info(&udev->dev, "160x120 mode selected\n");
b7eee616
AJ		 1472 cam->width = 160;
1473 cam->height = 120;
1474 break;
1475 case 2:
a482f327 1476 dev_info(&udev->dev, "640x480 mode selected\n");
b7eee616
AJ		 1477 cam->width = 640;
1478 cam->height = 480;
1479 break;
1480 default:
a482f327 1481 dev_info(&udev->dev, "320x240 mode selected\n");
b7eee616
AJ		 1482 cam->width = 320;
1483 cam->height = 240;
1484 break;
1485 }
1486
1487 m0d1[0] = mode;
1488 m1[2].value = 0xf000 + mode;
1489 m2[1].value = 0xf000 + mode;
08135ba2
AJ		 1490
1491 /* special case for METHOD3, the modes are different */
1492 if (cam->method == METHOD3) {
1493 switch (mode) {
1494 case 1:
1495 m2[1].value = 0xf000 + 4;
1496 break;
1497 case 2:
1498 m2[1].value = 0xf000 + 0;
1499 break;
1500 default:
1501 m2[1].value = 0xf000 + 1;
1502 break;
1503 }
1504 }
1505
b7eee616
AJ		 1506 header2[437] = cam->height / 256;
1507 header2[438] = cam->height % 256;
1508 header2[439] = cam->width / 256;
1509 header2[440] = cam->width % 256;
1510
1511 cam->nb = 0;
ccbf035a
LVS		 1512
1513 DBG("dev: %p, udev %p interface %p\n", cam, cam->udev, intf);
1514
1515 /* set up the endpoint information */
1516 iface_desc = intf->cur_altsetting;
1517 DBG("num endpoints %d\n", iface_desc->desc.bNumEndpoints);
1518 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1519 endpoint = &iface_desc->endpoint[i].desc;
1520 if (!cam->read_endpoint && usb_endpoint_is_bulk_in(endpoint)) {
1521 /* we found the bulk in endpoint */
1522 cam->read_endpoint = endpoint->bEndpointAddress;
1523 }
1524 }
b7eee616 1525
ccbf035a 1526 if (!cam->read_endpoint) {
1fc21a19 1527 err = -ENOMEM;
ccbf035a 1528 dev_err(&intf->dev, "Could not find bulk-in endpoint\n");
1fc21a19 1529 goto fail;
ccbf035a
LVS		 1530 }
1531
1532 /* v4l */
1533 INIT_LIST_HEAD(&cam->vidq.active);
1534 cam->vidq.cam = cam;
b7eee616
AJ		 1535
1536 usb_set_intfdata(intf, cam);
1537
ccbf035a
LVS		 1538 /* load zr364xx board specific */
1539 err = zr364xx_board_init(cam);
1fc21a19
HV		 1540 if (!err)
1541 err = v4l2_ctrl_handler_setup(hdl);
1542 if (err)
1543 goto fail;
ccbf035a
LVS		 1544
1545 spin_lock_init(&cam->slock);
1546
a065729d
HV		 1547 cam->fmt = formats;
1548
1549 videobuf_queue_vmalloc_init(&cam->vb_vidq, &zr364xx_video_qops,
1550 NULL, &cam->slock,
1551 V4L2_BUF_TYPE_VIDEO_CAPTURE,
1552 V4L2_FIELD_NONE,
1553 sizeof(struct zr364xx_buffer), cam, &cam->lock);
1554
2b99251f
HV		 1555 err = video_register_device(&cam->vdev, VFL_TYPE_GRABBER, -1);
1556 if (err) {
1557 dev_err(&udev->dev, "video_register_device failed\n");
1fc21a19 1558 goto fail;
2b99251f
HV		 1559 }
1560
38c7c036 1561 dev_info(&udev->dev, DRIVER_DESC " controlling device %s\n",
2b99251f 1562 video_device_node_name(&cam->vdev));
b7eee616 1563 return 0;
1fc21a19
HV		 1564
1565fail:
1566 v4l2_ctrl_handler_free(hdl);
1567 v4l2_device_unregister(&cam->v4l2_dev);
1568 kfree(cam);
1569 return err;
b7eee616
AJ		 1570}
1571
1572
1573static void zr364xx_disconnect(struct usb_interface *intf)
1574{
1575 struct zr364xx_camera *cam = usb_get_intfdata(intf);
a906f62f
HV		 1576
1577 mutex_lock(&cam->lock);
b7eee616 1578 usb_set_intfdata(intf, NULL);
a482f327 1579 dev_info(&intf->dev, DRIVER_DESC " webcam unplugged\n");
a906f62f
HV		 1580 video_unregister_device(&cam->vdev);
1581 v4l2_device_disconnect(&cam->v4l2_dev);
1582
1583 /* stops the read pipe if it is running */
1584 if (cam->b_acquire)
1585 zr364xx_stop_acquire(cam);
1586
1587 zr364xx_stop_readpipe(cam);
1588 mutex_unlock(&cam->lock);
1589 v4l2_device_put(&cam->v4l2_dev);
b7eee616
AJ		 1590}
1591
1592
587a5765
HV		 1593#ifdef CONFIG_PM
1594static int zr364xx_suspend(struct usb_interface *intf, pm_message_t message)
1595{
1596 struct zr364xx_camera *cam = usb_get_intfdata(intf);
1597
1598 cam->was_streaming = cam->b_acquire;
1599 if (!cam->was_streaming)
1600 return 0;
1601 zr364xx_stop_acquire(cam);
1602 zr364xx_stop_readpipe(cam);
1603 return 0;
1604}
1605
1606static int zr364xx_resume(struct usb_interface *intf)
1607{
1608 struct zr364xx_camera *cam = usb_get_intfdata(intf);
1609 int res;
1610
1611 if (!cam->was_streaming)
1612 return 0;
1613
1614 zr364xx_start_readpipe(cam);
1615 res = zr364xx_prepare(cam);
1616 if (!res)
1617 zr364xx_start_acquire(cam);
1618 return res;
1619}
1620#endif
b7eee616
AJ		 1621
1622/**********************/
1623/* Module integration */
1624/**********************/
1625
1626static struct usb_driver zr364xx_driver = {
1627 .name = "zr364xx",
1628 .probe = zr364xx_probe,
1629 .disconnect = zr364xx_disconnect,
587a5765
HV		 1630#ifdef CONFIG_PM
1631 .suspend = zr364xx_suspend,
1632 .resume = zr364xx_resume,
1633 .reset_resume = zr364xx_resume,
1634#endif
b7eee616
AJ		 1635 .id_table = device_table
1636};
1637
ecb3b2b3 1638module_usb_driver(zr364xx_driver);
b7eee616
AJ		 1639
1640MODULE_AUTHOR(DRIVER_AUTHOR);
1641MODULE_DESCRIPTION(DRIVER_DESC);
1642MODULE_LICENSE("GPL");
1990d50b 1643MODULE_VERSION(DRIVER_VERSION);
Linux kernel - Deliverables
This page took 0.677213 seconds and 5 git commands to generate.