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