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