1 |
1275 |
phoenix |
/*
|
2 |
|
|
* konicawc.c - konica webcam driver
|
3 |
|
|
*
|
4 |
|
|
* Author: Simon Evans <spse@secret.org.uk>
|
5 |
|
|
*
|
6 |
|
|
* Copyright (C) 2002 Simon Evans
|
7 |
|
|
*
|
8 |
|
|
* Licence: GPL
|
9 |
|
|
*
|
10 |
|
|
* Driver for USB webcams based on Konica chipset. This
|
11 |
|
|
* chipset is used in Intel YC76 camera.
|
12 |
|
|
*
|
13 |
|
|
*/
|
14 |
|
|
|
15 |
|
|
#include <linux/kernel.h>
|
16 |
|
|
#include <linux/module.h>
|
17 |
|
|
#include <linux/init.h>
|
18 |
|
|
#include <linux/input.h>
|
19 |
|
|
|
20 |
|
|
#include "usbvideo.h"
|
21 |
|
|
|
22 |
|
|
#define MAX_BRIGHTNESS 108
|
23 |
|
|
#define MAX_CONTRAST 108
|
24 |
|
|
#define MAX_SATURATION 108
|
25 |
|
|
#define MAX_SHARPNESS 108
|
26 |
|
|
#define MAX_WHITEBAL 372
|
27 |
|
|
#define MAX_SPEED 6
|
28 |
|
|
|
29 |
|
|
|
30 |
|
|
#define MAX_CAMERAS 1
|
31 |
|
|
|
32 |
|
|
#define DRIVER_VERSION "v1.4"
|
33 |
|
|
#define DRIVER_DESC "Konica Webcam driver"
|
34 |
|
|
|
35 |
|
|
enum ctrl_req {
|
36 |
|
|
SetWhitebal = 0x01,
|
37 |
|
|
SetBrightness = 0x02,
|
38 |
|
|
SetSharpness = 0x03,
|
39 |
|
|
SetContrast = 0x04,
|
40 |
|
|
SetSaturation = 0x05,
|
41 |
|
|
};
|
42 |
|
|
|
43 |
|
|
|
44 |
|
|
enum frame_sizes {
|
45 |
|
|
SIZE_160X120 = 0,
|
46 |
|
|
SIZE_160X136 = 1,
|
47 |
|
|
SIZE_176X144 = 2,
|
48 |
|
|
SIZE_320X240 = 3,
|
49 |
|
|
|
50 |
|
|
};
|
51 |
|
|
|
52 |
|
|
#define MAX_FRAME_SIZE SIZE_320X240
|
53 |
|
|
|
54 |
|
|
static struct usbvideo *cams;
|
55 |
|
|
|
56 |
|
|
#ifdef CONFIG_USB_DEBUG
|
57 |
|
|
static int debug;
|
58 |
|
|
#define DEBUG(n, format, arg...) \
|
59 |
|
|
if (n <= debug) { \
|
60 |
|
|
printk(KERN_DEBUG __FILE__ ":%s(): " format "\n", __FUNCTION__ , ## arg); \
|
61 |
|
|
}
|
62 |
|
|
#else
|
63 |
|
|
#define DEBUG(n, arg...)
|
64 |
|
|
static const int debug = 0;
|
65 |
|
|
#endif
|
66 |
|
|
|
67 |
|
|
|
68 |
|
|
/* Some default values for inital camera settings,
|
69 |
|
|
can be set by modprobe */
|
70 |
|
|
|
71 |
|
|
static enum frame_sizes size;
|
72 |
|
|
static int speed = 6; /* Speed (fps) 0 (slowest) to 6 (fastest) */
|
73 |
|
|
static int brightness = MAX_BRIGHTNESS/2;
|
74 |
|
|
static int contrast = MAX_CONTRAST/2;
|
75 |
|
|
static int saturation = MAX_SATURATION/2;
|
76 |
|
|
static int sharpness = MAX_SHARPNESS/2;
|
77 |
|
|
static int whitebal = 3*(MAX_WHITEBAL/4);
|
78 |
|
|
|
79 |
|
|
static int spd_to_iface[] = { 1, 0, 3, 2, 4, 5, 6 };
|
80 |
|
|
|
81 |
|
|
/* These FPS speeds are from the windows config box. They are
|
82 |
|
|
* indexed on size (0-3) and speed (0-6). Divide by 3 to get the
|
83 |
|
|
* real fps.
|
84 |
|
|
*/
|
85 |
|
|
|
86 |
|
|
static int spd_to_fps[][7] = { { 24, 40, 48, 60, 72, 80, 100 },
|
87 |
|
|
{ 24, 40, 48, 60, 72, 80, 100 },
|
88 |
|
|
{ 18, 30, 36, 45, 54, 60, 75 },
|
89 |
|
|
{ 6, 10, 12, 15, 18, 21, 25 } };
|
90 |
|
|
|
91 |
|
|
struct cam_size {
|
92 |
|
|
u16 width;
|
93 |
|
|
u16 height;
|
94 |
|
|
u8 cmd;
|
95 |
|
|
};
|
96 |
|
|
|
97 |
|
|
static struct cam_size camera_sizes[] = { { 160, 120, 0x7 },
|
98 |
|
|
{ 160, 136, 0xa },
|
99 |
|
|
{ 176, 144, 0x4 },
|
100 |
|
|
{ 320, 240, 0x5 } };
|
101 |
|
|
|
102 |
|
|
struct konicawc {
|
103 |
|
|
u8 brightness; /* camera uses 0 - 9, x11 for real value */
|
104 |
|
|
u8 contrast; /* as above */
|
105 |
|
|
u8 saturation; /* as above */
|
106 |
|
|
u8 sharpness; /* as above */
|
107 |
|
|
u8 white_bal; /* 0 - 33, x11 for real value */
|
108 |
|
|
u8 speed; /* Stored as 0 - 6, used as index in spd_to_* (above) */
|
109 |
|
|
u8 size; /* Frame Size */
|
110 |
|
|
int height;
|
111 |
|
|
int width;
|
112 |
|
|
struct urb *sts_urb[USBVIDEO_NUMSBUF];
|
113 |
|
|
u8 sts_buf[USBVIDEO_NUMSBUF][FRAMES_PER_DESC];
|
114 |
|
|
struct urb *last_data_urb, *last_sts_urb;
|
115 |
|
|
int lastframe;
|
116 |
|
|
int cur_frame_size; /* number of bytes in current frame size */
|
117 |
|
|
int maxline; /* number of lines per frame */
|
118 |
|
|
int yplanesz; /* Number of bytes in the Y plane */
|
119 |
|
|
unsigned int buttonsts:1;
|
120 |
|
|
#ifdef CONFIG_INPUT
|
121 |
|
|
struct input_dev input;
|
122 |
|
|
#endif
|
123 |
|
|
};
|
124 |
|
|
|
125 |
|
|
|
126 |
|
|
#define konicawc_set_misc(uvd, req, value, index) konicawc_ctrl_msg(uvd, USB_DIR_OUT, req, value, index, NULL, 0)
|
127 |
|
|
#define konicawc_get_misc(uvd, req, value, index, buf, sz) konicawc_ctrl_msg(uvd, USB_DIR_IN, req, value, index, buf, sz)
|
128 |
|
|
#define konicawc_set_value(uvd, value, index) konicawc_ctrl_msg(uvd, USB_DIR_OUT, 2, value, index, NULL, 0)
|
129 |
|
|
|
130 |
|
|
|
131 |
|
|
static int konicawc_ctrl_msg(struct uvd *uvd, u8 dir, u8 request, u16 value, u16 index, void *buf, int len)
|
132 |
|
|
{
|
133 |
|
|
int retval = usb_control_msg(uvd->dev,
|
134 |
|
|
dir ? usb_rcvctrlpipe(uvd->dev, 0) : usb_sndctrlpipe(uvd->dev, 0),
|
135 |
|
|
request, 0x40 | dir, value, index, buf, len, HZ);
|
136 |
|
|
return retval < 0 ? retval : 0;
|
137 |
|
|
}
|
138 |
|
|
|
139 |
|
|
|
140 |
|
|
static inline void konicawc_camera_on(struct uvd *uvd)
|
141 |
|
|
{
|
142 |
|
|
DEBUG(0, "camera on");
|
143 |
|
|
konicawc_set_misc(uvd, 0x2, 1, 0x0b);
|
144 |
|
|
}
|
145 |
|
|
|
146 |
|
|
|
147 |
|
|
static inline void konicawc_camera_off(struct uvd *uvd)
|
148 |
|
|
{
|
149 |
|
|
DEBUG(0, "camera off");
|
150 |
|
|
konicawc_set_misc(uvd, 0x2, 0, 0x0b);
|
151 |
|
|
}
|
152 |
|
|
|
153 |
|
|
|
154 |
|
|
static void konicawc_set_camera_size(struct uvd *uvd)
|
155 |
|
|
{
|
156 |
|
|
struct konicawc *cam = (struct konicawc *)uvd->user_data;
|
157 |
|
|
|
158 |
|
|
konicawc_set_misc(uvd, 0x2, camera_sizes[cam->size].cmd, 0x08);
|
159 |
|
|
cam->width = camera_sizes[cam->size].width;
|
160 |
|
|
cam->height = camera_sizes[cam->size].height;
|
161 |
|
|
cam->yplanesz = cam->height * cam->width;
|
162 |
|
|
cam->cur_frame_size = (cam->yplanesz * 3) / 2;
|
163 |
|
|
cam->maxline = cam->yplanesz / 256;
|
164 |
|
|
uvd->videosize = VIDEOSIZE(cam->width, cam->height);
|
165 |
|
|
}
|
166 |
|
|
|
167 |
|
|
|
168 |
|
|
static int konicawc_setup_on_open(struct uvd *uvd)
|
169 |
|
|
{
|
170 |
|
|
struct konicawc *cam = (struct konicawc *)uvd->user_data;
|
171 |
|
|
|
172 |
|
|
DEBUG(1, "setting brightness to %d (%d)", cam->brightness,
|
173 |
|
|
cam->brightness * 11);
|
174 |
|
|
konicawc_set_value(uvd, cam->brightness, SetBrightness);
|
175 |
|
|
DEBUG(1, "setting white balance to %d (%d)", cam->white_bal,
|
176 |
|
|
cam->white_bal * 11);
|
177 |
|
|
konicawc_set_value(uvd, cam->white_bal, SetWhitebal);
|
178 |
|
|
DEBUG(1, "setting contrast to %d (%d)", cam->contrast,
|
179 |
|
|
cam->contrast * 11);
|
180 |
|
|
konicawc_set_value(uvd, cam->contrast, SetContrast);
|
181 |
|
|
DEBUG(1, "setting saturation to %d (%d)", cam->saturation,
|
182 |
|
|
cam->saturation * 11);
|
183 |
|
|
konicawc_set_value(uvd, cam->saturation, SetSaturation);
|
184 |
|
|
DEBUG(1, "setting sharpness to %d (%d)", cam->sharpness,
|
185 |
|
|
cam->sharpness * 11);
|
186 |
|
|
konicawc_set_value(uvd, cam->sharpness, SetSharpness);
|
187 |
|
|
konicawc_set_camera_size(uvd);
|
188 |
|
|
cam->lastframe = -2;
|
189 |
|
|
cam->buttonsts = 0;
|
190 |
|
|
return 0;
|
191 |
|
|
}
|
192 |
|
|
|
193 |
|
|
|
194 |
|
|
static void konicawc_adjust_picture(struct uvd *uvd)
|
195 |
|
|
{
|
196 |
|
|
struct konicawc *cam = (struct konicawc *)uvd->user_data;
|
197 |
|
|
|
198 |
|
|
konicawc_camera_off(uvd);
|
199 |
|
|
DEBUG(1, "new brightness: %d", uvd->vpic.brightness);
|
200 |
|
|
uvd->vpic.brightness = (uvd->vpic.brightness > MAX_BRIGHTNESS) ? MAX_BRIGHTNESS : uvd->vpic.brightness;
|
201 |
|
|
if(cam->brightness != uvd->vpic.brightness / 11) {
|
202 |
|
|
cam->brightness = uvd->vpic.brightness / 11;
|
203 |
|
|
DEBUG(1, "setting brightness to %d (%d)", cam->brightness,
|
204 |
|
|
cam->brightness * 11);
|
205 |
|
|
konicawc_set_value(uvd, cam->brightness, SetBrightness);
|
206 |
|
|
}
|
207 |
|
|
|
208 |
|
|
DEBUG(1, "new contrast: %d", uvd->vpic.contrast);
|
209 |
|
|
uvd->vpic.contrast = (uvd->vpic.contrast > MAX_CONTRAST) ? MAX_CONTRAST : uvd->vpic.contrast;
|
210 |
|
|
if(cam->contrast != uvd->vpic.contrast / 11) {
|
211 |
|
|
cam->contrast = uvd->vpic.contrast / 11;
|
212 |
|
|
DEBUG(1, "setting contrast to %d (%d)", cam->contrast,
|
213 |
|
|
cam->contrast * 11);
|
214 |
|
|
konicawc_set_value(uvd, cam->contrast, SetContrast);
|
215 |
|
|
}
|
216 |
|
|
konicawc_camera_on(uvd);
|
217 |
|
|
}
|
218 |
|
|
|
219 |
|
|
|
220 |
|
|
static int konicawc_compress_iso(struct uvd *uvd, struct urb *dataurb, struct urb *stsurb)
|
221 |
|
|
{
|
222 |
|
|
char *cdata;
|
223 |
|
|
int i, totlen = 0;
|
224 |
|
|
unsigned char *status = stsurb->transfer_buffer;
|
225 |
|
|
int keep = 0, discard = 0, bad = 0;
|
226 |
|
|
struct konicawc *cam = (struct konicawc *)uvd->user_data;
|
227 |
|
|
|
228 |
|
|
for (i = 0; i < dataurb->number_of_packets; i++) {
|
229 |
|
|
int button = cam->buttonsts;
|
230 |
|
|
unsigned char sts;
|
231 |
|
|
int n = dataurb->iso_frame_desc[i].actual_length;
|
232 |
|
|
int st = dataurb->iso_frame_desc[i].status;
|
233 |
|
|
cdata = dataurb->transfer_buffer +
|
234 |
|
|
dataurb->iso_frame_desc[i].offset;
|
235 |
|
|
|
236 |
|
|
/* Detect and ignore errored packets */
|
237 |
|
|
if (st < 0) {
|
238 |
|
|
DEBUG(1, "Data error: packet=%d. len=%d. status=%d.",
|
239 |
|
|
i, n, st);
|
240 |
|
|
uvd->stats.iso_err_count++;
|
241 |
|
|
continue;
|
242 |
|
|
}
|
243 |
|
|
|
244 |
|
|
/* Detect and ignore empty packets */
|
245 |
|
|
if (n <= 0) {
|
246 |
|
|
uvd->stats.iso_skip_count++;
|
247 |
|
|
continue;
|
248 |
|
|
}
|
249 |
|
|
|
250 |
|
|
/* See what the status data said about the packet */
|
251 |
|
|
sts = *(status+stsurb->iso_frame_desc[i].offset);
|
252 |
|
|
|
253 |
|
|
/* sts: 0x80-0xff: frame start with frame number (ie 0-7f)
|
254 |
|
|
* otherwise:
|
255 |
|
|
* bit 0 0: keep packet
|
256 |
|
|
* 1: drop packet (padding data)
|
257 |
|
|
*
|
258 |
|
|
* bit 4 0 button not clicked
|
259 |
|
|
* 1 button clicked
|
260 |
|
|
* button is used to `take a picture' (in software)
|
261 |
|
|
*/
|
262 |
|
|
|
263 |
|
|
if(sts < 0x80) {
|
264 |
|
|
button = !!(sts & 0x40);
|
265 |
|
|
sts &= ~0x40;
|
266 |
|
|
}
|
267 |
|
|
|
268 |
|
|
/* work out the button status, but dont do
|
269 |
|
|
anything with it for now */
|
270 |
|
|
|
271 |
|
|
if(button != cam->buttonsts) {
|
272 |
|
|
DEBUG(2, "button: %sclicked", button ? "" : "un");
|
273 |
|
|
cam->buttonsts = button;
|
274 |
|
|
#ifdef CONFIG_INPUT
|
275 |
|
|
input_report_key(&cam->input, BTN_0, cam->buttonsts);
|
276 |
|
|
#endif
|
277 |
|
|
}
|
278 |
|
|
|
279 |
|
|
if(sts == 0x01) { /* drop frame */
|
280 |
|
|
discard++;
|
281 |
|
|
continue;
|
282 |
|
|
}
|
283 |
|
|
|
284 |
|
|
if((sts > 0x01) && (sts < 0x80)) {
|
285 |
|
|
info("unknown status %2.2x", sts);
|
286 |
|
|
bad++;
|
287 |
|
|
continue;
|
288 |
|
|
}
|
289 |
|
|
if(!sts && cam->lastframe == -2) {
|
290 |
|
|
DEBUG(2, "dropping frame looking for image start");
|
291 |
|
|
continue;
|
292 |
|
|
}
|
293 |
|
|
|
294 |
|
|
keep++;
|
295 |
|
|
if(sts & 0x80) { /* frame start */
|
296 |
|
|
unsigned char marker[] = { 0, 0xff, 0, 0x00 };
|
297 |
|
|
|
298 |
|
|
if(cam->lastframe == -2) {
|
299 |
|
|
DEBUG(2, "found initial image");
|
300 |
|
|
cam->lastframe = -1;
|
301 |
|
|
}
|
302 |
|
|
|
303 |
|
|
marker[3] = sts & 0x7F;
|
304 |
|
|
RingQueue_Enqueue(&uvd->dp, marker, 4);
|
305 |
|
|
totlen += 4;
|
306 |
|
|
}
|
307 |
|
|
|
308 |
|
|
totlen += n; /* Little local accounting */
|
309 |
|
|
RingQueue_Enqueue(&uvd->dp, cdata, n);
|
310 |
|
|
}
|
311 |
|
|
DEBUG(8, "finished: keep = %d discard = %d bad = %d added %d bytes",
|
312 |
|
|
keep, discard, bad, totlen);
|
313 |
|
|
return totlen;
|
314 |
|
|
}
|
315 |
|
|
|
316 |
|
|
|
317 |
|
|
static void resubmit_urb(struct uvd *uvd, struct urb *urb)
|
318 |
|
|
{
|
319 |
|
|
int i, ret;
|
320 |
|
|
for (i = 0; i < FRAMES_PER_DESC; i++) {
|
321 |
|
|
urb->iso_frame_desc[i].status = 0;
|
322 |
|
|
}
|
323 |
|
|
urb->dev = uvd->dev;
|
324 |
|
|
urb->status = 0;
|
325 |
|
|
ret = usb_submit_urb(urb);
|
326 |
|
|
DEBUG(3, "submitting urb of length %d", urb->transfer_buffer_length);
|
327 |
|
|
if(ret)
|
328 |
|
|
err("usb_submit_urb error (%d)", ret);
|
329 |
|
|
|
330 |
|
|
}
|
331 |
|
|
|
332 |
|
|
|
333 |
|
|
static void konicawc_isoc_irq(struct urb *urb)
|
334 |
|
|
{
|
335 |
|
|
struct uvd *uvd = urb->context;
|
336 |
|
|
struct konicawc *cam = (struct konicawc *)uvd->user_data;
|
337 |
|
|
|
338 |
|
|
/* We don't want to do anything if we are about to be removed! */
|
339 |
|
|
if (!CAMERA_IS_OPERATIONAL(uvd))
|
340 |
|
|
return;
|
341 |
|
|
|
342 |
|
|
if (!uvd->streaming) {
|
343 |
|
|
DEBUG(1, "Not streaming, but interrupt!");
|
344 |
|
|
return;
|
345 |
|
|
}
|
346 |
|
|
|
347 |
|
|
DEBUG(3, "got frame %d len = %d buflen =%d", urb->start_frame, urb->actual_length, urb->transfer_buffer_length);
|
348 |
|
|
|
349 |
|
|
uvd->stats.urb_count++;
|
350 |
|
|
|
351 |
|
|
if (urb->transfer_buffer_length > 32) {
|
352 |
|
|
cam->last_data_urb = urb;
|
353 |
|
|
} else {
|
354 |
|
|
cam->last_sts_urb = urb;
|
355 |
|
|
}
|
356 |
|
|
/* Copy the data received into ring queue */
|
357 |
|
|
if(cam->last_data_urb && cam->last_sts_urb) {
|
358 |
|
|
int len = 0;
|
359 |
|
|
if(cam->last_sts_urb->start_frame != cam->last_data_urb->start_frame)
|
360 |
|
|
err("Lost sync on frames (%d != %d)",
|
361 |
|
|
cam->last_sts_urb->start_frame, cam->last_data_urb->start_frame);
|
362 |
|
|
else if (!cam->last_sts_urb->status && !cam->last_data_urb->status)
|
363 |
|
|
len = konicawc_compress_iso(uvd, cam->last_data_urb,
|
364 |
|
|
cam->last_sts_urb);
|
365 |
|
|
|
366 |
|
|
resubmit_urb(uvd, cam->last_sts_urb);
|
367 |
|
|
resubmit_urb(uvd, cam->last_data_urb);
|
368 |
|
|
cam->last_data_urb = NULL;
|
369 |
|
|
cam->last_sts_urb = NULL;
|
370 |
|
|
uvd->stats.urb_length = len;
|
371 |
|
|
uvd->stats.data_count += len;
|
372 |
|
|
if(len)
|
373 |
|
|
RingQueue_WakeUpInterruptible(&uvd->dp);
|
374 |
|
|
return;
|
375 |
|
|
}
|
376 |
|
|
return;
|
377 |
|
|
}
|
378 |
|
|
|
379 |
|
|
|
380 |
|
|
static int konicawc_start_data(struct uvd *uvd)
|
381 |
|
|
{
|
382 |
|
|
struct usb_device *dev = uvd->dev;
|
383 |
|
|
int i, errFlag;
|
384 |
|
|
struct konicawc *cam = (struct konicawc *)uvd->user_data;
|
385 |
|
|
int pktsz;
|
386 |
|
|
struct usb_interface_descriptor *interface;
|
387 |
|
|
|
388 |
|
|
interface = &dev->actconfig->interface[uvd->iface].altsetting[spd_to_iface[cam->speed]];
|
389 |
|
|
pktsz = interface->endpoint[1].wMaxPacketSize;
|
390 |
|
|
DEBUG(1, "pktsz = %d", pktsz);
|
391 |
|
|
if (!CAMERA_IS_OPERATIONAL(uvd)) {
|
392 |
|
|
err("Camera is not operational");
|
393 |
|
|
return -EFAULT;
|
394 |
|
|
}
|
395 |
|
|
uvd->curframe = -1;
|
396 |
|
|
konicawc_camera_on(uvd);
|
397 |
|
|
/* Alternate interface 1 is is the biggest frame size */
|
398 |
|
|
i = usb_set_interface(dev, uvd->iface, uvd->ifaceAltActive);
|
399 |
|
|
if (i < 0) {
|
400 |
|
|
err("usb_set_interface error");
|
401 |
|
|
uvd->last_error = i;
|
402 |
|
|
return -EBUSY;
|
403 |
|
|
}
|
404 |
|
|
|
405 |
|
|
/* We double buffer the Iso lists */
|
406 |
|
|
for (i=0; i < USBVIDEO_NUMSBUF; i++) {
|
407 |
|
|
int j, k;
|
408 |
|
|
struct urb *urb = uvd->sbuf[i].urb;
|
409 |
|
|
urb->dev = dev;
|
410 |
|
|
urb->context = uvd;
|
411 |
|
|
urb->pipe = usb_rcvisocpipe(dev, uvd->video_endp);
|
412 |
|
|
urb->interval = 1;
|
413 |
|
|
urb->transfer_flags = USB_ISO_ASAP;
|
414 |
|
|
urb->transfer_buffer = uvd->sbuf[i].data;
|
415 |
|
|
urb->complete = konicawc_isoc_irq;
|
416 |
|
|
urb->number_of_packets = FRAMES_PER_DESC;
|
417 |
|
|
urb->transfer_buffer_length = pktsz * FRAMES_PER_DESC;
|
418 |
|
|
for (j=k=0; j < FRAMES_PER_DESC; j++, k += pktsz) {
|
419 |
|
|
urb->iso_frame_desc[j].offset = k;
|
420 |
|
|
urb->iso_frame_desc[j].length = pktsz;
|
421 |
|
|
}
|
422 |
|
|
|
423 |
|
|
urb = cam->sts_urb[i];
|
424 |
|
|
urb->dev = dev;
|
425 |
|
|
urb->context = uvd;
|
426 |
|
|
urb->pipe = usb_rcvisocpipe(dev, uvd->video_endp-1);
|
427 |
|
|
urb->interval = 1;
|
428 |
|
|
urb->transfer_flags = USB_ISO_ASAP;
|
429 |
|
|
urb->transfer_buffer = cam->sts_buf[i];
|
430 |
|
|
urb->complete = konicawc_isoc_irq;
|
431 |
|
|
urb->number_of_packets = FRAMES_PER_DESC;
|
432 |
|
|
urb->transfer_buffer_length = FRAMES_PER_DESC;
|
433 |
|
|
for (j=0; j < FRAMES_PER_DESC; j++) {
|
434 |
|
|
urb->iso_frame_desc[j].offset = j;
|
435 |
|
|
urb->iso_frame_desc[j].length = 1;
|
436 |
|
|
}
|
437 |
|
|
}
|
438 |
|
|
|
439 |
|
|
cam->last_data_urb = NULL;
|
440 |
|
|
cam->last_sts_urb = NULL;
|
441 |
|
|
|
442 |
|
|
/* Submit all URBs */
|
443 |
|
|
for (i=0; i < USBVIDEO_NUMSBUF; i++) {
|
444 |
|
|
errFlag = usb_submit_urb(cam->sts_urb[i]);
|
445 |
|
|
if (errFlag)
|
446 |
|
|
err("usb_submit_isoc(%d) ret %d", i, errFlag);
|
447 |
|
|
|
448 |
|
|
errFlag = usb_submit_urb(uvd->sbuf[i].urb);
|
449 |
|
|
if (errFlag)
|
450 |
|
|
err ("usb_submit_isoc(%d) ret %d", i, errFlag);
|
451 |
|
|
}
|
452 |
|
|
|
453 |
|
|
uvd->streaming = 1;
|
454 |
|
|
DEBUG(1, "streaming=1 video_endp=$%02x", uvd->video_endp);
|
455 |
|
|
return 0;
|
456 |
|
|
}
|
457 |
|
|
|
458 |
|
|
|
459 |
|
|
static void konicawc_stop_data(struct uvd *uvd)
|
460 |
|
|
{
|
461 |
|
|
int i, j;
|
462 |
|
|
struct konicawc *cam;
|
463 |
|
|
|
464 |
|
|
if ((uvd == NULL) || (!uvd->streaming) || (uvd->dev == NULL))
|
465 |
|
|
return;
|
466 |
|
|
|
467 |
|
|
konicawc_camera_off(uvd);
|
468 |
|
|
uvd->streaming = 0;
|
469 |
|
|
cam = (struct konicawc *)uvd->user_data;
|
470 |
|
|
cam->last_data_urb = NULL;
|
471 |
|
|
cam->last_sts_urb = NULL;
|
472 |
|
|
|
473 |
|
|
/* Unschedule all of the iso td's */
|
474 |
|
|
for (i=0; i < USBVIDEO_NUMSBUF; i++) {
|
475 |
|
|
j = usb_unlink_urb(uvd->sbuf[i].urb);
|
476 |
|
|
if (j < 0)
|
477 |
|
|
err("usb_unlink_urb() error %d.", j);
|
478 |
|
|
|
479 |
|
|
j = usb_unlink_urb(cam->sts_urb[i]);
|
480 |
|
|
if (j < 0)
|
481 |
|
|
err("usb_unlink_urb() error %d.", j);
|
482 |
|
|
}
|
483 |
|
|
|
484 |
|
|
if (!uvd->remove_pending) {
|
485 |
|
|
/* Set packet size to 0 */
|
486 |
|
|
j = usb_set_interface(uvd->dev, uvd->iface, uvd->ifaceAltInactive);
|
487 |
|
|
if (j < 0) {
|
488 |
|
|
err("usb_set_interface() error %d.", j);
|
489 |
|
|
uvd->last_error = j;
|
490 |
|
|
}
|
491 |
|
|
}
|
492 |
|
|
}
|
493 |
|
|
|
494 |
|
|
|
495 |
|
|
static void konicawc_process_isoc(struct uvd *uvd, struct usbvideo_frame *frame)
|
496 |
|
|
{
|
497 |
|
|
struct konicawc *cam = (struct konicawc *)uvd->user_data;
|
498 |
|
|
int maxline = cam->maxline;
|
499 |
|
|
int yplanesz = cam->yplanesz;
|
500 |
|
|
|
501 |
|
|
assert(frame != NULL);
|
502 |
|
|
|
503 |
|
|
DEBUG(5, "maxline = %d yplanesz = %d", maxline, yplanesz);
|
504 |
|
|
DEBUG(3, "Frame state = %d", frame->scanstate);
|
505 |
|
|
|
506 |
|
|
if(frame->scanstate == ScanState_Scanning) {
|
507 |
|
|
int drop = 0;
|
508 |
|
|
int curframe;
|
509 |
|
|
int fdrops = 0;
|
510 |
|
|
DEBUG(3, "Searching for marker, queue len = %d", RingQueue_GetLength(&uvd->dp));
|
511 |
|
|
while(RingQueue_GetLength(&uvd->dp) >= 4) {
|
512 |
|
|
if ((RING_QUEUE_PEEK(&uvd->dp, 0) == 0x00) &&
|
513 |
|
|
(RING_QUEUE_PEEK(&uvd->dp, 1) == 0xff) &&
|
514 |
|
|
(RING_QUEUE_PEEK(&uvd->dp, 2) == 0x00) &&
|
515 |
|
|
(RING_QUEUE_PEEK(&uvd->dp, 3) < 0x80)) {
|
516 |
|
|
curframe = RING_QUEUE_PEEK(&uvd->dp, 3);
|
517 |
|
|
if(cam->lastframe >= 0) {
|
518 |
|
|
fdrops = (0x80 + curframe - cam->lastframe) & 0x7F;
|
519 |
|
|
fdrops--;
|
520 |
|
|
if(fdrops) {
|
521 |
|
|
info("Dropped %d frames (%d -> %d)", fdrops,
|
522 |
|
|
cam->lastframe, curframe);
|
523 |
|
|
}
|
524 |
|
|
}
|
525 |
|
|
cam->lastframe = curframe;
|
526 |
|
|
frame->curline = 0;
|
527 |
|
|
frame->scanstate = ScanState_Lines;
|
528 |
|
|
RING_QUEUE_DEQUEUE_BYTES(&uvd->dp, 4);
|
529 |
|
|
break;
|
530 |
|
|
}
|
531 |
|
|
RING_QUEUE_DEQUEUE_BYTES(&uvd->dp, 1);
|
532 |
|
|
drop++;
|
533 |
|
|
}
|
534 |
|
|
if(drop)
|
535 |
|
|
DEBUG(2, "dropped %d bytes looking for new frame", drop);
|
536 |
|
|
}
|
537 |
|
|
|
538 |
|
|
if(frame->scanstate == ScanState_Scanning)
|
539 |
|
|
return;
|
540 |
|
|
|
541 |
|
|
/* Try to move data from queue into frame buffer
|
542 |
|
|
* We get data in blocks of 384 bytes made up of:
|
543 |
|
|
* 256 Y, 64 U, 64 V.
|
544 |
|
|
* This needs to be written out as a Y plane, a U plane and a V plane.
|
545 |
|
|
*/
|
546 |
|
|
|
547 |
|
|
while ( frame->curline < maxline && (RingQueue_GetLength(&uvd->dp) >= 384)) {
|
548 |
|
|
/* Y */
|
549 |
|
|
RingQueue_Dequeue(&uvd->dp, frame->data + (frame->curline * 256), 256);
|
550 |
|
|
/* U */
|
551 |
|
|
RingQueue_Dequeue(&uvd->dp, frame->data + yplanesz + (frame->curline * 64), 64);
|
552 |
|
|
/* V */
|
553 |
|
|
RingQueue_Dequeue(&uvd->dp, frame->data + (5 * yplanesz)/4 + (frame->curline * 64), 64);
|
554 |
|
|
frame->seqRead_Length += 384;
|
555 |
|
|
frame->curline++;
|
556 |
|
|
}
|
557 |
|
|
/* See if we filled the frame */
|
558 |
|
|
if (frame->curline == maxline) {
|
559 |
|
|
DEBUG(5, "got whole frame");
|
560 |
|
|
|
561 |
|
|
frame->frameState = FrameState_Done_Hold;
|
562 |
|
|
frame->curline = 0;
|
563 |
|
|
uvd->curframe = -1;
|
564 |
|
|
uvd->stats.frame_num++;
|
565 |
|
|
}
|
566 |
|
|
}
|
567 |
|
|
|
568 |
|
|
|
569 |
|
|
static int konicawc_find_fps(int size, int fps)
|
570 |
|
|
{
|
571 |
|
|
int i;
|
572 |
|
|
|
573 |
|
|
fps *= 3;
|
574 |
|
|
DEBUG(1, "konica_find_fps: size = %d fps = %d", size, fps);
|
575 |
|
|
if(fps <= spd_to_fps[size][0])
|
576 |
|
|
return 0;
|
577 |
|
|
|
578 |
|
|
if(fps >= spd_to_fps[size][MAX_SPEED])
|
579 |
|
|
return MAX_SPEED;
|
580 |
|
|
|
581 |
|
|
for(i = 0; i < MAX_SPEED; i++) {
|
582 |
|
|
if((fps >= spd_to_fps[size][i]) && (fps <= spd_to_fps[size][i+1])) {
|
583 |
|
|
DEBUG(2, "fps %d between %d and %d", fps, i, i+1);
|
584 |
|
|
if( (fps - spd_to_fps[size][i]) < (spd_to_fps[size][i+1] - fps))
|
585 |
|
|
return i;
|
586 |
|
|
else
|
587 |
|
|
return i+1;
|
588 |
|
|
}
|
589 |
|
|
}
|
590 |
|
|
return MAX_SPEED+1;
|
591 |
|
|
}
|
592 |
|
|
|
593 |
|
|
|
594 |
|
|
static int konicawc_set_video_mode(struct uvd *uvd, struct video_window *vw)
|
595 |
|
|
{
|
596 |
|
|
struct konicawc *cam = (struct konicawc *)uvd->user_data;
|
597 |
|
|
int newspeed = cam->speed;
|
598 |
|
|
int newsize;
|
599 |
|
|
int x = vw->width;
|
600 |
|
|
int y = vw->height;
|
601 |
|
|
int fps = vw->flags;
|
602 |
|
|
|
603 |
|
|
if(x > 0 && y > 0) {
|
604 |
|
|
DEBUG(2, "trying to find size %d,%d", x, y);
|
605 |
|
|
for(newsize = 0; newsize <= MAX_FRAME_SIZE; newsize++) {
|
606 |
|
|
if((camera_sizes[newsize].width == x) && (camera_sizes[newsize].height == y))
|
607 |
|
|
break;
|
608 |
|
|
}
|
609 |
|
|
} else {
|
610 |
|
|
newsize = cam->size;
|
611 |
|
|
}
|
612 |
|
|
|
613 |
|
|
if(newsize > MAX_FRAME_SIZE) {
|
614 |
|
|
DEBUG(1, "couldnt find size %d,%d", x, y);
|
615 |
|
|
return -EINVAL;
|
616 |
|
|
}
|
617 |
|
|
|
618 |
|
|
if(fps > 0) {
|
619 |
|
|
DEBUG(1, "trying to set fps to %d", fps);
|
620 |
|
|
newspeed = konicawc_find_fps(newsize, fps);
|
621 |
|
|
DEBUG(1, "find_fps returned %d (%d)", newspeed, spd_to_fps[newsize][newspeed]);
|
622 |
|
|
}
|
623 |
|
|
|
624 |
|
|
if(newspeed > MAX_SPEED)
|
625 |
|
|
return -EINVAL;
|
626 |
|
|
|
627 |
|
|
DEBUG(1, "setting size to %d speed to %d", newsize, newspeed);
|
628 |
|
|
if((newsize == cam->size) && (newspeed == cam->speed)) {
|
629 |
|
|
DEBUG(1, "Nothing to do");
|
630 |
|
|
return 0;
|
631 |
|
|
}
|
632 |
|
|
DEBUG(0, "setting to %dx%d @ %d fps", camera_sizes[newsize].width,
|
633 |
|
|
camera_sizes[newsize].height, spd_to_fps[newsize][newspeed]/3);
|
634 |
|
|
|
635 |
|
|
konicawc_stop_data(uvd);
|
636 |
|
|
uvd->ifaceAltActive = spd_to_iface[newspeed];
|
637 |
|
|
DEBUG(1, "new interface = %d", uvd->ifaceAltActive);
|
638 |
|
|
cam->speed = newspeed;
|
639 |
|
|
|
640 |
|
|
if(cam->size != newsize) {
|
641 |
|
|
cam->size = newsize;
|
642 |
|
|
konicawc_set_camera_size(uvd);
|
643 |
|
|
}
|
644 |
|
|
|
645 |
|
|
/* Flush the input queue and clear any current frame in progress */
|
646 |
|
|
|
647 |
|
|
RingQueue_Flush(&uvd->dp);
|
648 |
|
|
cam->lastframe = -2;
|
649 |
|
|
if(uvd->curframe != -1) {
|
650 |
|
|
uvd->frame[uvd->curframe].curline = 0;
|
651 |
|
|
uvd->frame[uvd->curframe].seqRead_Length = 0;
|
652 |
|
|
uvd->frame[uvd->curframe].seqRead_Index = 0;
|
653 |
|
|
}
|
654 |
|
|
|
655 |
|
|
konicawc_start_data(uvd);
|
656 |
|
|
return 0;
|
657 |
|
|
}
|
658 |
|
|
|
659 |
|
|
|
660 |
|
|
static int konicawc_calculate_fps(struct uvd *uvd)
|
661 |
|
|
{
|
662 |
|
|
struct konicawc *cam = uvd->user_data;
|
663 |
|
|
return spd_to_fps[cam->size][cam->speed]/3;
|
664 |
|
|
}
|
665 |
|
|
|
666 |
|
|
|
667 |
|
|
static void konicawc_configure_video(struct uvd *uvd)
|
668 |
|
|
{
|
669 |
|
|
struct konicawc *cam = (struct konicawc *)uvd->user_data;
|
670 |
|
|
u8 buf[2];
|
671 |
|
|
|
672 |
|
|
memset(&uvd->vpic, 0, sizeof(uvd->vpic));
|
673 |
|
|
memset(&uvd->vpic_old, 0x55, sizeof(uvd->vpic_old));
|
674 |
|
|
|
675 |
|
|
RESTRICT_TO_RANGE(brightness, 0, MAX_BRIGHTNESS);
|
676 |
|
|
RESTRICT_TO_RANGE(contrast, 0, MAX_CONTRAST);
|
677 |
|
|
RESTRICT_TO_RANGE(saturation, 0, MAX_SATURATION);
|
678 |
|
|
RESTRICT_TO_RANGE(sharpness, 0, MAX_SHARPNESS);
|
679 |
|
|
RESTRICT_TO_RANGE(whitebal, 0, MAX_WHITEBAL);
|
680 |
|
|
|
681 |
|
|
cam->brightness = brightness / 11;
|
682 |
|
|
cam->contrast = contrast / 11;
|
683 |
|
|
cam->saturation = saturation / 11;
|
684 |
|
|
cam->sharpness = sharpness / 11;
|
685 |
|
|
cam->white_bal = whitebal / 11;
|
686 |
|
|
|
687 |
|
|
uvd->vpic.colour = 108;
|
688 |
|
|
uvd->vpic.hue = 108;
|
689 |
|
|
uvd->vpic.brightness = brightness;
|
690 |
|
|
uvd->vpic.contrast = contrast;
|
691 |
|
|
uvd->vpic.whiteness = whitebal;
|
692 |
|
|
uvd->vpic.depth = 6;
|
693 |
|
|
uvd->vpic.palette = VIDEO_PALETTE_YUV420P;
|
694 |
|
|
|
695 |
|
|
memset(&uvd->vcap, 0, sizeof(uvd->vcap));
|
696 |
|
|
strcpy(uvd->vcap.name, "Konica Webcam");
|
697 |
|
|
uvd->vcap.type = VID_TYPE_CAPTURE;
|
698 |
|
|
uvd->vcap.channels = 1;
|
699 |
|
|
uvd->vcap.audios = 0;
|
700 |
|
|
uvd->vcap.minwidth = camera_sizes[SIZE_160X120].width;
|
701 |
|
|
uvd->vcap.minheight = camera_sizes[SIZE_160X120].height;
|
702 |
|
|
uvd->vcap.maxwidth = camera_sizes[SIZE_320X240].width;
|
703 |
|
|
uvd->vcap.maxheight = camera_sizes[SIZE_320X240].height;
|
704 |
|
|
|
705 |
|
|
memset(&uvd->vchan, 0, sizeof(uvd->vchan));
|
706 |
|
|
uvd->vchan.flags = 0 ;
|
707 |
|
|
uvd->vchan.tuners = 0;
|
708 |
|
|
uvd->vchan.channel = 0;
|
709 |
|
|
uvd->vchan.type = VIDEO_TYPE_CAMERA;
|
710 |
|
|
strcpy(uvd->vchan.name, "Camera");
|
711 |
|
|
|
712 |
|
|
/* Talk to device */
|
713 |
|
|
DEBUG(1, "device init");
|
714 |
|
|
if(!konicawc_get_misc(uvd, 0x3, 0, 0x10, buf, 2))
|
715 |
|
|
DEBUG(2, "3,10 -> %2.2x %2.2x", buf[0], buf[1]);
|
716 |
|
|
if(!konicawc_get_misc(uvd, 0x3, 0, 0x10, buf, 2))
|
717 |
|
|
DEBUG(2, "3,10 -> %2.2x %2.2x", buf[0], buf[1]);
|
718 |
|
|
if(konicawc_set_misc(uvd, 0x2, 0, 0xd))
|
719 |
|
|
DEBUG(2, "2,0,d failed");
|
720 |
|
|
DEBUG(1, "setting initial values");
|
721 |
|
|
}
|
722 |
|
|
|
723 |
|
|
|
724 |
|
|
static void *konicawc_probe(struct usb_device *dev, unsigned int ifnum, const struct usb_device_id *devid)
|
725 |
|
|
{
|
726 |
|
|
struct uvd *uvd = NULL;
|
727 |
|
|
int i, nas;
|
728 |
|
|
int actInterface=-1, inactInterface=-1, maxPS=0;
|
729 |
|
|
unsigned char video_ep = 0;
|
730 |
|
|
|
731 |
|
|
DEBUG(1, "konicawc_probe(%p,%u.)", dev, ifnum);
|
732 |
|
|
|
733 |
|
|
/* We don't handle multi-config cameras */
|
734 |
|
|
if (dev->descriptor.bNumConfigurations != 1)
|
735 |
|
|
return NULL;
|
736 |
|
|
|
737 |
|
|
info("Konica Webcam (rev. 0x%04x)", dev->descriptor.bcdDevice);
|
738 |
|
|
RESTRICT_TO_RANGE(speed, 0, MAX_SPEED);
|
739 |
|
|
|
740 |
|
|
/* Validate found interface: must have one ISO endpoint */
|
741 |
|
|
nas = dev->actconfig->interface[ifnum].num_altsetting;
|
742 |
|
|
if (nas != 8) {
|
743 |
|
|
err("Incorrect number of alternate settings (%d) for this camera!", nas);
|
744 |
|
|
return NULL;
|
745 |
|
|
}
|
746 |
|
|
/* Validate all alternate settings */
|
747 |
|
|
for (i=0; i < nas; i++) {
|
748 |
|
|
const struct usb_interface_descriptor *interface;
|
749 |
|
|
const struct usb_endpoint_descriptor *endpoint;
|
750 |
|
|
|
751 |
|
|
interface = &dev->actconfig->interface[ifnum].altsetting[i];
|
752 |
|
|
if (interface->bNumEndpoints != 2) {
|
753 |
|
|
err("Interface %d. has %u. endpoints!",
|
754 |
|
|
ifnum, (unsigned)(interface->bNumEndpoints));
|
755 |
|
|
return NULL;
|
756 |
|
|
}
|
757 |
|
|
endpoint = &interface->endpoint[1];
|
758 |
|
|
DEBUG(1, "found endpoint: addr: 0x%2.2x maxps = 0x%4.4x",
|
759 |
|
|
endpoint->bEndpointAddress, endpoint->wMaxPacketSize);
|
760 |
|
|
if (video_ep == 0)
|
761 |
|
|
video_ep = endpoint->bEndpointAddress;
|
762 |
|
|
else if (video_ep != endpoint->bEndpointAddress) {
|
763 |
|
|
err("Alternate settings have different endpoint addresses!");
|
764 |
|
|
return NULL;
|
765 |
|
|
}
|
766 |
|
|
if ((endpoint->bmAttributes & 0x03) != 0x01) {
|
767 |
|
|
err("Interface %d. has non-ISO endpoint!", ifnum);
|
768 |
|
|
return NULL;
|
769 |
|
|
}
|
770 |
|
|
if ((endpoint->bEndpointAddress & 0x80) == 0) {
|
771 |
|
|
err("Interface %d. has ISO OUT endpoint!", ifnum);
|
772 |
|
|
return NULL;
|
773 |
|
|
}
|
774 |
|
|
if (endpoint->wMaxPacketSize == 0) {
|
775 |
|
|
if (inactInterface < 0)
|
776 |
|
|
inactInterface = i;
|
777 |
|
|
else {
|
778 |
|
|
err("More than one inactive alt. setting!");
|
779 |
|
|
return NULL;
|
780 |
|
|
}
|
781 |
|
|
} else {
|
782 |
|
|
if (i == spd_to_iface[speed]) {
|
783 |
|
|
/* This one is the requested one */
|
784 |
|
|
actInterface = i;
|
785 |
|
|
}
|
786 |
|
|
}
|
787 |
|
|
if(endpoint->wMaxPacketSize > maxPS)
|
788 |
|
|
maxPS = endpoint->wMaxPacketSize;
|
789 |
|
|
}
|
790 |
|
|
if(actInterface == -1) {
|
791 |
|
|
err("Cant find required endpoint");
|
792 |
|
|
return NULL;
|
793 |
|
|
}
|
794 |
|
|
|
795 |
|
|
DEBUG(1, "Selecting requested active setting=%d. maxPS=%d.", actInterface, maxPS);
|
796 |
|
|
|
797 |
|
|
/* Code below may sleep, need to lock module while we are here */
|
798 |
|
|
MOD_INC_USE_COUNT;
|
799 |
|
|
uvd = usbvideo_AllocateDevice(cams);
|
800 |
|
|
if (uvd != NULL) {
|
801 |
|
|
struct konicawc *cam = (struct konicawc *)(uvd->user_data);
|
802 |
|
|
/* Here uvd is a fully allocated uvd object */
|
803 |
|
|
for(i = 0; i < USBVIDEO_NUMSBUF; i++) {
|
804 |
|
|
cam->sts_urb[i] = usb_alloc_urb(FRAMES_PER_DESC);
|
805 |
|
|
if(cam->sts_urb[i] == NULL) {
|
806 |
|
|
while(i--) {
|
807 |
|
|
usb_free_urb(cam->sts_urb[i]);
|
808 |
|
|
}
|
809 |
|
|
err("cant allocate urbs");
|
810 |
|
|
return NULL;
|
811 |
|
|
}
|
812 |
|
|
}
|
813 |
|
|
cam->speed = speed;
|
814 |
|
|
RESTRICT_TO_RANGE(size, SIZE_160X120, SIZE_320X240);
|
815 |
|
|
cam->width = camera_sizes[size].width;
|
816 |
|
|
cam->height = camera_sizes[size].height;
|
817 |
|
|
cam->size = size;
|
818 |
|
|
|
819 |
|
|
uvd->flags = 0;
|
820 |
|
|
uvd->debug = debug;
|
821 |
|
|
uvd->dev = dev;
|
822 |
|
|
uvd->iface = ifnum;
|
823 |
|
|
uvd->ifaceAltInactive = inactInterface;
|
824 |
|
|
uvd->ifaceAltActive = actInterface;
|
825 |
|
|
uvd->video_endp = video_ep;
|
826 |
|
|
uvd->iso_packet_len = maxPS;
|
827 |
|
|
uvd->paletteBits = 1L << VIDEO_PALETTE_YUV420P;
|
828 |
|
|
uvd->defaultPalette = VIDEO_PALETTE_YUV420P;
|
829 |
|
|
uvd->canvas = VIDEOSIZE(320, 240);
|
830 |
|
|
uvd->videosize = VIDEOSIZE(cam->width, cam->height);
|
831 |
|
|
|
832 |
|
|
/* Initialize konicawc specific data */
|
833 |
|
|
konicawc_configure_video(uvd);
|
834 |
|
|
|
835 |
|
|
i = usbvideo_RegisterVideoDevice(uvd);
|
836 |
|
|
uvd->max_frame_size = (320 * 240 * 3)/2;
|
837 |
|
|
if (i != 0) {
|
838 |
|
|
err("usbvideo_RegisterVideoDevice() failed.");
|
839 |
|
|
uvd = NULL;
|
840 |
|
|
}
|
841 |
|
|
#ifdef CONFIG_INPUT
|
842 |
|
|
/* Register input device for button */
|
843 |
|
|
memset(&cam->input, 0, sizeof(struct input_dev));
|
844 |
|
|
cam->input.name = "Konicawc snapshot button";
|
845 |
|
|
cam->input.private = cam;
|
846 |
|
|
cam->input.evbit[0] = BIT(EV_KEY);
|
847 |
|
|
cam->input.keybit[LONG(BTN_0)] = BIT(BTN_0);
|
848 |
|
|
cam->input.idbus = BUS_USB;
|
849 |
|
|
cam->input.idvendor = dev->descriptor.idVendor;
|
850 |
|
|
cam->input.idproduct = dev->descriptor.idProduct;
|
851 |
|
|
cam->input.idversion = dev->descriptor.bcdDevice;
|
852 |
|
|
input_register_device(&cam->input);
|
853 |
|
|
#endif
|
854 |
|
|
}
|
855 |
|
|
MOD_DEC_USE_COUNT;
|
856 |
|
|
return uvd;
|
857 |
|
|
}
|
858 |
|
|
|
859 |
|
|
|
860 |
|
|
static void konicawc_free_uvd(struct uvd *uvd)
|
861 |
|
|
{
|
862 |
|
|
int i;
|
863 |
|
|
struct konicawc *cam = (struct konicawc *)uvd->user_data;
|
864 |
|
|
|
865 |
|
|
#ifdef CONFIG_INPUT
|
866 |
|
|
input_unregister_device(&cam->input);
|
867 |
|
|
#endif
|
868 |
|
|
for (i=0; i < USBVIDEO_NUMSBUF; i++) {
|
869 |
|
|
usb_free_urb(cam->sts_urb[i]);
|
870 |
|
|
cam->sts_urb[i] = NULL;
|
871 |
|
|
}
|
872 |
|
|
}
|
873 |
|
|
|
874 |
|
|
|
875 |
|
|
static struct usb_device_id id_table[] = {
|
876 |
|
|
{ USB_DEVICE(0x04c8, 0x0720) }, /* Intel YC 76 */
|
877 |
|
|
{ } /* Terminating entry */
|
878 |
|
|
};
|
879 |
|
|
|
880 |
|
|
|
881 |
|
|
static int __init konicawc_init(void)
|
882 |
|
|
{
|
883 |
|
|
struct usbvideo_cb cbTbl;
|
884 |
|
|
info(DRIVER_DESC " " DRIVER_VERSION);
|
885 |
|
|
memset(&cbTbl, 0, sizeof(cbTbl));
|
886 |
|
|
cbTbl.probe = konicawc_probe;
|
887 |
|
|
cbTbl.setupOnOpen = konicawc_setup_on_open;
|
888 |
|
|
cbTbl.processData = konicawc_process_isoc;
|
889 |
|
|
cbTbl.getFPS = konicawc_calculate_fps;
|
890 |
|
|
cbTbl.setVideoMode = konicawc_set_video_mode;
|
891 |
|
|
cbTbl.startDataPump = konicawc_start_data;
|
892 |
|
|
cbTbl.stopDataPump = konicawc_stop_data;
|
893 |
|
|
cbTbl.adjustPicture = konicawc_adjust_picture;
|
894 |
|
|
cbTbl.userFree = konicawc_free_uvd;
|
895 |
|
|
return usbvideo_register(
|
896 |
|
|
&cams,
|
897 |
|
|
MAX_CAMERAS,
|
898 |
|
|
sizeof(struct konicawc),
|
899 |
|
|
"konicawc",
|
900 |
|
|
&cbTbl,
|
901 |
|
|
THIS_MODULE,
|
902 |
|
|
id_table);
|
903 |
|
|
}
|
904 |
|
|
|
905 |
|
|
|
906 |
|
|
static void __exit konicawc_cleanup(void)
|
907 |
|
|
{
|
908 |
|
|
usbvideo_Deregister(&cams);
|
909 |
|
|
}
|
910 |
|
|
|
911 |
|
|
|
912 |
|
|
MODULE_DEVICE_TABLE(usb, id_table);
|
913 |
|
|
|
914 |
|
|
MODULE_LICENSE("GPL");
|
915 |
|
|
MODULE_AUTHOR("Simon Evans <spse@secret.org.uk>");
|
916 |
|
|
MODULE_DESCRIPTION(DRIVER_DESC);
|
917 |
|
|
MODULE_PARM(speed, "i");
|
918 |
|
|
MODULE_PARM_DESC(speed, "Initial speed: 0 (slowest) - 6 (fastest)");
|
919 |
|
|
MODULE_PARM(size, "i");
|
920 |
|
|
MODULE_PARM_DESC(size, "Initial Size 0: 160x120 1: 160x136 2: 176x144 3: 320x240");
|
921 |
|
|
MODULE_PARM(brightness, "i");
|
922 |
|
|
MODULE_PARM_DESC(brightness, "Initial brightness 0 - 108");
|
923 |
|
|
MODULE_PARM(contrast, "i");
|
924 |
|
|
MODULE_PARM_DESC(contrast, "Initial contrast 0 - 108");
|
925 |
|
|
MODULE_PARM(saturation, "i");
|
926 |
|
|
MODULE_PARM_DESC(saturation, "Initial saturation 0 - 108");
|
927 |
|
|
MODULE_PARM(sharpness, "i");
|
928 |
|
|
MODULE_PARM_DESC(sharpness, "Initial sharpness 0 - 108");
|
929 |
|
|
MODULE_PARM(whitebal, "i");
|
930 |
|
|
MODULE_PARM_DESC(whitebal, "Initial white balance 0 - 363");
|
931 |
|
|
|
932 |
|
|
#ifdef CONFIG_USB_DEBUG
|
933 |
|
|
MODULE_PARM(debug, "i");
|
934 |
|
|
MODULE_PARM_DESC(debug, "Debug level: 0-9 (default=0)");
|
935 |
|
|
#endif
|
936 |
|
|
|
937 |
|
|
module_init(konicawc_init);
|
938 |
|
|
module_exit(konicawc_cleanup);
|