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