Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 566789f6b0b6d4c6ec1618412184f05c7aa85f4d

Authored by Amerigo Wang
Committed by Mauro Carvalho Chehab
1 parent bb6dbe7480
Exists in master and in 7 other branches imx_3.0.35_4.1.0, imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga, smarc-l5.0.0_1.0.0-ga

V4L/DVB: Remove usbvideo quickcam_messenger driver 

obsolete v4l1 driver replaced by gspca_stv06xx

Signed-off-by: Amerigo Wang <amwang@redhat.com>
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>

Showing 5 changed files with 0 additions and 1261 deletions Side-by-side Diff

Documentation/feature-removal-schedule.txt
Diff comments   View file @ 566789f
... ... @@ -459,14 +459,6 @@
459 459  
460 460 ----------------------------
461 461  
462   -What: usbvideo quickcam_messenger driver
463   -When: 2.6.35
464   -Files: drivers/media/video/usbvideo/quickcam_messenger.[ch]
465   -Why: obsolete v4l1 driver replaced by gspca_stv06xx
466   -Who: Hans de Goede <hdegoede@redhat.com>
467   -
468   -----------------------------
469   -
470 462 What: ov511 v4l1 driver
471 463 When: 2.6.35
472 464 Files: drivers/media/video/ov511.[ch]
drivers/media/video/usbvideo/Kconfig
Diff comments   View file @ 566789f
... ... @@ -36,18 +36,4 @@
36 36  
37 37 To compile this driver as a module, choose M here: the
38 38 module will be called konicawc.
39   -
40   -config USB_QUICKCAM_MESSENGER
41   - tristate "USB Logitech Quickcam Messenger (DEPRECATED)"
42   - depends on VIDEO_V4L1
43   - select VIDEO_USBVIDEO
44   - ---help---
45   - This driver is DEPRECATED please use the gspca stv06xx module
46   - instead.
47   -
48   - Say Y or M here to enable support for the USB Logitech Quickcam
49   - Messenger webcam.
50   -
51   - To compile this driver as a module, choose M here: the
52   - module will be called quickcam_messenger.
drivers/media/video/usbvideo/Makefile
Diff comments   View file @ 566789f
... ... @@ -2,5 +2,4 @@
2 2 obj-$(CONFIG_USB_IBMCAM) += ibmcam.o ultracam.o
3 3 obj-$(CONFIG_USB_KONICAWC) += konicawc.o
4 4 obj-$(CONFIG_USB_VICAM) += vicam.o
5   -obj-$(CONFIG_USB_QUICKCAM_MESSENGER) += quickcam_messenger.o
drivers/media/video/usbvideo/quickcam_messenger.c
View file @ 566789f
Changes suppressed. Click to show
1   -/*
2   - * Driver for Logitech Quickcam Messenger usb video camera
3   - * Copyright (C) Jaya Kumar
4   - *
5   - * This work was sponsored by CIS(M) Sdn Bhd.
6   - * History:
7   - * 05/08/2006 - Jaya Kumar
8   - * I wrote this based on the konicawc by Simon Evans.
9   - * -
10   - * Full credit for reverse engineering and creating an initial
11   - * working linux driver for the VV6422 goes to the qce-ga project by
12   - * Tuukka Toivonen, Jochen Hoenicke, Peter McConnell,
13   - * Cristiano De Michele, Georg Acher, Jean-Frederic Clere as well as
14   - * others.
15   - * ---
16   - * This program is free software; you can redistribute it and/or modify
17   - * it under the terms of the GNU General Public License as published by
18   - * the Free Software Foundation; either version 2 of the License, or
19   - * (at your option) any later version.
20   - *
21   - * This program is distributed in the hope that it will be useful,
22   - * but WITHOUT ANY WARRANTY; without even the implied warranty of
23   - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24   - * GNU General Public License for more details.
25   - *
26   - * You should have received a copy of the GNU General Public License
27   - * along with this program; if not, write to the Free Software
28   - * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
29   - *
30   - */
31   -
32   -#include <linux/kernel.h>
33   -#include <linux/module.h>
34   -#include <linux/init.h>
35   -#include <linux/input.h>
36   -#include <linux/usb/input.h>
37   -#include <linux/slab.h>
38   -
39   -#include "usbvideo.h"
40   -#include "quickcam_messenger.h"
41   -
42   -/*
43   - * Version Information
44   - */
45   -
46   -#ifdef CONFIG_USB_DEBUG
47   -static int debug;
48   -#define DEBUG(n, format, arg...) \
49   - if (n <= debug) { \
50   - printk(KERN_DEBUG __FILE__ ":%s(): " format "\n", __func__ , ## arg); \
51   - }
52   -#else
53   -#define DEBUG(n, arg...)
54   -static const int debug;
55   -#endif
56   -
57   -#define DRIVER_VERSION "v0.01"
58   -#define DRIVER_DESC "Logitech Quickcam Messenger USB"
59   -
60   -#define USB_LOGITECH_VENDOR_ID 0x046D
61   -#define USB_QCM_PRODUCT_ID 0x08F0
62   -
63   -#define MAX_CAMERAS 1
64   -
65   -#define MAX_COLOUR 32768
66   -#define MAX_HUE 32768
67   -#define MAX_BRIGHTNESS 32768
68   -#define MAX_CONTRAST 32768
69   -#define MAX_WHITENESS 32768
70   -
71   -static int size = SIZE_320X240;
72   -static int colour = MAX_COLOUR;
73   -static int hue = MAX_HUE;
74   -static int brightness = MAX_BRIGHTNESS;
75   -static int contrast = MAX_CONTRAST;
76   -static int whiteness = MAX_WHITENESS;
77   -
78   -static struct usbvideo *cams;
79   -
80   -static struct usb_device_id qcm_table [] = {
81   - { USB_DEVICE(USB_LOGITECH_VENDOR_ID, USB_QCM_PRODUCT_ID) },
82   - { }
83   -};
84   -MODULE_DEVICE_TABLE(usb, qcm_table);
85   -
86   -#ifdef CONFIG_INPUT
87   -static void qcm_register_input(struct qcm *cam, struct usb_device *dev)
88   -{
89   - struct input_dev *input_dev;
90   - int error;
91   -
92   - usb_make_path(dev, cam->input_physname, sizeof(cam->input_physname));
93   - strlcat(cam->input_physname, "/input0", sizeof(cam->input_physname));
94   -
95   - cam->input = input_dev = input_allocate_device();
96   - if (!input_dev) {
97   - dev_warn(&dev->dev, "insufficient mem for cam input device\n");
98   - return;
99   - }
100   -
101   - input_dev->name = "QCM button";
102   - input_dev->phys = cam->input_physname;
103   - usb_to_input_id(dev, &input_dev->id);
104   - input_dev->dev.parent = &dev->dev;
105   -
106   - input_dev->evbit[0] = BIT_MASK(EV_KEY);
107   - input_dev->keybit[BIT_WORD(KEY_CAMERA)] = BIT_MASK(KEY_CAMERA);
108   -
109   - error = input_register_device(cam->input);
110   - if (error) {
111   - dev_warn(&dev->dev,
112   - "Failed to register camera's input device, err: %d\n",
113   - error);
114   - input_free_device(cam->input);
115   - cam->input = NULL;
116   - }
117   -}
118   -
119   -static void qcm_unregister_input(struct qcm *cam)
120   -{
121   - if (cam->input) {
122   - input_unregister_device(cam->input);
123   - cam->input = NULL;
124   - }
125   -}
126   -
127   -static void qcm_report_buttonstat(struct qcm *cam)
128   -{
129   - if (cam->input) {
130   - input_report_key(cam->input, KEY_CAMERA, cam->button_sts);
131   - input_sync(cam->input);
132   - }
133   -}
134   -
135   -static void qcm_int_irq(struct urb *urb)
136   -{
137   - int ret;
138   - struct uvd *uvd = urb->context;
139   - struct qcm *cam;
140   -
141   - if (!CAMERA_IS_OPERATIONAL(uvd))
142   - return;
143   -
144   - if (!uvd->streaming)
145   - return;
146   -
147   - uvd->stats.urb_count++;
148   -
149   - if (urb->status < 0)
150   - uvd->stats.iso_err_count++;
151   - else {
152   - if (urb->actual_length > 0 ) {
153   - cam = (struct qcm *) uvd->user_data;
154   - if (cam->button_sts_buf == 0x88)
155   - cam->button_sts = 0x0;
156   - else if (cam->button_sts_buf == 0x80)
157   - cam->button_sts = 0x1;
158   - qcm_report_buttonstat(cam);
159   - }
160   - }
161   -
162   - ret = usb_submit_urb(urb, GFP_ATOMIC);
163   - if (ret < 0)
164   - err("usb_submit_urb error (%d)", ret);
165   -}
166   -
167   -static int qcm_setup_input_int(struct qcm *cam, struct uvd *uvd)
168   -{
169   - int errflag;
170   - usb_fill_int_urb(cam->button_urb, uvd->dev,
171   - usb_rcvintpipe(uvd->dev, uvd->video_endp + 1),
172   - &cam->button_sts_buf,
173   - 1,
174   - qcm_int_irq,
175   - uvd, 16);
176   -
177   - errflag = usb_submit_urb(cam->button_urb, GFP_KERNEL);
178   - if (errflag)
179   - err ("usb_submit_int ret %d", errflag);
180   - return errflag;
181   -}
182   -
183   -static void qcm_stop_int_data(struct qcm *cam)
184   -{
185   - usb_kill_urb(cam->button_urb);
186   -}
187   -
188   -static int qcm_alloc_int_urb(struct qcm *cam)
189   -{
190   - cam->button_urb = usb_alloc_urb(0, GFP_KERNEL);
191   -
192   - if (!cam->button_urb)
193   - return -ENOMEM;
194   -
195   - return 0;
196   -}
197   -
198   -static void qcm_free_int(struct qcm *cam)
199   -{
200   - usb_free_urb(cam->button_urb);
201   -}
202   -#endif /* CONFIG_INPUT */
203   -
204   -static int qcm_stv_setb(struct usb_device *dev, u16 reg, u8 val)
205   -{
206   - int ret;
207   -
208   - /* we'll wait up to 3 slices but no more */
209   - ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
210   - 0x04, USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
211   - reg, 0, &val, 1, 3*HZ);
212   - return ret;
213   -}
214   -
215   -static int qcm_stv_setw(struct usb_device *dev, u16 reg, __le16 val)
216   -{
217   - int ret;
218   -
219   - /* we'll wait up to 3 slices but no more */
220   - ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
221   - 0x04, USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
222   - reg, 0, &val, 2, 3*HZ);
223   - return ret;
224   -}
225   -
226   -static int qcm_stv_getw(struct usb_device *dev, unsigned short reg,
227   - __le16 *val)
228   -{
229   - int ret;
230   -
231   - /* we'll wait up to 3 slices but no more */
232   - ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
233   - 0x04, USB_TYPE_VENDOR | USB_DIR_IN | USB_RECIP_DEVICE,
234   - reg, 0, val, 2, 3*HZ);
235   - return ret;
236   -}
237   -
238   -static int qcm_camera_on(struct uvd *uvd)
239   -{
240   - int ret;
241   - CHECK_RET(ret, qcm_stv_setb(uvd->dev, STV_ISO_ENABLE, 0x01));
242   - return 0;
243   -}
244   -
245   -static int qcm_camera_off(struct uvd *uvd)
246   -{
247   - int ret;
248   - CHECK_RET(ret, qcm_stv_setb(uvd->dev, STV_ISO_ENABLE, 0x00));
249   - return 0;
250   -}
251   -
252   -static void qcm_hsv2rgb(u16 hue, u16 sat, u16 val, u16 *r, u16 *g, u16 *b)
253   -{
254   - unsigned int segment, valsat;
255   - signed int h = (signed int) hue;
256   - unsigned int s = (sat - 32768) * 2; /* rescale */
257   - unsigned int v = val;
258   - unsigned int p;
259   -
260   - /*
261   - the registers controlling gain are 8 bit of which
262   - we affect only the last 4 bits with our gain.
263   - we know that if saturation is 0, (unsaturated) then
264   - we're grayscale (center axis of the colour cone) so
265   - we set rgb=value. we use a formula obtained from
266   - wikipedia to map the cone to the RGB plane. it's
267   - as follows for the human value case of h=0..360,
268   - s=0..1, v=0..1
269   - h_i = h/60 % 6 , f = h/60 - h_i , p = v(1-s)
270   - q = v(1 - f*s) , t = v(1 - (1-f)s)
271   - h_i==0 => r=v , g=t, b=p
272   - h_i==1 => r=q , g=v, b=p
273   - h_i==2 => r=p , g=v, b=t
274   - h_i==3 => r=p , g=q, b=v
275   - h_i==4 => r=t , g=p, b=v
276   - h_i==5 => r=v , g=p, b=q
277   - the bottom side (the point) and the stuff just up
278   - of that is black so we simplify those two cases.
279   - */
280   - if (sat < 32768) {
281   - /* anything less than this is unsaturated */
282   - *r = val;
283   - *g = val;
284   - *b = val;
285   - return;
286   - }
287   - if (val <= (0xFFFF/8)) {
288   - /* anything less than this is black */
289   - *r = 0;
290   - *g = 0;
291   - *b = 0;
292   - return;
293   - }
294   -
295   - /* the rest of this code is copying tukkat's
296   - implementation of the hsv2rgb conversion as taken
297   - from qc-usb-messenger code. the 10923 is 0xFFFF/6
298   - to divide the cone into 6 sectors. */
299   -
300   - segment = (h + 10923) & 0xFFFF;
301   - segment = segment*3 >> 16; /* 0..2: 0=R, 1=G, 2=B */
302   - hue -= segment * 21845; /* -10923..10923 */
303   - h = hue;
304   - h *= 3;
305   - valsat = v*s >> 16; /* 0..65534 */
306   - p = v - valsat;
307   - if (h >= 0) {
308   - unsigned int t = v - (valsat * (32769 - h) >> 15);
309   - switch (segment) {
310   - case 0: /* R-> */
311   - *r = v;
312   - *g = t;
313   - *b = p;
314   - break;
315   - case 1: /* G-> */
316   - *r = p;
317   - *g = v;
318   - *b = t;
319   - break;
320   - case 2: /* B-> */
321   - *r = t;
322   - *g = p;
323   - *b = v;
324   - break;
325   - }
326   - } else {
327   - unsigned int q = v - (valsat * (32769 + h) >> 15);
328   - switch (segment) {
329   - case 0: /* ->R */
330   - *r = v;
331   - *g = p;
332   - *b = q;
333   - break;
334   - case 1: /* ->G */
335   - *r = q;
336   - *g = v;
337   - *b = p;
338   - break;
339   - case 2: /* ->B */
340   - *r = p;
341   - *g = q;
342   - *b = v;
343   - break;
344   - }
345   - }
346   -}
347   -
348   -static int qcm_sensor_set_gains(struct uvd *uvd, u16 hue,
349   - u16 saturation, u16 value)
350   -{
351   - int ret;
352   - u16 r=0,g=0,b=0;
353   -
354   - /* this code is based on qc-usb-messenger */
355   - qcm_hsv2rgb(hue, saturation, value, &r, &g, &b);
356   -
357   - r >>= 12;
358   - g >>= 12;
359   - b >>= 12;
360   -
361   - /* min val is 8 */
362   - r = max((u16) 8, r);
363   - g = max((u16) 8, g);
364   - b = max((u16) 8, b);
365   -
366   - r |= 0x30;
367   - g |= 0x30;
368   - b |= 0x30;
369   -
370   - /* set the r,g,b gain registers */
371   - CHECK_RET(ret, qcm_stv_setb(uvd->dev, 0x0509, r));
372   - CHECK_RET(ret, qcm_stv_setb(uvd->dev, 0x050A, g));
373   - CHECK_RET(ret, qcm_stv_setb(uvd->dev, 0x050B, b));
374   -
375   - /* doing as qc-usb did */
376   - CHECK_RET(ret, qcm_stv_setb(uvd->dev, 0x050C, 0x2A));
377   - CHECK_RET(ret, qcm_stv_setb(uvd->dev, 0x050D, 0x01));
378   - CHECK_RET(ret, qcm_stv_setb(uvd->dev, 0x143F, 0x01));
379   -
380   - return 0;
381   -}
382   -
383   -static int qcm_sensor_set_exposure(struct uvd *uvd, int exposure)
384   -{
385   - int ret;
386   - int formedval;
387   -
388   - /* calculation was from qc-usb-messenger driver */
389   - formedval = ( exposure >> 12 );
390   -
391   - /* max value for formedval is 14 */
392   - formedval = min(formedval, 14);
393   -
394   - CHECK_RET(ret, qcm_stv_setb(uvd->dev,
395   - 0x143A, 0xF0 | formedval));
396   - CHECK_RET(ret, qcm_stv_setb(uvd->dev, 0x143F, 0x01));
397   - return 0;
398   -}
399   -
400   -static int qcm_sensor_setlevels(struct uvd *uvd, int brightness, int contrast,
401   - int hue, int colour)
402   -{
403   - int ret;
404   - /* brightness is exposure, contrast is gain, colour is saturation */
405   - CHECK_RET(ret,
406   - qcm_sensor_set_exposure(uvd, brightness));
407   - CHECK_RET(ret, qcm_sensor_set_gains(uvd, hue, colour, contrast));
408   -
409   - return 0;
410   -}
411   -
412   -static int qcm_sensor_setsize(struct uvd *uvd, u8 size)
413   -{
414   - int ret;
415   -
416   - CHECK_RET(ret, qcm_stv_setb(uvd->dev, 0x1505, size));
417   - return 0;
418   -}
419   -
420   -static int qcm_sensor_set_shutter(struct uvd *uvd, int whiteness)
421   -{
422   - int ret;
423   - /* some rescaling as done by the qc-usb-messenger code */
424   - if (whiteness > 0xC000)
425   - whiteness = 0xC000 + (whiteness & 0x3FFF)*8;
426   -
427   - CHECK_RET(ret, qcm_stv_setb(uvd->dev, 0x143D,
428   - (whiteness >> 8) & 0xFF));
429   - CHECK_RET(ret, qcm_stv_setb(uvd->dev, 0x143E,
430   - (whiteness >> 16) & 0x03));
431   - CHECK_RET(ret, qcm_stv_setb(uvd->dev, 0x143F, 0x01));
432   -
433   - return 0;
434   -}
435   -
436   -static int qcm_sensor_init(struct uvd *uvd)
437   -{
438   - struct qcm *cam = (struct qcm *) uvd->user_data;
439   - int ret;
440   - int i;
441   -
442   - for (i=0; i < ARRAY_SIZE(regval_table) ; i++) {
443   - CHECK_RET(ret, qcm_stv_setb(uvd->dev,
444   - regval_table[i].reg,
445   - regval_table[i].val));
446   - }
447   -
448   - CHECK_RET(ret, qcm_stv_setw(uvd->dev, 0x15c1,
449   - cpu_to_le16(ISOC_PACKET_SIZE)));
450   - CHECK_RET(ret, qcm_stv_setb(uvd->dev, 0x15c3, 0x08));
451   - CHECK_RET(ret, qcm_stv_setb(uvd->dev, 0x143f, 0x01));
452   -
453   - CHECK_RET(ret, qcm_stv_setb(uvd->dev, STV_ISO_ENABLE, 0x00));
454   -
455   - CHECK_RET(ret, qcm_sensor_setsize(uvd, camera_sizes[cam->size].cmd));
456   -
457   - CHECK_RET(ret, qcm_sensor_setlevels(uvd, uvd->vpic.brightness,
458   - uvd->vpic.contrast, uvd->vpic.hue, uvd->vpic.colour));
459   -
460   - CHECK_RET(ret, qcm_sensor_set_shutter(uvd, uvd->vpic.whiteness));
461   - CHECK_RET(ret, qcm_sensor_setsize(uvd, camera_sizes[cam->size].cmd));
462   -
463   - return 0;
464   -}
465   -
466   -static int qcm_set_camera_size(struct uvd *uvd)
467   -{
468   - int ret;
469   - struct qcm *cam = (struct qcm *) uvd->user_data;
470   -
471   - CHECK_RET(ret, qcm_sensor_setsize(uvd, camera_sizes[cam->size].cmd));
472   - cam->width = camera_sizes[cam->size].width;
473   - cam->height = camera_sizes[cam->size].height;
474   - uvd->videosize = VIDEOSIZE(cam->width, cam->height);
475   -
476   - return 0;
477   -}
478   -
479   -static int qcm_setup_on_open(struct uvd *uvd)
480   -{
481   - int ret;
482   -
483   - CHECK_RET(ret, qcm_sensor_set_gains(uvd, uvd->vpic.hue,
484   - uvd->vpic.colour, uvd->vpic.contrast));
485   - CHECK_RET(ret, qcm_sensor_set_exposure(uvd, uvd->vpic.brightness));
486   - CHECK_RET(ret, qcm_sensor_set_shutter(uvd, uvd->vpic.whiteness));
487   - CHECK_RET(ret, qcm_set_camera_size(uvd));
488   - CHECK_RET(ret, qcm_camera_on(uvd));
489   - return 0;
490   -}
491   -
492   -static void qcm_adjust_picture(struct uvd *uvd)
493   -{
494   - int ret;
495   - struct qcm *cam = (struct qcm *) uvd->user_data;
496   -
497   - ret = qcm_camera_off(uvd);
498   - if (ret) {
499   - err("can't turn camera off. abandoning pic adjustment");
500   - return;
501   - }
502   -
503   - /* if there's been a change in contrast, hue, or
504   - colour then we need to recalculate hsv in order
505   - to update gains */
506   - if ((cam->contrast != uvd->vpic.contrast) ||
507   - (cam->hue != uvd->vpic.hue) ||
508   - (cam->colour != uvd->vpic.colour)) {
509   - cam->contrast = uvd->vpic.contrast;
510   - cam->hue = uvd->vpic.hue;
511   - cam->colour = uvd->vpic.colour;
512   - ret = qcm_sensor_set_gains(uvd, cam->hue, cam->colour,
513   - cam->contrast);
514   - if (ret) {
515   - err("can't set gains. abandoning pic adjustment");
516   - return;
517   - }
518   - }
519   -
520   - if (cam->brightness != uvd->vpic.brightness) {
521   - cam->brightness = uvd->vpic.brightness;
522   - ret = qcm_sensor_set_exposure(uvd, cam->brightness);
523   - if (ret) {
524   - err("can't set exposure. abandoning pic adjustment");
525   - return;
526   - }
527   - }
528   -
529   - if (cam->whiteness != uvd->vpic.whiteness) {
530   - cam->whiteness = uvd->vpic.whiteness;
531   - qcm_sensor_set_shutter(uvd, cam->whiteness);
532   - if (ret) {
533   - err("can't set shutter. abandoning pic adjustment");
534   - return;
535   - }
536   - }
537   -
538   - ret = qcm_camera_on(uvd);
539   - if (ret) {
540   - err("can't reenable camera. pic adjustment failed");
541   - return;
542   - }
543   -}
544   -
545   -static int qcm_process_frame(struct uvd *uvd, u8 *cdata, int framelen)
546   -{
547   - int datalen;
548   - int totaldata;
549   - struct framehdr {
550   - __be16 id;
551   - __be16 len;
552   - };
553   - struct framehdr *fhdr;
554   -
555   - totaldata = 0;
556   - while (framelen) {
557   - fhdr = (struct framehdr *) cdata;
558   - datalen = be16_to_cpu(fhdr->len);
559   - framelen -= 4;
560   - cdata += 4;
561   -
562   - if ((fhdr->id) == cpu_to_be16(0x8001)) {
563   - RingQueue_Enqueue(&uvd->dp, marker, 4);
564   - totaldata += 4;
565   - continue;
566   - }
567   - if ((fhdr->id & cpu_to_be16(0xFF00)) == cpu_to_be16(0x0200)) {
568   - RingQueue_Enqueue(&uvd->dp, cdata, datalen);
569   - totaldata += datalen;
570   - }
571   - framelen -= datalen;
572   - cdata += datalen;
573   - }
574   - return totaldata;
575   -}
576   -
577   -static int qcm_compress_iso(struct uvd *uvd, struct urb *dataurb)
578   -{
579   - int totlen;
580   - int i;
581   - unsigned char *cdata;
582   -
583   - totlen=0;
584   - for (i = 0; i < dataurb->number_of_packets; i++) {
585   - int n = dataurb->iso_frame_desc[i].actual_length;
586   - int st = dataurb->iso_frame_desc[i].status;
587   -
588   - cdata = dataurb->transfer_buffer +
589   - dataurb->iso_frame_desc[i].offset;
590   -
591   - if (st < 0) {
592   - dev_warn(&uvd->dev->dev,
593   - "Data error: packet=%d. len=%d. status=%d.\n",
594   - i, n, st);
595   - uvd->stats.iso_err_count++;
596   - continue;
597   - }
598   - if (!n)
599   - continue;
600   -
601   - totlen += qcm_process_frame(uvd, cdata, n);
602   - }
603   - return totlen;
604   -}
605   -
606   -static void resubmit_urb(struct uvd *uvd, struct urb *urb)
607   -{
608   - int ret;
609   -
610   - urb->dev = uvd->dev;
611   - ret = usb_submit_urb(urb, GFP_ATOMIC);
612   - if (ret)
613   - err("usb_submit_urb error (%d)", ret);
614   -}
615   -
616   -static void qcm_isoc_irq(struct urb *urb)
617   -{
618   - int len;
619   - struct uvd *uvd = urb->context;
620   -
621   - if (!CAMERA_IS_OPERATIONAL(uvd))
622   - return;
623   -
624   - if (!uvd->streaming)
625   - return;
626   -
627   - uvd->stats.urb_count++;
628   -
629   - if (!urb->actual_length) {
630   - resubmit_urb(uvd, urb);
631   - return;
632   - }
633   -
634   - len = qcm_compress_iso(uvd, urb);
635   - resubmit_urb(uvd, urb);
636   - uvd->stats.urb_length = len;
637   - uvd->stats.data_count += len;
638   - if (len)
639   - RingQueue_WakeUpInterruptible(&uvd->dp);
640   -}
641   -
642   -static int qcm_start_data(struct uvd *uvd)
643   -{
644   - struct qcm *cam = (struct qcm *) uvd->user_data;
645   - int i;
646   - int errflag;
647   - int pktsz;
648   - int err;
649   -
650   - pktsz = uvd->iso_packet_len;
651   - if (!CAMERA_IS_OPERATIONAL(uvd)) {
652   - err("Camera is not operational");
653   - return -EFAULT;
654   - }
655   -
656   - err = usb_set_interface(uvd->dev, uvd->iface, uvd->ifaceAltActive);
657   - if (err < 0) {
658   - err("usb_set_interface error");
659   - uvd->last_error = err;
660   - return -EBUSY;
661   - }
662   -
663   - for (i=0; i < USBVIDEO_NUMSBUF; i++) {
664   - int j, k;
665   - struct urb *urb = uvd->sbuf[i].urb;
666   - urb->dev = uvd->dev;
667   - urb->context = uvd;
668   - urb->pipe = usb_rcvisocpipe(uvd->dev, uvd->video_endp);
669   - urb->interval = 1;
670   - urb->transfer_flags = URB_ISO_ASAP;
671   - urb->transfer_buffer = uvd->sbuf[i].data;
672   - urb->complete = qcm_isoc_irq;
673   - urb->number_of_packets = FRAMES_PER_DESC;
674   - urb->transfer_buffer_length = pktsz * FRAMES_PER_DESC;
675   - for (j=k=0; j < FRAMES_PER_DESC; j++, k += pktsz) {
676   - urb->iso_frame_desc[j].offset = k;
677   - urb->iso_frame_desc[j].length = pktsz;
678   - }
679   - }
680   -
681   - uvd->streaming = 1;
682   - uvd->curframe = -1;
683   - for (i=0; i < USBVIDEO_NUMSBUF; i++) {
684   - errflag = usb_submit_urb(uvd->sbuf[i].urb, GFP_KERNEL);
685   - if (errflag)
686   - err ("usb_submit_isoc(%d) ret %d", i, errflag);
687   - }
688   -
689   - CHECK_RET(err, qcm_setup_input_int(cam, uvd));
690   - CHECK_RET(err, qcm_camera_on(uvd));
691   - return 0;
692   -}
693   -
694   -static void qcm_stop_data(struct uvd *uvd)
695   -{
696   - struct qcm *cam;
697   - int i, j;
698   - int ret;
699   -
700   - if ((uvd == NULL) || (!uvd->streaming) || (uvd->dev == NULL))
701   - return;
702   - cam = (struct qcm *) uvd->user_data;
703   -
704   - ret = qcm_camera_off(uvd);
705   - if (ret)
706   - dev_warn(&uvd->dev->dev, "couldn't turn the cam off.\n");
707   -
708   - uvd->streaming = 0;
709   -
710   - /* Unschedule all of the iso td's */
711   - for (i=0; i < USBVIDEO_NUMSBUF; i++)
712   - usb_kill_urb(uvd->sbuf[i].urb);
713   -
714   - qcm_stop_int_data(cam);
715   -
716   - if (!uvd->remove_pending) {
717   - /* Set packet size to 0 */
718   - j = usb_set_interface(uvd->dev, uvd->iface,
719   - uvd->ifaceAltInactive);
720   - if (j < 0) {
721   - err("usb_set_interface() error %d.", j);
722   - uvd->last_error = j;
723   - }
724   - }
725   -}
726   -
727   -static void qcm_process_isoc(struct uvd *uvd, struct usbvideo_frame *frame)
728   -{
729   - struct qcm *cam = (struct qcm *) uvd->user_data;
730   - int x;
731   - struct rgb *rgbL0;
732   - struct rgb *rgbL1;
733   - struct bayL0 *bayL0;
734   - struct bayL1 *bayL1;
735   - int hor,ver,hordel,verdel;
736   - assert(frame != NULL);
737   -
738   - switch (cam->size) {
739   - case SIZE_160X120:
740   - hor = 162; ver = 124; hordel = 1; verdel = 2;
741   - break;
742   - case SIZE_320X240:
743   - default:
744   - hor = 324; ver = 248; hordel = 2; verdel = 4;
745   - break;
746   - }
747   -
748   - if (frame->scanstate == ScanState_Scanning) {
749   - while (RingQueue_GetLength(&uvd->dp) >=
750   - 4 + (hor*verdel + hordel)) {
751   - if ((RING_QUEUE_PEEK(&uvd->dp, 0) == 0x00) &&
752   - (RING_QUEUE_PEEK(&uvd->dp, 1) == 0xff) &&
753   - (RING_QUEUE_PEEK(&uvd->dp, 2) == 0x00) &&
754   - (RING_QUEUE_PEEK(&uvd->dp, 3) == 0xff)) {
755   - frame->curline = 0;
756   - frame->scanstate = ScanState_Lines;
757   - frame->frameState = FrameState_Grabbing;
758   - RING_QUEUE_DEQUEUE_BYTES(&uvd->dp, 4);
759   - /*
760   - * if we're starting, we need to discard the first
761   - * 4 lines of y bayer data
762   - * and the first 2 gr elements of x bayer data
763   - */
764   - RING_QUEUE_DEQUEUE_BYTES(&uvd->dp,
765   - (hor*verdel + hordel));
766   - break;
767   - }
768   - RING_QUEUE_DEQUEUE_BYTES(&uvd->dp, 1);
769   - }
770   - }
771   -
772   - if (frame->scanstate == ScanState_Scanning)
773   - return;
774   -
775   - /* now we can start processing bayer data so long as we have at least
776   - * 2 lines worth of data. this is the simplest demosaicing method that
777   - * I could think of. I use each 2x2 bayer element without interpolation
778   - * to generate 4 rgb pixels.
779   - */
780   - while ( frame->curline < cam->height &&
781   - (RingQueue_GetLength(&uvd->dp) >= hor*2)) {
782   - /* get 2 lines of bayer for demosaicing
783   - * into 2 lines of RGB */
784   - RingQueue_Dequeue(&uvd->dp, cam->scratch, hor*2);
785   - bayL0 = (struct bayL0 *) cam->scratch;
786   - bayL1 = (struct bayL1 *) (cam->scratch + hor);
787   - /* frame->curline is the rgb y line */
788   - rgbL0 = (struct rgb *)
789   - ( frame->data + (cam->width*3*frame->curline));
790   - /* w/2 because we're already doing 2 pixels */
791   - rgbL1 = rgbL0 + (cam->width/2);
792   -
793   - for (x=0; x < cam->width; x+=2) {
794   - rgbL0->r = bayL0->r;
795   - rgbL0->g = bayL0->g;
796   - rgbL0->b = bayL1->b;
797   -
798   - rgbL0->r2 = bayL0->r;
799   - rgbL0->g2 = bayL1->g;
800   - rgbL0->b2 = bayL1->b;
801   -
802   - rgbL1->r = bayL0->r;
803   - rgbL1->g = bayL1->g;
804   - rgbL1->b = bayL1->b;
805   -
806   - rgbL1->r2 = bayL0->r;
807   - rgbL1->g2 = bayL1->g;
808   - rgbL1->b2 = bayL1->b;
809   -
810   - rgbL0++;
811   - rgbL1++;
812   -
813   - bayL0++;
814   - bayL1++;
815   - }
816   -
817   - frame->seqRead_Length += cam->width*3*2;
818   - frame->curline += 2;
819   - }
820   - /* See if we filled the frame */
821   - if (frame->curline == cam->height) {
822   - frame->frameState = FrameState_Done_Hold;
823   - frame->curline = 0;
824   - uvd->curframe = -1;
825   - uvd->stats.frame_num++;
826   - }
827   -}
828   -
829   -/* taken from konicawc */
830   -static int qcm_set_video_mode(struct uvd *uvd, struct video_window *vw)
831   -{
832   - int ret;
833   - int newsize;
834   - int oldsize;
835   - int x = vw->width;
836   - int y = vw->height;
837   - struct qcm *cam = (struct qcm *) uvd->user_data;
838   -
839   - if (x > 0 && y > 0) {
840   - DEBUG(2, "trying to find size %d,%d", x, y);
841   - for (newsize = 0; newsize <= MAX_FRAME_SIZE; newsize++) {
842   - if ((camera_sizes[newsize].width == x) &&
843   - (camera_sizes[newsize].height == y))
844   - break;
845   - }
846   - } else
847   - newsize = cam->size;
848   -
849   - if (newsize > MAX_FRAME_SIZE) {
850   - DEBUG(1, "couldn't find size %d,%d", x, y);
851   - return -EINVAL;
852   - }
853   -
854   - if (newsize == cam->size) {
855   - DEBUG(1, "Nothing to do");
856   - return 0;
857   - }
858   -
859   - qcm_stop_data(uvd);
860   -
861   - if (cam->size != newsize) {
862   - oldsize = cam->size;
863   - cam->size = newsize;
864   - ret = qcm_set_camera_size(uvd);
865   - if (ret) {
866   - err("Couldn't set camera size, err=%d",ret);
867   - /* restore the original size */
868   - cam->size = oldsize;
869   - return ret;
870   - }
871   - }
872   -
873   - /* Flush the input queue and clear any current frame in progress */
874   -
875   - RingQueue_Flush(&uvd->dp);
876   - if (uvd->curframe != -1) {
877   - uvd->frame[uvd->curframe].curline = 0;
878   - uvd->frame[uvd->curframe].seqRead_Length = 0;
879   - uvd->frame[uvd->curframe].seqRead_Index = 0;
880   - }
881   -
882   - CHECK_RET(ret, qcm_start_data(uvd));
883   - return 0;
884   -}
885   -
886   -static int qcm_configure_video(struct uvd *uvd)
887   -{
888   - int ret;
889   - memset(&uvd->vpic, 0, sizeof(uvd->vpic));
890   - memset(&uvd->vpic_old, 0x55, sizeof(uvd->vpic_old));
891   -
892   - uvd->vpic.colour = colour;
893   - uvd->vpic.hue = hue;
894   - uvd->vpic.brightness = brightness;
895   - uvd->vpic.contrast = contrast;
896   - uvd->vpic.whiteness = whiteness;
897   - uvd->vpic.depth = 24;
898   - uvd->vpic.palette = VIDEO_PALETTE_RGB24;
899   -
900   - memset(&uvd->vcap, 0, sizeof(uvd->vcap));
901   - strcpy(uvd->vcap.name, "QCM USB Camera");
902   - uvd->vcap.type = VID_TYPE_CAPTURE;
903   - uvd->vcap.channels = 1;
904   - uvd->vcap.audios = 0;
905   -
906   - uvd->vcap.minwidth = camera_sizes[SIZE_160X120].width;
907   - uvd->vcap.minheight = camera_sizes[SIZE_160X120].height;
908   - uvd->vcap.maxwidth = camera_sizes[SIZE_320X240].width;
909   - uvd->vcap.maxheight = camera_sizes[SIZE_320X240].height;
910   -
911   - memset(&uvd->vchan, 0, sizeof(uvd->vchan));
912   - uvd->vchan.flags = 0 ;
913   - uvd->vchan.tuners = 0;
914   - uvd->vchan.channel = 0;
915   - uvd->vchan.type = VIDEO_TYPE_CAMERA;
916   - strcpy(uvd->vchan.name, "Camera");
917   -
918   - CHECK_RET(ret, qcm_sensor_init(uvd));
919   - return 0;
920   -}
921   -
922   -static int qcm_probe(struct usb_interface *intf,
923   - const struct usb_device_id *devid)
924   -{
925   - int err;
926   - struct uvd *uvd;
927   - struct usb_device *dev = interface_to_usbdev(intf);
928   - struct qcm *cam;
929   - size_t buffer_size;
930   - unsigned char video_ep;
931   - struct usb_host_interface *interface;
932   - struct usb_endpoint_descriptor *endpoint;
933   - int i,j;
934   - unsigned int ifacenum, ifacenum_inact=0;
935   - __le16 sensor_id;
936   -
937   - /* we don't support multiconfig cams */
938   - if (dev->descriptor.bNumConfigurations != 1)
939   - return -ENODEV;
940   -
941   - /* first check for the video interface and not
942   - * the audio interface */
943   - interface = &intf->cur_altsetting[0];
944   - if ((interface->desc.bInterfaceClass != USB_CLASS_VENDOR_SPEC)
945   - || (interface->desc.bInterfaceSubClass !=
946   - USB_CLASS_VENDOR_SPEC))
947   - return -ENODEV;
948   -
949   - /*
950   - walk through each endpoint in each setting in the interface
951   - stop when we find the one that's an isochronous IN endpoint.
952   - */
953   - for (i=0; i < intf->num_altsetting; i++) {
954   - interface = &intf->cur_altsetting[i];
955   - ifacenum = interface->desc.bAlternateSetting;
956   - /* walk the end points */
957   - for (j=0; j < interface->desc.bNumEndpoints; j++) {
958   - endpoint = &interface->endpoint[j].desc;
959   -
960   - if (usb_endpoint_dir_out(endpoint))
961   - continue; /* not input then not good */
962   -
963   - buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
964   - if (!buffer_size) {
965   - ifacenum_inact = ifacenum;
966   - continue; /* 0 pkt size is not what we want */
967   - }
968   -
969   - if (usb_endpoint_xfer_isoc(endpoint)) {
970   - video_ep = endpoint->bEndpointAddress;
971   - /* break out of the search */
972   - goto good_videoep;
973   - }
974   - }
975   - }
976   - /* failed out since nothing useful was found */
977   - err("No suitable endpoint was found\n");
978   - return -ENODEV;
979   -
980   -good_videoep:
981   - /* disable isochronous stream before doing anything else */
982   - err = qcm_stv_setb(dev, STV_ISO_ENABLE, 0);
983   - if (err < 0) {
984   - err("Failed to disable sensor stream");
985   - return -EIO;
986   - }
987   -
988   - /*
989   - Check that this is the same unknown sensor that is known to work. This
990   - sensor is suspected to be the ST VV6422C001. I'll check the same value
991   - that the qc-usb driver checks. This value is probably not even the
992   - sensor ID since it matches the USB dev ID. Oh well. If it doesn't
993   - match, it's probably a diff sensor so exit and apologize.
994   - */
995   - err = qcm_stv_getw(dev, CMOS_SENSOR_IDREV, &sensor_id);
996   - if (err < 0) {
997   - err("Couldn't read sensor values. Err %d\n",err);
998   - return err;
999   - }
1000   - if (sensor_id != cpu_to_le16(0x08F0)) {
1001   - err("Sensor ID %x != %x. Unsupported. Sorry\n",
1002   - le16_to_cpu(sensor_id), (0x08F0));
1003   - return -ENODEV;
1004   - }
1005   -
1006   - uvd = usbvideo_AllocateDevice(cams);
1007   - if (!uvd)
1008   - return -ENOMEM;
1009   -
1010   - cam = (struct qcm *) uvd->user_data;
1011   -
1012   - /* buf for doing demosaicing */
1013   - cam->scratch = kmalloc(324*2, GFP_KERNEL);
1014   - if (!cam->scratch) /* uvd freed in dereg */
1015   - return -ENOMEM;
1016   -
1017   - /* yes, if we fail after here, cam->scratch gets freed
1018   - by qcm_free_uvd */
1019   -
1020   - err = qcm_alloc_int_urb(cam);
1021   - if (err < 0)
1022   - return err;
1023   -
1024   - /* yes, if we fail after here, int urb gets freed
1025   - by qcm_free_uvd */
1026   -
1027   - RESTRICT_TO_RANGE(size, SIZE_160X120, SIZE_320X240);
1028   - cam->width = camera_sizes[size].width;
1029   - cam->height = camera_sizes[size].height;
1030   - cam->size = size;
1031   -
1032   - uvd->debug = debug;
1033   - uvd->flags = 0;
1034   - uvd->dev = dev;
1035   - uvd->iface = intf->altsetting->desc.bInterfaceNumber;
1036   - uvd->ifaceAltActive = ifacenum;
1037   - uvd->ifaceAltInactive = ifacenum_inact;
1038   - uvd->video_endp = video_ep;
1039   - uvd->iso_packet_len = buffer_size;
1040   - uvd->paletteBits = 1L << VIDEO_PALETTE_RGB24;
1041   - uvd->defaultPalette = VIDEO_PALETTE_RGB24;
1042   - uvd->canvas = VIDEOSIZE(320, 240);
1043   - uvd->videosize = VIDEOSIZE(cam->width, cam->height);
1044   - err = qcm_configure_video(uvd);
1045   - if (err) {
1046   - err("failed to configure video settings");
1047   - return err;
1048   - }
1049   -
1050   - err = usbvideo_RegisterVideoDevice(uvd);
1051   - if (err) { /* the uvd gets freed in Deregister */
1052   - err("usbvideo_RegisterVideoDevice() failed.");
1053   - return err;
1054   - }
1055   -
1056   - uvd->max_frame_size = (320 * 240 * 3);
1057   - qcm_register_input(cam, dev);
1058   - usb_set_intfdata(intf, uvd);
1059   - return 0;
1060   -}
1061   -
1062   -static void qcm_free_uvd(struct uvd *uvd)
1063   -{
1064   - struct qcm *cam = (struct qcm *) uvd->user_data;
1065   -
1066   - kfree(cam->scratch);
1067   - qcm_unregister_input(cam);
1068   - qcm_free_int(cam);
1069   -}
1070   -
1071   -static struct usbvideo_cb qcm_driver = {
1072   - .probe = qcm_probe,
1073   - .setupOnOpen = qcm_setup_on_open,
1074   - .processData = qcm_process_isoc,
1075   - .setVideoMode = qcm_set_video_mode,
1076   - .startDataPump = qcm_start_data,
1077   - .stopDataPump = qcm_stop_data,
1078   - .adjustPicture = qcm_adjust_picture,
1079   - .userFree = qcm_free_uvd
1080   -};
1081   -
1082   -static int __init qcm_init(void)
1083   -{
1084   - printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
1085   - DRIVER_DESC "\n");
1086   -
1087   - return usbvideo_register(
1088   - &cams,
1089   - MAX_CAMERAS,
1090   - sizeof(struct qcm),
1091   - "QCM",
1092   - &qcm_driver,
1093   - THIS_MODULE,
1094   - qcm_table);
1095   -}
1096   -
1097   -static void __exit qcm_exit(void)
1098   -{
1099   - usbvideo_Deregister(&cams);
1100   -}
1101   -
1102   -module_param(size, int, 0);
1103   -MODULE_PARM_DESC(size, "Initial Size 0: 160x120 1: 320x240");
1104   -module_param(colour, int, 0);
1105   -MODULE_PARM_DESC(colour, "Initial colour");
1106   -module_param(hue, int, 0);
1107   -MODULE_PARM_DESC(hue, "Initial hue");
1108   -module_param(brightness, int, 0);
1109   -MODULE_PARM_DESC(brightness, "Initial brightness");
1110   -module_param(contrast, int, 0);
1111   -MODULE_PARM_DESC(contrast, "Initial contrast");
1112   -module_param(whiteness, int, 0);
1113   -MODULE_PARM_DESC(whiteness, "Initial whiteness");
1114   -
1115   -#ifdef CONFIG_USB_DEBUG
1116   -module_param(debug, int, S_IRUGO | S_IWUSR);
1117   -MODULE_PARM_DESC(debug, "Debug level: 0-9 (default=0)");
1118   -#endif
1119   -
1120   -module_init(qcm_init);
1121   -module_exit(qcm_exit);
1122   -
1123   -MODULE_LICENSE("GPL");
1124   -MODULE_AUTHOR("Jaya Kumar");
1125   -MODULE_DESCRIPTION("QCM USB Camera");
1126   -MODULE_SUPPORTED_DEVICE("QCM USB Camera");
drivers/media/video/usbvideo/quickcam_messenger.h
View file @ 566789f
1   -#ifndef quickcam_messenger_h
2   -#define quickcam_messenger_h
3   -
4   -#ifndef CONFIG_INPUT
5   -/* if we're not using input we dummy out these functions */
6   -#define qcm_register_input(...)
7   -#define qcm_unregister_input(...)
8   -#define qcm_report_buttonstat(...)
9   -#define qcm_setup_input_int(...) 0
10   -#define qcm_stop_int_data(...)
11   -#define qcm_alloc_int_urb(...) 0
12   -#define qcm_free_int(...)
13   -#endif
14   -
15   -
16   -#define CHECK_RET(ret, expr) \
17   - if ((ret = expr) < 0) return ret
18   -
19   -/* Control Registers for the STVV6422 ASIC
20   - * - this define is taken from the qc-usb-messenger code
21   - */
22   -#define STV_ISO_ENABLE 0x1440
23   -#define ISOC_PACKET_SIZE 1023
24   -
25   -/* Chip identification number including revision indicator */
26   -#define CMOS_SENSOR_IDREV 0xE00A
27   -
28   -struct rgb {
29   - u8 b;
30   - u8 g;
31   - u8 r;
32   - u8 b2;
33   - u8 g2;
34   - u8 r2;
35   -};
36   -
37   -struct bayL0 {
38   - u8 g;
39   - u8 r;
40   -};
41   -
42   -struct bayL1 {
43   - u8 b;
44   - u8 g;
45   -};
46   -
47   -struct cam_size {
48   - u16 width;
49   - u16 height;
50   - u8 cmd;
51   -};
52   -
53   -static const struct cam_size camera_sizes[] = {
54   - { 160, 120, 0xf },
55   - { 320, 240, 0x2 },
56   -};
57   -
58   -enum frame_sizes {
59   - SIZE_160X120 = 0,
60   - SIZE_320X240 = 1,
61   -};
62   -
63   -#define MAX_FRAME_SIZE SIZE_320X240
64   -
65   -struct qcm {
66   - u16 colour;
67   - u16 hue;
68   - u16 brightness;
69   - u16 contrast;
70   - u16 whiteness;
71   -
72   - u8 size;
73   - int height;
74   - int width;
75   - u8 *scratch;
76   - struct urb *button_urb;
77   - u8 button_sts;
78   - u8 button_sts_buf;
79   -
80   -#ifdef CONFIG_INPUT
81   - struct input_dev *input;
82   - char input_physname[64];
83   -#endif
84   -};
85   -
86   -struct regval {
87   - u16 reg;
88   - u8 val;
89   -};
90   -/* this table is derived from the
91   -qc-usb-messenger code */
92   -static const struct regval regval_table[] = {
93   - { STV_ISO_ENABLE, 0x00 },
94   - { 0x1436, 0x00 }, { 0x1432, 0x03 },
95   - { 0x143a, 0xF9 }, { 0x0509, 0x38 },
96   - { 0x050a, 0x38 }, { 0x050b, 0x38 },
97   - { 0x050c, 0x2A }, { 0x050d, 0x01 },
98   - { 0x1431, 0x00 }, { 0x1433, 0x34 },
99   - { 0x1438, 0x18 }, { 0x1439, 0x00 },
100   - { 0x143b, 0x05 }, { 0x143c, 0x00 },
101   - { 0x143e, 0x01 }, { 0x143d, 0x00 },
102   - { 0x1442, 0xe2 }, { 0x1500, 0xd0 },
103   - { 0x1500, 0xd0 }, { 0x1500, 0x50 },
104   - { 0x1501, 0xaf }, { 0x1502, 0xc2 },
105   - { 0x1503, 0x45 }, { 0x1505, 0x02 },
106   - { 0x150e, 0x8e }, { 0x150f, 0x37 },
107   - { 0x15c0, 0x00 },
108   -};
109   -
110   -static const unsigned char marker[] = { 0x00, 0xff, 0x00, 0xFF };
111   -
112   -#endif /* quickcam_messenger_h */