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 <media/v4l2-common.h>
31
32 #include "em28xx.h"
33
34 /* #define ENABLE_DEBUG_ISOC_FRAMES */
35
36 static unsigned int core_debug;
37 module_param(core_debug, int, 0644);
38 MODULE_PARM_DESC(core_debug, "enable debug messages [core]");
39
40 #define em28xx_coredbg(fmt, arg...) do {\
41 if (core_debug) \
42 printk(KERN_INFO "%s %s :"fmt, \
43 dev->name, __func__ , ##arg); } while (0)
44
45 static unsigned int reg_debug;
46 module_param(reg_debug, int, 0644);
47 MODULE_PARM_DESC(reg_debug, "enable debug messages [URB reg]");
48
49 #define em28xx_regdbg(fmt, arg...) do {\
50 if (reg_debug) \
51 printk(KERN_INFO "%s %s :"fmt, \
52 dev->name, __func__ , ##arg); } while (0)
53
54 static int alt;
55 module_param(alt, int, 0644);
56 MODULE_PARM_DESC(alt, "alternate setting to use for video endpoint");
57
58 static unsigned int disable_vbi;
59 module_param(disable_vbi, int, 0644);
60 MODULE_PARM_DESC(disable_vbi, "disable vbi support");
61
62 /* FIXME */
63 #define em28xx_isocdbg(fmt, arg...) do {\
64 if (core_debug) \
65 printk(KERN_INFO "%s %s :"fmt, \
66 dev->name, __func__ , ##arg); } while (0)
67
68 /*
69 * em28xx_read_reg_req()
70 * reads data from the usb device specifying bRequest
71 */
em28xx_read_reg_req_len(struct em28xx * dev,u8 req,u16 reg,char * buf,int len)72 int em28xx_read_reg_req_len(struct em28xx *dev, u8 req, u16 reg,
73 char *buf, int len)
74 {
75 int ret;
76 int pipe = usb_rcvctrlpipe(dev->udev, 0);
77
78 if (dev->state & DEV_DISCONNECTED)
79 return -ENODEV;
80
81 if (len > URB_MAX_CTRL_SIZE)
82 return -EINVAL;
83
84 if (reg_debug) {
85 printk(KERN_DEBUG "(pipe 0x%08x): "
86 "IN: %02x %02x %02x %02x %02x %02x %02x %02x ",
87 pipe,
88 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
89 req, 0, 0,
90 reg & 0xff, reg >> 8,
91 len & 0xff, len >> 8);
92 }
93
94 mutex_lock(&dev->ctrl_urb_lock);
95 ret = usb_control_msg(dev->udev, pipe, req,
96 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
97 0x0000, reg, dev->urb_buf, len, HZ);
98 if (ret < 0) {
99 if (reg_debug)
100 printk(" failed!\n");
101 mutex_unlock(&dev->ctrl_urb_lock);
102 return ret;
103 }
104
105 if (len)
106 memcpy(buf, dev->urb_buf, len);
107
108 mutex_unlock(&dev->ctrl_urb_lock);
109
110 if (reg_debug) {
111 int byte;
112
113 printk("<<<");
114 for (byte = 0; byte < len; byte++)
115 printk(" %02x", (unsigned char)buf[byte]);
116 printk("\n");
117 }
118
119 return ret;
120 }
121
122 /*
123 * em28xx_read_reg_req()
124 * reads data from the usb device specifying bRequest
125 */
em28xx_read_reg_req(struct em28xx * dev,u8 req,u16 reg)126 int em28xx_read_reg_req(struct em28xx *dev, u8 req, u16 reg)
127 {
128 int ret;
129 u8 val;
130
131 ret = em28xx_read_reg_req_len(dev, req, reg, &val, 1);
132 if (ret < 0)
133 return ret;
134
135 return val;
136 }
137
em28xx_read_reg(struct em28xx * dev,u16 reg)138 int em28xx_read_reg(struct em28xx *dev, u16 reg)
139 {
140 return em28xx_read_reg_req(dev, USB_REQ_GET_STATUS, reg);
141 }
142
143 /*
144 * em28xx_write_regs_req()
145 * sends data to the usb device, specifying bRequest
146 */
em28xx_write_regs_req(struct em28xx * dev,u8 req,u16 reg,char * buf,int len)147 int em28xx_write_regs_req(struct em28xx *dev, u8 req, u16 reg, char *buf,
148 int len)
149 {
150 int ret;
151 int pipe = usb_sndctrlpipe(dev->udev, 0);
152
153 if (dev->state & DEV_DISCONNECTED)
154 return -ENODEV;
155
156 if ((len < 1) || (len > URB_MAX_CTRL_SIZE))
157 return -EINVAL;
158
159 if (reg_debug) {
160 int byte;
161
162 printk(KERN_DEBUG "(pipe 0x%08x): "
163 "OUT: %02x %02x %02x %02x %02x %02x %02x %02x >>>",
164 pipe,
165 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
166 req, 0, 0,
167 reg & 0xff, reg >> 8,
168 len & 0xff, len >> 8);
169
170 for (byte = 0; byte < len; byte++)
171 printk(" %02x", (unsigned char)buf[byte]);
172 printk("\n");
173 }
174
175 mutex_lock(&dev->ctrl_urb_lock);
176 memcpy(dev->urb_buf, buf, len);
177 ret = usb_control_msg(dev->udev, pipe, req,
178 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
179 0x0000, reg, dev->urb_buf, len, HZ);
180 mutex_unlock(&dev->ctrl_urb_lock);
181
182 if (dev->wait_after_write)
183 msleep(dev->wait_after_write);
184
185 return ret;
186 }
187
em28xx_write_regs(struct em28xx * dev,u16 reg,char * buf,int len)188 int em28xx_write_regs(struct em28xx *dev, u16 reg, char *buf, int len)
189 {
190 int rc;
191
192 rc = em28xx_write_regs_req(dev, USB_REQ_GET_STATUS, reg, buf, len);
193
194 /* Stores GPO/GPIO values at the cache, if changed
195 Only write values should be stored, since input on a GPIO
196 register will return the input bits.
197 Not sure what happens on reading GPO register.
198 */
199 if (rc >= 0) {
200 if (reg == dev->reg_gpo_num)
201 dev->reg_gpo = buf[0];
202 else if (reg == dev->reg_gpio_num)
203 dev->reg_gpio = buf[0];
204 }
205
206 return rc;
207 }
208
209 /* Write a single register */
em28xx_write_reg(struct em28xx * dev,u16 reg,u8 val)210 int em28xx_write_reg(struct em28xx *dev, u16 reg, u8 val)
211 {
212 return em28xx_write_regs(dev, reg, &val, 1);
213 }
214 EXPORT_SYMBOL_GPL(em28xx_write_reg);
215
216 /*
217 * em28xx_write_reg_bits()
218 * sets only some bits (specified by bitmask) of a register, by first reading
219 * the actual value
220 */
em28xx_write_reg_bits(struct em28xx * dev,u16 reg,u8 val,u8 bitmask)221 int em28xx_write_reg_bits(struct em28xx *dev, u16 reg, u8 val,
222 u8 bitmask)
223 {
224 int oldval;
225 u8 newval;
226
227 /* Uses cache for gpo/gpio registers */
228 if (reg == dev->reg_gpo_num)
229 oldval = dev->reg_gpo;
230 else if (reg == dev->reg_gpio_num)
231 oldval = dev->reg_gpio;
232 else
233 oldval = em28xx_read_reg(dev, reg);
234
235 if (oldval < 0)
236 return oldval;
237
238 newval = (((u8) oldval) & ~bitmask) | (val & bitmask);
239
240 return em28xx_write_regs(dev, reg, &newval, 1);
241 }
242
243 /*
244 * em28xx_is_ac97_ready()
245 * Checks if ac97 is ready
246 */
em28xx_is_ac97_ready(struct em28xx * dev)247 static int em28xx_is_ac97_ready(struct em28xx *dev)
248 {
249 int ret, i;
250
251 /* Wait up to 50 ms for AC97 command to complete */
252 for (i = 0; i < 10; i++, msleep(5)) {
253 ret = em28xx_read_reg(dev, EM28XX_R43_AC97BUSY);
254 if (ret < 0)
255 return ret;
256
257 if (!(ret & 0x01))
258 return 0;
259 }
260
261 em28xx_warn("AC97 command still being executed: not handled properly!\n");
262 return -EBUSY;
263 }
264
265 /*
266 * em28xx_read_ac97()
267 * write a 16 bit value to the specified AC97 address (LSB first!)
268 */
em28xx_read_ac97(struct em28xx * dev,u8 reg)269 int em28xx_read_ac97(struct em28xx *dev, u8 reg)
270 {
271 int ret;
272 u8 addr = (reg & 0x7f) | 0x80;
273 u16 val;
274
275 ret = em28xx_is_ac97_ready(dev);
276 if (ret < 0)
277 return ret;
278
279 ret = em28xx_write_regs(dev, EM28XX_R42_AC97ADDR, &addr, 1);
280 if (ret < 0)
281 return ret;
282
283 ret = dev->em28xx_read_reg_req_len(dev, 0, EM28XX_R40_AC97LSB,
284 (u8 *)&val, sizeof(val));
285
286 if (ret < 0)
287 return ret;
288 return le16_to_cpu(val);
289 }
290 EXPORT_SYMBOL_GPL(em28xx_read_ac97);
291
292 /*
293 * em28xx_write_ac97()
294 * write a 16 bit value to the specified AC97 address (LSB first!)
295 */
em28xx_write_ac97(struct em28xx * dev,u8 reg,u16 val)296 int em28xx_write_ac97(struct em28xx *dev, u8 reg, u16 val)
297 {
298 int ret;
299 u8 addr = reg & 0x7f;
300 __le16 value;
301
302 value = cpu_to_le16(val);
303
304 ret = em28xx_is_ac97_ready(dev);
305 if (ret < 0)
306 return ret;
307
308 ret = em28xx_write_regs(dev, EM28XX_R40_AC97LSB, (u8 *) &value, 2);
309 if (ret < 0)
310 return ret;
311
312 ret = em28xx_write_regs(dev, EM28XX_R42_AC97ADDR, &addr, 1);
313 if (ret < 0)
314 return ret;
315
316 return 0;
317 }
318 EXPORT_SYMBOL_GPL(em28xx_write_ac97);
319
320 struct em28xx_vol_itable {
321 enum em28xx_amux mux;
322 u8 reg;
323 };
324
325 static struct em28xx_vol_itable inputs[] = {
326 { EM28XX_AMUX_VIDEO, AC97_VIDEO_VOL },
327 { EM28XX_AMUX_LINE_IN, AC97_LINEIN_VOL },
328 { EM28XX_AMUX_PHONE, AC97_PHONE_VOL },
329 { EM28XX_AMUX_MIC, AC97_MIC_VOL },
330 { EM28XX_AMUX_CD, AC97_CD_VOL },
331 { EM28XX_AMUX_AUX, AC97_AUX_VOL },
332 { EM28XX_AMUX_PCM_OUT, AC97_PCM_OUT_VOL },
333 };
334
set_ac97_input(struct em28xx * dev)335 static int set_ac97_input(struct em28xx *dev)
336 {
337 int ret, i;
338 enum em28xx_amux amux = dev->ctl_ainput;
339
340 /* EM28XX_AMUX_VIDEO2 is a special case used to indicate that
341 em28xx should point to LINE IN, while AC97 should use VIDEO
342 */
343 if (amux == EM28XX_AMUX_VIDEO2)
344 amux = EM28XX_AMUX_VIDEO;
345
346 /* Mute all entres but the one that were selected */
347 for (i = 0; i < ARRAY_SIZE(inputs); i++) {
348 if (amux == inputs[i].mux)
349 ret = em28xx_write_ac97(dev, inputs[i].reg, 0x0808);
350 else
351 ret = em28xx_write_ac97(dev, inputs[i].reg, 0x8000);
352
353 if (ret < 0)
354 em28xx_warn("couldn't setup AC97 register %d\n",
355 inputs[i].reg);
356 }
357 return 0;
358 }
359
em28xx_set_audio_source(struct em28xx * dev)360 static int em28xx_set_audio_source(struct em28xx *dev)
361 {
362 int ret;
363 u8 input;
364
365 if (dev->board.is_em2800) {
366 if (dev->ctl_ainput == EM28XX_AMUX_VIDEO)
367 input = EM2800_AUDIO_SRC_TUNER;
368 else
369 input = EM2800_AUDIO_SRC_LINE;
370
371 ret = em28xx_write_regs(dev, EM2800_R08_AUDIOSRC, &input, 1);
372 if (ret < 0)
373 return ret;
374 }
375
376 if (dev->board.has_msp34xx)
377 input = EM28XX_AUDIO_SRC_TUNER;
378 else {
379 switch (dev->ctl_ainput) {
380 case EM28XX_AMUX_VIDEO:
381 input = EM28XX_AUDIO_SRC_TUNER;
382 break;
383 default:
384 input = EM28XX_AUDIO_SRC_LINE;
385 break;
386 }
387 }
388
389 if (dev->board.mute_gpio && dev->mute)
390 em28xx_gpio_set(dev, dev->board.mute_gpio);
391 else
392 em28xx_gpio_set(dev, INPUT(dev->ctl_input)->gpio);
393
394 ret = em28xx_write_reg_bits(dev, EM28XX_R0E_AUDIOSRC, input, 0xc0);
395 if (ret < 0)
396 return ret;
397 msleep(5);
398
399 switch (dev->audio_mode.ac97) {
400 case EM28XX_NO_AC97:
401 break;
402 default:
403 ret = set_ac97_input(dev);
404 }
405
406 return ret;
407 }
408
409 struct em28xx_vol_otable {
410 enum em28xx_aout mux;
411 u8 reg;
412 };
413
414 static const struct em28xx_vol_otable outputs[] = {
415 { EM28XX_AOUT_MASTER, AC97_MASTER_VOL },
416 { EM28XX_AOUT_LINE, AC97_LINE_LEVEL_VOL },
417 { EM28XX_AOUT_MONO, AC97_MASTER_MONO_VOL },
418 { EM28XX_AOUT_LFE, AC97_LFE_MASTER_VOL },
419 { EM28XX_AOUT_SURR, AC97_SURR_MASTER_VOL },
420 };
421
em28xx_audio_analog_set(struct em28xx * dev)422 int em28xx_audio_analog_set(struct em28xx *dev)
423 {
424 int ret, i;
425 u8 xclk;
426
427 if (!dev->audio_mode.has_audio)
428 return 0;
429
430 /* It is assumed that all devices use master volume for output.
431 It would be possible to use also line output.
432 */
433 if (dev->audio_mode.ac97 != EM28XX_NO_AC97) {
434 /* Mute all outputs */
435 for (i = 0; i < ARRAY_SIZE(outputs); i++) {
436 ret = em28xx_write_ac97(dev, outputs[i].reg, 0x8000);
437 if (ret < 0)
438 em28xx_warn("couldn't setup AC97 register %d\n",
439 outputs[i].reg);
440 }
441 }
442
443 xclk = dev->board.xclk & 0x7f;
444 if (!dev->mute)
445 xclk |= EM28XX_XCLK_AUDIO_UNMUTE;
446
447 ret = em28xx_write_reg(dev, EM28XX_R0F_XCLK, xclk);
448 if (ret < 0)
449 return ret;
450 msleep(10);
451
452 /* Selects the proper audio input */
453 ret = em28xx_set_audio_source(dev);
454
455 /* Sets volume */
456 if (dev->audio_mode.ac97 != EM28XX_NO_AC97) {
457 int vol;
458
459 em28xx_write_ac97(dev, AC97_POWER_DOWN_CTRL, 0x4200);
460 em28xx_write_ac97(dev, AC97_EXT_AUD_CTRL, 0x0031);
461 em28xx_write_ac97(dev, AC97_PCM_IN_SRATE, 0xbb80);
462
463 /* LSB: left channel - both channels with the same level */
464 vol = (0x1f - dev->volume) | ((0x1f - dev->volume) << 8);
465
466 /* Mute device, if needed */
467 if (dev->mute)
468 vol |= 0x8000;
469
470 /* Sets volume */
471 for (i = 0; i < ARRAY_SIZE(outputs); i++) {
472 if (dev->ctl_aoutput & outputs[i].mux)
473 ret = em28xx_write_ac97(dev, outputs[i].reg,
474 vol);
475 if (ret < 0)
476 em28xx_warn("couldn't setup AC97 register %d\n",
477 outputs[i].reg);
478 }
479
480 if (dev->ctl_aoutput & EM28XX_AOUT_PCM_IN) {
481 int sel = ac97_return_record_select(dev->ctl_aoutput);
482
483 /* Use the same input for both left and right
484 channels */
485 sel |= (sel << 8);
486
487 em28xx_write_ac97(dev, AC97_RECORD_SELECT, sel);
488 }
489 }
490
491 return ret;
492 }
493 EXPORT_SYMBOL_GPL(em28xx_audio_analog_set);
494
em28xx_audio_setup(struct em28xx * dev)495 int em28xx_audio_setup(struct em28xx *dev)
496 {
497 int vid1, vid2, feat, cfg;
498 u32 vid;
499
500 if (dev->chip_id == CHIP_ID_EM2870 || dev->chip_id == CHIP_ID_EM2874
501 || dev->chip_id == CHIP_ID_EM28174) {
502 /* Digital only device - don't load any alsa module */
503 dev->audio_mode.has_audio = false;
504 dev->has_audio_class = false;
505 dev->has_alsa_audio = false;
506 return 0;
507 }
508
509 dev->audio_mode.has_audio = true;
510
511 /* See how this device is configured */
512 cfg = em28xx_read_reg(dev, EM28XX_R00_CHIPCFG);
513 em28xx_info("Config register raw data: 0x%02x\n", cfg);
514 if (cfg < 0) {
515 /* Register read error? */
516 cfg = EM28XX_CHIPCFG_AC97; /* Be conservative */
517 } else if ((cfg & EM28XX_CHIPCFG_AUDIOMASK) == 0x00) {
518 /* The device doesn't have vendor audio at all */
519 dev->has_alsa_audio = false;
520 dev->audio_mode.has_audio = false;
521 return 0;
522 } else if ((cfg & EM28XX_CHIPCFG_AUDIOMASK) ==
523 EM28XX_CHIPCFG_I2S_3_SAMPRATES) {
524 em28xx_info("I2S Audio (3 sample rates)\n");
525 dev->audio_mode.i2s_3rates = 1;
526 } else if ((cfg & EM28XX_CHIPCFG_AUDIOMASK) ==
527 EM28XX_CHIPCFG_I2S_5_SAMPRATES) {
528 em28xx_info("I2S Audio (5 sample rates)\n");
529 dev->audio_mode.i2s_5rates = 1;
530 }
531
532 if ((cfg & EM28XX_CHIPCFG_AUDIOMASK) != EM28XX_CHIPCFG_AC97) {
533 /* Skip the code that does AC97 vendor detection */
534 dev->audio_mode.ac97 = EM28XX_NO_AC97;
535 goto init_audio;
536 }
537
538 dev->audio_mode.ac97 = EM28XX_AC97_OTHER;
539
540 vid1 = em28xx_read_ac97(dev, AC97_VENDOR_ID1);
541 if (vid1 < 0) {
542 /*
543 * Device likely doesn't support AC97
544 * Note: (some) em2800 devices without eeprom reports 0x91 on
545 * CHIPCFG register, even not having an AC97 chip
546 */
547 em28xx_warn("AC97 chip type couldn't be determined\n");
548 dev->audio_mode.ac97 = EM28XX_NO_AC97;
549 dev->has_alsa_audio = false;
550 dev->audio_mode.has_audio = false;
551 goto init_audio;
552 }
553
554 vid2 = em28xx_read_ac97(dev, AC97_VENDOR_ID2);
555 if (vid2 < 0)
556 goto init_audio;
557
558 vid = vid1 << 16 | vid2;
559
560 dev->audio_mode.ac97_vendor_id = vid;
561 em28xx_warn("AC97 vendor ID = 0x%08x\n", vid);
562
563 feat = em28xx_read_ac97(dev, AC97_RESET);
564 if (feat < 0)
565 goto init_audio;
566
567 dev->audio_mode.ac97_feat = feat;
568 em28xx_warn("AC97 features = 0x%04x\n", feat);
569
570 /* Try to identify what audio processor we have */
571 if (((vid == 0xffffffff) || (vid == 0x83847650)) && (feat == 0x6a90))
572 dev->audio_mode.ac97 = EM28XX_AC97_EM202;
573 else if ((vid >> 8) == 0x838476)
574 dev->audio_mode.ac97 = EM28XX_AC97_SIGMATEL;
575
576 init_audio:
577 /* Reports detected AC97 processor */
578 switch (dev->audio_mode.ac97) {
579 case EM28XX_NO_AC97:
580 em28xx_info("No AC97 audio processor\n");
581 break;
582 case EM28XX_AC97_EM202:
583 em28xx_info("Empia 202 AC97 audio processor detected\n");
584 break;
585 case EM28XX_AC97_SIGMATEL:
586 em28xx_info("Sigmatel audio processor detected(stac 97%02x)\n",
587 dev->audio_mode.ac97_vendor_id & 0xff);
588 break;
589 case EM28XX_AC97_OTHER:
590 em28xx_warn("Unknown AC97 audio processor detected!\n");
591 break;
592 default:
593 break;
594 }
595
596 return em28xx_audio_analog_set(dev);
597 }
598 EXPORT_SYMBOL_GPL(em28xx_audio_setup);
599
em28xx_colorlevels_set_default(struct em28xx * dev)600 int em28xx_colorlevels_set_default(struct em28xx *dev)
601 {
602 em28xx_write_reg(dev, EM28XX_R20_YGAIN, 0x10); /* contrast */
603 em28xx_write_reg(dev, EM28XX_R21_YOFFSET, 0x00); /* brightness */
604 em28xx_write_reg(dev, EM28XX_R22_UVGAIN, 0x10); /* saturation */
605 em28xx_write_reg(dev, EM28XX_R23_UOFFSET, 0x00);
606 em28xx_write_reg(dev, EM28XX_R24_VOFFSET, 0x00);
607 em28xx_write_reg(dev, EM28XX_R25_SHARPNESS, 0x00);
608
609 em28xx_write_reg(dev, EM28XX_R14_GAMMA, 0x20);
610 em28xx_write_reg(dev, EM28XX_R15_RGAIN, 0x20);
611 em28xx_write_reg(dev, EM28XX_R16_GGAIN, 0x20);
612 em28xx_write_reg(dev, EM28XX_R17_BGAIN, 0x20);
613 em28xx_write_reg(dev, EM28XX_R18_ROFFSET, 0x00);
614 em28xx_write_reg(dev, EM28XX_R19_GOFFSET, 0x00);
615 return em28xx_write_reg(dev, EM28XX_R1A_BOFFSET, 0x00);
616 }
617
em28xx_capture_start(struct em28xx * dev,int start)618 int em28xx_capture_start(struct em28xx *dev, int start)
619 {
620 int rc;
621
622 if (dev->chip_id == CHIP_ID_EM2874 ||
623 dev->chip_id == CHIP_ID_EM2884 ||
624 dev->chip_id == CHIP_ID_EM28174) {
625 /* The Transport Stream Enable Register moved in em2874 */
626 if (!start) {
627 rc = em28xx_write_reg_bits(dev, EM2874_R5F_TS_ENABLE,
628 0x00,
629 EM2874_TS1_CAPTURE_ENABLE);
630 return rc;
631 }
632
633 /* Enable Transport Stream */
634 rc = em28xx_write_reg_bits(dev, EM2874_R5F_TS_ENABLE,
635 EM2874_TS1_CAPTURE_ENABLE,
636 EM2874_TS1_CAPTURE_ENABLE);
637 return rc;
638 }
639
640
641 /* FIXME: which is the best order? */
642 /* video registers are sampled by VREF */
643 rc = em28xx_write_reg_bits(dev, EM28XX_R0C_USBSUSP,
644 start ? 0x10 : 0x00, 0x10);
645 if (rc < 0)
646 return rc;
647
648 if (!start) {
649 /* disable video capture */
650 rc = em28xx_write_reg(dev, EM28XX_R12_VINENABLE, 0x27);
651 return rc;
652 }
653
654 if (dev->board.is_webcam)
655 rc = em28xx_write_reg(dev, 0x13, 0x0c);
656
657 /* enable video capture */
658 rc = em28xx_write_reg(dev, 0x48, 0x00);
659
660 if (dev->mode == EM28XX_ANALOG_MODE)
661 rc = em28xx_write_reg(dev, EM28XX_R12_VINENABLE, 0x67);
662 else
663 rc = em28xx_write_reg(dev, EM28XX_R12_VINENABLE, 0x37);
664
665 msleep(6);
666
667 return rc;
668 }
669
em28xx_vbi_supported(struct em28xx * dev)670 int em28xx_vbi_supported(struct em28xx *dev)
671 {
672 /* Modprobe option to manually disable */
673 if (disable_vbi == 1)
674 return 0;
675
676 if (dev->chip_id == CHIP_ID_EM2860 ||
677 dev->chip_id == CHIP_ID_EM2883)
678 return 1;
679
680 /* Version of em28xx that does not support VBI */
681 return 0;
682 }
683
em28xx_set_outfmt(struct em28xx * dev)684 int em28xx_set_outfmt(struct em28xx *dev)
685 {
686 int ret;
687 u8 vinctrl;
688
689 ret = em28xx_write_reg_bits(dev, EM28XX_R27_OUTFMT,
690 dev->format->reg | 0x20, 0xff);
691 if (ret < 0)
692 return ret;
693
694 ret = em28xx_write_reg(dev, EM28XX_R10_VINMODE, dev->vinmode);
695 if (ret < 0)
696 return ret;
697
698 vinctrl = dev->vinctl;
699 if (em28xx_vbi_supported(dev) == 1) {
700 vinctrl |= EM28XX_VINCTRL_VBI_RAW;
701 em28xx_write_reg(dev, EM28XX_R34_VBI_START_H, 0x00);
702 em28xx_write_reg(dev, EM28XX_R36_VBI_WIDTH, dev->vbi_width/4);
703 em28xx_write_reg(dev, EM28XX_R37_VBI_HEIGHT, dev->vbi_height);
704 if (dev->norm & V4L2_STD_525_60) {
705 /* NTSC */
706 em28xx_write_reg(dev, EM28XX_R35_VBI_START_V, 0x09);
707 } else if (dev->norm & V4L2_STD_625_50) {
708 /* PAL */
709 em28xx_write_reg(dev, EM28XX_R35_VBI_START_V, 0x07);
710 }
711 }
712
713 return em28xx_write_reg(dev, EM28XX_R11_VINCTRL, vinctrl);
714 }
715
em28xx_accumulator_set(struct em28xx * dev,u8 xmin,u8 xmax,u8 ymin,u8 ymax)716 static int em28xx_accumulator_set(struct em28xx *dev, u8 xmin, u8 xmax,
717 u8 ymin, u8 ymax)
718 {
719 em28xx_coredbg("em28xx Scale: (%d,%d)-(%d,%d)\n",
720 xmin, ymin, xmax, ymax);
721
722 em28xx_write_regs(dev, EM28XX_R28_XMIN, &xmin, 1);
723 em28xx_write_regs(dev, EM28XX_R29_XMAX, &xmax, 1);
724 em28xx_write_regs(dev, EM28XX_R2A_YMIN, &ymin, 1);
725 return em28xx_write_regs(dev, EM28XX_R2B_YMAX, &ymax, 1);
726 }
727
em28xx_capture_area_set(struct em28xx * dev,u8 hstart,u8 vstart,u16 width,u16 height)728 static int em28xx_capture_area_set(struct em28xx *dev, u8 hstart, u8 vstart,
729 u16 width, u16 height)
730 {
731 u8 cwidth = width;
732 u8 cheight = height;
733 u8 overflow = (height >> 7 & 0x02) | (width >> 8 & 0x01);
734
735 em28xx_coredbg("em28xx Area Set: (%d,%d)\n",
736 (width | (overflow & 2) << 7),
737 (height | (overflow & 1) << 8));
738
739 em28xx_write_regs(dev, EM28XX_R1C_HSTART, &hstart, 1);
740 em28xx_write_regs(dev, EM28XX_R1D_VSTART, &vstart, 1);
741 em28xx_write_regs(dev, EM28XX_R1E_CWIDTH, &cwidth, 1);
742 em28xx_write_regs(dev, EM28XX_R1F_CHEIGHT, &cheight, 1);
743 return em28xx_write_regs(dev, EM28XX_R1B_OFLOW, &overflow, 1);
744 }
745
em28xx_scaler_set(struct em28xx * dev,u16 h,u16 v)746 static int em28xx_scaler_set(struct em28xx *dev, u16 h, u16 v)
747 {
748 u8 mode;
749 /* the em2800 scaler only supports scaling down to 50% */
750
751 if (dev->board.is_em2800) {
752 mode = (v ? 0x20 : 0x00) | (h ? 0x10 : 0x00);
753 } else {
754 u8 buf[2];
755
756 buf[0] = h;
757 buf[1] = h >> 8;
758 em28xx_write_regs(dev, EM28XX_R30_HSCALELOW, (char *)buf, 2);
759
760 buf[0] = v;
761 buf[1] = v >> 8;
762 em28xx_write_regs(dev, EM28XX_R32_VSCALELOW, (char *)buf, 2);
763 /* it seems that both H and V scalers must be active
764 to work correctly */
765 mode = (h || v) ? 0x30 : 0x00;
766 }
767 return em28xx_write_reg_bits(dev, EM28XX_R26_COMPR, mode, 0x30);
768 }
769
770 /* FIXME: this only function read values from dev */
em28xx_resolution_set(struct em28xx * dev)771 int em28xx_resolution_set(struct em28xx *dev)
772 {
773 int width, height;
774 width = norm_maxw(dev);
775 height = norm_maxh(dev);
776
777 /* Properly setup VBI */
778 dev->vbi_width = 720;
779 if (dev->norm & V4L2_STD_525_60)
780 dev->vbi_height = 12;
781 else
782 dev->vbi_height = 18;
783
784 if (!dev->progressive)
785 height >>= norm_maxh(dev);
786
787 em28xx_set_outfmt(dev);
788
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
em28xx_set_alternate(struct em28xx * dev)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
em28xx_gpio_set(struct em28xx * dev,struct em28xx_reg_seq * gpio)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
em28xx_set_mode(struct em28xx * dev,enum em28xx_mode set_mode)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 */
em28xx_irq_callback(struct urb * urb)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 */
em28xx_uninit_isoc(struct em28xx * dev)964 void em28xx_uninit_isoc(struct em28xx *dev)
965 {
966 struct urb *urb;
967 int i;
968
969 em28xx_isocdbg("em28xx: called em28xx_uninit_isoc\n");
970
971 dev->isoc_ctl.nfields = -1;
972 for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
973 urb = dev->isoc_ctl.urb[i];
974 if (urb) {
975 if (!irqs_disabled())
976 usb_kill_urb(urb);
977 else
978 usb_unlink_urb(urb);
979
980 if (dev->isoc_ctl.transfer_buffer[i]) {
981 usb_free_coherent(dev->udev,
982 urb->transfer_buffer_length,
983 dev->isoc_ctl.transfer_buffer[i],
984 urb->transfer_dma);
985 }
986 usb_free_urb(urb);
987 dev->isoc_ctl.urb[i] = NULL;
988 }
989 dev->isoc_ctl.transfer_buffer[i] = NULL;
990 }
991
992 kfree(dev->isoc_ctl.urb);
993 kfree(dev->isoc_ctl.transfer_buffer);
994
995 dev->isoc_ctl.urb = NULL;
996 dev->isoc_ctl.transfer_buffer = NULL;
997 dev->isoc_ctl.num_bufs = 0;
998
999 em28xx_capture_start(dev, 0);
1000 }
1001 EXPORT_SYMBOL_GPL(em28xx_uninit_isoc);
1002
1003 /*
1004 * Allocate URBs and start IRQ
1005 */
em28xx_init_isoc(struct em28xx * dev,int max_packets,int num_bufs,int max_pkt_size,int (* isoc_copy)(struct em28xx * dev,struct urb * urb))1006 int em28xx_init_isoc(struct em28xx *dev, int max_packets,
1007 int num_bufs, int max_pkt_size,
1008 int (*isoc_copy) (struct em28xx *dev, struct urb *urb))
1009 {
1010 struct em28xx_dmaqueue *dma_q = &dev->vidq;
1011 struct em28xx_dmaqueue *vbi_dma_q = &dev->vbiq;
1012 int i;
1013 int sb_size, pipe;
1014 struct urb *urb;
1015 int j, k;
1016 int rc;
1017
1018 em28xx_isocdbg("em28xx: called em28xx_prepare_isoc\n");
1019
1020 /* De-allocates all pending stuff */
1021 em28xx_uninit_isoc(dev);
1022
1023 dev->isoc_ctl.isoc_copy = isoc_copy;
1024 dev->isoc_ctl.num_bufs = num_bufs;
1025
1026 dev->isoc_ctl.urb = kzalloc(sizeof(void *)*num_bufs, GFP_KERNEL);
1027 if (!dev->isoc_ctl.urb) {
1028 em28xx_errdev("cannot alloc memory for usb buffers\n");
1029 return -ENOMEM;
1030 }
1031
1032 dev->isoc_ctl.transfer_buffer = kzalloc(sizeof(void *)*num_bufs,
1033 GFP_KERNEL);
1034 if (!dev->isoc_ctl.transfer_buffer) {
1035 em28xx_errdev("cannot allocate memory for usb transfer\n");
1036 kfree(dev->isoc_ctl.urb);
1037 return -ENOMEM;
1038 }
1039
1040 dev->isoc_ctl.max_pkt_size = max_pkt_size;
1041 dev->isoc_ctl.vid_buf = NULL;
1042 dev->isoc_ctl.vbi_buf = NULL;
1043
1044 sb_size = max_packets * dev->isoc_ctl.max_pkt_size;
1045
1046 /* allocate urbs and transfer buffers */
1047 for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
1048 urb = usb_alloc_urb(max_packets, GFP_KERNEL);
1049 if (!urb) {
1050 em28xx_err("cannot alloc isoc_ctl.urb %i\n", i);
1051 em28xx_uninit_isoc(dev);
1052 return -ENOMEM;
1053 }
1054 dev->isoc_ctl.urb[i] = urb;
1055
1056 dev->isoc_ctl.transfer_buffer[i] = usb_alloc_coherent(dev->udev,
1057 sb_size, GFP_KERNEL, &urb->transfer_dma);
1058 if (!dev->isoc_ctl.transfer_buffer[i]) {
1059 em28xx_err("unable to allocate %i bytes for transfer"
1060 " buffer %i%s\n",
1061 sb_size, i,
1062 in_interrupt() ? " while in int" : "");
1063 em28xx_uninit_isoc(dev);
1064 return -ENOMEM;
1065 }
1066 memset(dev->isoc_ctl.transfer_buffer[i], 0, sb_size);
1067
1068 /* FIXME: this is a hack - should be
1069 'desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK'
1070 should also be using 'desc.bInterval'
1071 */
1072 pipe = usb_rcvisocpipe(dev->udev,
1073 dev->mode == EM28XX_ANALOG_MODE ?
1074 EM28XX_EP_ANALOG : EM28XX_EP_DIGITAL);
1075
1076 usb_fill_int_urb(urb, dev->udev, pipe,
1077 dev->isoc_ctl.transfer_buffer[i], sb_size,
1078 em28xx_irq_callback, dev, 1);
1079
1080 urb->number_of_packets = max_packets;
1081 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
1082
1083 k = 0;
1084 for (j = 0; j < max_packets; j++) {
1085 urb->iso_frame_desc[j].offset = k;
1086 urb->iso_frame_desc[j].length =
1087 dev->isoc_ctl.max_pkt_size;
1088 k += dev->isoc_ctl.max_pkt_size;
1089 }
1090 }
1091
1092 init_waitqueue_head(&dma_q->wq);
1093 init_waitqueue_head(&vbi_dma_q->wq);
1094
1095 em28xx_capture_start(dev, 1);
1096
1097 /* submit urbs and enables IRQ */
1098 for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
1099 rc = usb_submit_urb(dev->isoc_ctl.urb[i], GFP_ATOMIC);
1100 if (rc) {
1101 em28xx_err("submit of urb %i failed (error=%i)\n", i,
1102 rc);
1103 em28xx_uninit_isoc(dev);
1104 return rc;
1105 }
1106 }
1107
1108 return 0;
1109 }
1110 EXPORT_SYMBOL_GPL(em28xx_init_isoc);
1111
1112 /*
1113 * em28xx_wake_i2c()
1114 * configure i2c attached devices
1115 */
em28xx_wake_i2c(struct em28xx * dev)1116 void em28xx_wake_i2c(struct em28xx *dev)
1117 {
1118 v4l2_device_call_all(&dev->v4l2_dev, 0, core, reset, 0);
1119 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_routing,
1120 INPUT(dev->ctl_input)->vmux, 0, 0);
1121 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_stream, 0);
1122 }
1123
1124 /*
1125 * Device control list
1126 */
1127
1128 static LIST_HEAD(em28xx_devlist);
1129 static DEFINE_MUTEX(em28xx_devlist_mutex);
1130
1131 /*
1132 * Extension interface
1133 */
1134
1135 static LIST_HEAD(em28xx_extension_devlist);
1136
em28xx_register_extension(struct em28xx_ops * ops)1137 int em28xx_register_extension(struct em28xx_ops *ops)
1138 {
1139 struct em28xx *dev = NULL;
1140
1141 mutex_lock(&em28xx_devlist_mutex);
1142 list_add_tail(&ops->next, &em28xx_extension_devlist);
1143 list_for_each_entry(dev, &em28xx_devlist, devlist) {
1144 ops->init(dev);
1145 }
1146 mutex_unlock(&em28xx_devlist_mutex);
1147 printk(KERN_INFO "Em28xx: Initialized (%s) extension\n", ops->name);
1148 return 0;
1149 }
1150 EXPORT_SYMBOL(em28xx_register_extension);
1151
em28xx_unregister_extension(struct em28xx_ops * ops)1152 void em28xx_unregister_extension(struct em28xx_ops *ops)
1153 {
1154 struct em28xx *dev = NULL;
1155
1156 mutex_lock(&em28xx_devlist_mutex);
1157 list_for_each_entry(dev, &em28xx_devlist, devlist) {
1158 ops->fini(dev);
1159 }
1160 list_del(&ops->next);
1161 mutex_unlock(&em28xx_devlist_mutex);
1162 printk(KERN_INFO "Em28xx: Removed (%s) extension\n", ops->name);
1163 }
1164 EXPORT_SYMBOL(em28xx_unregister_extension);
1165
em28xx_init_extension(struct em28xx * dev)1166 void em28xx_init_extension(struct em28xx *dev)
1167 {
1168 const struct em28xx_ops *ops = NULL;
1169
1170 mutex_lock(&em28xx_devlist_mutex);
1171 list_add_tail(&dev->devlist, &em28xx_devlist);
1172 list_for_each_entry(ops, &em28xx_extension_devlist, next) {
1173 if (ops->init)
1174 ops->init(dev);
1175 }
1176 mutex_unlock(&em28xx_devlist_mutex);
1177 }
1178
em28xx_close_extension(struct em28xx * dev)1179 void em28xx_close_extension(struct em28xx *dev)
1180 {
1181 const struct em28xx_ops *ops = NULL;
1182
1183 mutex_lock(&em28xx_devlist_mutex);
1184 list_for_each_entry(ops, &em28xx_extension_devlist, next) {
1185 if (ops->fini)
1186 ops->fini(dev);
1187 }
1188 list_del(&dev->devlist);
1189 mutex_unlock(&em28xx_devlist_mutex);
1190 }
1191