projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
V4L/DVB (10135): v4l2: introduce v4l2_file_operations.
[deliverable/linux.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 */
a482f327 55#define DBG(x...) if (debug) printk(KERN_INFO KBUILD_MODNAME x)
b7eee616
AJ		 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;
33d27a45 119 int users;
b7eee616
AJ		 120};
121
122
123/* function used to send initialisation commands to the camera */
124static 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) {
a482f327 131 dev_err(&udev->dev, "kmalloc(%d) failed\n", size);
b7eee616
AJ		 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)
a482f327
GKH		 147 dev_err(&udev->dev,
148 "Failed sending control message, error %d.\n", status);
b7eee616
AJ		 149
150 return status;
151}
152
153
154/* Control messages sent to the camera to initialize it
155 * and launch the capture */
156typedef struct {
157 unsigned int value;
158 unsigned int size;
159 unsigned char *bytes;
160} message;
161
162/* method 0 */
163static unsigned char m0d1[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
164static unsigned char m0d2[] = { 0, 0, 0, 0, 0, 0 };
165static unsigned char m0d3[] = { 0, 0 };
166static 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 */
182static unsigned char m1d1[] = { 0xff, 0xff };
183static unsigned char m1d2[] = { 0x00, 0x00 };
184static 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 */
202static unsigned char m2d1[] = { 0xff, 0xff };
203static 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 */
216static message *init[3] = { m0, m1, m2 };
217
218
219/* JPEG static data in header (Huffman table, etc) */
220static 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};
228static 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};
273static 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... */
283static int read_frame(struct zr364xx_camera *cam, int framenum)
284{
285 int i, n, temp, head, size, actual_length;
93566ad8 286 unsigned char *ptr = NULL, *jpeg;
b7eee616
AJ		 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) {
a482f327 308 dev_err(&cam->udev->dev, "error reading bulk msg\n");
b7eee616
AJ		 309 return 0;
310 }
311 if (actual_length < 0 || actual_length > BUFFER_SIZE) {
a482f327 312 dev_err(&cam->udev->dev, "wrong number of bytes\n");
b7eee616
AJ		 313 return 0;
314 }
315
316 /* swap bytes if camera needs it */
93566ad8
TP		 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 }
b7eee616
AJ		 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
97cf010a 396static ssize_t zr364xx_read(struct file *file, char __user *buf, size_t cnt,
b7eee616
AJ		 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
425static 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
434static 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
446static int zr364xx_vidioc_g_input(struct file *file, void *priv,
447 unsigned int *i)
448{
449 *i = 0;
450 return 0;
451}
452
453static 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
461static 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
487static 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
507static 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
78b526a4 527static int zr364xx_vidioc_enum_fmt_vid_cap(struct file *file,
b7eee616
AJ		 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
78b526a4 543static int zr364xx_vidioc_try_fmt_vid_cap(struct file *file, void *priv,
b7eee616
AJ		 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
78b526a4 570static int zr364xx_vidioc_g_fmt_vid_cap(struct file *file, void *priv,
b7eee616
AJ		 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
78b526a4 595static int zr364xx_vidioc_s_fmt_vid_cap(struct file *file, void *priv,
b7eee616
AJ		 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
623static int zr364xx_vidioc_streamon(struct file *file, void *priv,
624 enum v4l2_buf_type type)
625{
626 return 0;
627}
628
629static 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 */
bec43661 637static int zr364xx_open(struct file *file)
b7eee616
AJ		 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
69025c93
AJ		 646 mutex_lock(&cam->lock);
647
33d27a45
AJ		 648 if (cam->users) {
649 err = -EBUSY;
69025c93 650 goto out;
33d27a45 651 }
b7eee616
AJ		 652
653 if (!cam->framebuf) {
654 cam->framebuf = vmalloc_32(MAX_FRAME_SIZE * FRAMES);
655 if (!cam->framebuf) {
a482f327 656 dev_err(&cam->udev->dev, "vmalloc_32 failed!\n");
69025c93
AJ		 657 err = -ENOMEM;
658 goto out;
b7eee616
AJ		 659 }
660 }
661
b7eee616
AJ		 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) {
a482f327
GKH		 668 dev_err(&cam->udev->dev,
669 "error during open sequence: %d\n", i);
69025c93 670 goto out;
b7eee616
AJ		 671 }
672 }
673
33d27a45
AJ		 674 cam->skip = 2;
675 cam->users++;
b7eee616
AJ		 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);
69025c93 682 err = 0;
b7eee616 683
69025c93 684out:
b7eee616 685 mutex_unlock(&cam->lock);
69025c93 686 return err;
b7eee616
AJ		 687}
688
689
690/* release the camera */
bec43661 691static int zr364xx_release(struct file *file)
b7eee616
AJ		 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);
33d27a45
AJ		 707
708 cam->users--;
709 file->private_data = NULL;
710
b7eee616
AJ		 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) {
a482f327 717 dev_err(&udev->dev, "error during release sequence\n");
33d27a45 718 goto out;
b7eee616
AJ		 719 }
720 }
721
b7eee616
AJ		 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);
33d27a45 726 err = 0;
b7eee616 727
33d27a45 728out:
b7eee616 729 mutex_unlock(&cam->lock);
33d27a45 730 return err;
b7eee616
AJ		 731}
732
733
734static 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
bec43661 764static const struct v4l2_file_operations zr364xx_fops = {
b7eee616
AJ		 765 .owner = THIS_MODULE,
766 .open = zr364xx_open,
767 .release = zr364xx_release,
768 .read = zr364xx_read,
769 .mmap = zr364xx_mmap,
770 .ioctl = video_ioctl2,
b7eee616
AJ		 771};
772
a399810c 773static const struct v4l2_ioctl_ops zr364xx_ioctl_ops = {
b7eee616 774 .vidioc_querycap = zr364xx_vidioc_querycap,
78b526a4
HV		 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,
b7eee616
AJ		 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
a399810c 789static struct video_device zr364xx_template = {
a399810c 790 .name = DRIVER_DESC,
a399810c
HV		 791 .fops = &zr364xx_fops,
792 .ioctl_ops = &zr364xx_ioctl_ops,
793 .release = video_device_release,
794 .minor = -1,
795};
796
b7eee616
AJ		 797
798
799/*******************/
800/* USB integration */
801/*******************/
802
803static 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;
783aa8fa 808 int err;
b7eee616
AJ		 809
810 DBG("probing...");
811
a482f327
GKH		 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));
b7eee616 816
783aa8fa
AM		 817 cam = kzalloc(sizeof(struct zr364xx_camera), GFP_KERNEL);
818 if (cam == NULL) {
a482f327 819 dev_err(&udev->dev, "cam: out of memory !\n");
783aa8fa 820 return -ENOMEM;
b7eee616 821 }
b7eee616
AJ		 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) {
a482f327 827 dev_err(&udev->dev, "cam->vdev: out of memory !\n");
b7eee616 828 kfree(cam);
783aa8fa 829 return -ENOMEM;
b7eee616
AJ		 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) {
a482f327 839 dev_info(&udev->dev, "cam->buffer: out of memory !\n");
b7eee616
AJ		 840 video_device_release(cam->vdev);
841 kfree(cam);
842 return -ENODEV;
843 }
844
845 switch (mode) {
846 case 1:
a482f327 847 dev_info(&udev->dev, "160x120 mode selected\n");
b7eee616
AJ		 848 cam->width = 160;
849 cam->height = 120;
850 break;
851 case 2:
a482f327 852 dev_info(&udev->dev, "640x480 mode selected\n");
b7eee616
AJ		 853 cam->width = 640;
854 cam->height = 480;
855 break;
856 default:
a482f327 857 dev_info(&udev->dev, "320x240 mode selected\n");
b7eee616
AJ		 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
783aa8fa
AM		 875 err = video_register_device(cam->vdev, VFL_TYPE_GRABBER, -1);
876 if (err) {
a482f327 877 dev_err(&udev->dev, "video_register_device failed\n");
b7eee616
AJ		 878 video_device_release(cam->vdev);
879 kfree(cam->buffer);
880 kfree(cam);
783aa8fa 881 return err;
b7eee616
AJ		 882 }
883
884 usb_set_intfdata(intf, cam);
885
a482f327 886 dev_info(&udev->dev, DRIVER_DESC " controlling video device %d\n",
c6330fb8 887 cam->vdev->num);
b7eee616
AJ		 888 return 0;
889}
890
891
892static 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_set_drvdata(&intf->dev, NULL);
a482f327 897 dev_info(&intf->dev, DRIVER_DESC " webcam unplugged\n");
b7eee616
AJ		 898 if (cam->vdev)
899 video_unregister_device(cam->vdev);
900 cam->vdev = NULL;
901 kfree(cam->buffer);
902 if (cam->framebuf)
903 vfree(cam->framebuf);
904 kfree(cam);
905}
906
907
908
909/**********************/
910/* Module integration */
911/**********************/
912
913static struct usb_driver zr364xx_driver = {
914 .name = "zr364xx",
915 .probe = zr364xx_probe,
916 .disconnect = zr364xx_disconnect,
917 .id_table = device_table
918};
919
920
921static int __init zr364xx_init(void)
922{
923 int retval;
783aa8fa 924 retval = usb_register(&zr364xx_driver);
b7eee616 925 if (retval)
a482f327 926 printk(KERN_ERR KBUILD_MODNAME ": usb_register failed!\n");
b7eee616 927 else
a482f327 928 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
b7eee616
AJ		 929 return retval;
930}
931
932
933static void __exit zr364xx_exit(void)
934{
a482f327 935 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC " module unloaded\n");
b7eee616
AJ		 936 usb_deregister(&zr364xx_driver);
937}
938
939
940module_init(zr364xx_init);
941module_exit(zr364xx_exit);
942
943MODULE_AUTHOR(DRIVER_AUTHOR);
944MODULE_DESCRIPTION(DRIVER_DESC);
945MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.322963 seconds and 5 git commands to generate.