?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[media] rename most media/video usb drivers to media/usb
[linux-2.6/btrfs-unstable.git] / drivers / media / usb / em28xx / em28xx-core.c
blobbed07a6c33f8156df80919725c05857cd0fd9b37
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/slab.h>
28 #include <linux/usb.h>
29 #include <linux/vmalloc.h>
30 #include <sound/ac97_codec.h>
31 #include <media/v4l2-common.h>
32
33 #include "em28xx.h"
34
35 /* #define ENABLE_DEBUG_ISOC_FRAMES */
36
37 static unsigned int core_debug;
38 module_param(core_debug, int, 0644);
39 MODULE_PARM_DESC(core_debug, "enable debug messages [core]");
40
41 #define em28xx_coredbg(fmt, arg...) do {\
42 if (core_debug) \
43 printk(KERN_INFO "%s %s :"fmt, \
44 dev->name, __func__ , ##arg); } while (0)
45
46 static unsigned int reg_debug;
47 module_param(reg_debug, int, 0644);
48 MODULE_PARM_DESC(reg_debug, "enable debug messages [URB reg]");
49
50 #define em28xx_regdbg(fmt, arg...) do {\
51 if (reg_debug) \
52 printk(KERN_INFO "%s %s :"fmt, \
53 dev->name, __func__ , ##arg); } while (0)
54
55 static int alt;
56 module_param(alt, int, 0644);
57 MODULE_PARM_DESC(alt, "alternate setting to use for video endpoint");
58
59 static unsigned int disable_vbi;
60 module_param(disable_vbi, int, 0644);
61 MODULE_PARM_DESC(disable_vbi, "disable vbi support");
62
63 /* FIXME */
64 #define em28xx_isocdbg(fmt, arg...) do {\
65 if (core_debug) \
66 printk(KERN_INFO "%s %s :"fmt, \
67 dev->name, __func__ , ##arg); } while (0)
68
69 /*
70 * em28xx_read_reg_req()
71 * reads data from the usb device specifying bRequest
72 */
73 int em28xx_read_reg_req_len(struct em28xx *dev, u8 req, u16 reg,
74 char *buf, int len)
75 {
76 int ret;
77 int pipe = usb_rcvctrlpipe(dev->udev, 0);
78
79 if (dev->state & DEV_DISCONNECTED)
80 return -ENODEV;
81
82 if (len > URB_MAX_CTRL_SIZE)
83 return -EINVAL;
84
85 if (reg_debug) {
86 printk(KERN_DEBUG "(pipe 0x%08x): "
87 "IN: %02x %02x %02x %02x %02x %02x %02x %02x ",
88 pipe,
89 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
90 req, 0, 0,
91 reg & 0xff, reg >> 8,
92 len & 0xff, len >> 8);
93 }
94
95 mutex_lock(&dev->ctrl_urb_lock);
96 ret = usb_control_msg(dev->udev, pipe, req,
97 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
98 0x0000, reg, dev->urb_buf, len, HZ);
99 if (ret < 0) {
100 if (reg_debug)
101 printk(" failed!\n");
102 mutex_unlock(&dev->ctrl_urb_lock);
103 return ret;
104 }
105
106 if (len)
107 memcpy(buf, dev->urb_buf, len);
108
109 mutex_unlock(&dev->ctrl_urb_lock);
110
111 if (reg_debug) {
112 int byte;
113
114 printk("<<<");
115 for (byte = 0; byte < len; byte++)
116 printk(" %02x", (unsigned char)buf[byte]);
117 printk("\n");
118 }
119
120 return ret;
121 }
122
123 /*
124 * em28xx_read_reg_req()
125 * reads data from the usb device specifying bRequest
126 */
127 int em28xx_read_reg_req(struct em28xx *dev, u8 req, u16 reg)
128 {
129 int ret;
130 u8 val;
131
132 ret = em28xx_read_reg_req_len(dev, req, reg, &val, 1);
133 if (ret < 0)
134 return ret;
135
136 return val;
137 }
138
139 int em28xx_read_reg(struct em28xx *dev, u16 reg)
140 {
141 return em28xx_read_reg_req(dev, USB_REQ_GET_STATUS, reg);
142 }
143 EXPORT_SYMBOL_GPL(em28xx_read_reg);
144
145 /*
146 * em28xx_write_regs_req()
147 * sends data to the usb device, specifying bRequest
148 */
149 int em28xx_write_regs_req(struct em28xx *dev, u8 req, u16 reg, char *buf,
150 int len)
151 {
152 int ret;
153 int pipe = usb_sndctrlpipe(dev->udev, 0);
154
155 if (dev->state & DEV_DISCONNECTED)
156 return -ENODEV;
157
158 if ((len < 1) || (len > URB_MAX_CTRL_SIZE))
159 return -EINVAL;
160
161 if (reg_debug) {
162 int byte;
163
164 printk(KERN_DEBUG "(pipe 0x%08x): "
165 "OUT: %02x %02x %02x %02x %02x %02x %02x %02x >>>",
166 pipe,
167 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
168 req, 0, 0,
169 reg & 0xff, reg >> 8,
170 len & 0xff, len >> 8);
171
172 for (byte = 0; byte < len; byte++)
173 printk(" %02x", (unsigned char)buf[byte]);
174 printk("\n");
175 }
176
177 mutex_lock(&dev->ctrl_urb_lock);
178 memcpy(dev->urb_buf, buf, len);
179 ret = usb_control_msg(dev->udev, pipe, req,
180 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
181 0x0000, reg, dev->urb_buf, len, HZ);
182 mutex_unlock(&dev->ctrl_urb_lock);
183
184 if (dev->wait_after_write)
185 msleep(dev->wait_after_write);
186
187 return ret;
188 }
189
190 int em28xx_write_regs(struct em28xx *dev, u16 reg, char *buf, int len)
191 {
192 int rc;
193
194 rc = em28xx_write_regs_req(dev, USB_REQ_GET_STATUS, reg, buf, len);
195
196 /* Stores GPO/GPIO values at the cache, if changed
197 Only write values should be stored, since input on a GPIO
198 register will return the input bits.
199 Not sure what happens on reading GPO register.
200 */
201 if (rc >= 0) {
202 if (reg == dev->reg_gpo_num)
203 dev->reg_gpo = buf[0];
204 else if (reg == dev->reg_gpio_num)
205 dev->reg_gpio = buf[0];
206 }
207
208 return rc;
209 }
210 EXPORT_SYMBOL_GPL(em28xx_write_regs);
211
212 /* Write a single register */
213 int em28xx_write_reg(struct em28xx *dev, u16 reg, u8 val)
214 {
215 return em28xx_write_regs(dev, reg, &val, 1);
216 }
217 EXPORT_SYMBOL_GPL(em28xx_write_reg);
218
219 /*
220 * em28xx_write_reg_bits()
221 * sets only some bits (specified by bitmask) of a register, by first reading
222 * the actual value
223 */
224 int em28xx_write_reg_bits(struct em28xx *dev, u16 reg, u8 val,
225 u8 bitmask)
226 {
227 int oldval;
228 u8 newval;
229
230 /* Uses cache for gpo/gpio registers */
231 if (reg == dev->reg_gpo_num)
232 oldval = dev->reg_gpo;
233 else if (reg == dev->reg_gpio_num)
234 oldval = dev->reg_gpio;
235 else
236 oldval = em28xx_read_reg(dev, reg);
237
238 if (oldval < 0)
239 return oldval;
240
241 newval = (((u8) oldval) & ~bitmask) | (val & bitmask);
242
243 return em28xx_write_regs(dev, reg, &newval, 1);
244 }
245 EXPORT_SYMBOL_GPL(em28xx_write_reg_bits);
246
247 /*
248 * em28xx_is_ac97_ready()
249 * Checks if ac97 is ready
250 */
251 static int em28xx_is_ac97_ready(struct em28xx *dev)
252 {
253 int ret, i;
254
255 /* Wait up to 50 ms for AC97 command to complete */
256 for (i = 0; i < 10; i++, msleep(5)) {
257 ret = em28xx_read_reg(dev, EM28XX_R43_AC97BUSY);
258 if (ret < 0)
259 return ret;
260
261 if (!(ret & 0x01))
262 return 0;
263 }
264
265 em28xx_warn("AC97 command still being executed: not handled properly!\n");
266 return -EBUSY;
267 }
268
269 /*
270 * em28xx_read_ac97()
271 * write a 16 bit value to the specified AC97 address (LSB first!)
272 */
273 int em28xx_read_ac97(struct em28xx *dev, u8 reg)
274 {
275 int ret;
276 u8 addr = (reg & 0x7f) | 0x80;
277 u16 val;
278
279 ret = em28xx_is_ac97_ready(dev);
280 if (ret < 0)
281 return ret;
282
283 ret = em28xx_write_regs(dev, EM28XX_R42_AC97ADDR, &addr, 1);
284 if (ret < 0)
285 return ret;
286
287 ret = dev->em28xx_read_reg_req_len(dev, 0, EM28XX_R40_AC97LSB,
288 (u8 *)&val, sizeof(val));
289
290 if (ret < 0)
291 return ret;
292 return le16_to_cpu(val);
293 }
294 EXPORT_SYMBOL_GPL(em28xx_read_ac97);
295
296 /*
297 * em28xx_write_ac97()
298 * write a 16 bit value to the specified AC97 address (LSB first!)
299 */
300 int em28xx_write_ac97(struct em28xx *dev, u8 reg, u16 val)
301 {
302 int ret;
303 u8 addr = reg & 0x7f;
304 __le16 value;
305
306 value = cpu_to_le16(val);
307
308 ret = em28xx_is_ac97_ready(dev);
309 if (ret < 0)
310 return ret;
311
312 ret = em28xx_write_regs(dev, EM28XX_R40_AC97LSB, (u8 *) &value, 2);
313 if (ret < 0)
314 return ret;
315
316 ret = em28xx_write_regs(dev, EM28XX_R42_AC97ADDR, &addr, 1);
317 if (ret < 0)
318 return ret;
319
320 return 0;
321 }
322 EXPORT_SYMBOL_GPL(em28xx_write_ac97);
323
324 struct em28xx_vol_itable {
325 enum em28xx_amux mux;
326 u8 reg;
327 };
328
329 static struct em28xx_vol_itable inputs[] = {
330 { EM28XX_AMUX_VIDEO, AC97_VIDEO },
331 { EM28XX_AMUX_LINE_IN, AC97_LINE },
332 { EM28XX_AMUX_PHONE, AC97_PHONE },
333 { EM28XX_AMUX_MIC, AC97_MIC },
334 { EM28XX_AMUX_CD, AC97_CD },
335 { EM28XX_AMUX_AUX, AC97_AUX },
336 { EM28XX_AMUX_PCM_OUT, AC97_PCM },
337 };
338
339 static int set_ac97_input(struct em28xx *dev)
340 {
341 int ret, i;
342 enum em28xx_amux amux = dev->ctl_ainput;
343
344 /* EM28XX_AMUX_VIDEO2 is a special case used to indicate that
345 em28xx should point to LINE IN, while AC97 should use VIDEO
346 */
347 if (amux == EM28XX_AMUX_VIDEO2)
348 amux = EM28XX_AMUX_VIDEO;
349
350 /* Mute all entres but the one that were selected */
351 for (i = 0; i < ARRAY_SIZE(inputs); i++) {
352 if (amux == inputs[i].mux)
353 ret = em28xx_write_ac97(dev, inputs[i].reg, 0x0808);
354 else
355 ret = em28xx_write_ac97(dev, inputs[i].reg, 0x8000);
356
357 if (ret < 0)
358 em28xx_warn("couldn't setup AC97 register %d\n",
359 inputs[i].reg);
360 }
361 return 0;
362 }
363
364 static int em28xx_set_audio_source(struct em28xx *dev)
365 {
366 int ret;
367 u8 input;
368
369 if (dev->board.is_em2800) {
370 if (dev->ctl_ainput == EM28XX_AMUX_VIDEO)
371 input = EM2800_AUDIO_SRC_TUNER;
372 else
373 input = EM2800_AUDIO_SRC_LINE;
374
375 ret = em28xx_write_regs(dev, EM2800_R08_AUDIOSRC, &input, 1);
376 if (ret < 0)
377 return ret;
378 }
379
380 if (dev->board.has_msp34xx)
381 input = EM28XX_AUDIO_SRC_TUNER;
382 else {
383 switch (dev->ctl_ainput) {
384 case EM28XX_AMUX_VIDEO:
385 input = EM28XX_AUDIO_SRC_TUNER;
386 break;
387 default:
388 input = EM28XX_AUDIO_SRC_LINE;
389 break;
390 }
391 }
392
393 if (dev->board.mute_gpio && dev->mute)
394 em28xx_gpio_set(dev, dev->board.mute_gpio);
395 else
396 em28xx_gpio_set(dev, INPUT(dev->ctl_input)->gpio);
397
398 ret = em28xx_write_reg_bits(dev, EM28XX_R0E_AUDIOSRC, input, 0xc0);
399 if (ret < 0)
400 return ret;
401 msleep(5);
402
403 switch (dev->audio_mode.ac97) {
404 case EM28XX_NO_AC97:
405 break;
406 default:
407 ret = set_ac97_input(dev);
408 }
409
410 return ret;
411 }
412
413 struct em28xx_vol_otable {
414 enum em28xx_aout mux;
415 u8 reg;
416 };
417
418 static const struct em28xx_vol_otable outputs[] = {
419 { EM28XX_AOUT_MASTER, AC97_MASTER },
420 { EM28XX_AOUT_LINE, AC97_HEADPHONE },
421 { EM28XX_AOUT_MONO, AC97_MASTER_MONO },
422 { EM28XX_AOUT_LFE, AC97_CENTER_LFE_MASTER },
423 { EM28XX_AOUT_SURR, AC97_SURROUND_MASTER },
424 };
425
426 int em28xx_audio_analog_set(struct em28xx *dev)
427 {
428 int ret, i;
429 u8 xclk;
430
431 if (!dev->audio_mode.has_audio)
432 return 0;
433
434 /* It is assumed that all devices use master volume for output.
435 It would be possible to use also line output.
436 */
437 if (dev->audio_mode.ac97 != EM28XX_NO_AC97) {
438 /* Mute all outputs */
439 for (i = 0; i < ARRAY_SIZE(outputs); i++) {
440 ret = em28xx_write_ac97(dev, outputs[i].reg, 0x8000);
441 if (ret < 0)
442 em28xx_warn("couldn't setup AC97 register %d\n",
443 outputs[i].reg);
444 }
445 }
446
447 xclk = dev->board.xclk & 0x7f;
448 if (!dev->mute)
449 xclk |= EM28XX_XCLK_AUDIO_UNMUTE;
450
451 ret = em28xx_write_reg(dev, EM28XX_R0F_XCLK, xclk);
452 if (ret < 0)
453 return ret;
454 msleep(10);
455
456 /* Selects the proper audio input */
457 ret = em28xx_set_audio_source(dev);
458
459 /* Sets volume */
460 if (dev->audio_mode.ac97 != EM28XX_NO_AC97) {
461 int vol;
462
463 em28xx_write_ac97(dev, AC97_POWERDOWN, 0x4200);
464 em28xx_write_ac97(dev, AC97_EXTENDED_STATUS, 0x0031);
465 em28xx_write_ac97(dev, AC97_PCM_LR_ADC_RATE, 0xbb80);
466
467 /* LSB: left channel - both channels with the same level */
468 vol = (0x1f - dev->volume) | ((0x1f - dev->volume) << 8);
469
470 /* Mute device, if needed */
471 if (dev->mute)
472 vol |= 0x8000;
473
474 /* Sets volume */
475 for (i = 0; i < ARRAY_SIZE(outputs); i++) {
476 if (dev->ctl_aoutput & outputs[i].mux)
477 ret = em28xx_write_ac97(dev, outputs[i].reg,
478 vol);
479 if (ret < 0)
480 em28xx_warn("couldn't setup AC97 register %d\n",
481 outputs[i].reg);
482 }
483
484 if (dev->ctl_aoutput & EM28XX_AOUT_PCM_IN) {
485 int sel = ac97_return_record_select(dev->ctl_aoutput);
486
487 /* Use the same input for both left and right
488 channels */
489 sel |= (sel << 8);
490
491 em28xx_write_ac97(dev, AC97_REC_SEL, sel);
492 }
493 }
494
495 return ret;
496 }
497 EXPORT_SYMBOL_GPL(em28xx_audio_analog_set);
498
499 int em28xx_audio_setup(struct em28xx *dev)
500 {
501 int vid1, vid2, feat, cfg;
502 u32 vid;
503
504 if (dev->chip_id == CHIP_ID_EM2870 || dev->chip_id == CHIP_ID_EM2874
505 || dev->chip_id == CHIP_ID_EM28174) {
506 /* Digital only device - don't load any alsa module */
507 dev->audio_mode.has_audio = false;
508 dev->has_audio_class = false;
509 dev->has_alsa_audio = false;
510 return 0;
511 }
512
513 dev->audio_mode.has_audio = true;
514
515 /* See how this device is configured */
516 cfg = em28xx_read_reg(dev, EM28XX_R00_CHIPCFG);
517 em28xx_info("Config register raw data: 0x%02x\n", cfg);
518 if (cfg < 0) {
519 /* Register read error? */
520 cfg = EM28XX_CHIPCFG_AC97; /* Be conservative */
521 } else if ((cfg & EM28XX_CHIPCFG_AUDIOMASK) == 0x00) {
522 /* The device doesn't have vendor audio at all */
523 dev->has_alsa_audio = false;
524 dev->audio_mode.has_audio = false;
525 return 0;
526 } else if ((cfg & EM28XX_CHIPCFG_AUDIOMASK) ==
527 EM28XX_CHIPCFG_I2S_3_SAMPRATES) {
528 em28xx_info("I2S Audio (3 sample rates)\n");
529 dev->audio_mode.i2s_3rates = 1;
530 } else if ((cfg & EM28XX_CHIPCFG_AUDIOMASK) ==
531 EM28XX_CHIPCFG_I2S_5_SAMPRATES) {
532 em28xx_info("I2S Audio (5 sample rates)\n");
533 dev->audio_mode.i2s_5rates = 1;
534 }
535
536 if ((cfg & EM28XX_CHIPCFG_AUDIOMASK) != EM28XX_CHIPCFG_AC97) {
537 /* Skip the code that does AC97 vendor detection */
538 dev->audio_mode.ac97 = EM28XX_NO_AC97;
539 goto init_audio;
540 }
541
542 dev->audio_mode.ac97 = EM28XX_AC97_OTHER;
543
544 vid1 = em28xx_read_ac97(dev, AC97_VENDOR_ID1);
545 if (vid1 < 0) {
546 /*
547 * Device likely doesn't support AC97
548 * Note: (some) em2800 devices without eeprom reports 0x91 on
549 * CHIPCFG register, even not having an AC97 chip
550 */
551 em28xx_warn("AC97 chip type couldn't be determined\n");
552 dev->audio_mode.ac97 = EM28XX_NO_AC97;
553 dev->has_alsa_audio = false;
554 dev->audio_mode.has_audio = false;
555 goto init_audio;
556 }
557
558 vid2 = em28xx_read_ac97(dev, AC97_VENDOR_ID2);
559 if (vid2 < 0)
560 goto init_audio;
561
562 vid = vid1 << 16 | vid2;
563
564 dev->audio_mode.ac97_vendor_id = vid;
565 em28xx_warn("AC97 vendor ID = 0x%08x\n", vid);
566
567 feat = em28xx_read_ac97(dev, AC97_RESET);
568 if (feat < 0)
569 goto init_audio;
570
571 dev->audio_mode.ac97_feat = feat;
572 em28xx_warn("AC97 features = 0x%04x\n", feat);
573
574 /* Try to identify what audio processor we have */
575 if (((vid == 0xffffffff) || (vid == 0x83847650)) && (feat == 0x6a90))
576 dev->audio_mode.ac97 = EM28XX_AC97_EM202;
577 else if ((vid >> 8) == 0x838476)
578 dev->audio_mode.ac97 = EM28XX_AC97_SIGMATEL;
579
580 init_audio:
581 /* Reports detected AC97 processor */
582 switch (dev->audio_mode.ac97) {
583 case EM28XX_NO_AC97:
584 em28xx_info("No AC97 audio processor\n");
585 break;
586 case EM28XX_AC97_EM202:
587 em28xx_info("Empia 202 AC97 audio processor detected\n");
588 break;
589 case EM28XX_AC97_SIGMATEL:
590 em28xx_info("Sigmatel audio processor detected(stac 97%02x)\n",
591 dev->audio_mode.ac97_vendor_id & 0xff);
592 break;
593 case EM28XX_AC97_OTHER:
594 em28xx_warn("Unknown AC97 audio processor detected!\n");
595 break;
596 default:
597 break;
598 }
599
600 return em28xx_audio_analog_set(dev);
601 }
602 EXPORT_SYMBOL_GPL(em28xx_audio_setup);
603
604 int em28xx_colorlevels_set_default(struct em28xx *dev)
605 {
606 em28xx_write_reg(dev, EM28XX_R20_YGAIN, 0x10); /* contrast */
607 em28xx_write_reg(dev, EM28XX_R21_YOFFSET, 0x00); /* brightness */
608 em28xx_write_reg(dev, EM28XX_R22_UVGAIN, 0x10); /* saturation */
609 em28xx_write_reg(dev, EM28XX_R23_UOFFSET, 0x00);
610 em28xx_write_reg(dev, EM28XX_R24_VOFFSET, 0x00);
611 em28xx_write_reg(dev, EM28XX_R25_SHARPNESS, 0x00);
612
613 em28xx_write_reg(dev, EM28XX_R14_GAMMA, 0x20);
614 em28xx_write_reg(dev, EM28XX_R15_RGAIN, 0x20);
615 em28xx_write_reg(dev, EM28XX_R16_GGAIN, 0x20);
616 em28xx_write_reg(dev, EM28XX_R17_BGAIN, 0x20);
617 em28xx_write_reg(dev, EM28XX_R18_ROFFSET, 0x00);
618 em28xx_write_reg(dev, EM28XX_R19_GOFFSET, 0x00);
619 return em28xx_write_reg(dev, EM28XX_R1A_BOFFSET, 0x00);
620 }
621
622 int em28xx_capture_start(struct em28xx *dev, int start)
623 {
624 int rc;
625
626 if (dev->chip_id == CHIP_ID_EM2874 ||
627 dev->chip_id == CHIP_ID_EM2884 ||
628 dev->chip_id == CHIP_ID_EM28174) {
629 /* The Transport Stream Enable Register moved in em2874 */
630 if (!start) {
631 rc = em28xx_write_reg_bits(dev, EM2874_R5F_TS_ENABLE,
632 0x00,
633 EM2874_TS1_CAPTURE_ENABLE);
634 return rc;
635 }
636
637 /* Enable Transport Stream */
638 rc = em28xx_write_reg_bits(dev, EM2874_R5F_TS_ENABLE,
639 EM2874_TS1_CAPTURE_ENABLE,
640 EM2874_TS1_CAPTURE_ENABLE);
641 return rc;
642 }
643
644
645 /* FIXME: which is the best order? */
646 /* video registers are sampled by VREF */
647 rc = em28xx_write_reg_bits(dev, EM28XX_R0C_USBSUSP,
648 start ? 0x10 : 0x00, 0x10);
649 if (rc < 0)
650 return rc;
651
652 if (!start) {
653 /* disable video capture */
654 rc = em28xx_write_reg(dev, EM28XX_R12_VINENABLE, 0x27);
655 return rc;
656 }
657
658 if (dev->board.is_webcam)
659 rc = em28xx_write_reg(dev, 0x13, 0x0c);
660
661 /* enable video capture */
662 rc = em28xx_write_reg(dev, 0x48, 0x00);
663
664 if (dev->mode == EM28XX_ANALOG_MODE)
665 rc = em28xx_write_reg(dev, EM28XX_R12_VINENABLE, 0x67);
666 else
667 rc = em28xx_write_reg(dev, EM28XX_R12_VINENABLE, 0x37);
668
669 msleep(6);
670
671 return rc;
672 }
673
674 int em28xx_vbi_supported(struct em28xx *dev)
675 {
676 /* Modprobe option to manually disable */
677 if (disable_vbi == 1)
678 return 0;
679
680 if (dev->chip_id == CHIP_ID_EM2860 ||
681 dev->chip_id == CHIP_ID_EM2883)
682 return 1;
683
684 /* Version of em28xx that does not support VBI */
685 return 0;
686 }
687
688 int em28xx_set_outfmt(struct em28xx *dev)
689 {
690 int ret;
691 u8 vinctrl;
692
693 ret = em28xx_write_reg_bits(dev, EM28XX_R27_OUTFMT,
694 dev->format->reg | 0x20, 0xff);
695 if (ret < 0)
696 return ret;
697
698 ret = em28xx_write_reg(dev, EM28XX_R10_VINMODE, dev->vinmode);
699 if (ret < 0)
700 return ret;
701
702 vinctrl = dev->vinctl;
703 if (em28xx_vbi_supported(dev) == 1) {
704 vinctrl |= EM28XX_VINCTRL_VBI_RAW;
705 em28xx_write_reg(dev, EM28XX_R34_VBI_START_H, 0x00);
706 em28xx_write_reg(dev, EM28XX_R36_VBI_WIDTH, dev->vbi_width/4);
707 em28xx_write_reg(dev, EM28XX_R37_VBI_HEIGHT, dev->vbi_height);
708 if (dev->norm & V4L2_STD_525_60) {
709 /* NTSC */
710 em28xx_write_reg(dev, EM28XX_R35_VBI_START_V, 0x09);
711 } else if (dev->norm & V4L2_STD_625_50) {
712 /* PAL */
713 em28xx_write_reg(dev, EM28XX_R35_VBI_START_V, 0x07);
714 }
715 }
716
717 return em28xx_write_reg(dev, EM28XX_R11_VINCTRL, vinctrl);
718 }
719
720 static int em28xx_accumulator_set(struct em28xx *dev, u8 xmin, u8 xmax,
721 u8 ymin, u8 ymax)
722 {
723 em28xx_coredbg("em28xx Scale: (%d,%d)-(%d,%d)\n",
724 xmin, ymin, xmax, ymax);
725
726 em28xx_write_regs(dev, EM28XX_R28_XMIN, &xmin, 1);
727 em28xx_write_regs(dev, EM28XX_R29_XMAX, &xmax, 1);
728 em28xx_write_regs(dev, EM28XX_R2A_YMIN, &ymin, 1);
729 return em28xx_write_regs(dev, EM28XX_R2B_YMAX, &ymax, 1);
730 }
731
732 static int em28xx_capture_area_set(struct em28xx *dev, u8 hstart, u8 vstart,
733 u16 width, u16 height)
734 {
735 u8 cwidth = width;
736 u8 cheight = height;
737 u8 overflow = (height >> 7 & 0x02) | (width >> 8 & 0x01);
738
739 em28xx_coredbg("em28xx Area Set: (%d,%d)\n",
740 (width | (overflow & 2) << 7),
741 (height | (overflow & 1) << 8));
742
743 em28xx_write_regs(dev, EM28XX_R1C_HSTART, &hstart, 1);
744 em28xx_write_regs(dev, EM28XX_R1D_VSTART, &vstart, 1);
745 em28xx_write_regs(dev, EM28XX_R1E_CWIDTH, &cwidth, 1);
746 em28xx_write_regs(dev, EM28XX_R1F_CHEIGHT, &cheight, 1);
747 return em28xx_write_regs(dev, EM28XX_R1B_OFLOW, &overflow, 1);
748 }
749
750 static int em28xx_scaler_set(struct em28xx *dev, u16 h, u16 v)
751 {
752 u8 mode;
753 /* the em2800 scaler only supports scaling down to 50% */
754
755 if (dev->board.is_em2800) {
756 mode = (v ? 0x20 : 0x00) | (h ? 0x10 : 0x00);
757 } else {
758 u8 buf[2];
759
760 buf[0] = h;
761 buf[1] = h >> 8;
762 em28xx_write_regs(dev, EM28XX_R30_HSCALELOW, (char *)buf, 2);
763
764 buf[0] = v;
765 buf[1] = v >> 8;
766 em28xx_write_regs(dev, EM28XX_R32_VSCALELOW, (char *)buf, 2);
767 /* it seems that both H and V scalers must be active
768 to work correctly */
769 mode = (h || v) ? 0x30 : 0x00;
770 }
771 return em28xx_write_reg_bits(dev, EM28XX_R26_COMPR, mode, 0x30);
772 }
773
774 /* FIXME: this only function read values from dev */
775 int em28xx_resolution_set(struct em28xx *dev)
776 {
777 int width, height;
778 width = norm_maxw(dev);
779 height = norm_maxh(dev);
780
781 /* Properly setup VBI */
782 dev->vbi_width = 720;
783 if (dev->norm & V4L2_STD_525_60)
784 dev->vbi_height = 12;
785 else
786 dev->vbi_height = 18;
787
788 em28xx_set_outfmt(dev);
789
790 em28xx_accumulator_set(dev, 1, (width - 4) >> 2, 1, (height - 4) >> 2);
791
792 /* If we don't set the start position to 2 in VBI mode, we end up
793 with line 20/21 being YUYV encoded instead of being in 8-bit
794 greyscale. The core of the issue is that line 21 (and line 23 for
795 PAL WSS) are inside of active video region, and as a result they
796 get the pixelformatting associated with that area. So by cropping
797 it out, we end up with the same format as the rest of the VBI
798 region */
799 if (em28xx_vbi_supported(dev) == 1)
800 em28xx_capture_area_set(dev, 0, 2, width >> 2, height >> 2);
801 else
802 em28xx_capture_area_set(dev, 0, 0, width >> 2, height >> 2);
803
804 return em28xx_scaler_set(dev, dev->hscale, dev->vscale);
805 }
806
807 int em28xx_set_alternate(struct em28xx *dev)
808 {
809 int errCode, prev_alt = dev->alt;
810 int i;
811 unsigned int min_pkt_size = dev->width * 2 + 4;
812
813 /*
814 * alt = 0 is used only for control messages, so, only values
815 * greater than 0 can be used for streaming.
816 */
817 if (alt && alt < dev->num_alt) {
818 em28xx_coredbg("alternate forced to %d\n", dev->alt);
819 dev->alt = alt;
820 goto set_alt;
821 }
822
823 /* When image size is bigger than a certain value,
824 the frame size should be increased, otherwise, only
825 green screen will be received.
826 */
827 if (dev->width * 2 * dev->height > 720 * 240 * 2)
828 min_pkt_size *= 2;
829
830 for (i = 0; i < dev->num_alt; i++) {
831 /* stop when the selected alt setting offers enough bandwidth */
832 if (dev->alt_max_pkt_size[i] >= min_pkt_size) {
833 dev->alt = i;
834 break;
835 /* otherwise make sure that we end up with the maximum bandwidth
836 because the min_pkt_size equation might be wrong...
837 */
838 } else if (dev->alt_max_pkt_size[i] >
839 dev->alt_max_pkt_size[dev->alt])
840 dev->alt = i;
841 }
842
843 set_alt:
844 if (dev->alt != prev_alt) {
845 em28xx_coredbg("minimum isoc packet size: %u (alt=%d)\n",
846 min_pkt_size, dev->alt);
847 dev->max_pkt_size = dev->alt_max_pkt_size[dev->alt];
848 em28xx_coredbg("setting alternate %d with wMaxPacketSize=%u\n",
849 dev->alt, dev->max_pkt_size);
850 errCode = usb_set_interface(dev->udev, 0, dev->alt);
851 if (errCode < 0) {
852 em28xx_errdev("cannot change alternate number to %d (error=%i)\n",
853 dev->alt, errCode);
854 return errCode;
855 }
856 }
857 return 0;
858 }
859
860 int em28xx_gpio_set(struct em28xx *dev, struct em28xx_reg_seq *gpio)
861 {
862 int rc = 0;
863
864 if (!gpio)
865 return rc;
866
867 if (dev->mode != EM28XX_SUSPEND) {
868 em28xx_write_reg(dev, 0x48, 0x00);
869 if (dev->mode == EM28XX_ANALOG_MODE)
870 em28xx_write_reg(dev, EM28XX_R12_VINENABLE, 0x67);
871 else
872 em28xx_write_reg(dev, EM28XX_R12_VINENABLE, 0x37);
873 msleep(6);
874 }
875
876 /* Send GPIO reset sequences specified at board entry */
877 while (gpio->sleep >= 0) {
878 if (gpio->reg >= 0) {
879 rc = em28xx_write_reg_bits(dev,
880 gpio->reg,
881 gpio->val,
882 gpio->mask);
883 if (rc < 0)
884 return rc;
885 }
886 if (gpio->sleep > 0)
887 msleep(gpio->sleep);
888
889 gpio++;
890 }
891 return rc;
892 }
893 EXPORT_SYMBOL_GPL(em28xx_gpio_set);
894
895 int em28xx_set_mode(struct em28xx *dev, enum em28xx_mode set_mode)
896 {
897 if (dev->mode == set_mode)
898 return 0;
899
900 if (set_mode == EM28XX_SUSPEND) {
901 dev->mode = set_mode;
902
903 /* FIXME: add suspend support for ac97 */
904
905 return em28xx_gpio_set(dev, dev->board.suspend_gpio);
906 }
907
908 dev->mode = set_mode;
909
910 if (dev->mode == EM28XX_DIGITAL_MODE)
911 return em28xx_gpio_set(dev, dev->board.dvb_gpio);
912 else
913 return em28xx_gpio_set(dev, INPUT(dev->ctl_input)->gpio);
914 }
915 EXPORT_SYMBOL_GPL(em28xx_set_mode);
916
917 /* ------------------------------------------------------------------
918 URB control
919 ------------------------------------------------------------------*/
920
921 /*
922 * IRQ callback, called by URB callback
923 */
924 static void em28xx_irq_callback(struct urb *urb)
925 {
926 struct em28xx *dev = urb->context;
927 int i;
928
929 switch (urb->status) {
930 case 0: /* success */
931 case -ETIMEDOUT: /* NAK */
932 break;
933 case -ECONNRESET: /* kill */
934 case -ENOENT:
935 case -ESHUTDOWN:
936 return;
937 default: /* error */
938 em28xx_isocdbg("urb completition error %d.\n", urb->status);
939 break;
940 }
941
942 /* Copy data from URB */
943 spin_lock(&dev->slock);
944 dev->isoc_ctl.isoc_copy(dev, urb);
945 spin_unlock(&dev->slock);
946
947 /* Reset urb buffers */
948 for (i = 0; i < urb->number_of_packets; i++) {
949 urb->iso_frame_desc[i].status = 0;
950 urb->iso_frame_desc[i].actual_length = 0;
951 }
952 urb->status = 0;
953
954 urb->status = usb_submit_urb(urb, GFP_ATOMIC);
955 if (urb->status) {
956 em28xx_isocdbg("urb resubmit failed (error=%i)\n",
957 urb->status);
958 }
959 }
960
961 /*
962 * Stop and Deallocate URBs
963 */
964 void em28xx_uninit_isoc(struct em28xx *dev, enum em28xx_mode mode)
965 {
966 struct urb *urb;
967 struct em28xx_usb_isoc_bufs *isoc_bufs;
968 int i;
969
970 em28xx_isocdbg("em28xx: called em28xx_uninit_isoc in mode %d\n", mode);
971
972 if (mode == EM28XX_DIGITAL_MODE)
973 isoc_bufs = &dev->isoc_ctl.digital_bufs;
974 else
975 isoc_bufs = &dev->isoc_ctl.analog_bufs;
976
977 for (i = 0; i < isoc_bufs->num_bufs; i++) {
978 urb = isoc_bufs->urb[i];
979 if (urb) {
980 if (!irqs_disabled())
981 usb_kill_urb(urb);
982 else
983 usb_unlink_urb(urb);
984
985 if (isoc_bufs->transfer_buffer[i]) {
986 usb_free_coherent(dev->udev,
987 urb->transfer_buffer_length,
988 isoc_bufs->transfer_buffer[i],
989 urb->transfer_dma);
990 }
991 usb_free_urb(urb);
992 isoc_bufs->urb[i] = NULL;
993 }
994 isoc_bufs->transfer_buffer[i] = NULL;
995 }
996
997 kfree(isoc_bufs->urb);
998 kfree(isoc_bufs->transfer_buffer);
999
1000 isoc_bufs->urb = NULL;
1001 isoc_bufs->transfer_buffer = NULL;
1002 isoc_bufs->num_bufs = 0;
1003
1004 em28xx_capture_start(dev, 0);
1005 }
1006 EXPORT_SYMBOL_GPL(em28xx_uninit_isoc);
1007
1008 /*
1009 * Stop URBs
1010 */
1011 void em28xx_stop_urbs(struct em28xx *dev)
1012 {
1013 int i;
1014 struct urb *urb;
1015 struct em28xx_usb_isoc_bufs *isoc_bufs = &dev->isoc_ctl.digital_bufs;
1016
1017 em28xx_isocdbg("em28xx: called em28xx_stop_urbs\n");
1018
1019 for (i = 0; i < isoc_bufs->num_bufs; i++) {
1020 urb = isoc_bufs->urb[i];
1021 if (urb) {
1022 if (!irqs_disabled())
1023 usb_kill_urb(urb);
1024 else
1025 usb_unlink_urb(urb);
1026 }
1027 }
1028
1029 em28xx_capture_start(dev, 0);
1030 }
1031 EXPORT_SYMBOL_GPL(em28xx_stop_urbs);
1032
1033 /*
1034 * Allocate URBs
1035 */
1036 int em28xx_alloc_isoc(struct em28xx *dev, enum em28xx_mode mode,
1037 int max_packets, int num_bufs, int max_pkt_size)
1038 {
1039 struct em28xx_usb_isoc_bufs *isoc_bufs;
1040 int i;
1041 int sb_size, pipe;
1042 struct urb *urb;
1043 int j, k;
1044
1045 em28xx_isocdbg("em28xx: called em28xx_alloc_isoc in mode %d\n", mode);
1046
1047 if (mode == EM28XX_DIGITAL_MODE)
1048 isoc_bufs = &dev->isoc_ctl.digital_bufs;
1049 else
1050 isoc_bufs = &dev->isoc_ctl.analog_bufs;
1051
1052 /* De-allocates all pending stuff */
1053 em28xx_uninit_isoc(dev, mode);
1054
1055 isoc_bufs->num_bufs = num_bufs;
1056
1057 isoc_bufs->urb = kzalloc(sizeof(void *)*num_bufs, GFP_KERNEL);
1058 if (!isoc_bufs->urb) {
1059 em28xx_errdev("cannot alloc memory for usb buffers\n");
1060 return -ENOMEM;
1061 }
1062
1063 isoc_bufs->transfer_buffer = kzalloc(sizeof(void *)*num_bufs,
1064 GFP_KERNEL);
1065 if (!isoc_bufs->transfer_buffer) {
1066 em28xx_errdev("cannot allocate memory for usb transfer\n");
1067 kfree(isoc_bufs->urb);
1068 return -ENOMEM;
1069 }
1070
1071 isoc_bufs->max_pkt_size = max_pkt_size;
1072 isoc_bufs->num_packets = max_packets;
1073 dev->isoc_ctl.vid_buf = NULL;
1074 dev->isoc_ctl.vbi_buf = NULL;
1075
1076 sb_size = isoc_bufs->num_packets * isoc_bufs->max_pkt_size;
1077
1078 /* allocate urbs and transfer buffers */
1079 for (i = 0; i < isoc_bufs->num_bufs; i++) {
1080 urb = usb_alloc_urb(isoc_bufs->num_packets, GFP_KERNEL);
1081 if (!urb) {
1082 em28xx_err("cannot alloc isoc_ctl.urb %i\n", i);
1083 em28xx_uninit_isoc(dev, mode);
1084 return -ENOMEM;
1085 }
1086 isoc_bufs->urb[i] = urb;
1087
1088 isoc_bufs->transfer_buffer[i] = usb_alloc_coherent(dev->udev,
1089 sb_size, GFP_KERNEL, &urb->transfer_dma);
1090 if (!isoc_bufs->transfer_buffer[i]) {
1091 em28xx_err("unable to allocate %i bytes for transfer"
1092 " buffer %i%s\n",
1093 sb_size, i,
1094 in_interrupt() ? " while in int" : "");
1095 em28xx_uninit_isoc(dev, mode);
1096 return -ENOMEM;
1097 }
1098 memset(isoc_bufs->transfer_buffer[i], 0, sb_size);
1099
1100 /* FIXME: this is a hack - should be
1101 'desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK'
1102 should also be using 'desc.bInterval'
1103 */
1104 pipe = usb_rcvisocpipe(dev->udev,
1105 mode == EM28XX_ANALOG_MODE ?
1106 EM28XX_EP_ANALOG : EM28XX_EP_DIGITAL);
1107
1108 usb_fill_int_urb(urb, dev->udev, pipe,
1109 isoc_bufs->transfer_buffer[i], sb_size,
1110 em28xx_irq_callback, dev, 1);
1111
1112 urb->number_of_packets = isoc_bufs->num_packets;
1113 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
1114
1115 k = 0;
1116 for (j = 0; j < isoc_bufs->num_packets; j++) {
1117 urb->iso_frame_desc[j].offset = k;
1118 urb->iso_frame_desc[j].length =
1119 isoc_bufs->max_pkt_size;
1120 k += isoc_bufs->max_pkt_size;
1121 }
1122 }
1123
1124 return 0;
1125 }
1126 EXPORT_SYMBOL_GPL(em28xx_alloc_isoc);
1127
1128 /*
1129 * Allocate URBs and start IRQ
1130 */
1131 int em28xx_init_isoc(struct em28xx *dev, enum em28xx_mode mode,
1132 int max_packets, int num_bufs, int max_pkt_size,
1133 int (*isoc_copy) (struct em28xx *dev, struct urb *urb))
1134 {
1135 struct em28xx_dmaqueue *dma_q = &dev->vidq;
1136 struct em28xx_dmaqueue *vbi_dma_q = &dev->vbiq;
1137 struct em28xx_usb_isoc_bufs *isoc_bufs;
1138 int i;
1139 int rc;
1140 int alloc;
1141
1142 em28xx_isocdbg("em28xx: called em28xx_init_isoc in mode %d\n", mode);
1143
1144 dev->isoc_ctl.isoc_copy = isoc_copy;
1145
1146 if (mode == EM28XX_DIGITAL_MODE) {
1147 isoc_bufs = &dev->isoc_ctl.digital_bufs;
1148 /* no need to free/alloc isoc buffers in digital mode */
1149 alloc = 0;
1150 } else {
1151 isoc_bufs = &dev->isoc_ctl.analog_bufs;
1152 alloc = 1;
1153 }
1154
1155 if (alloc) {
1156 rc = em28xx_alloc_isoc(dev, mode, max_packets,
1157 num_bufs, max_pkt_size);
1158 if (rc)
1159 return rc;
1160 }
1161
1162 init_waitqueue_head(&dma_q->wq);
1163 init_waitqueue_head(&vbi_dma_q->wq);
1164
1165 em28xx_capture_start(dev, 1);
1166
1167 /* submit urbs and enables IRQ */
1168 for (i = 0; i < isoc_bufs->num_bufs; i++) {
1169 rc = usb_submit_urb(isoc_bufs->urb[i], GFP_ATOMIC);
1170 if (rc) {
1171 em28xx_err("submit of urb %i failed (error=%i)\n", i,
1172 rc);
1173 em28xx_uninit_isoc(dev, mode);
1174 return rc;
1175 }
1176 }
1177
1178 return 0;
1179 }
1180 EXPORT_SYMBOL_GPL(em28xx_init_isoc);
1181
1182 /*
1183 * em28xx_wake_i2c()
1184 * configure i2c attached devices
1185 */
1186 void em28xx_wake_i2c(struct em28xx *dev)
1187 {
1188 v4l2_device_call_all(&dev->v4l2_dev, 0, core, reset, 0);
1189 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_routing,
1190 INPUT(dev->ctl_input)->vmux, 0, 0);
1191 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_stream, 0);
1192 }
1193
1194 /*
1195 * Device control list
1196 */
1197
1198 static LIST_HEAD(em28xx_devlist);
1199 static DEFINE_MUTEX(em28xx_devlist_mutex);
1200
1201 /*
1202 * Extension interface
1203 */
1204
1205 static LIST_HEAD(em28xx_extension_devlist);
1206
1207 int em28xx_register_extension(struct em28xx_ops *ops)
1208 {
1209 struct em28xx *dev = NULL;
1210
1211 mutex_lock(&em28xx_devlist_mutex);
1212 list_add_tail(&ops->next, &em28xx_extension_devlist);
1213 list_for_each_entry(dev, &em28xx_devlist, devlist) {
1214 ops->init(dev);
1215 }
1216 mutex_unlock(&em28xx_devlist_mutex);
1217 printk(KERN_INFO "Em28xx: Initialized (%s) extension\n", ops->name);
1218 return 0;
1219 }
1220 EXPORT_SYMBOL(em28xx_register_extension);
1221
1222 void em28xx_unregister_extension(struct em28xx_ops *ops)
1223 {
1224 struct em28xx *dev = NULL;
1225
1226 mutex_lock(&em28xx_devlist_mutex);
1227 list_for_each_entry(dev, &em28xx_devlist, devlist) {
1228 ops->fini(dev);
1229 }
1230 list_del(&ops->next);
1231 mutex_unlock(&em28xx_devlist_mutex);
1232 printk(KERN_INFO "Em28xx: Removed (%s) extension\n", ops->name);
1233 }
1234 EXPORT_SYMBOL(em28xx_unregister_extension);
1235
1236 void em28xx_init_extension(struct em28xx *dev)
1237 {
1238 const struct em28xx_ops *ops = NULL;
1239
1240 mutex_lock(&em28xx_devlist_mutex);
1241 list_add_tail(&dev->devlist, &em28xx_devlist);
1242 list_for_each_entry(ops, &em28xx_extension_devlist, next) {
1243 if (ops->init)
1244 ops->init(dev);
1245 }
1246 mutex_unlock(&em28xx_devlist_mutex);
1247 }
1248
1249 void em28xx_close_extension(struct em28xx *dev)
1250 {
1251 const struct em28xx_ops *ops = NULL;
1252
1253 mutex_lock(&em28xx_devlist_mutex);
1254 list_for_each_entry(ops, &em28xx_extension_devlist, next) {
1255 if (ops->fini)
1256 ops->fini(dev);
1257 }
1258 list_del(&dev->devlist);
1259 mutex_unlock(&em28xx_devlist_mutex);
1260 }
(deprecated) Btrfs devel tree