?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6
[wrt350n-kernel.git] / drivers / media / video / em28xx / em28xx-core.c
blob1fc321d46bdbc357e954daec3fa85eefd77b255b
1 /*
2 em28xx-core.c - driver for Empia EM2800/EM2820/2840 USB video capture devices
3
4 Copyright (C) 2005 Ludovico Cavedon <cavedon@sssup.it>
5 Markus Rechberger <mrechberger@gmail.com>
6 Mauro Carvalho Chehab <mchehab@infradead.org>
7 Sascha Sommer <saschasommer@freenet.de>
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 */
23
24 #include <linux/init.h>
25 #include <linux/list.h>
26 #include <linux/module.h>
27 #include <linux/usb.h>
28 #include <linux/vmalloc.h>
29
30 #include "em28xx.h"
31
32 /* #define ENABLE_DEBUG_ISOC_FRAMES */
33
34 static unsigned int core_debug = 0;
35 module_param(core_debug,int,0644);
36 MODULE_PARM_DESC(core_debug,"enable debug messages [core]");
37
38 #define em28xx_coredbg(fmt, arg...) do {\
39 if (core_debug) \
40 printk(KERN_INFO "%s %s :"fmt, \
41 dev->name, __FUNCTION__ , ##arg); } while (0)
42
43 static unsigned int reg_debug = 0;
44 module_param(reg_debug,int,0644);
45 MODULE_PARM_DESC(reg_debug,"enable debug messages [URB reg]");
46
47 #define em28xx_regdbg(fmt, arg...) do {\
48 if (reg_debug) \
49 printk(KERN_INFO "%s %s :"fmt, \
50 dev->name, __FUNCTION__ , ##arg); } while (0)
51
52 static unsigned int isoc_debug = 0;
53 module_param(isoc_debug,int,0644);
54 MODULE_PARM_DESC(isoc_debug,"enable debug messages [isoc transfers]");
55
56 #define em28xx_isocdbg(fmt, arg...) do {\
57 if (isoc_debug) \
58 printk(KERN_INFO "%s %s :"fmt, \
59 dev->name, __FUNCTION__ , ##arg); } while (0)
60
61 static int alt = EM28XX_PINOUT;
62 module_param(alt, int, 0644);
63 MODULE_PARM_DESC(alt, "alternate setting to use for video endpoint");
64
65
66 /*
67 * em28xx_request_buffers()
68 * allocate a number of buffers
69 */
70 u32 em28xx_request_buffers(struct em28xx *dev, u32 count)
71 {
72 const size_t imagesize = PAGE_ALIGN(dev->frame_size); /*needs to be page aligned cause the buffers can be mapped individually! */
73 void *buff = NULL;
74 u32 i;
75 <<<<<<< HEAD:drivers/media/video/em28xx/em28xx-core.c
76 em28xx_coredbg("requested %i buffers with size %zi", count, imagesize);
77 =======
78 em28xx_coredbg("requested %i buffers with size %zi\n",
79 count, imagesize);
80 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/media/video/em28xx/em28xx-core.c
81 if (count > EM28XX_NUM_FRAMES)
82 count = EM28XX_NUM_FRAMES;
83
84 dev->num_frames = count;
85 while (dev->num_frames > 0) {
86 if ((buff = vmalloc_32(dev->num_frames * imagesize))) {
87 memset(buff, 0, dev->num_frames * imagesize);
88 break;
89 }
90 dev->num_frames--;
91 }
92
93 for (i = 0; i < dev->num_frames; i++) {
94 dev->frame[i].bufmem = buff + i * imagesize;
95 dev->frame[i].buf.index = i;
96 dev->frame[i].buf.m.offset = i * imagesize;
97 dev->frame[i].buf.length = dev->frame_size;
98 dev->frame[i].buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
99 dev->frame[i].buf.sequence = 0;
100 dev->frame[i].buf.field = V4L2_FIELD_NONE;
101 dev->frame[i].buf.memory = V4L2_MEMORY_MMAP;
102 dev->frame[i].buf.flags = 0;
103 }
104 return dev->num_frames;
105 }
106
107 /*
108 * em28xx_queue_unusedframes()
109 * add all frames that are not currently in use to the inbuffer queue
110 */
111 void em28xx_queue_unusedframes(struct em28xx *dev)
112 {
113 unsigned long lock_flags;
114 u32 i;
115
116 for (i = 0; i < dev->num_frames; i++)
117 if (dev->frame[i].state == F_UNUSED) {
118 dev->frame[i].state = F_QUEUED;
119 spin_lock_irqsave(&dev->queue_lock, lock_flags);
120 list_add_tail(&dev->frame[i].frame, &dev->inqueue);
121 spin_unlock_irqrestore(&dev->queue_lock, lock_flags);
122 }
123 }
124
125 /*
126 * em28xx_release_buffers()
127 * free frame buffers
128 */
129 void em28xx_release_buffers(struct em28xx *dev)
130 {
131 if (dev->num_frames) {
132 vfree(dev->frame[0].bufmem);
133 dev->num_frames = 0;
134 }
135 }
136
137 /*
138 * em28xx_read_reg_req()
139 * reads data from the usb device specifying bRequest
140 */
141 int em28xx_read_reg_req_len(struct em28xx *dev, u8 req, u16 reg,
142 char *buf, int len)
143 {
144 int ret, byte;
145
146 if (dev->state & DEV_DISCONNECTED)
147 return(-ENODEV);
148
149 em28xx_regdbg("req=%02x, reg=%02x ", req, reg);
150
151 ret = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0), req,
152 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
153 0x0000, reg, buf, len, HZ);
154
155 if (reg_debug){
156 printk(ret < 0 ? " failed!\n" : "%02x values: ", ret);
157 for (byte = 0; byte < len; byte++) {
158 <<<<<<< HEAD:drivers/media/video/em28xx/em28xx-core.c
159 printk(" %02x", buf[byte]);
160 =======
161 printk(" %02x", (unsigned char)buf[byte]);
162 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/media/video/em28xx/em28xx-core.c
163 }
164 printk("\n");
165 }
166
167 return ret;
168 }
169
170 /*
171 * em28xx_read_reg_req()
172 * reads data from the usb device specifying bRequest
173 */
174 int em28xx_read_reg_req(struct em28xx *dev, u8 req, u16 reg)
175 {
176 u8 val;
177 int ret;
178
179 if (dev->state & DEV_DISCONNECTED)
180 return(-ENODEV);
181
182 em28xx_regdbg("req=%02x, reg=%02x:", req, reg);
183
184 ret = usb_control_msg(dev->udev, usb_rcvctrlpipe(dev->udev, 0), req,
185 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
186 0x0000, reg, &val, 1, HZ);
187
188 if (reg_debug)
189 <<<<<<< HEAD:drivers/media/video/em28xx/em28xx-core.c
190 printk(ret < 0 ? " failed!\n" : "%02x\n", val);
191 =======
192 printk(ret < 0 ? " failed!\n" :
193 "%02x\n", (unsigned char) val);
194 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/media/video/em28xx/em28xx-core.c
195
196 if (ret < 0)
197 return ret;
198
199 return val;
200 }
201
202 int em28xx_read_reg(struct em28xx *dev, u16 reg)
203 {
204 return em28xx_read_reg_req(dev, USB_REQ_GET_STATUS, reg);
205 }
206
207 /*
208 * em28xx_write_regs_req()
209 * sends data to the usb device, specifying bRequest
210 */
211 int em28xx_write_regs_req(struct em28xx *dev, u8 req, u16 reg, char *buf,
212 int len)
213 {
214 int ret;
215
216 /*usb_control_msg seems to expect a kmalloced buffer */
217 unsigned char *bufs;
218
219 if (dev->state & DEV_DISCONNECTED)
220 return(-ENODEV);
221
222 bufs = kmalloc(len, GFP_KERNEL);
223
224 em28xx_regdbg("req=%02x reg=%02x:", req, reg);
225
226 if (reg_debug) {
227 int i;
228 for (i = 0; i < len; ++i)
229 printk (" %02x", (unsigned char)buf[i]);
230 printk ("\n");
231 }
232
233 if (!bufs)
234 return -ENOMEM;
235 memcpy(bufs, buf, len);
236 ret = usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0), req,
237 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
238 0x0000, reg, bufs, len, HZ);
239 msleep(5); /* FIXME: magic number */
240 kfree(bufs);
241 return ret;
242 }
243
244 int em28xx_write_regs(struct em28xx *dev, u16 reg, char *buf, int len)
245 {
246 return em28xx_write_regs_req(dev, USB_REQ_GET_STATUS, reg, buf, len);
247 }
248
249 /*
250 * em28xx_write_reg_bits()
251 * sets only some bits (specified by bitmask) of a register, by first reading
252 * the actual value
253 */
254 <<<<<<< HEAD:drivers/media/video/em28xx/em28xx-core.c
255 int em28xx_write_reg_bits(struct em28xx *dev, u16 reg, u8 val,
256 =======
257 static int em28xx_write_reg_bits(struct em28xx *dev, u16 reg, u8 val,
258 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/media/video/em28xx/em28xx-core.c
259 u8 bitmask)
260 {
261 int oldval;
262 u8 newval;
263 if ((oldval = em28xx_read_reg(dev, reg)) < 0)
264 return oldval;
265 newval = (((u8) oldval) & ~bitmask) | (val & bitmask);
266 return em28xx_write_regs(dev, reg, &newval, 1);
267 }
268
269 /*
270 * em28xx_write_ac97()
271 * write a 16 bit value to the specified AC97 address (LSB first!)
272 */
273 static int em28xx_write_ac97(struct em28xx *dev, u8 reg, u8 *val)
274 {
275 <<<<<<< HEAD:drivers/media/video/em28xx/em28xx-core.c
276 int ret;
277 =======
278 int ret, i;
279 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/media/video/em28xx/em28xx-core.c
280 u8 addr = reg & 0x7f;
281 if ((ret = em28xx_write_regs(dev, AC97LSB_REG, val, 2)) < 0)
282 return ret;
283 if ((ret = em28xx_write_regs(dev, AC97ADDR_REG, &addr, 1)) < 0)
284 return ret;
285 <<<<<<< HEAD:drivers/media/video/em28xx/em28xx-core.c
286 if ((ret = em28xx_read_reg(dev, AC97BUSY_REG)) < 0)
287 return ret;
288 else if (((u8) ret) & 0x01) {
289 em28xx_warn ("AC97 command still being executed: not handled properly!\n");
290 =======
291
292 /* Wait up to 50 ms for AC97 command to complete */
293 for (i = 0; i < 10; i++) {
294 if ((ret = em28xx_read_reg(dev, AC97BUSY_REG)) < 0)
295 return ret;
296 if (!((u8) ret) & 0x01)
297 return 0;
298 msleep(5);
299 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/media/video/em28xx/em28xx-core.c
300 }
301 <<<<<<< HEAD:drivers/media/video/em28xx/em28xx-core.c
302 =======
303 em28xx_warn ("AC97 command still being executed: not handled properly!\n");
304 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/media/video/em28xx/em28xx-core.c
305 return 0;
306 }
307
308 <<<<<<< HEAD:drivers/media/video/em28xx/em28xx-core.c
309 int em28xx_set_audio_source(struct em28xx *dev)
310 =======
311 static int em28xx_set_audio_source(struct em28xx *dev)
312 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/media/video/em28xx/em28xx-core.c
313 {
314 static char *enable = "\x08\x08";
315 static char *disable = "\x08\x88";
316 char *video = enable, *line = disable;
317 <<<<<<< HEAD:drivers/media/video/em28xx/em28xx-core.c
318 int ret, no_ac97;
319 =======
320 int ret;
321 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/media/video/em28xx/em28xx-core.c
322 u8 input;
323
324 if (dev->is_em2800) {
325 if (dev->ctl_ainput)
326 input = EM2800_AUDIO_SRC_LINE;
327 else
328 input = EM2800_AUDIO_SRC_TUNER;
329
330 ret = em28xx_write_regs(dev, EM2800_AUDIOSRC_REG, &input, 1);
331 if (ret < 0)
332 return ret;
333 }
334
335 if (dev->has_msp34xx)
336 input = EM28XX_AUDIO_SRC_TUNER;
337 else {
338 switch (dev->ctl_ainput) {
339 case EM28XX_AMUX_VIDEO:
340 input = EM28XX_AUDIO_SRC_TUNER;
341 <<<<<<< HEAD:drivers/media/video/em28xx/em28xx-core.c
342 no_ac97 = 1;
343 =======
344 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/media/video/em28xx/em28xx-core.c
345 break;
346 case EM28XX_AMUX_LINE_IN:
347 input = EM28XX_AUDIO_SRC_LINE;
348 <<<<<<< HEAD:drivers/media/video/em28xx/em28xx-core.c
349 no_ac97 = 1;
350 =======
351 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/media/video/em28xx/em28xx-core.c
352 break;
353 case EM28XX_AMUX_AC97_VIDEO:
354 input = EM28XX_AUDIO_SRC_LINE;
355 break;
356 case EM28XX_AMUX_AC97_LINE_IN:
357 input = EM28XX_AUDIO_SRC_LINE;
358 video = disable;
359 line = enable;
360 break;
361 }
362 }
363
364 ret = em28xx_write_reg_bits(dev, AUDIOSRC_REG, input, 0xc0);
365 if (ret < 0)
366 return ret;
367 <<<<<<< HEAD:drivers/media/video/em28xx/em28xx-core.c
368 =======
369 msleep(5);
370 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/media/video/em28xx/em28xx-core.c
371
372 <<<<<<< HEAD:drivers/media/video/em28xx/em28xx-core.c
373 if (no_ac97)
374 return 0;
375
376 /* Sets AC97 mixer registers */
377
378 =======
379 /* Sets AC97 mixer registers
380 This is seems to be needed, even for non-ac97 configs
381 */
382 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/media/video/em28xx/em28xx-core.c
383 ret = em28xx_write_ac97(dev, VIDEO_AC97, video);
384 if (ret < 0)
385 return ret;
386
387 ret = em28xx_write_ac97(dev, LINE_IN_AC97, line);
388
389 return ret;
390 }
391
392 int em28xx_audio_analog_set(struct em28xx *dev)
393 {
394 int ret;
395 char s[2] = { 0x00, 0x00 };
396 u8 xclk = 0x07;
397
398 s[0] |= 0x1f - dev->volume;
399 s[1] |= 0x1f - dev->volume;
400
401 <<<<<<< HEAD:drivers/media/video/em28xx/em28xx-core.c
402 if (dev->mute)
403 s[1] |= 0x80;
404 =======
405 /* Mute */
406 s[1] |= 0x80;
407 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/media/video/em28xx/em28xx-core.c
408 ret = em28xx_write_ac97(dev, MASTER_AC97, s);
409 <<<<<<< HEAD:drivers/media/video/em28xx/em28xx-core.c
410 =======
411
412 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/media/video/em28xx/em28xx-core.c
413 if (ret < 0)
414 return ret;
415
416 if (dev->has_12mhz_i2s)
417 xclk |= 0x20;
418
419 if (!dev->mute)
420 xclk |= 0x80;
421
422 ret = em28xx_write_reg_bits(dev, XCLK_REG, xclk, 0xa7);
423 if (ret < 0)
424 return ret;
425 msleep(10);
426
427 /* Selects the proper audio input */
428 ret = em28xx_set_audio_source(dev);
429
430 <<<<<<< HEAD:drivers/media/video/em28xx/em28xx-core.c
431 =======
432 /* Unmute device */
433 if (!dev->mute)
434 s[1] &= ~0x80;
435 ret = em28xx_write_ac97(dev, MASTER_AC97, s);
436
437 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/media/video/em28xx/em28xx-core.c
438 return ret;
439 }
440 EXPORT_SYMBOL_GPL(em28xx_audio_analog_set);
441
442 int em28xx_colorlevels_set_default(struct em28xx *dev)
443 {
444 em28xx_write_regs(dev, YGAIN_REG, "\x10", 1); /* contrast */
445 em28xx_write_regs(dev, YOFFSET_REG, "\x00", 1); /* brightness */
446 em28xx_write_regs(dev, UVGAIN_REG, "\x10", 1); /* saturation */
447 em28xx_write_regs(dev, UOFFSET_REG, "\x00", 1);
448 em28xx_write_regs(dev, VOFFSET_REG, "\x00", 1);
449 em28xx_write_regs(dev, SHARPNESS_REG, "\x00", 1);
450
451 em28xx_write_regs(dev, GAMMA_REG, "\x20", 1);
452 em28xx_write_regs(dev, RGAIN_REG, "\x20", 1);
453 em28xx_write_regs(dev, GGAIN_REG, "\x20", 1);
454 em28xx_write_regs(dev, BGAIN_REG, "\x20", 1);
455 em28xx_write_regs(dev, ROFFSET_REG, "\x00", 1);
456 em28xx_write_regs(dev, GOFFSET_REG, "\x00", 1);
457 return em28xx_write_regs(dev, BOFFSET_REG, "\x00", 1);
458 }
459
460 int em28xx_capture_start(struct em28xx *dev, int start)
461 {
462 int ret;
463 /* FIXME: which is the best order? */
464 /* video registers are sampled by VREF */
465 if ((ret = em28xx_write_reg_bits(dev, USBSUSP_REG, start ? 0x10 : 0x00,
466 0x10)) < 0)
467 return ret;
468 /* enable video capture */
469 return em28xx_write_regs(dev, VINENABLE_REG, start ? "\x67" : "\x27", 1);
470 }
471
472 int em28xx_outfmt_set_yuv422(struct em28xx *dev)
473 {
474 em28xx_write_regs(dev, OUTFMT_REG, "\x34", 1);
475 em28xx_write_regs(dev, VINMODE_REG, "\x10", 1);
476 return em28xx_write_regs(dev, VINCTRL_REG, "\x11", 1);
477 }
478
479 static int em28xx_accumulator_set(struct em28xx *dev, u8 xmin, u8 xmax,
480 u8 ymin, u8 ymax)
481 {
482 em28xx_coredbg("em28xx Scale: (%d,%d)-(%d,%d)\n", xmin, ymin, xmax, ymax);
483
484 em28xx_write_regs(dev, XMIN_REG, &xmin, 1);
485 em28xx_write_regs(dev, XMAX_REG, &xmax, 1);
486 em28xx_write_regs(dev, YMIN_REG, &ymin, 1);
487 return em28xx_write_regs(dev, YMAX_REG, &ymax, 1);
488 }
489
490 static int em28xx_capture_area_set(struct em28xx *dev, u8 hstart, u8 vstart,
491 u16 width, u16 height)
492 {
493 u8 cwidth = width;
494 u8 cheight = height;
495 u8 overflow = (height >> 7 & 0x02) | (width >> 8 & 0x01);
496
497 em28xx_coredbg("em28xx Area Set: (%d,%d)\n", (width | (overflow & 2) << 7),
498 (height | (overflow & 1) << 8));
499
500 em28xx_write_regs(dev, HSTART_REG, &hstart, 1);
501 em28xx_write_regs(dev, VSTART_REG, &vstart, 1);
502 em28xx_write_regs(dev, CWIDTH_REG, &cwidth, 1);
503 em28xx_write_regs(dev, CHEIGHT_REG, &cheight, 1);
504 return em28xx_write_regs(dev, OFLOW_REG, &overflow, 1);
505 }
506
507 static int em28xx_scaler_set(struct em28xx *dev, u16 h, u16 v)
508 {
509 u8 mode;
510 /* the em2800 scaler only supports scaling down to 50% */
511 if(dev->is_em2800)
512 mode = (v ? 0x20 : 0x00) | (h ? 0x10 : 0x00);
513 else {
514 u8 buf[2];
515 buf[0] = h;
516 buf[1] = h >> 8;
517 em28xx_write_regs(dev, HSCALELOW_REG, (char *)buf, 2);
518 buf[0] = v;
519 buf[1] = v >> 8;
520 em28xx_write_regs(dev, VSCALELOW_REG, (char *)buf, 2);
521 /* it seems that both H and V scalers must be active to work correctly */
522 mode = (h || v)? 0x30: 0x00;
523 }
524 return em28xx_write_reg_bits(dev, COMPR_REG, mode, 0x30);
525 }
526
527 /* FIXME: this only function read values from dev */
528 int em28xx_resolution_set(struct em28xx *dev)
529 {
530 int width, height;
531 width = norm_maxw(dev);
532 height = norm_maxh(dev) >> 1;
533
534 em28xx_outfmt_set_yuv422(dev);
535 em28xx_accumulator_set(dev, 1, (width - 4) >> 2, 1, (height - 4) >> 2);
536 em28xx_capture_area_set(dev, 0, 0, width >> 2, height >> 2);
537 return em28xx_scaler_set(dev, dev->hscale, dev->vscale);
538 }
539
540
541 /******************* isoc transfer handling ****************************/
542
543 #ifdef ENABLE_DEBUG_ISOC_FRAMES
544 static void em28xx_isoc_dump(struct urb *urb)
545 {
546 int len = 0;
547 int ntrans = 0;
548 int i;
549
550 printk(KERN_DEBUG "isocIrq: sf=%d np=%d ec=%x\n",
551 urb->start_frame, urb->number_of_packets,
552 urb->error_count);
553 for (i = 0; i < urb->number_of_packets; i++) {
554 unsigned char *buf =
555 urb->transfer_buffer +
556 urb->iso_frame_desc[i].offset;
557 int alen = urb->iso_frame_desc[i].actual_length;
558 if (alen > 0) {
559 if (buf[0] == 0x88) {
560 ntrans++;
561 len += alen;
562 } else if (buf[0] == 0x22) {
563 printk(KERN_DEBUG
564 "= l=%d nt=%d bpp=%d\n",
565 len - 4 * ntrans, ntrans,
566 ntrans == 0 ? 0 : len / ntrans);
567 ntrans = 1;
568 len = alen;
569 } else
570 printk(KERN_DEBUG "!\n");
571 }
572 printk(KERN_DEBUG " n=%d s=%d al=%d %x\n", i,
573 urb->iso_frame_desc[i].status,
574 urb->iso_frame_desc[i].actual_length,
575 (unsigned int)
576 *((unsigned char *)(urb->transfer_buffer +
577 urb->iso_frame_desc[i].
578 offset)));
579 }
580 }
581 #endif
582
583 static inline int em28xx_isoc_video(struct em28xx *dev,struct em28xx_frame_t **f,
584 unsigned long *lock_flags, unsigned char buf)
585 {
586 if (!(buf & 0x01)) {
587 if ((*f)->state == F_GRABBING) {
588 /*previous frame is incomplete */
589 if ((*f)->fieldbytesused < dev->field_size) {
590 (*f)->state = F_ERROR;
591 em28xx_isocdbg ("dropping incomplete bottom field (%i missing bytes)",
592 dev->field_size-(*f)->fieldbytesused);
593 } else {
594 (*f)->state = F_DONE;
595 (*f)->buf.bytesused = dev->frame_size;
596 }
597 }
598 if ((*f)->state == F_DONE || (*f)->state == F_ERROR) {
599 /* move current frame to outqueue and get next free buffer from inqueue */
600 spin_lock_irqsave(&dev-> queue_lock, *lock_flags);
601 list_move_tail(&(*f)->frame, &dev->outqueue);
602 if (!list_empty(&dev->inqueue))
603 (*f) = list_entry(dev-> inqueue.next,
604 struct em28xx_frame_t,frame);
605 else
606 (*f) = NULL;
607 spin_unlock_irqrestore(&dev->queue_lock,*lock_flags);
608 }
609 if (!(*f)) {
610 em28xx_isocdbg ("new frame but no buffer is free");
611 return -1;
612 }
613 do_gettimeofday(&(*f)->buf.timestamp);
614 (*f)->buf.sequence = ++dev->frame_count;
615 (*f)->buf.field = V4L2_FIELD_INTERLACED;
616 (*f)->state = F_GRABBING;
617 (*f)->buf.bytesused = 0;
618 (*f)->top_field = 1;
619 (*f)->fieldbytesused = 0;
620 } else {
621 /* acquiring bottom field */
622 if ((*f)->state == F_GRABBING) {
623 if (!(*f)->top_field) {
624 (*f)->state = F_ERROR;
625 em28xx_isocdbg ("unexpected begin of bottom field; discarding it");
626 } else if ((*f)-> fieldbytesused < dev->field_size - 172) {
627 (*f)->state = F_ERROR;
628 em28xx_isocdbg ("dropping incomplete top field (%i missing bytes)",
629 dev->field_size-(*f)->fieldbytesused);
630 } else {
631 (*f)->top_field = 0;
632 (*f)->fieldbytesused = 0;
633 }
634 }
635 }
636 return (0);
637 }
638
639 static inline void em28xx_isoc_video_copy(struct em28xx *dev,
640 struct em28xx_frame_t **f, unsigned char *buf, int len)
641 {
642 void *fieldstart, *startwrite, *startread;
643 int linesdone, currlinedone, offset, lencopy,remain;
644
645 if(dev->frame_size != (*f)->buf.length){
646 em28xx_err("frame_size %i and buf.length %i are different!!!\n",dev->frame_size,(*f)->buf.length);
647 return;
648 }
649
650 if ((*f)->fieldbytesused + len > dev->field_size)
651 len =dev->field_size - (*f)->fieldbytesused;
652
653 if (buf[0] != 0x88 && buf[0] != 0x22) {
654 em28xx_isocdbg("frame is not complete\n");
655 startread = buf;
656 len+=4;
657 } else
658 startread = buf + 4;
659
660 remain = len;
661
662 if ((*f)->top_field)
663 fieldstart = (*f)->bufmem;
664 else
665 fieldstart = (*f)->bufmem + dev->bytesperline;
666
667 linesdone = (*f)->fieldbytesused / dev->bytesperline;
668 currlinedone = (*f)->fieldbytesused % dev->bytesperline;
669 offset = linesdone * dev->bytesperline * 2 + currlinedone;
670 startwrite = fieldstart + offset;
671 lencopy = dev->bytesperline - currlinedone;
672 lencopy = lencopy > remain ? remain : lencopy;
673
674 memcpy(startwrite, startread, lencopy);
675 remain -= lencopy;
676
677 while (remain > 0) {
678 startwrite += lencopy + dev->bytesperline;
679 startread += lencopy;
680 if (dev->bytesperline > remain)
681 lencopy = remain;
682 else
683 lencopy = dev->bytesperline;
684
685 memcpy(startwrite, startread, lencopy);
686 remain -= lencopy;
687 }
688
689 (*f)->fieldbytesused += len;
690 }
691
692 /*
693 * em28xx_isoIrq()
694 * handles the incoming isoc urbs and fills the frames from our inqueue
695 */
696 static void em28xx_isocIrq(struct urb *urb)
697 {
698 struct em28xx *dev = urb->context;
699 int i, status;
700 struct em28xx_frame_t **f;
701 unsigned long lock_flags;
702
703 if (!dev)
704 return;
705 #ifdef ENABLE_DEBUG_ISOC_FRAMES
706 if (isoc_debug>1)
707 em28xx_isoc_dump(urb);
708 #endif
709
710 if (urb->status == -ENOENT)
711 return;
712
713 f = &dev->frame_current;
714
715 if (dev->stream == STREAM_INTERRUPT) {
716 dev->stream = STREAM_OFF;
717 if ((*f))
718 (*f)->state = F_QUEUED;
719 em28xx_isocdbg("stream interrupted");
720 wake_up_interruptible(&dev->wait_stream);
721 }
722
723 if ((dev->state & DEV_DISCONNECTED) || (dev->state & DEV_MISCONFIGURED))
724 return;
725
726 if (dev->stream == STREAM_ON && !list_empty(&dev->inqueue)) {
727 if (!(*f))
728 (*f) = list_entry(dev->inqueue.next,
729 struct em28xx_frame_t, frame);
730
731 for (i = 0; i < urb->number_of_packets; i++) {
732 unsigned char *buf = urb->transfer_buffer +
733 urb->iso_frame_desc[i].offset;
734 int len = urb->iso_frame_desc[i].actual_length - 4;
735
736 if (urb->iso_frame_desc[i].status) {
737 em28xx_isocdbg("data error: [%d] len=%d, status=%d", i,
738 urb->iso_frame_desc[i].actual_length,
739 urb->iso_frame_desc[i].status);
740 if (urb->iso_frame_desc[i].status != -EPROTO)
741 continue;
742 }
743 if (urb->iso_frame_desc[i].actual_length <= 0) {
744 em28xx_isocdbg("packet %d is empty",i);
745 continue;
746 }
747 if (urb->iso_frame_desc[i].actual_length >
748 <<<<<<< HEAD:drivers/media/video/em28xx/em28xx-core.c
749 dev->max_pkt_size) {
750 =======
751 urb->iso_frame_desc[i].length) {
752 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/media/video/em28xx/em28xx-core.c
753 em28xx_isocdbg("packet bigger than packet size");
754 continue;
755 }
756 /*new frame */
757 if (buf[0] == 0x22 && buf[1] == 0x5a) {
758 em28xx_isocdbg("Video frame, length=%i!",len);
759
760 if (em28xx_isoc_video(dev,f,&lock_flags,buf[2]))
761 break;
762 } else if (buf[0]==0x33 && buf[1]==0x95 && buf[2]==0x00) {
763 em28xx_isocdbg("VBI HEADER!!!");
764 }
765
766 /* actual copying */
767 if ((*f)->state == F_GRABBING) {
768 em28xx_isoc_video_copy(dev,f,buf, len);
769 }
770 }
771 }
772
773 for (i = 0; i < urb->number_of_packets; i++) {
774 urb->iso_frame_desc[i].status = 0;
775 urb->iso_frame_desc[i].actual_length = 0;
776 }
777
778 urb->status = 0;
779 if ((status = usb_submit_urb(urb, GFP_ATOMIC))) {
780 em28xx_errdev("resubmit of urb failed (error=%i)\n", status);
781 dev->state |= DEV_MISCONFIGURED;
782 }
783 wake_up_interruptible(&dev->wait_frame);
784 return;
785 }
786
787 /*
788 * em28xx_uninit_isoc()
789 * deallocates the buffers and urbs allocated during em28xx_init_iosc()
790 */
791 void em28xx_uninit_isoc(struct em28xx *dev)
792 {
793 int i;
794
795 for (i = 0; i < EM28XX_NUM_BUFS; i++) {
796 if (dev->urb[i]) {
797 usb_kill_urb(dev->urb[i]);
798 <<<<<<< HEAD:drivers/media/video/em28xx/em28xx-core.c
799 if (dev->transfer_buffer[i]){
800 usb_buffer_free(dev->udev,(EM28XX_NUM_PACKETS*dev->max_pkt_size),dev->transfer_buffer[i],dev->urb[i]->transfer_dma);
801 =======
802 if (dev->transfer_buffer[i]) {
803 usb_buffer_free(dev->udev,
804 dev->urb[i]->transfer_buffer_length,
805 dev->transfer_buffer[i],
806 dev->urb[i]->transfer_dma);
807 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/media/video/em28xx/em28xx-core.c
808 }
809 usb_free_urb(dev->urb[i]);
810 }
811 dev->urb[i] = NULL;
812 dev->transfer_buffer[i] = NULL;
813 }
814 em28xx_capture_start(dev, 0);
815 }
816
817 /*
818 * em28xx_init_isoc()
819 * allocates transfer buffers and submits the urbs for isoc transfer
820 */
821 int em28xx_init_isoc(struct em28xx *dev)
822 {
823 /* change interface to 3 which allows the biggest packet sizes */
824 int i, errCode;
825 <<<<<<< HEAD:drivers/media/video/em28xx/em28xx-core.c
826 const int sb_size = EM28XX_NUM_PACKETS * dev->max_pkt_size;
827 =======
828 int sb_size;
829
830 em28xx_set_alternate(dev);
831 sb_size = EM28XX_NUM_PACKETS * dev->max_pkt_size;
832 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/media/video/em28xx/em28xx-core.c
833
834 /* reset streaming vars */
835 dev->frame_current = NULL;
836 dev->frame_count = 0;
837
838 /* allocate urbs */
839 for (i = 0; i < EM28XX_NUM_BUFS; i++) {
840 struct urb *urb;
841 <<<<<<< HEAD:drivers/media/video/em28xx/em28xx-core.c
842 int j, k;
843 =======
844 int j;
845 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/media/video/em28xx/em28xx-core.c
846 /* allocate transfer buffer */
847 urb = usb_alloc_urb(EM28XX_NUM_PACKETS, GFP_KERNEL);
848 if (!urb){
849 em28xx_errdev("cannot alloc urb %i\n", i);
850 em28xx_uninit_isoc(dev);
851 return -ENOMEM;
852 }
853 <<<<<<< HEAD:drivers/media/video/em28xx/em28xx-core.c
854 dev->transfer_buffer[i] = usb_buffer_alloc(dev->udev, sb_size, GFP_KERNEL,&urb->transfer_dma);
855 =======
856 dev->transfer_buffer[i] = usb_buffer_alloc(dev->udev, sb_size,
857 GFP_KERNEL,
858 &urb->transfer_dma);
859 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/media/video/em28xx/em28xx-core.c
860 if (!dev->transfer_buffer[i]) {
861 em28xx_errdev
862 ("unable to allocate %i bytes for transfer buffer %i\n",
863 sb_size, i);
864 em28xx_uninit_isoc(dev);
865 usb_free_urb(urb);
866 return -ENOMEM;
867 }
868 memset(dev->transfer_buffer[i], 0, sb_size);
869 urb->dev = dev->udev;
870 urb->context = dev;
871 urb->pipe = usb_rcvisocpipe(dev->udev, 0x82);
872 <<<<<<< HEAD:drivers/media/video/em28xx/em28xx-core.c
873 urb->transfer_flags = URB_ISO_ASAP;
874 =======
875 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
876 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/media/video/em28xx/em28xx-core.c
877 urb->interval = 1;
878 urb->transfer_buffer = dev->transfer_buffer[i];
879 urb->complete = em28xx_isocIrq;
880 urb->number_of_packets = EM28XX_NUM_PACKETS;
881 urb->transfer_buffer_length = sb_size;
882 <<<<<<< HEAD:drivers/media/video/em28xx/em28xx-core.c
883 for (j = k = 0; j < EM28XX_NUM_PACKETS;
884 j++, k += dev->max_pkt_size) {
885 urb->iso_frame_desc[j].offset = k;
886 urb->iso_frame_desc[j].length =
887 dev->max_pkt_size;
888 =======
889 for (j = 0; j < EM28XX_NUM_PACKETS; j++) {
890 urb->iso_frame_desc[j].offset = j * dev->max_pkt_size;
891 urb->iso_frame_desc[j].length = dev->max_pkt_size;
892 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/media/video/em28xx/em28xx-core.c
893 }
894 dev->urb[i] = urb;
895 }
896
897 /* submit urbs */
898 <<<<<<< HEAD:drivers/media/video/em28xx/em28xx-core.c
899 =======
900 em28xx_coredbg("Submitting %d urbs of %d packets (%d each)\n",
901 EM28XX_NUM_BUFS, EM28XX_NUM_PACKETS, dev->max_pkt_size);
902 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/media/video/em28xx/em28xx-core.c
903 for (i = 0; i < EM28XX_NUM_BUFS; i++) {
904 errCode = usb_submit_urb(dev->urb[i], GFP_KERNEL);
905 if (errCode) {
906 em28xx_errdev("submit of urb %i failed (error=%i)\n", i,
907 errCode);
908 em28xx_uninit_isoc(dev);
909 return errCode;
910 }
911 }
912
913 return 0;
914 }
915
916 int em28xx_set_alternate(struct em28xx *dev)
917 {
918 int errCode, prev_alt = dev->alt;
919 <<<<<<< HEAD:drivers/media/video/em28xx/em28xx-core.c
920 dev->alt = alt;
921 if (dev->alt == 0) {
922 int i;
923 for(i=0;i< dev->num_alt; i++)
924 if(dev->alt_max_pkt_size[i]>dev->alt_max_pkt_size[dev->alt])
925 dev->alt=i;
926 }
927 =======
928 int i;
929 unsigned int min_pkt_size = dev->bytesperline+4;
930
931 /* When image size is bigger than a ceirtain value,
932 the frame size should be increased, otherwise, only
933 green screen will be received.
934 */
935 if (dev->frame_size > 720*240*2)
936 min_pkt_size *= 2;
937
938 for (i = 0; i < dev->num_alt; i++)
939 if (dev->alt_max_pkt_size[i] >= min_pkt_size)
940 break;
941 dev->alt = i;
942 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/media/video/em28xx/em28xx-core.c
943
944 if (dev->alt != prev_alt) {
945 <<<<<<< HEAD:drivers/media/video/em28xx/em28xx-core.c
946 =======
947 em28xx_coredbg("minimum isoc packet size: %u (alt=%d)\n",
948 min_pkt_size, dev->alt);
949 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/media/video/em28xx/em28xx-core.c
950 dev->max_pkt_size = dev->alt_max_pkt_size[dev->alt];
951 <<<<<<< HEAD:drivers/media/video/em28xx/em28xx-core.c
952 em28xx_coredbg("setting alternate %d with wMaxPacketSize=%u\n", dev->alt,
953 dev->max_pkt_size);
954 =======
955 em28xx_coredbg("setting alternate %d with wMaxPacketSize=%u\n",
956 dev->alt, dev->max_pkt_size);
957 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/media/video/em28xx/em28xx-core.c
958 errCode = usb_set_interface(dev->udev, 0, dev->alt);
959 if (errCode < 0) {
960 em28xx_errdev ("cannot change alternate number to %d (error=%i)\n",
961 <<<<<<< HEAD:drivers/media/video/em28xx/em28xx-core.c
962 dev->alt, errCode);
963 =======
964 dev->alt, errCode);
965 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/media/video/em28xx/em28xx-core.c
966 return errCode;
967 }
968 }
969 return 0;
970 }
WRT350N Kernel Patches