?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
V4L/DVB (10171): Use usb_set_intfdata
[linux-2.6/mini2440.git] / drivers / media / video / zr364xx.c
blob93023560f3242550f0ed2e026954cfcac9c0794c
1 /*
2 * Zoran 364xx based USB webcam module version 0.72
3 *
4 * Allows you to use your USB webcam with V4L2 applications
5 * This is still in heavy developpement !
6 *
7 * Copyright (C) 2004 Antoine Jacquet <royale@zerezo.com>
8 * http://royale.zerezo.com/zr364xx/
9 *
10 * Heavily inspired by usb-skeleton.c, vicam.c, cpia.c and spca50x.c drivers
11 * V4L2 version inspired by meye.c driver
12 *
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2 of the License, or
16 * (at your option) any later version.
17 *
18 * This program is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
22 *
23 * You should have received a copy of the GNU General Public License
24 * along with this program; if not, write to the Free Software
25 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 */
27
28
29 #include <linux/version.h>
30 #include <linux/module.h>
31 #include <linux/init.h>
32 #include <linux/usb.h>
33 #include <linux/vmalloc.h>
34 #include <linux/slab.h>
35 #include <linux/proc_fs.h>
36 #include <linux/highmem.h>
37 #include <media/v4l2-common.h>
38 #include <media/v4l2-ioctl.h>
39
40
41 /* Version Information */
42 #define DRIVER_VERSION "v0.72"
43 #define DRIVER_AUTHOR "Antoine Jacquet, http://royale.zerezo.com/"
44 #define DRIVER_DESC "Zoran 364xx"
45
46
47 /* Camera */
48 #define FRAMES 2
49 #define MAX_FRAME_SIZE 100000
50 #define BUFFER_SIZE 0x1000
51 #define CTRL_TIMEOUT 500
52
53
54 /* Debug macro */
55 #define DBG(x...) if (debug) printk(KERN_INFO KBUILD_MODNAME x)
56
57
58 /* Init methods, need to find nicer names for these
59 * the exact names of the chipsets would be the best if someone finds it */
60 #define METHOD0 0
61 #define METHOD1 1
62 #define METHOD2 2
63
64
65 /* Module parameters */
66 static int debug;
67 static int mode;
68
69
70 /* Module parameters interface */
71 module_param(debug, int, 0644);
72 MODULE_PARM_DESC(debug, "Debug level");
73 module_param(mode, int, 0644);
74 MODULE_PARM_DESC(mode, "0 = 320x240, 1 = 160x120, 2 = 640x480");
75
76
77 /* Devices supported by this driver
78 * .driver_info contains the init method used by the camera */
79 static struct usb_device_id device_table[] = {
80 {USB_DEVICE(0x08ca, 0x0109), .driver_info = METHOD0 },
81 {USB_DEVICE(0x041e, 0x4024), .driver_info = METHOD0 },
82 {USB_DEVICE(0x0d64, 0x0108), .driver_info = METHOD0 },
83 {USB_DEVICE(0x0546, 0x3187), .driver_info = METHOD0 },
84 {USB_DEVICE(0x0d64, 0x3108), .driver_info = METHOD0 },
85 {USB_DEVICE(0x0595, 0x4343), .driver_info = METHOD0 },
86 {USB_DEVICE(0x0bb0, 0x500d), .driver_info = METHOD0 },
87 {USB_DEVICE(0x0feb, 0x2004), .driver_info = METHOD0 },
88 {USB_DEVICE(0x055f, 0xb500), .driver_info = METHOD0 },
89 {USB_DEVICE(0x08ca, 0x2062), .driver_info = METHOD2 },
90 {USB_DEVICE(0x052b, 0x1a18), .driver_info = METHOD1 },
91 {USB_DEVICE(0x04c8, 0x0729), .driver_info = METHOD0 },
92 {USB_DEVICE(0x04f2, 0xa208), .driver_info = METHOD0 },
93 {USB_DEVICE(0x0784, 0x0040), .driver_info = METHOD1 },
94 {USB_DEVICE(0x06d6, 0x0034), .driver_info = METHOD0 },
95 {USB_DEVICE(0x0a17, 0x0062), .driver_info = METHOD2 },
96 {USB_DEVICE(0x06d6, 0x003b), .driver_info = METHOD0 },
97 {USB_DEVICE(0x0a17, 0x004e), .driver_info = METHOD2 },
98 {USB_DEVICE(0x041e, 0x405d), .driver_info = METHOD2 },
99 {} /* Terminating entry */
100 };
101
102 MODULE_DEVICE_TABLE(usb, device_table);
103
104
105 /* Camera stuff */
106 struct zr364xx_camera {
107 struct usb_device *udev; /* save off the usb device pointer */
108 struct usb_interface *interface;/* the interface for this device */
109 struct video_device *vdev; /* v4l video device */
110 u8 *framebuf;
111 int nb;
112 unsigned char *buffer;
113 int skip;
114 int brightness;
115 int width;
116 int height;
117 int method;
118 struct mutex lock;
119 int users;
120 };
121
122
123 /* function used to send initialisation commands to the camera */
124 static int send_control_msg(struct usb_device *udev, u8 request, u16 value,
125 u16 index, unsigned char *cp, u16 size)
126 {
127 int status;
128
129 unsigned char *transfer_buffer = kmalloc(size, GFP_KERNEL);
130 if (!transfer_buffer) {
131 dev_err(&udev->dev, "kmalloc(%d) failed\n", size);
132 return -ENOMEM;
133 }
134
135 memcpy(transfer_buffer, cp, size);
136
137 status = usb_control_msg(udev,
138 usb_sndctrlpipe(udev, 0),
139 request,
140 USB_DIR_OUT | USB_TYPE_VENDOR |
141 USB_RECIP_DEVICE, value, index,
142 transfer_buffer, size, CTRL_TIMEOUT);
143
144 kfree(transfer_buffer);
145
146 if (status < 0)
147 dev_err(&udev->dev,
148 "Failed sending control message, error %d.\n", status);
149
150 return status;
151 }
152
153
154 /* Control messages sent to the camera to initialize it
155 * and launch the capture */
156 typedef struct {
157 unsigned int value;
158 unsigned int size;
159 unsigned char *bytes;
160 } message;
161
162 /* method 0 */
163 static unsigned char m0d1[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
164 static unsigned char m0d2[] = { 0, 0, 0, 0, 0, 0 };
165 static unsigned char m0d3[] = { 0, 0 };
166 static message m0[] = {
167 {0x1f30, 0, NULL},
168 {0xd000, 0, NULL},
169 {0x3370, sizeof(m0d1), m0d1},
170 {0x2000, 0, NULL},
171 {0x2f0f, 0, NULL},
172 {0x2610, sizeof(m0d2), m0d2},
173 {0xe107, 0, NULL},
174 {0x2502, 0, NULL},
175 {0x1f70, 0, NULL},
176 {0xd000, 0, NULL},
177 {0x9a01, sizeof(m0d3), m0d3},
178 {-1, -1, NULL}
179 };
180
181 /* method 1 */
182 static unsigned char m1d1[] = { 0xff, 0xff };
183 static unsigned char m1d2[] = { 0x00, 0x00 };
184 static message m1[] = {
185 {0x1f30, 0, NULL},
186 {0xd000, 0, NULL},
187 {0xf000, 0, NULL},
188 {0x2000, 0, NULL},
189 {0x2f0f, 0, NULL},
190 {0x2650, 0, NULL},
191 {0xe107, 0, NULL},
192 {0x2502, sizeof(m1d1), m1d1},
193 {0x1f70, 0, NULL},
194 {0xd000, 0, NULL},
195 {0xd000, 0, NULL},
196 {0xd000, 0, NULL},
197 {0x9a01, sizeof(m1d2), m1d2},
198 {-1, -1, NULL}
199 };
200
201 /* method 2 */
202 static unsigned char m2d1[] = { 0xff, 0xff };
203 static message m2[] = {
204 {0x1f30, 0, NULL},
205 {0xf000, 0, NULL},
206 {0x2000, 0, NULL},
207 {0x2f0f, 0, NULL},
208 {0x2650, 0, NULL},
209 {0xe107, 0, NULL},
210 {0x2502, sizeof(m2d1), m2d1},
211 {0x1f70, 0, NULL},
212 {-1, -1, NULL}
213 };
214
215 /* init table */
216 static message *init[3] = { m0, m1, m2 };
217
218
219 /* JPEG static data in header (Huffman table, etc) */
220 static unsigned char header1[] = {
221 0xFF, 0xD8,
222 /*
223 0xFF, 0xE0, 0x00, 0x10, 'J', 'F', 'I', 'F',
224 0x00, 0x01, 0x01, 0x00, 0x33, 0x8A, 0x00, 0x00, 0x33, 0x88,
225 */
226 0xFF, 0xDB, 0x00, 0x84
227 };
228 static unsigned char header2[] = {
229 0xFF, 0xC4, 0x00, 0x1F, 0x00, 0x00, 0x01, 0x05, 0x01, 0x01, 0x01,
230 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
231 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,
232 0xFF, 0xC4, 0x00, 0xB5, 0x10, 0x00, 0x02, 0x01, 0x03, 0x03, 0x02,
233 0x04, 0x03, 0x05, 0x05, 0x04, 0x04, 0x00, 0x00, 0x01, 0x7D, 0x01,
234 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06,
235 0x13, 0x51, 0x61, 0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xA1,
236 0x08, 0x23, 0x42, 0xB1, 0xC1, 0x15, 0x52, 0xD1, 0xF0, 0x24, 0x33,
237 0x62, 0x72, 0x82, 0x09, 0x0A, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x25,
238 0x26, 0x27, 0x28, 0x29, 0x2A, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
239 0x3A, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54,
240 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67,
241 0x68, 0x69, 0x6A, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A,
242 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94,
243 0x95, 0x96, 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6,
244 0xA7, 0xA8, 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8,
245 0xB9, 0xBA, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA,
246 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE1, 0xE2,
247 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF1, 0xF2, 0xF3,
248 0xF4, 0xF5, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA, 0xFF, 0xC4, 0x00, 0x1F,
249 0x01, 0x00, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
250 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x03, 0x04,
251 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0xFF, 0xC4, 0x00, 0xB5,
252 0x11, 0x00, 0x02, 0x01, 0x02, 0x04, 0x04, 0x03, 0x04, 0x07, 0x05,
253 0x04, 0x04, 0x00, 0x01, 0x02, 0x77, 0x00, 0x01, 0x02, 0x03, 0x11,
254 0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
255 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91, 0xA1, 0xB1, 0xC1,
256 0x09, 0x23, 0x33, 0x52, 0xF0, 0x15, 0x62, 0x72, 0xD1, 0x0A, 0x16,
257 0x24, 0x34, 0xE1, 0x25, 0xF1, 0x17, 0x18, 0x19, 0x1A, 0x26, 0x27,
258 0x28, 0x29, 0x2A, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x43, 0x44,
259 0x45, 0x46, 0x47, 0x48, 0x49, 0x4A, 0x53, 0x54, 0x55, 0x56, 0x57,
260 0x58, 0x59, 0x5A, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A,
261 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x82, 0x83, 0x84,
262 0x85, 0x86, 0x87, 0x88, 0x89, 0x8A, 0x92, 0x93, 0x94, 0x95, 0x96,
263 0x97, 0x98, 0x99, 0x9A, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, 0xA8,
264 0xA9, 0xAA, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, 0xB8, 0xB9, 0xBA,
265 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xCA, 0xD2, 0xD3,
266 0xD4, 0xD5, 0xD6, 0xD7, 0xD8, 0xD9, 0xDA, 0xE2, 0xE3, 0xE4, 0xE5,
267 0xE6, 0xE7, 0xE8, 0xE9, 0xEA, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
268 0xF8, 0xF9, 0xFA, 0xFF, 0xC0, 0x00, 0x11, 0x08, 0x00, 0xF0, 0x01,
269 0x40, 0x03, 0x01, 0x21, 0x00, 0x02, 0x11, 0x01, 0x03, 0x11, 0x01,
270 0xFF, 0xDA, 0x00, 0x0C, 0x03, 0x01, 0x00, 0x02, 0x11, 0x03, 0x11,
271 0x00, 0x3F, 0x00
272 };
273 static unsigned char header3;
274
275
276
277 /********************/
278 /* V4L2 integration */
279 /********************/
280
281 /* this function reads a full JPEG picture synchronously
282 * TODO: do it asynchronously... */
283 static int read_frame(struct zr364xx_camera *cam, int framenum)
284 {
285 int i, n, temp, head, size, actual_length;
286 unsigned char *ptr = NULL, *jpeg;
287
288 redo:
289 /* hardware brightness */
290 n = send_control_msg(cam->udev, 1, 0x2001, 0, NULL, 0);
291 temp = (0x60 << 8) + 127 - cam->brightness;
292 n = send_control_msg(cam->udev, 1, temp, 0, NULL, 0);
293
294 /* during the first loop we are going to insert JPEG header */
295 head = 0;
296 /* this is the place in memory where we are going to build
297 * the JPEG image */
298 jpeg = cam->framebuf + framenum * MAX_FRAME_SIZE;
299 /* read data... */
300 do {
301 n = usb_bulk_msg(cam->udev,
302 usb_rcvbulkpipe(cam->udev, 0x81),
303 cam->buffer, BUFFER_SIZE, &actual_length,
304 CTRL_TIMEOUT);
305 DBG("buffer : %d %d", cam->buffer[0], cam->buffer[1]);
306 DBG("bulk : n=%d size=%d", n, actual_length);
307 if (n < 0) {
308 dev_err(&cam->udev->dev, "error reading bulk msg\n");
309 return 0;
310 }
311 if (actual_length < 0 || actual_length > BUFFER_SIZE) {
312 dev_err(&cam->udev->dev, "wrong number of bytes\n");
313 return 0;
314 }
315
316 /* swap bytes if camera needs it */
317 if (cam->method == METHOD0) {
318 u16 *buf = (u16*)cam->buffer;
319 for (i = 0; i < BUFFER_SIZE/2; i++)
320 swab16s(buf + i);
321 }
322
323 /* write the JPEG header */
324 if (!head) {
325 DBG("jpeg header");
326 ptr = jpeg;
327 memcpy(ptr, header1, sizeof(header1));
328 ptr += sizeof(header1);
329 header3 = 0;
330 memcpy(ptr, &header3, 1);
331 ptr++;
332 memcpy(ptr, cam->buffer, 64);
333 ptr += 64;
334 header3 = 1;
335 memcpy(ptr, &header3, 1);
336 ptr++;
337 memcpy(ptr, cam->buffer + 64, 64);
338 ptr += 64;
339 memcpy(ptr, header2, sizeof(header2));
340 ptr += sizeof(header2);
341 memcpy(ptr, cam->buffer + 128,
342 actual_length - 128);
343 ptr += actual_length - 128;
344 head = 1;
345 DBG("header : %d %d %d %d %d %d %d %d %d",
346 cam->buffer[0], cam->buffer[1], cam->buffer[2],
347 cam->buffer[3], cam->buffer[4], cam->buffer[5],
348 cam->buffer[6], cam->buffer[7], cam->buffer[8]);
349 } else {
350 memcpy(ptr, cam->buffer, actual_length);
351 ptr += actual_length;
352 }
353 }
354 /* ... until there is no more */
355 while (actual_length == BUFFER_SIZE);
356
357 /* we skip the 2 first frames which are usually buggy */
358 if (cam->skip) {
359 cam->skip--;
360 goto redo;
361 }
362
363 /* go back to find the JPEG EOI marker */
364 size = ptr - jpeg;
365 ptr -= 2;
366 while (ptr > jpeg) {
367 if (*ptr == 0xFF && *(ptr + 1) == 0xD9
368 && *(ptr + 2) == 0xFF)
369 break;
370 ptr--;
371 }
372 if (ptr == jpeg)
373 DBG("No EOI marker");
374
375 /* Sometimes there is junk data in the middle of the picture,
376 * we want to skip this bogus frames */
377 while (ptr > jpeg) {
378 if (*ptr == 0xFF && *(ptr + 1) == 0xFF
379 && *(ptr + 2) == 0xFF)
380 break;
381 ptr--;
382 }
383 if (ptr != jpeg) {
384 DBG("Bogus frame ? %d", cam->nb);
385 goto redo;
386 }
387
388 DBG("jpeg : %d %d %d %d %d %d %d %d",
389 jpeg[0], jpeg[1], jpeg[2], jpeg[3],
390 jpeg[4], jpeg[5], jpeg[6], jpeg[7]);
391
392 return size;
393 }
394
395
396 static ssize_t zr364xx_read(struct file *file, char __user *buf, size_t cnt,
397 loff_t * ppos)
398 {
399 unsigned long count = cnt;
400 struct video_device *vdev = video_devdata(file);
401 struct zr364xx_camera *cam;
402
403 DBG("zr364xx_read: read %d bytes.", (int) count);
404
405 if (vdev == NULL)
406 return -ENODEV;
407 cam = video_get_drvdata(vdev);
408
409 if (!buf)
410 return -EINVAL;
411
412 if (!count)
413 return -EINVAL;
414
415 /* NoMan Sux ! */
416 count = read_frame(cam, 0);
417
418 if (copy_to_user(buf, cam->framebuf, count))
419 return -EFAULT;
420
421 return count;
422 }
423
424
425 static int zr364xx_vidioc_querycap(struct file *file, void *priv,
426 struct v4l2_capability *cap)
427 {
428 memset(cap, 0, sizeof(*cap));
429 strcpy(cap->driver, DRIVER_DESC);
430 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE;
431 return 0;
432 }
433
434 static int zr364xx_vidioc_enum_input(struct file *file, void *priv,
435 struct v4l2_input *i)
436 {
437 if (i->index != 0)
438 return -EINVAL;
439 memset(i, 0, sizeof(*i));
440 i->index = 0;
441 strcpy(i->name, DRIVER_DESC " Camera");
442 i->type = V4L2_INPUT_TYPE_CAMERA;
443 return 0;
444 }
445
446 static int zr364xx_vidioc_g_input(struct file *file, void *priv,
447 unsigned int *i)
448 {
449 *i = 0;
450 return 0;
451 }
452
453 static int zr364xx_vidioc_s_input(struct file *file, void *priv,
454 unsigned int i)
455 {
456 if (i != 0)
457 return -EINVAL;
458 return 0;
459 }
460
461 static int zr364xx_vidioc_queryctrl(struct file *file, void *priv,
462 struct v4l2_queryctrl *c)
463 {
464 struct video_device *vdev = video_devdata(file);
465 struct zr364xx_camera *cam;
466
467 if (vdev == NULL)
468 return -ENODEV;
469 cam = video_get_drvdata(vdev);
470
471 switch (c->id) {
472 case V4L2_CID_BRIGHTNESS:
473 c->type = V4L2_CTRL_TYPE_INTEGER;
474 strcpy(c->name, "Brightness");
475 c->minimum = 0;
476 c->maximum = 127;
477 c->step = 1;
478 c->default_value = cam->brightness;
479 c->flags = 0;
480 break;
481 default:
482 return -EINVAL;
483 }
484 return 0;
485 }
486
487 static int zr364xx_vidioc_s_ctrl(struct file *file, void *priv,
488 struct v4l2_control *c)
489 {
490 struct video_device *vdev = video_devdata(file);
491 struct zr364xx_camera *cam;
492
493 if (vdev == NULL)
494 return -ENODEV;
495 cam = video_get_drvdata(vdev);
496
497 switch (c->id) {
498 case V4L2_CID_BRIGHTNESS:
499 cam->brightness = c->value;
500 break;
501 default:
502 return -EINVAL;
503 }
504 return 0;
505 }
506
507 static int zr364xx_vidioc_g_ctrl(struct file *file, void *priv,
508 struct v4l2_control *c)
509 {
510 struct video_device *vdev = video_devdata(file);
511 struct zr364xx_camera *cam;
512
513 if (vdev == NULL)
514 return -ENODEV;
515 cam = video_get_drvdata(vdev);
516
517 switch (c->id) {
518 case V4L2_CID_BRIGHTNESS:
519 c->value = cam->brightness;
520 break;
521 default:
522 return -EINVAL;
523 }
524 return 0;
525 }
526
527 static int zr364xx_vidioc_enum_fmt_vid_cap(struct file *file,
528 void *priv, struct v4l2_fmtdesc *f)
529 {
530 if (f->index > 0)
531 return -EINVAL;
532 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
533 return -EINVAL;
534 memset(f, 0, sizeof(*f));
535 f->index = 0;
536 f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
537 f->flags = V4L2_FMT_FLAG_COMPRESSED;
538 strcpy(f->description, "JPEG");
539 f->pixelformat = V4L2_PIX_FMT_JPEG;
540 return 0;
541 }
542
543 static int zr364xx_vidioc_try_fmt_vid_cap(struct file *file, void *priv,
544 struct v4l2_format *f)
545 {
546 struct video_device *vdev = video_devdata(file);
547 struct zr364xx_camera *cam;
548
549 if (vdev == NULL)
550 return -ENODEV;
551 cam = video_get_drvdata(vdev);
552
553 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
554 return -EINVAL;
555 if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_JPEG)
556 return -EINVAL;
557 if (f->fmt.pix.field != V4L2_FIELD_ANY &&
558 f->fmt.pix.field != V4L2_FIELD_NONE)
559 return -EINVAL;
560 f->fmt.pix.field = V4L2_FIELD_NONE;
561 f->fmt.pix.width = cam->width;
562 f->fmt.pix.height = cam->height;
563 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
564 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
565 f->fmt.pix.colorspace = 0;
566 f->fmt.pix.priv = 0;
567 return 0;
568 }
569
570 static int zr364xx_vidioc_g_fmt_vid_cap(struct file *file, void *priv,
571 struct v4l2_format *f)
572 {
573 struct video_device *vdev = video_devdata(file);
574 struct zr364xx_camera *cam;
575
576 if (vdev == NULL)
577 return -ENODEV;
578 cam = video_get_drvdata(vdev);
579
580 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
581 return -EINVAL;
582 memset(&f->fmt.pix, 0, sizeof(struct v4l2_pix_format));
583 f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
584 f->fmt.pix.pixelformat = V4L2_PIX_FMT_JPEG;
585 f->fmt.pix.field = V4L2_FIELD_NONE;
586 f->fmt.pix.width = cam->width;
587 f->fmt.pix.height = cam->height;
588 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
589 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
590 f->fmt.pix.colorspace = 0;
591 f->fmt.pix.priv = 0;
592 return 0;
593 }
594
595 static int zr364xx_vidioc_s_fmt_vid_cap(struct file *file, void *priv,
596 struct v4l2_format *f)
597 {
598 struct video_device *vdev = video_devdata(file);
599 struct zr364xx_camera *cam;
600
601 if (vdev == NULL)
602 return -ENODEV;
603 cam = video_get_drvdata(vdev);
604
605 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
606 return -EINVAL;
607 if (f->fmt.pix.pixelformat != V4L2_PIX_FMT_JPEG)
608 return -EINVAL;
609 if (f->fmt.pix.field != V4L2_FIELD_ANY &&
610 f->fmt.pix.field != V4L2_FIELD_NONE)
611 return -EINVAL;
612 f->fmt.pix.field = V4L2_FIELD_NONE;
613 f->fmt.pix.width = cam->width;
614 f->fmt.pix.height = cam->height;
615 f->fmt.pix.bytesperline = f->fmt.pix.width * 2;
616 f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
617 f->fmt.pix.colorspace = 0;
618 f->fmt.pix.priv = 0;
619 DBG("ok!");
620 return 0;
621 }
622
623 static int zr364xx_vidioc_streamon(struct file *file, void *priv,
624 enum v4l2_buf_type type)
625 {
626 return 0;
627 }
628
629 static int zr364xx_vidioc_streamoff(struct file *file, void *priv,
630 enum v4l2_buf_type type)
631 {
632 return 0;
633 }
634
635
636 /* open the camera */
637 static int zr364xx_open(struct file *file)
638 {
639 struct video_device *vdev = video_devdata(file);
640 struct zr364xx_camera *cam = video_get_drvdata(vdev);
641 struct usb_device *udev = cam->udev;
642 int i, err;
643
644 DBG("zr364xx_open");
645
646 mutex_lock(&cam->lock);
647
648 if (cam->users) {
649 err = -EBUSY;
650 goto out;
651 }
652
653 if (!cam->framebuf) {
654 cam->framebuf = vmalloc_32(MAX_FRAME_SIZE * FRAMES);
655 if (!cam->framebuf) {
656 dev_err(&cam->udev->dev, "vmalloc_32 failed!\n");
657 err = -ENOMEM;
658 goto out;
659 }
660 }
661
662 for (i = 0; init[cam->method][i].size != -1; i++) {
663 err =
664 send_control_msg(udev, 1, init[cam->method][i].value,
665 0, init[cam->method][i].bytes,
666 init[cam->method][i].size);
667 if (err < 0) {
668 dev_err(&cam->udev->dev,
669 "error during open sequence: %d\n", i);
670 goto out;
671 }
672 }
673
674 cam->skip = 2;
675 cam->users++;
676 file->private_data = vdev;
677
678 /* Added some delay here, since opening/closing the camera quickly,
679 * like Ekiga does during its startup, can crash the webcam
680 */
681 mdelay(100);
682 err = 0;
683
684 out:
685 mutex_unlock(&cam->lock);
686 return err;
687 }
688
689
690 /* release the camera */
691 static int zr364xx_release(struct file *file)
692 {
693 struct video_device *vdev = video_devdata(file);
694 struct zr364xx_camera *cam;
695 struct usb_device *udev;
696 int i, err;
697
698 DBG("zr364xx_release");
699
700 if (vdev == NULL)
701 return -ENODEV;
702 cam = video_get_drvdata(vdev);
703
704 udev = cam->udev;
705
706 mutex_lock(&cam->lock);
707
708 cam->users--;
709 file->private_data = NULL;
710
711 for (i = 0; i < 2; i++) {
712 err =
713 send_control_msg(udev, 1, init[cam->method][i].value,
714 0, init[i][cam->method].bytes,
715 init[cam->method][i].size);
716 if (err < 0) {
717 dev_err(&udev->dev, "error during release sequence\n");
718 goto out;
719 }
720 }
721
722 /* Added some delay here, since opening/closing the camera quickly,
723 * like Ekiga does during its startup, can crash the webcam
724 */
725 mdelay(100);
726 err = 0;
727
728 out:
729 mutex_unlock(&cam->lock);
730 return err;
731 }
732
733
734 static int zr364xx_mmap(struct file *file, struct vm_area_struct *vma)
735 {
736 void *pos;
737 unsigned long start = vma->vm_start;
738 unsigned long size = vma->vm_end - vma->vm_start;
739 struct video_device *vdev = video_devdata(file);
740 struct zr364xx_camera *cam;
741
742 DBG("zr364xx_mmap: %ld\n", size);
743
744 if (vdev == NULL)
745 return -ENODEV;
746 cam = video_get_drvdata(vdev);
747
748 pos = cam->framebuf;
749 while (size > 0) {
750 if (vm_insert_page(vma, start, vmalloc_to_page(pos)))
751 return -EAGAIN;
752 start += PAGE_SIZE;
753 pos += PAGE_SIZE;
754 if (size > PAGE_SIZE)
755 size -= PAGE_SIZE;
756 else
757 size = 0;
758 }
759
760 return 0;
761 }
762
763
764 static const struct v4l2_file_operations zr364xx_fops = {
765 .owner = THIS_MODULE,
766 .open = zr364xx_open,
767 .release = zr364xx_release,
768 .read = zr364xx_read,
769 .mmap = zr364xx_mmap,
770 .ioctl = video_ioctl2,
771 };
772
773 static const struct v4l2_ioctl_ops zr364xx_ioctl_ops = {
774 .vidioc_querycap = zr364xx_vidioc_querycap,
775 .vidioc_enum_fmt_vid_cap = zr364xx_vidioc_enum_fmt_vid_cap,
776 .vidioc_try_fmt_vid_cap = zr364xx_vidioc_try_fmt_vid_cap,
777 .vidioc_s_fmt_vid_cap = zr364xx_vidioc_s_fmt_vid_cap,
778 .vidioc_g_fmt_vid_cap = zr364xx_vidioc_g_fmt_vid_cap,
779 .vidioc_enum_input = zr364xx_vidioc_enum_input,
780 .vidioc_g_input = zr364xx_vidioc_g_input,
781 .vidioc_s_input = zr364xx_vidioc_s_input,
782 .vidioc_streamon = zr364xx_vidioc_streamon,
783 .vidioc_streamoff = zr364xx_vidioc_streamoff,
784 .vidioc_queryctrl = zr364xx_vidioc_queryctrl,
785 .vidioc_g_ctrl = zr364xx_vidioc_g_ctrl,
786 .vidioc_s_ctrl = zr364xx_vidioc_s_ctrl,
787 };
788
789 static struct video_device zr364xx_template = {
790 .name = DRIVER_DESC,
791 .fops = &zr364xx_fops,
792 .ioctl_ops = &zr364xx_ioctl_ops,
793 .release = video_device_release,
794 .minor = -1,
795 };
796
797
798
799 /*******************/
800 /* USB integration */
801 /*******************/
802
803 static int zr364xx_probe(struct usb_interface *intf,
804 const struct usb_device_id *id)
805 {
806 struct usb_device *udev = interface_to_usbdev(intf);
807 struct zr364xx_camera *cam = NULL;
808 int err;
809
810 DBG("probing...");
811
812 dev_info(&intf->dev, DRIVER_DESC " compatible webcam plugged\n");
813 dev_info(&intf->dev, "model %04x:%04x detected\n",
814 le16_to_cpu(udev->descriptor.idVendor),
815 le16_to_cpu(udev->descriptor.idProduct));
816
817 cam = kzalloc(sizeof(struct zr364xx_camera), GFP_KERNEL);
818 if (cam == NULL) {
819 dev_err(&udev->dev, "cam: out of memory !\n");
820 return -ENOMEM;
821 }
822 /* save the init method used by this camera */
823 cam->method = id->driver_info;
824
825 cam->vdev = video_device_alloc();
826 if (cam->vdev == NULL) {
827 dev_err(&udev->dev, "cam->vdev: out of memory !\n");
828 kfree(cam);
829 return -ENOMEM;
830 }
831 memcpy(cam->vdev, &zr364xx_template, sizeof(zr364xx_template));
832 video_set_drvdata(cam->vdev, cam);
833 if (debug)
834 cam->vdev->debug = V4L2_DEBUG_IOCTL | V4L2_DEBUG_IOCTL_ARG;
835
836 cam->udev = udev;
837
838 if ((cam->buffer = kmalloc(BUFFER_SIZE, GFP_KERNEL)) == NULL) {
839 dev_info(&udev->dev, "cam->buffer: out of memory !\n");
840 video_device_release(cam->vdev);
841 kfree(cam);
842 return -ENODEV;
843 }
844
845 switch (mode) {
846 case 1:
847 dev_info(&udev->dev, "160x120 mode selected\n");
848 cam->width = 160;
849 cam->height = 120;
850 break;
851 case 2:
852 dev_info(&udev->dev, "640x480 mode selected\n");
853 cam->width = 640;
854 cam->height = 480;
855 break;
856 default:
857 dev_info(&udev->dev, "320x240 mode selected\n");
858 cam->width = 320;
859 cam->height = 240;
860 break;
861 }
862
863 m0d1[0] = mode;
864 m1[2].value = 0xf000 + mode;
865 m2[1].value = 0xf000 + mode;
866 header2[437] = cam->height / 256;
867 header2[438] = cam->height % 256;
868 header2[439] = cam->width / 256;
869 header2[440] = cam->width % 256;
870
871 cam->nb = 0;
872 cam->brightness = 64;
873 mutex_init(&cam->lock);
874
875 err = video_register_device(cam->vdev, VFL_TYPE_GRABBER, -1);
876 if (err) {
877 dev_err(&udev->dev, "video_register_device failed\n");
878 video_device_release(cam->vdev);
879 kfree(cam->buffer);
880 kfree(cam);
881 return err;
882 }
883
884 usb_set_intfdata(intf, cam);
885
886 dev_info(&udev->dev, DRIVER_DESC " controlling video device %d\n",
887 cam->vdev->num);
888 return 0;
889 }
890
891
892 static void zr364xx_disconnect(struct usb_interface *intf)
893 {
894 struct zr364xx_camera *cam = usb_get_intfdata(intf);
895 usb_set_intfdata(intf, NULL);
896 dev_info(&intf->dev, DRIVER_DESC " webcam unplugged\n");
897 if (cam->vdev)
898 video_unregister_device(cam->vdev);
899 cam->vdev = NULL;
900 kfree(cam->buffer);
901 if (cam->framebuf)
902 vfree(cam->framebuf);
903 kfree(cam);
904 }
905
906
907
908 /**********************/
909 /* Module integration */
910 /**********************/
911
912 static struct usb_driver zr364xx_driver = {
913 .name = "zr364xx",
914 .probe = zr364xx_probe,
915 .disconnect = zr364xx_disconnect,
916 .id_table = device_table
917 };
918
919
920 static int __init zr364xx_init(void)
921 {
922 int retval;
923 retval = usb_register(&zr364xx_driver);
924 if (retval)
925 printk(KERN_ERR KBUILD_MODNAME ": usb_register failed!\n");
926 else
927 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
928 return retval;
929 }
930
931
932 static void __exit zr364xx_exit(void)
933 {
934 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC " module unloaded\n");
935 usb_deregister(&zr364xx_driver);
936 }
937
938
939 module_init(zr364xx_init);
940 module_exit(zr364xx_exit);
941
942 MODULE_AUTHOR(DRIVER_AUTHOR);
943 MODULE_DESCRIPTION(DRIVER_DESC);
944 MODULE_LICENSE("GPL");
Support for the Chinese Samsung S3C2440 based development boards