aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/media/video/em28xx
diff options
context:
space:
mode:
Diffstat (limited to 'drivers/media/video/em28xx')
-rw-r--r--drivers/media/video/em28xx/Kconfig56
-rw-r--r--drivers/media/video/em28xx/Makefile16
-rw-r--r--drivers/media/video/em28xx/em28xx-audio.c748
-rw-r--r--drivers/media/video/em28xx/em28xx-cards.c3315
-rw-r--r--drivers/media/video/em28xx/em28xx-core.c1266
-rw-r--r--drivers/media/video/em28xx/em28xx-dvb.c877
-rw-r--r--drivers/media/video/em28xx/em28xx-i2c.c578
-rw-r--r--drivers/media/video/em28xx/em28xx-input.c560
-rw-r--r--drivers/media/video/em28xx/em28xx-reg.h270
-rw-r--r--drivers/media/video/em28xx/em28xx-vbi.c145
-rw-r--r--drivers/media/video/em28xx/em28xx-video.c2535
-rw-r--r--drivers/media/video/em28xx/em28xx.h845
12 files changed, 11211 insertions, 0 deletions
diff --git a/drivers/media/video/em28xx/Kconfig b/drivers/media/video/em28xx/Kconfig
new file mode 100644
index 00000000000..281ee427c2a
--- /dev/null
+++ b/drivers/media/video/em28xx/Kconfig
@@ -0,0 +1,56 @@
1config VIDEO_EM28XX
2 tristate "Empia EM28xx USB video capture support"
3 depends on VIDEO_DEV && I2C
4 select VIDEO_TUNER
5 select VIDEO_TVEEPROM
6 select VIDEOBUF_VMALLOC
7 select VIDEO_SAA711X if VIDEO_HELPER_CHIPS_AUTO
8 select VIDEO_TVP5150 if VIDEO_HELPER_CHIPS_AUTO
9 select VIDEO_MSP3400 if VIDEO_HELPER_CHIPS_AUTO
10 select VIDEO_MT9V011 if VIDEO_HELPER_CHIPS_AUTO
11
12 ---help---
13 This is a video4linux driver for Empia 28xx based TV cards.
14
15 To compile this driver as a module, choose M here: the
16 module will be called em28xx
17
18config VIDEO_EM28XX_ALSA
19 depends on VIDEO_EM28XX && SND
20 select SND_PCM
21 tristate "Empia EM28xx ALSA audio module"
22 ---help---
23 This is an ALSA driver for some Empia 28xx based TV cards.
24
25 This is not required for em2800/em2820/em2821 boards. However,
26 newer em28xx devices uses Vendor Class for audio, instead of
27 implementing the USB Audio Class. For those chips, this module
28 will enable digital audio.
29
30 To compile this driver as a module, choose M here: the
31 module will be called em28xx-alsa
32
33config VIDEO_EM28XX_DVB
34 tristate "DVB/ATSC Support for em28xx based TV cards"
35 depends on VIDEO_EM28XX && DVB_CORE
36 select DVB_LGDT330X if !DVB_FE_CUSTOMISE
37 select DVB_ZL10353 if !DVB_FE_CUSTOMISE
38 select DVB_TDA10023 if !DVB_FE_CUSTOMISE
39 select DVB_S921 if !DVB_FE_CUSTOMISE
40 select DVB_DRXD if !DVB_FE_CUSTOMISE
41 select DVB_CXD2820R if !DVB_FE_CUSTOMISE
42 select DVB_DRXK if !DVB_FE_CUSTOMISE
43 select DVB_TDA18271C2DD if !DVB_FE_CUSTOMISE
44 select VIDEOBUF_DVB
45 ---help---
46 This adds support for DVB cards based on the
47 Empiatech em28xx chips.
48
49config VIDEO_EM28XX_RC
50 bool "EM28XX Remote Controller support"
51 depends on RC_CORE
52 depends on VIDEO_EM28XX
53 depends on !(RC_CORE=m && VIDEO_EM28XX=y)
54 default y
55 ---help---
56 Enables Remote Controller support on em28xx driver.
diff --git a/drivers/media/video/em28xx/Makefile b/drivers/media/video/em28xx/Makefile
new file mode 100644
index 00000000000..38aaa004f57
--- /dev/null
+++ b/drivers/media/video/em28xx/Makefile
@@ -0,0 +1,16 @@
1em28xx-y := em28xx-video.o em28xx-i2c.o em28xx-cards.o
2em28xx-y += em28xx-core.o em28xx-vbi.o
3
4em28xx-$(CONFIG_VIDEO_EM28XX_RC) += em28xx-input.o
5
6em28xx-alsa-objs := em28xx-audio.o
7
8obj-$(CONFIG_VIDEO_EM28XX) += em28xx.o
9obj-$(CONFIG_VIDEO_EM28XX_ALSA) += em28xx-alsa.o
10obj-$(CONFIG_VIDEO_EM28XX_DVB) += em28xx-dvb.o
11
12EXTRA_CFLAGS += -Idrivers/media/video
13EXTRA_CFLAGS += -Idrivers/media/common/tuners
14EXTRA_CFLAGS += -Idrivers/media/dvb/dvb-core
15EXTRA_CFLAGS += -Idrivers/media/dvb/frontends
16
diff --git a/drivers/media/video/em28xx/em28xx-audio.c b/drivers/media/video/em28xx/em28xx-audio.c
new file mode 100644
index 00000000000..cff0768afbf
--- /dev/null
+++ b/drivers/media/video/em28xx/em28xx-audio.c
@@ -0,0 +1,748 @@
1/*
2 * Empiatech em28x1 audio extension
3 *
4 * Copyright (C) 2006 Markus Rechberger <mrechberger@gmail.com>
5 *
6 * Copyright (C) 2007-2011 Mauro Carvalho Chehab <mchehab@redhat.com>
7 * - Port to work with the in-kernel driver
8 * - Cleanups, fixes, alsa-controls, etc.
9 *
10 * This driver is based on my previous au600 usb pstn audio driver
11 * and inherits all the copyrights
12 *
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2 of the License, or
16 * (at your option) any later version.
17 *
18 * This program is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
22 *
23 * You should have received a copy of the GNU General Public License
24 * along with this program; if not, write to the Free Software
25 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 */
27
28#include <linux/kernel.h>
29#include <linux/usb.h>
30#include <linux/init.h>
31#include <linux/sound.h>
32#include <linux/spinlock.h>
33#include <linux/soundcard.h>
34#include <linux/slab.h>
35#include <linux/vmalloc.h>
36#include <linux/proc_fs.h>
37#include <linux/module.h>
38#include <sound/core.h>
39#include <sound/pcm.h>
40#include <sound/pcm_params.h>
41#include <sound/info.h>
42#include <sound/initval.h>
43#include <sound/control.h>
44#include <sound/tlv.h>
45#include <media/v4l2-common.h>
46#include "em28xx.h"
47
48static int debug;
49module_param(debug, int, 0644);
50MODULE_PARM_DESC(debug, "activates debug info");
51
52#define dprintk(fmt, arg...) do { \
53 if (debug) \
54 printk(KERN_INFO "em28xx-audio %s: " fmt, \
55 __func__, ##arg); \
56 } while (0)
57
58static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
59
60static int em28xx_deinit_isoc_audio(struct em28xx *dev)
61{
62 int i;
63
64 dprintk("Stopping isoc\n");
65 for (i = 0; i < EM28XX_AUDIO_BUFS; i++) {
66 if (!irqs_disabled())
67 usb_kill_urb(dev->adev.urb[i]);
68 else
69 usb_unlink_urb(dev->adev.urb[i]);
70
71 usb_free_urb(dev->adev.urb[i]);
72 dev->adev.urb[i] = NULL;
73
74 kfree(dev->adev.transfer_buffer[i]);
75 dev->adev.transfer_buffer[i] = NULL;
76 }
77
78 return 0;
79}
80
81static void em28xx_audio_isocirq(struct urb *urb)
82{
83 struct em28xx *dev = urb->context;
84 int i;
85 unsigned int oldptr;
86 int period_elapsed = 0;
87 int status;
88 unsigned char *cp;
89 unsigned int stride;
90 struct snd_pcm_substream *substream;
91 struct snd_pcm_runtime *runtime;
92
93 switch (urb->status) {
94 case 0: /* success */
95 case -ETIMEDOUT: /* NAK */
96 break;
97 case -ECONNRESET: /* kill */
98 case -ENOENT:
99 case -ESHUTDOWN:
100 return;
101 default: /* error */
102 dprintk("urb completition error %d.\n", urb->status);
103 break;
104 }
105
106 if (atomic_read(&dev->stream_started) == 0)
107 return;
108
109 if (dev->adev.capture_pcm_substream) {
110 substream = dev->adev.capture_pcm_substream;
111 runtime = substream->runtime;
112 stride = runtime->frame_bits >> 3;
113
114 for (i = 0; i < urb->number_of_packets; i++) {
115 int length =
116 urb->iso_frame_desc[i].actual_length / stride;
117 cp = (unsigned char *)urb->transfer_buffer +
118 urb->iso_frame_desc[i].offset;
119
120 if (!length)
121 continue;
122
123 oldptr = dev->adev.hwptr_done_capture;
124 if (oldptr + length >= runtime->buffer_size) {
125 unsigned int cnt =
126 runtime->buffer_size - oldptr;
127 memcpy(runtime->dma_area + oldptr * stride, cp,
128 cnt * stride);
129 memcpy(runtime->dma_area, cp + cnt * stride,
130 length * stride - cnt * stride);
131 } else {
132 memcpy(runtime->dma_area + oldptr * stride, cp,
133 length * stride);
134 }
135
136 snd_pcm_stream_lock(substream);
137
138 dev->adev.hwptr_done_capture += length;
139 if (dev->adev.hwptr_done_capture >=
140 runtime->buffer_size)
141 dev->adev.hwptr_done_capture -=
142 runtime->buffer_size;
143
144 dev->adev.capture_transfer_done += length;
145 if (dev->adev.capture_transfer_done >=
146 runtime->period_size) {
147 dev->adev.capture_transfer_done -=
148 runtime->period_size;
149 period_elapsed = 1;
150 }
151
152 snd_pcm_stream_unlock(substream);
153 }
154 if (period_elapsed)
155 snd_pcm_period_elapsed(substream);
156 }
157 urb->status = 0;
158
159 status = usb_submit_urb(urb, GFP_ATOMIC);
160 if (status < 0) {
161 em28xx_errdev("resubmit of audio urb failed (error=%i)\n",
162 status);
163 }
164 return;
165}
166
167static int em28xx_init_audio_isoc(struct em28xx *dev)
168{
169 int i, errCode;
170 const int sb_size = EM28XX_NUM_AUDIO_PACKETS *
171 EM28XX_AUDIO_MAX_PACKET_SIZE;
172
173 dprintk("Starting isoc transfers\n");
174
175 for (i = 0; i < EM28XX_AUDIO_BUFS; i++) {
176 struct urb *urb;
177 int j, k;
178
179 dev->adev.transfer_buffer[i] = kmalloc(sb_size, GFP_ATOMIC);
180 if (!dev->adev.transfer_buffer[i])
181 return -ENOMEM;
182
183 memset(dev->adev.transfer_buffer[i], 0x80, sb_size);
184 urb = usb_alloc_urb(EM28XX_NUM_AUDIO_PACKETS, GFP_ATOMIC);
185 if (!urb) {
186 em28xx_errdev("usb_alloc_urb failed!\n");
187 for (j = 0; j < i; j++) {
188 usb_free_urb(dev->adev.urb[j]);
189 kfree(dev->adev.transfer_buffer[j]);
190 }
191 return -ENOMEM;
192 }
193
194 urb->dev = dev->udev;
195 urb->context = dev;
196 urb->pipe = usb_rcvisocpipe(dev->udev, 0x83);
197 urb->transfer_flags = URB_ISO_ASAP;
198 urb->transfer_buffer = dev->adev.transfer_buffer[i];
199 urb->interval = 1;
200 urb->complete = em28xx_audio_isocirq;
201 urb->number_of_packets = EM28XX_NUM_AUDIO_PACKETS;
202 urb->transfer_buffer_length = sb_size;
203
204 for (j = k = 0; j < EM28XX_NUM_AUDIO_PACKETS;
205 j++, k += EM28XX_AUDIO_MAX_PACKET_SIZE) {
206 urb->iso_frame_desc[j].offset = k;
207 urb->iso_frame_desc[j].length =
208 EM28XX_AUDIO_MAX_PACKET_SIZE;
209 }
210 dev->adev.urb[i] = urb;
211 }
212
213 for (i = 0; i < EM28XX_AUDIO_BUFS; i++) {
214 errCode = usb_submit_urb(dev->adev.urb[i], GFP_ATOMIC);
215 if (errCode) {
216 em28xx_errdev("submit of audio urb failed\n");
217 em28xx_deinit_isoc_audio(dev);
218 atomic_set(&dev->stream_started, 0);
219 return errCode;
220 }
221
222 }
223
224 return 0;
225}
226
227static int snd_pcm_alloc_vmalloc_buffer(struct snd_pcm_substream *subs,
228 size_t size)
229{
230 struct snd_pcm_runtime *runtime = subs->runtime;
231
232 dprintk("Allocating vbuffer\n");
233 if (runtime->dma_area) {
234 if (runtime->dma_bytes > size)
235 return 0;
236
237 vfree(runtime->dma_area);
238 }
239 runtime->dma_area = vmalloc(size);
240 if (!runtime->dma_area)
241 return -ENOMEM;
242
243 runtime->dma_bytes = size;
244
245 return 0;
246}
247
248static struct snd_pcm_hardware snd_em28xx_hw_capture = {
249 .info = SNDRV_PCM_INFO_BLOCK_TRANSFER |
250 SNDRV_PCM_INFO_MMAP |
251 SNDRV_PCM_INFO_INTERLEAVED |
252 SNDRV_PCM_INFO_BATCH |
253 SNDRV_PCM_INFO_MMAP_VALID,
254
255 .formats = SNDRV_PCM_FMTBIT_S16_LE,
256
257 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_KNOT,
258
259 .rate_min = 48000,
260 .rate_max = 48000,
261 .channels_min = 2,
262 .channels_max = 2,
263 .buffer_bytes_max = 62720 * 8, /* just about the value in usbaudio.c */
264 .period_bytes_min = 64, /* 12544/2, */
265 .period_bytes_max = 12544,
266 .periods_min = 2,
267 .periods_max = 98, /* 12544, */
268};
269
270static int snd_em28xx_capture_open(struct snd_pcm_substream *substream)
271{
272 struct em28xx *dev = snd_pcm_substream_chip(substream);
273 struct snd_pcm_runtime *runtime = substream->runtime;
274 int ret = 0;
275
276 dprintk("opening device and trying to acquire exclusive lock\n");
277
278 if (!dev) {
279 em28xx_err("BUG: em28xx can't find device struct."
280 " Can't proceed with open\n");
281 return -ENODEV;
282 }
283
284 runtime->hw = snd_em28xx_hw_capture;
285 if ((dev->alt == 0 || dev->audio_ifnum) && dev->adev.users == 0) {
286 if (dev->audio_ifnum)
287 dev->alt = 1;
288 else
289 dev->alt = 7;
290
291 dprintk("changing alternate number on interface %d to %d\n",
292 dev->audio_ifnum, dev->alt);
293 usb_set_interface(dev->udev, dev->audio_ifnum, dev->alt);
294
295 /* Sets volume, mute, etc */
296 dev->mute = 0;
297 mutex_lock(&dev->lock);
298 ret = em28xx_audio_analog_set(dev);
299 if (ret < 0)
300 goto err;
301
302 dev->adev.users++;
303 mutex_unlock(&dev->lock);
304 }
305
306 snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
307 dev->adev.capture_pcm_substream = substream;
308 runtime->private_data = dev;
309
310 return 0;
311err:
312 mutex_unlock(&dev->lock);
313
314 em28xx_err("Error while configuring em28xx mixer\n");
315 return ret;
316}
317
318static int snd_em28xx_pcm_close(struct snd_pcm_substream *substream)
319{
320 struct em28xx *dev = snd_pcm_substream_chip(substream);
321
322 dprintk("closing device\n");
323
324 dev->mute = 1;
325 mutex_lock(&dev->lock);
326 dev->adev.users--;
327 if (atomic_read(&dev->stream_started) > 0) {
328 atomic_set(&dev->stream_started, 0);
329 schedule_work(&dev->wq_trigger);
330 }
331
332 em28xx_audio_analog_set(dev);
333 if (substream->runtime->dma_area) {
334 dprintk("freeing\n");
335 vfree(substream->runtime->dma_area);
336 substream->runtime->dma_area = NULL;
337 }
338 mutex_unlock(&dev->lock);
339
340 return 0;
341}
342
343static int snd_em28xx_hw_capture_params(struct snd_pcm_substream *substream,
344 struct snd_pcm_hw_params *hw_params)
345{
346 unsigned int channels, rate, format;
347 int ret;
348
349 dprintk("Setting capture parameters\n");
350
351 ret = snd_pcm_alloc_vmalloc_buffer(substream,
352 params_buffer_bytes(hw_params));
353 if (ret < 0)
354 return ret;
355 format = params_format(hw_params);
356 rate = params_rate(hw_params);
357 channels = params_channels(hw_params);
358
359 /* TODO: set up em28xx audio chip to deliver the correct audio format,
360 current default is 48000hz multiplexed => 96000hz mono
361 which shouldn't matter since analogue TV only supports mono */
362 return 0;
363}
364
365static int snd_em28xx_hw_capture_free(struct snd_pcm_substream *substream)
366{
367 struct em28xx *dev = snd_pcm_substream_chip(substream);
368
369 dprintk("Stop capture, if needed\n");
370
371 if (atomic_read(&dev->stream_started) > 0) {
372 atomic_set(&dev->stream_started, 0);
373 schedule_work(&dev->wq_trigger);
374 }
375
376 return 0;
377}
378
379static int snd_em28xx_prepare(struct snd_pcm_substream *substream)
380{
381 struct em28xx *dev = snd_pcm_substream_chip(substream);
382
383 dev->adev.hwptr_done_capture = 0;
384 dev->adev.capture_transfer_done = 0;
385
386 return 0;
387}
388
389static void audio_trigger(struct work_struct *work)
390{
391 struct em28xx *dev = container_of(work, struct em28xx, wq_trigger);
392
393 if (atomic_read(&dev->stream_started)) {
394 dprintk("starting capture");
395 em28xx_init_audio_isoc(dev);
396 } else {
397 dprintk("stopping capture");
398 em28xx_deinit_isoc_audio(dev);
399 }
400}
401
402static int snd_em28xx_capture_trigger(struct snd_pcm_substream *substream,
403 int cmd)
404{
405 struct em28xx *dev = snd_pcm_substream_chip(substream);
406 int retval = 0;
407
408 switch (cmd) {
409 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: /* fall through */
410 case SNDRV_PCM_TRIGGER_RESUME: /* fall through */
411 case SNDRV_PCM_TRIGGER_START:
412 atomic_set(&dev->stream_started, 1);
413 break;
414 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: /* fall through */
415 case SNDRV_PCM_TRIGGER_SUSPEND: /* fall through */
416 case SNDRV_PCM_TRIGGER_STOP:
417 atomic_set(&dev->stream_started, 0);
418 break;
419 default:
420 retval = -EINVAL;
421 }
422 schedule_work(&dev->wq_trigger);
423 return retval;
424}
425
426static snd_pcm_uframes_t snd_em28xx_capture_pointer(struct snd_pcm_substream
427 *substream)
428{
429 unsigned long flags;
430 struct em28xx *dev;
431 snd_pcm_uframes_t hwptr_done;
432
433 dev = snd_pcm_substream_chip(substream);
434 spin_lock_irqsave(&dev->adev.slock, flags);
435 hwptr_done = dev->adev.hwptr_done_capture;
436 spin_unlock_irqrestore(&dev->adev.slock, flags);
437
438 return hwptr_done;
439}
440
441static struct page *snd_pcm_get_vmalloc_page(struct snd_pcm_substream *subs,
442 unsigned long offset)
443{
444 void *pageptr = subs->runtime->dma_area + offset;
445
446 return vmalloc_to_page(pageptr);
447}
448
449/*
450 * AC97 volume control support
451 */
452static int em28xx_vol_info(struct snd_kcontrol *kcontrol,
453 struct snd_ctl_elem_info *info)
454{
455 info->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
456 info->count = 2;
457 info->value.integer.min = 0;
458 info->value.integer.max = 0x1f;
459
460 return 0;
461}
462
463static int em28xx_vol_put(struct snd_kcontrol *kcontrol,
464 struct snd_ctl_elem_value *value)
465{
466 struct em28xx *dev = snd_kcontrol_chip(kcontrol);
467 u16 val = (0x1f - (value->value.integer.value[0] & 0x1f)) |
468 (0x1f - (value->value.integer.value[1] & 0x1f)) << 8;
469 int rc;
470
471 mutex_lock(&dev->lock);
472 rc = em28xx_read_ac97(dev, kcontrol->private_value);
473 if (rc < 0)
474 goto err;
475
476 val |= rc & 0x8000; /* Preserve the mute flag */
477
478 rc = em28xx_write_ac97(dev, kcontrol->private_value, val);
479 if (rc < 0)
480 goto err;
481
482 dprintk("%sleft vol %d, right vol %d (0x%04x) to ac97 volume control 0x%04x\n",
483 (val & 0x8000) ? "muted " : "",
484 0x1f - ((val >> 8) & 0x1f), 0x1f - (val & 0x1f),
485 val, (int)kcontrol->private_value);
486
487err:
488 mutex_unlock(&dev->lock);
489 return rc;
490}
491
492static int em28xx_vol_get(struct snd_kcontrol *kcontrol,
493 struct snd_ctl_elem_value *value)
494{
495 struct em28xx *dev = snd_kcontrol_chip(kcontrol);
496 int val;
497
498 mutex_lock(&dev->lock);
499 val = em28xx_read_ac97(dev, kcontrol->private_value);
500 mutex_unlock(&dev->lock);
501 if (val < 0)
502 return val;
503
504 dprintk("%sleft vol %d, right vol %d (0x%04x) from ac97 volume control 0x%04x\n",
505 (val & 0x8000) ? "muted " : "",
506 0x1f - ((val >> 8) & 0x1f), 0x1f - (val & 0x1f),
507 val, (int)kcontrol->private_value);
508
509 value->value.integer.value[0] = 0x1f - (val & 0x1f);
510 value->value.integer.value[1] = 0x1f - ((val << 8) & 0x1f);
511
512 return 0;
513}
514
515static int em28xx_vol_put_mute(struct snd_kcontrol *kcontrol,
516 struct snd_ctl_elem_value *value)
517{
518 struct em28xx *dev = snd_kcontrol_chip(kcontrol);
519 u16 val = value->value.integer.value[0];
520 int rc;
521
522 mutex_lock(&dev->lock);
523 rc = em28xx_read_ac97(dev, kcontrol->private_value);
524 if (rc < 0)
525 goto err;
526
527 if (val)
528 rc &= 0x1f1f;
529 else
530 rc |= 0x8000;
531
532 rc = em28xx_write_ac97(dev, kcontrol->private_value, rc);
533 if (rc < 0)
534 goto err;
535
536 dprintk("%sleft vol %d, right vol %d (0x%04x) to ac97 volume control 0x%04x\n",
537 (val & 0x8000) ? "muted " : "",
538 0x1f - ((val >> 8) & 0x1f), 0x1f - (val & 0x1f),
539 val, (int)kcontrol->private_value);
540
541err:
542 mutex_unlock(&dev->lock);
543 return rc;
544}
545
546static int em28xx_vol_get_mute(struct snd_kcontrol *kcontrol,
547 struct snd_ctl_elem_value *value)
548{
549 struct em28xx *dev = snd_kcontrol_chip(kcontrol);
550 int val;
551
552 mutex_lock(&dev->lock);
553 val = em28xx_read_ac97(dev, kcontrol->private_value);
554 mutex_unlock(&dev->lock);
555 if (val < 0)
556 return val;
557
558 if (val & 0x8000)
559 value->value.integer.value[0] = 0;
560 else
561 value->value.integer.value[0] = 1;
562
563 dprintk("%sleft vol %d, right vol %d (0x%04x) from ac97 volume control 0x%04x\n",
564 (val & 0x8000) ? "muted " : "",
565 0x1f - ((val >> 8) & 0x1f), 0x1f - (val & 0x1f),
566 val, (int)kcontrol->private_value);
567
568 return 0;
569}
570
571static const DECLARE_TLV_DB_SCALE(em28xx_db_scale, -3450, 150, 0);
572
573static int em28xx_cvol_new(struct snd_card *card, struct em28xx *dev,
574 char *name, int id)
575{
576 int err;
577 char ctl_name[44];
578 struct snd_kcontrol *kctl;
579 struct snd_kcontrol_new tmp;
580
581 memset (&tmp, 0, sizeof(tmp));
582 tmp.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
583 tmp.private_value = id,
584 tmp.name = ctl_name,
585
586 /* Add Mute Control */
587 sprintf(ctl_name, "%s Switch", name);
588 tmp.get = em28xx_vol_get_mute;
589 tmp.put = em28xx_vol_put_mute;
590 tmp.info = snd_ctl_boolean_mono_info;
591 kctl = snd_ctl_new1(&tmp, dev);
592 err = snd_ctl_add(card, kctl);
593 if (err < 0)
594 return err;
595 dprintk("Added control %s for ac97 volume control 0x%04x\n",
596 ctl_name, id);
597
598 memset (&tmp, 0, sizeof(tmp));
599 tmp.iface = SNDRV_CTL_ELEM_IFACE_MIXER,
600 tmp.private_value = id,
601 tmp.name = ctl_name,
602
603 /* Add Volume Control */
604 sprintf(ctl_name, "%s Volume", name);
605 tmp.get = em28xx_vol_get;
606 tmp.put = em28xx_vol_put;
607 tmp.info = em28xx_vol_info;
608 tmp.tlv.p = em28xx_db_scale,
609 kctl = snd_ctl_new1(&tmp, dev);
610 err = snd_ctl_add(card, kctl);
611 if (err < 0)
612 return err;
613 dprintk("Added control %s for ac97 volume control 0x%04x\n",
614 ctl_name, id);
615
616 return 0;
617}
618
619/*
620 * register/unregister code and data
621 */
622static struct snd_pcm_ops snd_em28xx_pcm_capture = {
623 .open = snd_em28xx_capture_open,
624 .close = snd_em28xx_pcm_close,
625 .ioctl = snd_pcm_lib_ioctl,
626 .hw_params = snd_em28xx_hw_capture_params,
627 .hw_free = snd_em28xx_hw_capture_free,
628 .prepare = snd_em28xx_prepare,
629 .trigger = snd_em28xx_capture_trigger,
630 .pointer = snd_em28xx_capture_pointer,
631 .page = snd_pcm_get_vmalloc_page,
632};
633
634static int em28xx_audio_init(struct em28xx *dev)
635{
636 struct em28xx_audio *adev = &dev->adev;
637 struct snd_pcm *pcm;
638 struct snd_card *card;
639 static int devnr;
640 int err;
641
642 if (!dev->has_alsa_audio || dev->audio_ifnum < 0) {
643 /* This device does not support the extension (in this case
644 the device is expecting the snd-usb-audio module or
645 doesn't have analog audio support at all) */
646 return 0;
647 }
648
649 printk(KERN_INFO "em28xx-audio.c: probing for em28xx Audio Vendor Class\n");
650 printk(KERN_INFO "em28xx-audio.c: Copyright (C) 2006 Markus "
651 "Rechberger\n");
652 printk(KERN_INFO "em28xx-audio.c: Copyright (C) 2007-2011 Mauro Carvalho Chehab\n");
653
654 err = snd_card_create(index[devnr], "Em28xx Audio", THIS_MODULE, 0,
655 &card);
656 if (err < 0)
657 return err;
658
659 spin_lock_init(&adev->slock);
660 err = snd_pcm_new(card, "Em28xx Audio", 0, 0, 1, &pcm);
661 if (err < 0) {
662 snd_card_free(card);
663 return err;
664 }
665
666 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_em28xx_pcm_capture);
667 pcm->info_flags = 0;
668 pcm->private_data = dev;
669 strcpy(pcm->name, "Empia 28xx Capture");
670
671 snd_card_set_dev(card, &dev->udev->dev);
672 strcpy(card->driver, "Em28xx-Audio");
673 strcpy(card->shortname, "Em28xx Audio");
674 strcpy(card->longname, "Empia Em28xx Audio");
675
676 INIT_WORK(&dev->wq_trigger, audio_trigger);
677
678 if (dev->audio_mode.ac97 != EM28XX_NO_AC97) {
679 em28xx_cvol_new(card, dev, "Video", AC97_VIDEO_VOL);
680 em28xx_cvol_new(card, dev, "Line In", AC97_LINEIN_VOL);
681 em28xx_cvol_new(card, dev, "Phone", AC97_PHONE_VOL);
682 em28xx_cvol_new(card, dev, "Microphone", AC97_PHONE_VOL);
683 em28xx_cvol_new(card, dev, "CD", AC97_CD_VOL);
684 em28xx_cvol_new(card, dev, "AUX", AC97_AUX_VOL);
685 em28xx_cvol_new(card, dev, "PCM", AC97_PCM_OUT_VOL);
686
687 em28xx_cvol_new(card, dev, "Master", AC97_MASTER_VOL);
688 em28xx_cvol_new(card, dev, "Line", AC97_LINE_LEVEL_VOL);
689 em28xx_cvol_new(card, dev, "Mono", AC97_MASTER_MONO_VOL);
690 em28xx_cvol_new(card, dev, "LFE", AC97_LFE_MASTER_VOL);
691 em28xx_cvol_new(card, dev, "Surround", AC97_SURR_MASTER_VOL);
692 }
693
694 err = snd_card_register(card);
695 if (err < 0) {
696 snd_card_free(card);
697 return err;
698 }
699 adev->sndcard = card;
700 adev->udev = dev->udev;
701
702 return 0;
703}
704
705static int em28xx_audio_fini(struct em28xx *dev)
706{
707 if (dev == NULL)
708 return 0;
709
710 if (dev->has_alsa_audio != 1) {
711 /* This device does not support the extension (in this case
712 the device is expecting the snd-usb-audio module or
713 doesn't have analog audio support at all) */
714 return 0;
715 }
716
717 if (dev->adev.sndcard) {
718 snd_card_free(dev->adev.sndcard);
719 dev->adev.sndcard = NULL;
720 }
721
722 return 0;
723}
724
725static struct em28xx_ops audio_ops = {
726 .id = EM28XX_AUDIO,
727 .name = "Em28xx Audio Extension",
728 .init = em28xx_audio_init,
729 .fini = em28xx_audio_fini,
730};
731
732static int __init em28xx_alsa_register(void)
733{
734 return em28xx_register_extension(&audio_ops);
735}
736
737static void __exit em28xx_alsa_unregister(void)
738{
739 em28xx_unregister_extension(&audio_ops);
740}
741
742MODULE_LICENSE("GPL");
743MODULE_AUTHOR("Markus Rechberger <mrechberger@gmail.com>");
744MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@redhat.com>");
745MODULE_DESCRIPTION("Em28xx Audio driver");
746
747module_init(em28xx_alsa_register);
748module_exit(em28xx_alsa_unregister);
diff --git a/drivers/media/video/em28xx/em28xx-cards.c b/drivers/media/video/em28xx/em28xx-cards.c
new file mode 100644
index 00000000000..3e3959fee41
--- /dev/null
+++ b/drivers/media/video/em28xx/em28xx-cards.c
@@ -0,0 +1,3315 @@
1/*
2 em28xx-cards.c - driver for Empia EM2800/EM2820/2840 USB
3 video capture devices
4
5 Copyright (C) 2005 Ludovico Cavedon <cavedon@sssup.it>
6 Markus Rechberger <mrechberger@gmail.com>
7 Mauro Carvalho Chehab <mchehab@infradead.org>
8 Sascha Sommer <saschasommer@freenet.de>
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 */
24
25#include <linux/init.h>
26#include <linux/module.h>
27#include <linux/slab.h>
28#include <linux/delay.h>
29#include <linux/i2c.h>
30#include <linux/usb.h>
31#include <media/tuner.h>
32#include <media/msp3400.h>
33#include <media/saa7115.h>
34#include <media/tvp5150.h>
35#include <media/tvaudio.h>
36#include <media/mt9v011.h>
37#include <media/i2c-addr.h>
38#include <media/tveeprom.h>
39#include <media/v4l2-common.h>
40#include <media/v4l2-chip-ident.h>
41
42#include "em28xx.h"
43
44#define DRIVER_NAME "em28xx"
45
46static int tuner = -1;
47module_param(tuner, int, 0444);
48MODULE_PARM_DESC(tuner, "tuner type");
49
50static unsigned int disable_ir;
51module_param(disable_ir, int, 0444);
52MODULE_PARM_DESC(disable_ir, "disable infrared remote support");
53
54static unsigned int disable_usb_speed_check;
55module_param(disable_usb_speed_check, int, 0444);
56MODULE_PARM_DESC(disable_usb_speed_check,
57 "override min bandwidth requirement of 480M bps");
58
59static unsigned int card[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = UNSET };
60module_param_array(card, int, NULL, 0444);
61MODULE_PARM_DESC(card, "card type");
62
63/* Bitmask marking allocated devices from 0 to EM28XX_MAXBOARDS */
64static unsigned long em28xx_devused;
65
66struct em28xx_hash_table {
67 unsigned long hash;
68 unsigned int model;
69 unsigned int tuner;
70};
71
72/*
73 * Reset sequences for analog/digital modes
74 */
75
76/* Reset for the most [analog] boards */
77static struct em28xx_reg_seq default_analog[] = {
78 {EM28XX_R08_GPIO, 0x6d, ~EM_GPIO_4, 10},
79 { -1, -1, -1, -1},
80};
81
82/* Reset for the most [digital] boards */
83static struct em28xx_reg_seq default_digital[] = {
84 {EM28XX_R08_GPIO, 0x6e, ~EM_GPIO_4, 10},
85 { -1, -1, -1, -1},
86};
87
88/* Board Hauppauge WinTV HVR 900 analog */
89static struct em28xx_reg_seq hauppauge_wintv_hvr_900_analog[] = {
90 {EM28XX_R08_GPIO, 0x2d, ~EM_GPIO_4, 10},
91 {0x05, 0xff, 0x10, 10},
92 { -1, -1, -1, -1},
93};
94
95/* Board Hauppauge WinTV HVR 900 digital */
96static struct em28xx_reg_seq hauppauge_wintv_hvr_900_digital[] = {
97 {EM28XX_R08_GPIO, 0x2e, ~EM_GPIO_4, 10},
98 {EM2880_R04_GPO, 0x04, 0x0f, 10},
99 {EM2880_R04_GPO, 0x0c, 0x0f, 10},
100 { -1, -1, -1, -1},
101};
102
103/* Board Hauppauge WinTV HVR 900 (R2) digital */
104static struct em28xx_reg_seq hauppauge_wintv_hvr_900R2_digital[] = {
105 {EM28XX_R08_GPIO, 0x2e, ~EM_GPIO_4, 10},
106 {EM2880_R04_GPO, 0x0c, 0x0f, 10},
107 { -1, -1, -1, -1},
108};
109
110/* Boards - EM2880 MSI DIGIVOX AD and EM2880_BOARD_MSI_DIGIVOX_AD_II */
111static struct em28xx_reg_seq em2880_msi_digivox_ad_analog[] = {
112 {EM28XX_R08_GPIO, 0x69, ~EM_GPIO_4, 10},
113 { -1, -1, -1, -1},
114};
115
116/* Boards - EM2880 MSI DIGIVOX AD and EM2880_BOARD_MSI_DIGIVOX_AD_II */
117
118/* Board - EM2870 Kworld 355u
119 Analog - No input analog */
120
121/* Board - EM2882 Kworld 315U digital */
122static struct em28xx_reg_seq em2882_kworld_315u_digital[] = {
123 {EM28XX_R08_GPIO, 0xff, 0xff, 10},
124 {EM28XX_R08_GPIO, 0xfe, 0xff, 10},
125 {EM2880_R04_GPO, 0x04, 0xff, 10},
126 {EM2880_R04_GPO, 0x0c, 0xff, 10},
127 {EM28XX_R08_GPIO, 0x7e, 0xff, 10},
128 { -1, -1, -1, -1},
129};
130
131static struct em28xx_reg_seq em2882_kworld_315u_tuner_gpio[] = {
132 {EM2880_R04_GPO, 0x08, 0xff, 10},
133 {EM2880_R04_GPO, 0x0c, 0xff, 10},
134 {EM2880_R04_GPO, 0x08, 0xff, 10},
135 {EM2880_R04_GPO, 0x0c, 0xff, 10},
136 { -1, -1, -1, -1},
137};
138
139static struct em28xx_reg_seq kworld_330u_analog[] = {
140 {EM28XX_R08_GPIO, 0x6d, ~EM_GPIO_4, 10},
141 {EM2880_R04_GPO, 0x00, 0xff, 10},
142 { -1, -1, -1, -1},
143};
144
145static struct em28xx_reg_seq kworld_330u_digital[] = {
146 {EM28XX_R08_GPIO, 0x6e, ~EM_GPIO_4, 10},
147 {EM2880_R04_GPO, 0x08, 0xff, 10},
148 { -1, -1, -1, -1},
149};
150
151/* Evga inDtube
152 GPIO0 - Enable digital power (s5h1409) - low to enable
153 GPIO1 - Enable analog power (tvp5150/emp202) - low to enable
154 GPIO4 - xc3028 reset
155 GOP3 - s5h1409 reset
156 */
157static struct em28xx_reg_seq evga_indtube_analog[] = {
158 {EM28XX_R08_GPIO, 0x79, 0xff, 60},
159 { -1, -1, -1, -1},
160};
161
162static struct em28xx_reg_seq evga_indtube_digital[] = {
163 {EM28XX_R08_GPIO, 0x7a, 0xff, 1},
164 {EM2880_R04_GPO, 0x04, 0xff, 10},
165 {EM2880_R04_GPO, 0x0c, 0xff, 1},
166 { -1, -1, -1, -1},
167};
168
169/*
170 * KWorld PlusTV 340U and UB435-Q (ATSC) GPIOs map:
171 * EM_GPIO_0 - currently unknown
172 * EM_GPIO_1 - LED disable/enable (1 = off, 0 = on)
173 * EM_GPIO_2 - currently unknown
174 * EM_GPIO_3 - currently unknown
175 * EM_GPIO_4 - TDA18271HD/C1 tuner (1 = active, 0 = in reset)
176 * EM_GPIO_5 - LGDT3304 ATSC/QAM demod (1 = active, 0 = in reset)
177 * EM_GPIO_6 - currently unknown
178 * EM_GPIO_7 - currently unknown
179 */
180static struct em28xx_reg_seq kworld_a340_digital[] = {
181 {EM28XX_R08_GPIO, 0x6d, ~EM_GPIO_4, 10},
182 { -1, -1, -1, -1},
183};
184
185/* Pinnacle Hybrid Pro eb1a:2881 */
186static struct em28xx_reg_seq pinnacle_hybrid_pro_analog[] = {
187 {EM28XX_R08_GPIO, 0xfd, ~EM_GPIO_4, 10},
188 { -1, -1, -1, -1},
189};
190
191static struct em28xx_reg_seq pinnacle_hybrid_pro_digital[] = {
192 {EM28XX_R08_GPIO, 0x6e, ~EM_GPIO_4, 10},
193 {EM2880_R04_GPO, 0x04, 0xff, 100},/* zl10353 reset */
194 {EM2880_R04_GPO, 0x0c, 0xff, 1},
195 { -1, -1, -1, -1},
196};
197
198static struct em28xx_reg_seq terratec_cinergy_USB_XS_FR_analog[] = {
199 {EM28XX_R08_GPIO, 0x6d, ~EM_GPIO_4, 10},
200 {EM2880_R04_GPO, 0x00, 0xff, 10},
201 { -1, -1, -1, -1},
202};
203
204static struct em28xx_reg_seq terratec_cinergy_USB_XS_FR_digital[] = {
205 {EM28XX_R08_GPIO, 0x6e, ~EM_GPIO_4, 10},
206 {EM2880_R04_GPO, 0x08, 0xff, 10},
207 { -1, -1, -1, -1},
208};
209
210/* eb1a:2868 Reddo DVB-C USB TV Box
211 GPIO4 - CU1216L NIM
212 Other GPIOs seems to be don't care. */
213static struct em28xx_reg_seq reddo_dvb_c_usb_box[] = {
214 {EM28XX_R08_GPIO, 0xfe, 0xff, 10},
215 {EM28XX_R08_GPIO, 0xde, 0xff, 10},
216 {EM28XX_R08_GPIO, 0xfe, 0xff, 10},
217 {EM28XX_R08_GPIO, 0xff, 0xff, 10},
218 {EM28XX_R08_GPIO, 0x7f, 0xff, 10},
219 {EM28XX_R08_GPIO, 0x6f, 0xff, 10},
220 {EM28XX_R08_GPIO, 0xff, 0xff, 10},
221 {-1, -1, -1, -1},
222};
223
224/* Callback for the most boards */
225static struct em28xx_reg_seq default_tuner_gpio[] = {
226 {EM28XX_R08_GPIO, EM_GPIO_4, EM_GPIO_4, 10},
227 {EM28XX_R08_GPIO, 0, EM_GPIO_4, 10},
228 {EM28XX_R08_GPIO, EM_GPIO_4, EM_GPIO_4, 10},
229 { -1, -1, -1, -1},
230};
231
232/* Mute/unmute */
233static struct em28xx_reg_seq compro_unmute_tv_gpio[] = {
234 {EM28XX_R08_GPIO, 5, 7, 10},
235 { -1, -1, -1, -1},
236};
237
238static struct em28xx_reg_seq compro_unmute_svid_gpio[] = {
239 {EM28XX_R08_GPIO, 4, 7, 10},
240 { -1, -1, -1, -1},
241};
242
243static struct em28xx_reg_seq compro_mute_gpio[] = {
244 {EM28XX_R08_GPIO, 6, 7, 10},
245 { -1, -1, -1, -1},
246};
247
248/* Terratec AV350 */
249static struct em28xx_reg_seq terratec_av350_mute_gpio[] = {
250 {EM28XX_R08_GPIO, 0xff, 0x7f, 10},
251 { -1, -1, -1, -1},
252};
253
254static struct em28xx_reg_seq terratec_av350_unmute_gpio[] = {
255 {EM28XX_R08_GPIO, 0xff, 0xff, 10},
256 { -1, -1, -1, -1},
257};
258
259static struct em28xx_reg_seq silvercrest_reg_seq[] = {
260 {EM28XX_R08_GPIO, 0xff, 0xff, 10},
261 {EM28XX_R08_GPIO, 0x01, 0xf7, 10},
262 { -1, -1, -1, -1},
263};
264
265static struct em28xx_reg_seq vc211a_enable[] = {
266 {EM28XX_R08_GPIO, 0xff, 0x07, 10},
267 {EM28XX_R08_GPIO, 0xff, 0x0f, 10},
268 {EM28XX_R08_GPIO, 0xff, 0x0b, 10},
269 { -1, -1, -1, -1},
270};
271
272static struct em28xx_reg_seq dikom_dk300_digital[] = {
273 {EM28XX_R08_GPIO, 0x6e, ~EM_GPIO_4, 10},
274 {EM2880_R04_GPO, 0x08, 0xff, 10},
275 { -1, -1, -1, -1},
276};
277
278
279/* Reset for the most [digital] boards */
280static struct em28xx_reg_seq leadership_digital[] = {
281 {EM2874_R80_GPIO, 0x70, 0xff, 10},
282 { -1, -1, -1, -1},
283};
284
285static struct em28xx_reg_seq leadership_reset[] = {
286 {EM2874_R80_GPIO, 0xf0, 0xff, 10},
287 {EM2874_R80_GPIO, 0xb0, 0xff, 10},
288 {EM2874_R80_GPIO, 0xf0, 0xff, 10},
289 { -1, -1, -1, -1},
290};
291
292/* 2013:024f PCTV nanoStick T2 290e
293 * GPIO_6 - demod reset
294 * GPIO_7 - LED
295 */
296static struct em28xx_reg_seq pctv_290e[] = {
297 {EM2874_R80_GPIO, 0x00, 0xff, 80},
298 {EM2874_R80_GPIO, 0x40, 0xff, 80}, /* GPIO_6 = 1 */
299 {EM2874_R80_GPIO, 0xc0, 0xff, 80}, /* GPIO_7 = 1 */
300 {-1, -1, -1, -1},
301};
302
303#if 0
304static struct em28xx_reg_seq terratec_h5_gpio[] = {
305 {EM28XX_R08_GPIO, 0xff, 0xff, 10},
306 {EM2874_R80_GPIO, 0xf6, 0xff, 100},
307 {EM2874_R80_GPIO, 0xf2, 0xff, 50},
308 {EM2874_R80_GPIO, 0xf6, 0xff, 50},
309 { -1, -1, -1, -1},
310};
311
312static struct em28xx_reg_seq terratec_h5_digital[] = {
313 {EM2874_R80_GPIO, 0xf6, 0xff, 10},
314 {EM2874_R80_GPIO, 0xe6, 0xff, 100},
315 {EM2874_R80_GPIO, 0xa6, 0xff, 10},
316 { -1, -1, -1, -1},
317};
318#endif
319
320/*
321 * Board definitions
322 */
323struct em28xx_board em28xx_boards[] = {
324 [EM2750_BOARD_UNKNOWN] = {
325 .name = "EM2710/EM2750/EM2751 webcam grabber",
326 .xclk = EM28XX_XCLK_FREQUENCY_20MHZ,
327 .tuner_type = TUNER_ABSENT,
328 .is_webcam = 1,
329 .input = { {
330 .type = EM28XX_VMUX_COMPOSITE1,
331 .vmux = 0,
332 .amux = EM28XX_AMUX_VIDEO,
333 .gpio = silvercrest_reg_seq,
334 } },
335 },
336 [EM2800_BOARD_UNKNOWN] = {
337 .name = "Unknown EM2800 video grabber",
338 .is_em2800 = 1,
339 .tda9887_conf = TDA9887_PRESENT,
340 .decoder = EM28XX_SAA711X,
341 .tuner_type = TUNER_ABSENT,
342 .input = { {
343 .type = EM28XX_VMUX_COMPOSITE1,
344 .vmux = SAA7115_COMPOSITE0,
345 .amux = EM28XX_AMUX_LINE_IN,
346 }, {
347 .type = EM28XX_VMUX_SVIDEO,
348 .vmux = SAA7115_SVIDEO3,
349 .amux = EM28XX_AMUX_LINE_IN,
350 } },
351 },
352 [EM2820_BOARD_UNKNOWN] = {
353 .name = "Unknown EM2750/28xx video grabber",
354 .tuner_type = TUNER_ABSENT,
355 .is_webcam = 1, /* To enable sensor probe */
356 },
357 [EM2750_BOARD_DLCW_130] = {
358 /* Beijing Huaqi Information Digital Technology Co., Ltd */
359 .name = "Huaqi DLCW-130",
360 .valid = EM28XX_BOARD_NOT_VALIDATED,
361 .xclk = EM28XX_XCLK_FREQUENCY_48MHZ,
362 .tuner_type = TUNER_ABSENT,
363 .is_webcam = 1,
364 .input = { {
365 .type = EM28XX_VMUX_COMPOSITE1,
366 .vmux = 0,
367 .amux = EM28XX_AMUX_VIDEO,
368 } },
369 },
370 [EM2820_BOARD_KWORLD_PVRTV2800RF] = {
371 .name = "Kworld PVR TV 2800 RF",
372 .tuner_type = TUNER_TEMIC_PAL,
373 .tda9887_conf = TDA9887_PRESENT,
374 .decoder = EM28XX_SAA711X,
375 .input = { {
376 .type = EM28XX_VMUX_COMPOSITE1,
377 .vmux = SAA7115_COMPOSITE0,
378 .amux = EM28XX_AMUX_LINE_IN,
379 }, {
380 .type = EM28XX_VMUX_SVIDEO,
381 .vmux = SAA7115_SVIDEO3,
382 .amux = EM28XX_AMUX_LINE_IN,
383 } },
384 },
385 [EM2820_BOARD_GADMEI_TVR200] = {
386 .name = "Gadmei TVR200",
387 .tuner_type = TUNER_LG_PAL_NEW_TAPC,
388 .tda9887_conf = TDA9887_PRESENT,
389 .decoder = EM28XX_SAA711X,
390 .input = { {
391 .type = EM28XX_VMUX_TELEVISION,
392 .vmux = SAA7115_COMPOSITE2,
393 .amux = EM28XX_AMUX_LINE_IN,
394 }, {
395 .type = EM28XX_VMUX_COMPOSITE1,
396 .vmux = SAA7115_COMPOSITE0,
397 .amux = EM28XX_AMUX_LINE_IN,
398 }, {
399 .type = EM28XX_VMUX_SVIDEO,
400 .vmux = SAA7115_SVIDEO3,
401 .amux = EM28XX_AMUX_LINE_IN,
402 } },
403 },
404 [EM2820_BOARD_TERRATEC_CINERGY_250] = {
405 .name = "Terratec Cinergy 250 USB",
406 .tuner_type = TUNER_LG_PAL_NEW_TAPC,
407 .has_ir_i2c = 1,
408 .tda9887_conf = TDA9887_PRESENT,
409 .decoder = EM28XX_SAA711X,
410 .input = { {
411 .type = EM28XX_VMUX_TELEVISION,
412 .vmux = SAA7115_COMPOSITE2,
413 .amux = EM28XX_AMUX_LINE_IN,
414 }, {
415 .type = EM28XX_VMUX_COMPOSITE1,
416 .vmux = SAA7115_COMPOSITE0,
417 .amux = EM28XX_AMUX_LINE_IN,
418 }, {
419 .type = EM28XX_VMUX_SVIDEO,
420 .vmux = SAA7115_SVIDEO3,
421 .amux = EM28XX_AMUX_LINE_IN,
422 } },
423 },
424 [EM2820_BOARD_PINNACLE_USB_2] = {
425 .name = "Pinnacle PCTV USB 2",
426 .tuner_type = TUNER_LG_PAL_NEW_TAPC,
427 .has_ir_i2c = 1,
428 .tda9887_conf = TDA9887_PRESENT,
429 .decoder = EM28XX_SAA711X,
430 .input = { {
431 .type = EM28XX_VMUX_TELEVISION,
432 .vmux = SAA7115_COMPOSITE2,
433 .amux = EM28XX_AMUX_VIDEO,
434 }, {
435 .type = EM28XX_VMUX_COMPOSITE1,
436 .vmux = SAA7115_COMPOSITE0,
437 .amux = EM28XX_AMUX_LINE_IN,
438 }, {
439 .type = EM28XX_VMUX_SVIDEO,
440 .vmux = SAA7115_SVIDEO3,
441 .amux = EM28XX_AMUX_LINE_IN,
442 } },
443 },
444 [EM2820_BOARD_HAUPPAUGE_WINTV_USB_2] = {
445 .name = "Hauppauge WinTV USB 2",
446 .tuner_type = TUNER_PHILIPS_FM1236_MK3,
447 .tda9887_conf = TDA9887_PRESENT |
448 TDA9887_PORT1_ACTIVE |
449 TDA9887_PORT2_ACTIVE,
450 .decoder = EM28XX_TVP5150,
451 .has_msp34xx = 1,
452 .has_ir_i2c = 1,
453 .input = { {
454 .type = EM28XX_VMUX_TELEVISION,
455 .vmux = TVP5150_COMPOSITE0,
456 .amux = MSP_INPUT_DEFAULT,
457 }, {
458 .type = EM28XX_VMUX_SVIDEO,
459 .vmux = TVP5150_SVIDEO,
460 .amux = MSP_INPUT(MSP_IN_SCART1, MSP_IN_TUNER1,
461 MSP_DSP_IN_SCART, MSP_DSP_IN_SCART),
462 } },
463 },
464 [EM2820_BOARD_DLINK_USB_TV] = {
465 .name = "D-Link DUB-T210 TV Tuner",
466 .valid = EM28XX_BOARD_NOT_VALIDATED,
467 .tuner_type = TUNER_LG_PAL_NEW_TAPC,
468 .tda9887_conf = TDA9887_PRESENT,
469 .decoder = EM28XX_SAA711X,
470 .input = { {
471 .type = EM28XX_VMUX_TELEVISION,
472 .vmux = SAA7115_COMPOSITE2,
473 .amux = EM28XX_AMUX_LINE_IN,
474 }, {
475 .type = EM28XX_VMUX_COMPOSITE1,
476 .vmux = SAA7115_COMPOSITE0,
477 .amux = EM28XX_AMUX_LINE_IN,
478 }, {
479 .type = EM28XX_VMUX_SVIDEO,
480 .vmux = SAA7115_SVIDEO3,
481 .amux = EM28XX_AMUX_LINE_IN,
482 } },
483 },
484 [EM2820_BOARD_HERCULES_SMART_TV_USB2] = {
485 .name = "Hercules Smart TV USB 2.0",
486 .valid = EM28XX_BOARD_NOT_VALIDATED,
487 .tuner_type = TUNER_LG_PAL_NEW_TAPC,
488 .tda9887_conf = TDA9887_PRESENT,
489 .decoder = EM28XX_SAA711X,
490 .input = { {
491 .type = EM28XX_VMUX_TELEVISION,
492 .vmux = SAA7115_COMPOSITE2,
493 .amux = EM28XX_AMUX_LINE_IN,
494 }, {
495 .type = EM28XX_VMUX_COMPOSITE1,
496 .vmux = SAA7115_COMPOSITE0,
497 .amux = EM28XX_AMUX_LINE_IN,
498 }, {
499 .type = EM28XX_VMUX_SVIDEO,
500 .vmux = SAA7115_SVIDEO3,
501 .amux = EM28XX_AMUX_LINE_IN,
502 } },
503 },
504 [EM2820_BOARD_PINNACLE_USB_2_FM1216ME] = {
505 .name = "Pinnacle PCTV USB 2 (Philips FM1216ME)",
506 .valid = EM28XX_BOARD_NOT_VALIDATED,
507 .tuner_type = TUNER_PHILIPS_FM1216ME_MK3,
508 .tda9887_conf = TDA9887_PRESENT,
509 .decoder = EM28XX_SAA711X,
510 .input = { {
511 .type = EM28XX_VMUX_TELEVISION,
512 .vmux = SAA7115_COMPOSITE2,
513 .amux = EM28XX_AMUX_VIDEO,
514 }, {
515 .type = EM28XX_VMUX_COMPOSITE1,
516 .vmux = SAA7115_COMPOSITE0,
517 .amux = EM28XX_AMUX_LINE_IN,
518 }, {
519 .type = EM28XX_VMUX_SVIDEO,
520 .vmux = SAA7115_SVIDEO3,
521 .amux = EM28XX_AMUX_LINE_IN,
522 } },
523 },
524 [EM2820_BOARD_GADMEI_UTV310] = {
525 .name = "Gadmei UTV310",
526 .valid = EM28XX_BOARD_NOT_VALIDATED,
527 .tuner_type = TUNER_TNF_5335MF,
528 .tda9887_conf = TDA9887_PRESENT,
529 .decoder = EM28XX_SAA711X,
530 .input = { {
531 .type = EM28XX_VMUX_TELEVISION,
532 .vmux = SAA7115_COMPOSITE1,
533 .amux = EM28XX_AMUX_LINE_IN,
534 }, {
535 .type = EM28XX_VMUX_COMPOSITE1,
536 .vmux = SAA7115_COMPOSITE0,
537 .amux = EM28XX_AMUX_LINE_IN,
538 }, {
539 .type = EM28XX_VMUX_SVIDEO,
540 .vmux = SAA7115_SVIDEO3,
541 .amux = EM28XX_AMUX_LINE_IN,
542 } },
543 },
544 [EM2820_BOARD_LEADTEK_WINFAST_USBII_DELUXE] = {
545 .name = "Leadtek Winfast USB II Deluxe",
546 .valid = EM28XX_BOARD_NOT_VALIDATED,
547 .tuner_type = TUNER_PHILIPS_FM1216ME_MK3,
548 .has_ir_i2c = 1,
549 .tvaudio_addr = 0x58,
550 .tda9887_conf = TDA9887_PRESENT |
551 TDA9887_PORT2_ACTIVE |
552 TDA9887_QSS,
553 .decoder = EM28XX_SAA711X,
554 .adecoder = EM28XX_TVAUDIO,
555 .input = { {
556 .type = EM28XX_VMUX_TELEVISION,
557 .vmux = SAA7115_COMPOSITE4,
558 .amux = EM28XX_AMUX_AUX,
559 }, {
560 .type = EM28XX_VMUX_COMPOSITE1,
561 .vmux = SAA7115_COMPOSITE5,
562 .amux = EM28XX_AMUX_LINE_IN,
563 }, {
564 .type = EM28XX_VMUX_SVIDEO,
565 .vmux = SAA7115_SVIDEO3,
566 .amux = EM28XX_AMUX_LINE_IN,
567 } },
568 .radio = {
569 .type = EM28XX_RADIO,
570 .amux = EM28XX_AMUX_AUX,
571 }
572 },
573 [EM2820_BOARD_VIDEOLOGY_20K14XUSB] = {
574 .name = "Videology 20K14XUSB USB2.0",
575 .valid = EM28XX_BOARD_NOT_VALIDATED,
576 .tuner_type = TUNER_ABSENT,
577 .is_webcam = 1,
578 .input = { {
579 .type = EM28XX_VMUX_COMPOSITE1,
580 .vmux = 0,
581 .amux = EM28XX_AMUX_VIDEO,
582 } },
583 },
584 [EM2820_BOARD_SILVERCREST_WEBCAM] = {
585 .name = "Silvercrest Webcam 1.3mpix",
586 .tuner_type = TUNER_ABSENT,
587 .is_webcam = 1,
588 .input = { {
589 .type = EM28XX_VMUX_COMPOSITE1,
590 .vmux = 0,
591 .amux = EM28XX_AMUX_VIDEO,
592 .gpio = silvercrest_reg_seq,
593 } },
594 },
595 [EM2821_BOARD_SUPERCOMP_USB_2] = {
596 .name = "Supercomp USB 2.0 TV",
597 .valid = EM28XX_BOARD_NOT_VALIDATED,
598 .tuner_type = TUNER_PHILIPS_FM1236_MK3,
599 .tda9887_conf = TDA9887_PRESENT |
600 TDA9887_PORT1_ACTIVE |
601 TDA9887_PORT2_ACTIVE,
602 .decoder = EM28XX_SAA711X,
603 .input = { {
604 .type = EM28XX_VMUX_TELEVISION,
605 .vmux = SAA7115_COMPOSITE2,
606 .amux = EM28XX_AMUX_LINE_IN,
607 }, {
608 .type = EM28XX_VMUX_COMPOSITE1,
609 .vmux = SAA7115_COMPOSITE0,
610 .amux = EM28XX_AMUX_VIDEO,
611 }, {
612 .type = EM28XX_VMUX_SVIDEO,
613 .vmux = SAA7115_SVIDEO3,
614 .amux = EM28XX_AMUX_LINE_IN,
615 } },
616 },
617 [EM2821_BOARD_USBGEAR_VD204] = {
618 .name = "Usbgear VD204v9",
619 .valid = EM28XX_BOARD_NOT_VALIDATED,
620 .tuner_type = TUNER_ABSENT, /* Capture only device */
621 .decoder = EM28XX_SAA711X,
622 .input = { {
623 .type = EM28XX_VMUX_COMPOSITE1,
624 .vmux = SAA7115_COMPOSITE0,
625 .amux = EM28XX_AMUX_LINE_IN,
626 }, {
627 .type = EM28XX_VMUX_SVIDEO,
628 .vmux = SAA7115_SVIDEO3,
629 .amux = EM28XX_AMUX_LINE_IN,
630 } },
631 },
632 [EM2860_BOARD_NETGMBH_CAM] = {
633 /* Beijing Huaqi Information Digital Technology Co., Ltd */
634 .name = "NetGMBH Cam",
635 .valid = EM28XX_BOARD_NOT_VALIDATED,
636 .tuner_type = TUNER_ABSENT,
637 .is_webcam = 1,
638 .input = { {
639 .type = EM28XX_VMUX_COMPOSITE1,
640 .vmux = 0,
641 .amux = EM28XX_AMUX_VIDEO,
642 } },
643 },
644 [EM2860_BOARD_TYPHOON_DVD_MAKER] = {
645 .name = "Typhoon DVD Maker",
646 .decoder = EM28XX_SAA711X,
647 .tuner_type = TUNER_ABSENT, /* Capture only device */
648 .input = { {
649 .type = EM28XX_VMUX_COMPOSITE1,
650 .vmux = SAA7115_COMPOSITE0,
651 .amux = EM28XX_AMUX_LINE_IN,
652 }, {
653 .type = EM28XX_VMUX_SVIDEO,
654 .vmux = SAA7115_SVIDEO3,
655 .amux = EM28XX_AMUX_LINE_IN,
656 } },
657 },
658 [EM2860_BOARD_GADMEI_UTV330] = {
659 .name = "Gadmei UTV330",
660 .valid = EM28XX_BOARD_NOT_VALIDATED,
661 .tuner_type = TUNER_TNF_5335MF,
662 .tda9887_conf = TDA9887_PRESENT,
663 .decoder = EM28XX_SAA711X,
664 .input = { {
665 .type = EM28XX_VMUX_TELEVISION,
666 .vmux = SAA7115_COMPOSITE2,
667 .amux = EM28XX_AMUX_VIDEO,
668 }, {
669 .type = EM28XX_VMUX_COMPOSITE1,
670 .vmux = SAA7115_COMPOSITE0,
671 .amux = EM28XX_AMUX_LINE_IN,
672 }, {
673 .type = EM28XX_VMUX_SVIDEO,
674 .vmux = SAA7115_SVIDEO3,
675 .amux = EM28XX_AMUX_LINE_IN,
676 } },
677 },
678 [EM2861_BOARD_GADMEI_UTV330PLUS] = {
679 .name = "Gadmei UTV330+",
680 .tuner_type = TUNER_TNF_5335MF,
681 .tda9887_conf = TDA9887_PRESENT,
682 .ir_codes = RC_MAP_GADMEI_RM008Z,
683 .decoder = EM28XX_SAA711X,
684 .xclk = EM28XX_XCLK_FREQUENCY_12MHZ,
685 .input = { {
686 .type = EM28XX_VMUX_TELEVISION,
687 .vmux = SAA7115_COMPOSITE2,
688 .amux = EM28XX_AMUX_VIDEO,
689 }, {
690 .type = EM28XX_VMUX_COMPOSITE1,
691 .vmux = SAA7115_COMPOSITE0,
692 .amux = EM28XX_AMUX_LINE_IN,
693 }, {
694 .type = EM28XX_VMUX_SVIDEO,
695 .vmux = SAA7115_SVIDEO3,
696 .amux = EM28XX_AMUX_LINE_IN,
697 } },
698 },
699 [EM2860_BOARD_TERRATEC_HYBRID_XS] = {
700 .name = "Terratec Cinergy A Hybrid XS",
701 .valid = EM28XX_BOARD_NOT_VALIDATED,
702 .tuner_type = TUNER_XC2028,
703 .tuner_gpio = default_tuner_gpio,
704 .decoder = EM28XX_TVP5150,
705
706 .input = { {
707 .type = EM28XX_VMUX_TELEVISION,
708 .vmux = TVP5150_COMPOSITE0,
709 .amux = EM28XX_AMUX_VIDEO,
710 .gpio = hauppauge_wintv_hvr_900_analog,
711 }, {
712 .type = EM28XX_VMUX_COMPOSITE1,
713 .vmux = TVP5150_COMPOSITE1,
714 .amux = EM28XX_AMUX_LINE_IN,
715 .gpio = hauppauge_wintv_hvr_900_analog,
716 }, {
717 .type = EM28XX_VMUX_SVIDEO,
718 .vmux = TVP5150_SVIDEO,
719 .amux = EM28XX_AMUX_LINE_IN,
720 .gpio = hauppauge_wintv_hvr_900_analog,
721 } },
722 },
723 [EM2861_BOARD_KWORLD_PVRTV_300U] = {
724 .name = "KWorld PVRTV 300U",
725 .valid = EM28XX_BOARD_NOT_VALIDATED,
726 .tuner_type = TUNER_XC2028,
727 .tuner_gpio = default_tuner_gpio,
728 .decoder = EM28XX_TVP5150,
729 .input = { {
730 .type = EM28XX_VMUX_TELEVISION,
731 .vmux = TVP5150_COMPOSITE0,
732 .amux = EM28XX_AMUX_VIDEO,
733 }, {
734 .type = EM28XX_VMUX_COMPOSITE1,
735 .vmux = TVP5150_COMPOSITE1,
736 .amux = EM28XX_AMUX_LINE_IN,
737 }, {
738 .type = EM28XX_VMUX_SVIDEO,
739 .vmux = TVP5150_SVIDEO,
740 .amux = EM28XX_AMUX_LINE_IN,
741 } },
742 },
743 [EM2861_BOARD_YAKUMO_MOVIE_MIXER] = {
744 .name = "Yakumo MovieMixer",
745 .tuner_type = TUNER_ABSENT, /* Capture only device */
746 .decoder = EM28XX_TVP5150,
747 .input = { {
748 .type = EM28XX_VMUX_TELEVISION,
749 .vmux = TVP5150_COMPOSITE0,
750 .amux = EM28XX_AMUX_VIDEO,
751 }, {
752 .type = EM28XX_VMUX_COMPOSITE1,
753 .vmux = TVP5150_COMPOSITE1,
754 .amux = EM28XX_AMUX_LINE_IN,
755 }, {
756 .type = EM28XX_VMUX_SVIDEO,
757 .vmux = TVP5150_SVIDEO,
758 .amux = EM28XX_AMUX_LINE_IN,
759 } },
760 },
761 [EM2860_BOARD_TVP5150_REFERENCE_DESIGN] = {
762 .name = "EM2860/TVP5150 Reference Design",
763 .tuner_type = TUNER_ABSENT, /* Capture only device */
764 .decoder = EM28XX_TVP5150,
765 .input = { {
766 .type = EM28XX_VMUX_COMPOSITE1,
767 .vmux = TVP5150_COMPOSITE1,
768 .amux = EM28XX_AMUX_LINE_IN,
769 }, {
770 .type = EM28XX_VMUX_SVIDEO,
771 .vmux = TVP5150_SVIDEO,
772 .amux = EM28XX_AMUX_LINE_IN,
773 } },
774 },
775 [EM2861_BOARD_PLEXTOR_PX_TV100U] = {
776 .name = "Plextor ConvertX PX-TV100U",
777 .tuner_type = TUNER_TNF_5335MF,
778 .xclk = EM28XX_XCLK_I2S_MSB_TIMING |
779 EM28XX_XCLK_FREQUENCY_12MHZ,
780 .tda9887_conf = TDA9887_PRESENT,
781 .decoder = EM28XX_TVP5150,
782 .has_msp34xx = 1,
783 .input = { {
784 .type = EM28XX_VMUX_TELEVISION,
785 .vmux = TVP5150_COMPOSITE0,
786 .amux = EM28XX_AMUX_LINE_IN,
787 .gpio = pinnacle_hybrid_pro_analog,
788 }, {
789 .type = EM28XX_VMUX_COMPOSITE1,
790 .vmux = TVP5150_COMPOSITE1,
791 .amux = EM28XX_AMUX_LINE_IN,
792 .gpio = pinnacle_hybrid_pro_analog,
793 }, {
794 .type = EM28XX_VMUX_SVIDEO,
795 .vmux = TVP5150_SVIDEO,
796 .amux = EM28XX_AMUX_LINE_IN,
797 .gpio = pinnacle_hybrid_pro_analog,
798 } },
799 },
800
801 /* Those boards with em2870 are DVB Only*/
802
803 [EM2870_BOARD_TERRATEC_XS] = {
804 .name = "Terratec Cinergy T XS",
805 .valid = EM28XX_BOARD_NOT_VALIDATED,
806 .tuner_type = TUNER_XC2028,
807 .tuner_gpio = default_tuner_gpio,
808 },
809 [EM2870_BOARD_TERRATEC_XS_MT2060] = {
810 .name = "Terratec Cinergy T XS (MT2060)",
811 .valid = EM28XX_BOARD_NOT_VALIDATED,
812 .tuner_type = TUNER_ABSENT, /* MT2060 */
813 },
814 [EM2870_BOARD_KWORLD_350U] = {
815 .name = "Kworld 350 U DVB-T",
816 .valid = EM28XX_BOARD_NOT_VALIDATED,
817 .tuner_type = TUNER_XC2028,
818 .tuner_gpio = default_tuner_gpio,
819 },
820 [EM2870_BOARD_KWORLD_355U] = {
821 .name = "Kworld 355 U DVB-T",
822 .valid = EM28XX_BOARD_NOT_VALIDATED,
823 },
824 [EM2870_BOARD_PINNACLE_PCTV_DVB] = {
825 .name = "Pinnacle PCTV DVB-T",
826 .valid = EM28XX_BOARD_NOT_VALIDATED,
827 .tuner_type = TUNER_ABSENT, /* MT2060 */
828 /* djh - I have serious doubts this is right... */
829 .xclk = EM28XX_XCLK_IR_RC5_MODE |
830 EM28XX_XCLK_FREQUENCY_10MHZ,
831 },
832 [EM2870_BOARD_COMPRO_VIDEOMATE] = {
833 .name = "Compro, VideoMate U3",
834 .valid = EM28XX_BOARD_NOT_VALIDATED,
835 .tuner_type = TUNER_ABSENT, /* MT2060 */
836 },
837
838 [EM2880_BOARD_TERRATEC_HYBRID_XS_FR] = {
839 .name = "Terratec Hybrid XS Secam",
840 .has_msp34xx = 1,
841 .tuner_type = TUNER_XC2028,
842 .tuner_gpio = default_tuner_gpio,
843 .decoder = EM28XX_TVP5150,
844 .has_dvb = 1,
845 .dvb_gpio = terratec_cinergy_USB_XS_FR_digital,
846 .input = { {
847 .type = EM28XX_VMUX_TELEVISION,
848 .vmux = TVP5150_COMPOSITE0,
849 .amux = EM28XX_AMUX_VIDEO,
850 .gpio = terratec_cinergy_USB_XS_FR_analog,
851 }, {
852 .type = EM28XX_VMUX_COMPOSITE1,
853 .vmux = TVP5150_COMPOSITE1,
854 .amux = EM28XX_AMUX_LINE_IN,
855 .gpio = terratec_cinergy_USB_XS_FR_analog,
856 }, {
857 .type = EM28XX_VMUX_SVIDEO,
858 .vmux = TVP5150_SVIDEO,
859 .amux = EM28XX_AMUX_LINE_IN,
860 .gpio = terratec_cinergy_USB_XS_FR_analog,
861 } },
862 },
863 [EM2884_BOARD_TERRATEC_H5] = {
864 .name = "Terratec Cinergy H5",
865 .has_dvb = 1,
866#if 0
867 .tuner_type = TUNER_PHILIPS_TDA8290,
868 .tuner_addr = 0x41,
869 .dvb_gpio = terratec_h5_digital, /* FIXME: probably wrong */
870 .tuner_gpio = terratec_h5_gpio,
871#endif
872 .i2c_speed = EM2874_I2C_SECONDARY_BUS_SELECT |
873 EM28XX_I2C_CLK_WAIT_ENABLE |
874 EM28XX_I2C_FREQ_400_KHZ,
875 },
876 [EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900] = {
877 .name = "Hauppauge WinTV HVR 900",
878 .tda9887_conf = TDA9887_PRESENT,
879 .tuner_type = TUNER_XC2028,
880 .tuner_gpio = default_tuner_gpio,
881 .mts_firmware = 1,
882 .has_dvb = 1,
883 .dvb_gpio = hauppauge_wintv_hvr_900_digital,
884 .ir_codes = RC_MAP_HAUPPAUGE,
885 .decoder = EM28XX_TVP5150,
886 .input = { {
887 .type = EM28XX_VMUX_TELEVISION,
888 .vmux = TVP5150_COMPOSITE0,
889 .amux = EM28XX_AMUX_VIDEO,
890 .gpio = hauppauge_wintv_hvr_900_analog,
891 }, {
892 .type = EM28XX_VMUX_COMPOSITE1,
893 .vmux = TVP5150_COMPOSITE1,
894 .amux = EM28XX_AMUX_LINE_IN,
895 .gpio = hauppauge_wintv_hvr_900_analog,
896 }, {
897 .type = EM28XX_VMUX_SVIDEO,
898 .vmux = TVP5150_SVIDEO,
899 .amux = EM28XX_AMUX_LINE_IN,
900 .gpio = hauppauge_wintv_hvr_900_analog,
901 } },
902 },
903 [EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900_R2] = {
904 .name = "Hauppauge WinTV HVR 900 (R2)",
905 .tda9887_conf = TDA9887_PRESENT,
906 .tuner_type = TUNER_XC2028,
907 .tuner_gpio = default_tuner_gpio,
908 .mts_firmware = 1,
909 .has_dvb = 1,
910 .dvb_gpio = hauppauge_wintv_hvr_900R2_digital,
911 .ir_codes = RC_MAP_HAUPPAUGE,
912 .decoder = EM28XX_TVP5150,
913 .input = { {
914 .type = EM28XX_VMUX_TELEVISION,
915 .vmux = TVP5150_COMPOSITE0,
916 .amux = EM28XX_AMUX_VIDEO,
917 .gpio = hauppauge_wintv_hvr_900_analog,
918 }, {
919 .type = EM28XX_VMUX_COMPOSITE1,
920 .vmux = TVP5150_COMPOSITE1,
921 .amux = EM28XX_AMUX_LINE_IN,
922 .gpio = hauppauge_wintv_hvr_900_analog,
923 }, {
924 .type = EM28XX_VMUX_SVIDEO,
925 .vmux = TVP5150_SVIDEO,
926 .amux = EM28XX_AMUX_LINE_IN,
927 .gpio = hauppauge_wintv_hvr_900_analog,
928 } },
929 },
930 [EM2883_BOARD_HAUPPAUGE_WINTV_HVR_850] = {
931 .name = "Hauppauge WinTV HVR 850",
932 .tuner_type = TUNER_XC2028,
933 .tuner_gpio = default_tuner_gpio,
934 .mts_firmware = 1,
935 .has_dvb = 1,
936 .dvb_gpio = hauppauge_wintv_hvr_900_digital,
937 .ir_codes = RC_MAP_HAUPPAUGE,
938 .decoder = EM28XX_TVP5150,
939 .input = { {
940 .type = EM28XX_VMUX_TELEVISION,
941 .vmux = TVP5150_COMPOSITE0,
942 .amux = EM28XX_AMUX_VIDEO,
943 .gpio = hauppauge_wintv_hvr_900_analog,
944 }, {
945 .type = EM28XX_VMUX_COMPOSITE1,
946 .vmux = TVP5150_COMPOSITE1,
947 .amux = EM28XX_AMUX_LINE_IN,
948 .gpio = hauppauge_wintv_hvr_900_analog,
949 }, {
950 .type = EM28XX_VMUX_SVIDEO,
951 .vmux = TVP5150_SVIDEO,
952 .amux = EM28XX_AMUX_LINE_IN,
953 .gpio = hauppauge_wintv_hvr_900_analog,
954 } },
955 },
956 [EM2883_BOARD_HAUPPAUGE_WINTV_HVR_950] = {
957 .name = "Hauppauge WinTV HVR 950",
958 .tuner_type = TUNER_XC2028,
959 .tuner_gpio = default_tuner_gpio,
960 .mts_firmware = 1,
961 .has_dvb = 1,
962 .dvb_gpio = hauppauge_wintv_hvr_900_digital,
963 .ir_codes = RC_MAP_HAUPPAUGE,
964 .decoder = EM28XX_TVP5150,
965 .input = { {
966 .type = EM28XX_VMUX_TELEVISION,
967 .vmux = TVP5150_COMPOSITE0,
968 .amux = EM28XX_AMUX_VIDEO,
969 .gpio = hauppauge_wintv_hvr_900_analog,
970 }, {
971 .type = EM28XX_VMUX_COMPOSITE1,
972 .vmux = TVP5150_COMPOSITE1,
973 .amux = EM28XX_AMUX_LINE_IN,
974 .gpio = hauppauge_wintv_hvr_900_analog,
975 }, {
976 .type = EM28XX_VMUX_SVIDEO,
977 .vmux = TVP5150_SVIDEO,
978 .amux = EM28XX_AMUX_LINE_IN,
979 .gpio = hauppauge_wintv_hvr_900_analog,
980 } },
981 },
982 [EM2880_BOARD_PINNACLE_PCTV_HD_PRO] = {
983 .name = "Pinnacle PCTV HD Pro Stick",
984 .tuner_type = TUNER_XC2028,
985 .tuner_gpio = default_tuner_gpio,
986 .mts_firmware = 1,
987 .has_dvb = 1,
988 .dvb_gpio = hauppauge_wintv_hvr_900_digital,
989 .ir_codes = RC_MAP_PINNACLE_PCTV_HD,
990 .decoder = EM28XX_TVP5150,
991 .input = { {
992 .type = EM28XX_VMUX_TELEVISION,
993 .vmux = TVP5150_COMPOSITE0,
994 .amux = EM28XX_AMUX_VIDEO,
995 .gpio = hauppauge_wintv_hvr_900_analog,
996 }, {
997 .type = EM28XX_VMUX_COMPOSITE1,
998 .vmux = TVP5150_COMPOSITE1,
999 .amux = EM28XX_AMUX_LINE_IN,
1000 .gpio = hauppauge_wintv_hvr_900_analog,
1001 }, {
1002 .type = EM28XX_VMUX_SVIDEO,
1003 .vmux = TVP5150_SVIDEO,
1004 .amux = EM28XX_AMUX_LINE_IN,
1005 .gpio = hauppauge_wintv_hvr_900_analog,
1006 } },
1007 },
1008 [EM2880_BOARD_AMD_ATI_TV_WONDER_HD_600] = {
1009 .name = "AMD ATI TV Wonder HD 600",
1010 .tuner_type = TUNER_XC2028,
1011 .tuner_gpio = default_tuner_gpio,
1012 .mts_firmware = 1,
1013 .has_dvb = 1,
1014 .dvb_gpio = hauppauge_wintv_hvr_900_digital,
1015 .ir_codes = RC_MAP_ATI_TV_WONDER_HD_600,
1016 .decoder = EM28XX_TVP5150,
1017 .input = { {
1018 .type = EM28XX_VMUX_TELEVISION,
1019 .vmux = TVP5150_COMPOSITE0,
1020 .amux = EM28XX_AMUX_VIDEO,
1021 .gpio = hauppauge_wintv_hvr_900_analog,
1022 }, {
1023 .type = EM28XX_VMUX_COMPOSITE1,
1024 .vmux = TVP5150_COMPOSITE1,
1025 .amux = EM28XX_AMUX_LINE_IN,
1026 .gpio = hauppauge_wintv_hvr_900_analog,
1027 }, {
1028 .type = EM28XX_VMUX_SVIDEO,
1029 .vmux = TVP5150_SVIDEO,
1030 .amux = EM28XX_AMUX_LINE_IN,
1031 .gpio = hauppauge_wintv_hvr_900_analog,
1032 } },
1033 },
1034 [EM2880_BOARD_TERRATEC_HYBRID_XS] = {
1035 .name = "Terratec Hybrid XS",
1036 .tuner_type = TUNER_XC2028,
1037 .tuner_gpio = default_tuner_gpio,
1038 .decoder = EM28XX_TVP5150,
1039 .has_dvb = 1,
1040 .dvb_gpio = default_digital,
1041 .ir_codes = RC_MAP_TERRATEC_CINERGY_XS,
1042 .xclk = EM28XX_XCLK_FREQUENCY_12MHZ, /* NEC IR */
1043 .input = { {
1044 .type = EM28XX_VMUX_TELEVISION,
1045 .vmux = TVP5150_COMPOSITE0,
1046 .amux = EM28XX_AMUX_VIDEO,
1047 .gpio = default_analog,
1048 }, {
1049 .type = EM28XX_VMUX_COMPOSITE1,
1050 .vmux = TVP5150_COMPOSITE1,
1051 .amux = EM28XX_AMUX_LINE_IN,
1052 .gpio = default_analog,
1053 }, {
1054 .type = EM28XX_VMUX_SVIDEO,
1055 .vmux = TVP5150_SVIDEO,
1056 .amux = EM28XX_AMUX_LINE_IN,
1057 .gpio = default_analog,
1058 } },
1059 },
1060 /* maybe there's a reason behind it why Terratec sells the Hybrid XS
1061 as Prodigy XS with a different PID, let's keep it separated for now
1062 maybe we'll need it lateron */
1063 [EM2880_BOARD_TERRATEC_PRODIGY_XS] = {
1064 .name = "Terratec Prodigy XS",
1065 .tuner_type = TUNER_XC2028,
1066 .tuner_gpio = default_tuner_gpio,
1067 .decoder = EM28XX_TVP5150,
1068 .input = { {
1069 .type = EM28XX_VMUX_TELEVISION,
1070 .vmux = TVP5150_COMPOSITE0,
1071 .amux = EM28XX_AMUX_VIDEO,
1072 .gpio = hauppauge_wintv_hvr_900_analog,
1073 }, {
1074 .type = EM28XX_VMUX_COMPOSITE1,
1075 .vmux = TVP5150_COMPOSITE1,
1076 .amux = EM28XX_AMUX_LINE_IN,
1077 .gpio = hauppauge_wintv_hvr_900_analog,
1078 }, {
1079 .type = EM28XX_VMUX_SVIDEO,
1080 .vmux = TVP5150_SVIDEO,
1081 .amux = EM28XX_AMUX_LINE_IN,
1082 .gpio = hauppauge_wintv_hvr_900_analog,
1083 } },
1084 },
1085 [EM2820_BOARD_MSI_VOX_USB_2] = {
1086 .name = "MSI VOX USB 2.0",
1087 .tuner_type = TUNER_LG_PAL_NEW_TAPC,
1088 .tda9887_conf = TDA9887_PRESENT |
1089 TDA9887_PORT1_ACTIVE |
1090 TDA9887_PORT2_ACTIVE,
1091 .max_range_640_480 = 1,
1092 .decoder = EM28XX_SAA711X,
1093 .input = { {
1094 .type = EM28XX_VMUX_TELEVISION,
1095 .vmux = SAA7115_COMPOSITE4,
1096 .amux = EM28XX_AMUX_VIDEO,
1097 }, {
1098 .type = EM28XX_VMUX_COMPOSITE1,
1099 .vmux = SAA7115_COMPOSITE0,
1100 .amux = EM28XX_AMUX_LINE_IN,
1101 }, {
1102 .type = EM28XX_VMUX_SVIDEO,
1103 .vmux = SAA7115_SVIDEO3,
1104 .amux = EM28XX_AMUX_LINE_IN,
1105 } },
1106 },
1107 [EM2800_BOARD_TERRATEC_CINERGY_200] = {
1108 .name = "Terratec Cinergy 200 USB",
1109 .is_em2800 = 1,
1110 .has_ir_i2c = 1,
1111 .tuner_type = TUNER_LG_PAL_NEW_TAPC,
1112 .tda9887_conf = TDA9887_PRESENT,
1113 .decoder = EM28XX_SAA711X,
1114 .input = { {
1115 .type = EM28XX_VMUX_TELEVISION,
1116 .vmux = SAA7115_COMPOSITE2,
1117 .amux = EM28XX_AMUX_VIDEO,
1118 }, {
1119 .type = EM28XX_VMUX_COMPOSITE1,
1120 .vmux = SAA7115_COMPOSITE0,
1121 .amux = EM28XX_AMUX_LINE_IN,
1122 }, {
1123 .type = EM28XX_VMUX_SVIDEO,
1124 .vmux = SAA7115_SVIDEO3,
1125 .amux = EM28XX_AMUX_LINE_IN,
1126 } },
1127 },
1128 [EM2800_BOARD_GRABBEEX_USB2800] = {
1129 .name = "eMPIA Technology, Inc. GrabBeeX+ Video Encoder",
1130 .is_em2800 = 1,
1131 .decoder = EM28XX_SAA711X,
1132 .tuner_type = TUNER_ABSENT, /* capture only board */
1133 .input = { {
1134 .type = EM28XX_VMUX_COMPOSITE1,
1135 .vmux = SAA7115_COMPOSITE0,
1136 .amux = EM28XX_AMUX_LINE_IN,
1137 }, {
1138 .type = EM28XX_VMUX_SVIDEO,
1139 .vmux = SAA7115_SVIDEO3,
1140 .amux = EM28XX_AMUX_LINE_IN,
1141 } },
1142 },
1143 [EM2800_BOARD_VC211A] = {
1144 .name = "Actionmaster/LinXcel/Digitus VC211A",
1145 .is_em2800 = 1,
1146 .tuner_type = TUNER_ABSENT, /* Capture-only board */
1147 .decoder = EM28XX_SAA711X,
1148 .input = { {
1149 .type = EM28XX_VMUX_COMPOSITE1,
1150 .vmux = SAA7115_COMPOSITE0,
1151 .amux = EM28XX_AMUX_LINE_IN,
1152 .gpio = vc211a_enable,
1153 }, {
1154 .type = EM28XX_VMUX_SVIDEO,
1155 .vmux = SAA7115_SVIDEO3,
1156 .amux = EM28XX_AMUX_LINE_IN,
1157 .gpio = vc211a_enable,
1158 } },
1159 },
1160 [EM2800_BOARD_LEADTEK_WINFAST_USBII] = {
1161 .name = "Leadtek Winfast USB II",
1162 .is_em2800 = 1,
1163 .tuner_type = TUNER_LG_PAL_NEW_TAPC,
1164 .tda9887_conf = TDA9887_PRESENT,
1165 .decoder = EM28XX_SAA711X,
1166 .input = { {
1167 .type = EM28XX_VMUX_TELEVISION,
1168 .vmux = SAA7115_COMPOSITE2,
1169 .amux = EM28XX_AMUX_VIDEO,
1170 }, {
1171 .type = EM28XX_VMUX_COMPOSITE1,
1172 .vmux = SAA7115_COMPOSITE0,
1173 .amux = EM28XX_AMUX_LINE_IN,
1174 }, {
1175 .type = EM28XX_VMUX_SVIDEO,
1176 .vmux = SAA7115_SVIDEO3,
1177 .amux = EM28XX_AMUX_LINE_IN,
1178 } },
1179 },
1180 [EM2800_BOARD_KWORLD_USB2800] = {
1181 .name = "Kworld USB2800",
1182 .is_em2800 = 1,
1183 .tuner_type = TUNER_PHILIPS_FCV1236D,
1184 .tda9887_conf = TDA9887_PRESENT,
1185 .decoder = EM28XX_SAA711X,
1186 .input = { {
1187 .type = EM28XX_VMUX_TELEVISION,
1188 .vmux = SAA7115_COMPOSITE2,
1189 .amux = EM28XX_AMUX_VIDEO,
1190 }, {
1191 .type = EM28XX_VMUX_COMPOSITE1,
1192 .vmux = SAA7115_COMPOSITE0,
1193 .amux = EM28XX_AMUX_LINE_IN,
1194 }, {
1195 .type = EM28XX_VMUX_SVIDEO,
1196 .vmux = SAA7115_SVIDEO3,
1197 .amux = EM28XX_AMUX_LINE_IN,
1198 } },
1199 },
1200 [EM2820_BOARD_PINNACLE_DVC_90] = {
1201 .name = "Pinnacle Dazzle DVC 90/100/101/107 / Kaiser Baas Video to DVD maker "
1202 "/ Kworld DVD Maker 2",
1203 .tuner_type = TUNER_ABSENT, /* capture only board */
1204 .decoder = EM28XX_SAA711X,
1205 .input = { {
1206 .type = EM28XX_VMUX_COMPOSITE1,
1207 .vmux = SAA7115_COMPOSITE0,
1208 .amux = EM28XX_AMUX_LINE_IN,
1209 }, {
1210 .type = EM28XX_VMUX_SVIDEO,
1211 .vmux = SAA7115_SVIDEO3,
1212 .amux = EM28XX_AMUX_LINE_IN,
1213 } },
1214 },
1215 [EM2800_BOARD_VGEAR_POCKETTV] = {
1216 .name = "V-Gear PocketTV",
1217 .is_em2800 = 1,
1218 .tuner_type = TUNER_LG_PAL_NEW_TAPC,
1219 .tda9887_conf = TDA9887_PRESENT,
1220 .decoder = EM28XX_SAA711X,
1221 .input = { {
1222 .type = EM28XX_VMUX_TELEVISION,
1223 .vmux = SAA7115_COMPOSITE2,
1224 .amux = EM28XX_AMUX_VIDEO,
1225 }, {
1226 .type = EM28XX_VMUX_COMPOSITE1,
1227 .vmux = SAA7115_COMPOSITE0,
1228 .amux = EM28XX_AMUX_LINE_IN,
1229 }, {
1230 .type = EM28XX_VMUX_SVIDEO,
1231 .vmux = SAA7115_SVIDEO3,
1232 .amux = EM28XX_AMUX_LINE_IN,
1233 } },
1234 },
1235 [EM2820_BOARD_PROLINK_PLAYTV_BOX4_USB2] = {
1236 .name = "Pixelview PlayTV Box 4 USB 2.0",
1237 .tda9887_conf = TDA9887_PRESENT,
1238 .tuner_type = TUNER_YMEC_TVF_5533MF,
1239 .decoder = EM28XX_SAA711X,
1240 .input = { {
1241 .type = EM28XX_VMUX_TELEVISION,
1242 .vmux = SAA7115_COMPOSITE2,
1243 .amux = EM28XX_AMUX_VIDEO,
1244 .aout = EM28XX_AOUT_MONO | /* I2S */
1245 EM28XX_AOUT_MASTER, /* Line out pin */
1246 }, {
1247 .type = EM28XX_VMUX_COMPOSITE1,
1248 .vmux = SAA7115_COMPOSITE0,
1249 .amux = EM28XX_AMUX_LINE_IN,
1250 }, {
1251 .type = EM28XX_VMUX_SVIDEO,
1252 .vmux = SAA7115_SVIDEO3,
1253 .amux = EM28XX_AMUX_LINE_IN,
1254 } },
1255 },
1256 [EM2820_BOARD_PROLINK_PLAYTV_USB2] = {
1257 .name = "SIIG AVTuner-PVR / Pixelview Prolink PlayTV USB 2.0",
1258 .has_snapshot_button = 1,
1259 .tda9887_conf = TDA9887_PRESENT,
1260 .tuner_type = TUNER_YMEC_TVF_5533MF,
1261 .decoder = EM28XX_SAA711X,
1262 .input = { {
1263 .type = EM28XX_VMUX_TELEVISION,
1264 .vmux = SAA7115_COMPOSITE2,
1265 .amux = EM28XX_AMUX_VIDEO,
1266 .aout = EM28XX_AOUT_MONO | /* I2S */
1267 EM28XX_AOUT_MASTER, /* Line out pin */
1268 }, {
1269 .type = EM28XX_VMUX_COMPOSITE1,
1270 .vmux = SAA7115_COMPOSITE0,
1271 .amux = EM28XX_AMUX_LINE_IN,
1272 }, {
1273 .type = EM28XX_VMUX_SVIDEO,
1274 .vmux = SAA7115_SVIDEO3,
1275 .amux = EM28XX_AMUX_LINE_IN,
1276 } },
1277 },
1278 [EM2860_BOARD_SAA711X_REFERENCE_DESIGN] = {
1279 .name = "EM2860/SAA711X Reference Design",
1280 .has_snapshot_button = 1,
1281 .tuner_type = TUNER_ABSENT,
1282 .decoder = EM28XX_SAA711X,
1283 .input = { {
1284 .type = EM28XX_VMUX_SVIDEO,
1285 .vmux = SAA7115_SVIDEO3,
1286 }, {
1287 .type = EM28XX_VMUX_COMPOSITE1,
1288 .vmux = SAA7115_COMPOSITE0,
1289 } },
1290 },
1291
1292 [EM2874_BOARD_LEADERSHIP_ISDBT] = {
1293 .i2c_speed = EM2874_I2C_SECONDARY_BUS_SELECT |
1294 EM28XX_I2C_CLK_WAIT_ENABLE |
1295 EM28XX_I2C_FREQ_100_KHZ,
1296 .xclk = EM28XX_XCLK_FREQUENCY_10MHZ,
1297 .name = "EM2874 Leadership ISDBT",
1298 .tuner_type = TUNER_ABSENT,
1299 .tuner_gpio = leadership_reset,
1300 .dvb_gpio = leadership_digital,
1301 .has_dvb = 1,
1302 },
1303
1304 [EM2880_BOARD_MSI_DIGIVOX_AD] = {
1305 .name = "MSI DigiVox A/D",
1306 .valid = EM28XX_BOARD_NOT_VALIDATED,
1307 .tuner_type = TUNER_XC2028,
1308 .tuner_gpio = default_tuner_gpio,
1309 .decoder = EM28XX_TVP5150,
1310 .input = { {
1311 .type = EM28XX_VMUX_TELEVISION,
1312 .vmux = TVP5150_COMPOSITE0,
1313 .amux = EM28XX_AMUX_VIDEO,
1314 .gpio = em2880_msi_digivox_ad_analog,
1315 }, {
1316 .type = EM28XX_VMUX_COMPOSITE1,
1317 .vmux = TVP5150_COMPOSITE1,
1318 .amux = EM28XX_AMUX_LINE_IN,
1319 .gpio = em2880_msi_digivox_ad_analog,
1320 }, {
1321 .type = EM28XX_VMUX_SVIDEO,
1322 .vmux = TVP5150_SVIDEO,
1323 .amux = EM28XX_AMUX_LINE_IN,
1324 .gpio = em2880_msi_digivox_ad_analog,
1325 } },
1326 },
1327 [EM2880_BOARD_MSI_DIGIVOX_AD_II] = {
1328 .name = "MSI DigiVox A/D II",
1329 .valid = EM28XX_BOARD_NOT_VALIDATED,
1330 .tuner_type = TUNER_XC2028,
1331 .tuner_gpio = default_tuner_gpio,
1332 .decoder = EM28XX_TVP5150,
1333 .input = { {
1334 .type = EM28XX_VMUX_TELEVISION,
1335 .vmux = TVP5150_COMPOSITE0,
1336 .amux = EM28XX_AMUX_VIDEO,
1337 .gpio = em2880_msi_digivox_ad_analog,
1338 }, {
1339 .type = EM28XX_VMUX_COMPOSITE1,
1340 .vmux = TVP5150_COMPOSITE1,
1341 .amux = EM28XX_AMUX_LINE_IN,
1342 .gpio = em2880_msi_digivox_ad_analog,
1343 }, {
1344 .type = EM28XX_VMUX_SVIDEO,
1345 .vmux = TVP5150_SVIDEO,
1346 .amux = EM28XX_AMUX_LINE_IN,
1347 .gpio = em2880_msi_digivox_ad_analog,
1348 } },
1349 },
1350 [EM2880_BOARD_KWORLD_DVB_305U] = {
1351 .name = "KWorld DVB-T 305U",
1352 .tuner_type = TUNER_XC2028,
1353 .tuner_gpio = default_tuner_gpio,
1354 .decoder = EM28XX_TVP5150,
1355 .input = { {
1356 .type = EM28XX_VMUX_TELEVISION,
1357 .vmux = TVP5150_COMPOSITE0,
1358 .amux = EM28XX_AMUX_VIDEO,
1359 }, {
1360 .type = EM28XX_VMUX_COMPOSITE1,
1361 .vmux = TVP5150_COMPOSITE1,
1362 .amux = EM28XX_AMUX_LINE_IN,
1363 }, {
1364 .type = EM28XX_VMUX_SVIDEO,
1365 .vmux = TVP5150_SVIDEO,
1366 .amux = EM28XX_AMUX_LINE_IN,
1367 } },
1368 },
1369 [EM2880_BOARD_KWORLD_DVB_310U] = {
1370 .name = "KWorld DVB-T 310U",
1371 .tuner_type = TUNER_XC2028,
1372 .tuner_gpio = default_tuner_gpio,
1373 .has_dvb = 1,
1374 .dvb_gpio = default_digital,
1375 .mts_firmware = 1,
1376 .decoder = EM28XX_TVP5150,
1377 .input = { {
1378 .type = EM28XX_VMUX_TELEVISION,
1379 .vmux = TVP5150_COMPOSITE0,
1380 .amux = EM28XX_AMUX_VIDEO,
1381 .gpio = default_analog,
1382 }, {
1383 .type = EM28XX_VMUX_COMPOSITE1,
1384 .vmux = TVP5150_COMPOSITE1,
1385 .amux = EM28XX_AMUX_LINE_IN,
1386 .gpio = default_analog,
1387 }, { /* S-video has not been tested yet */
1388 .type = EM28XX_VMUX_SVIDEO,
1389 .vmux = TVP5150_SVIDEO,
1390 .amux = EM28XX_AMUX_LINE_IN,
1391 .gpio = default_analog,
1392 } },
1393 },
1394 [EM2882_BOARD_KWORLD_ATSC_315U] = {
1395 .name = "KWorld ATSC 315U HDTV TV Box",
1396 .valid = EM28XX_BOARD_NOT_VALIDATED,
1397 .tuner_type = TUNER_THOMSON_DTT761X,
1398 .tuner_gpio = em2882_kworld_315u_tuner_gpio,
1399 .tda9887_conf = TDA9887_PRESENT,
1400 .decoder = EM28XX_SAA711X,
1401 .has_dvb = 1,
1402 .dvb_gpio = em2882_kworld_315u_digital,
1403 .ir_codes = RC_MAP_KWORLD_315U,
1404 .xclk = EM28XX_XCLK_FREQUENCY_12MHZ,
1405 .i2c_speed = EM28XX_I2C_CLK_WAIT_ENABLE,
1406 /* Analog mode - still not ready */
1407 /*.input = { {
1408 .type = EM28XX_VMUX_TELEVISION,
1409 .vmux = SAA7115_COMPOSITE2,
1410 .amux = EM28XX_AMUX_VIDEO,
1411 .gpio = em2882_kworld_315u_analog,
1412 .aout = EM28XX_AOUT_PCM_IN | EM28XX_AOUT_PCM_STEREO,
1413 }, {
1414 .type = EM28XX_VMUX_COMPOSITE1,
1415 .vmux = SAA7115_COMPOSITE0,
1416 .amux = EM28XX_AMUX_LINE_IN,
1417 .gpio = em2882_kworld_315u_analog1,
1418 .aout = EM28XX_AOUT_PCM_IN | EM28XX_AOUT_PCM_STEREO,
1419 }, {
1420 .type = EM28XX_VMUX_SVIDEO,
1421 .vmux = SAA7115_SVIDEO3,
1422 .amux = EM28XX_AMUX_LINE_IN,
1423 .gpio = em2882_kworld_315u_analog1,
1424 .aout = EM28XX_AOUT_PCM_IN | EM28XX_AOUT_PCM_STEREO,
1425 } }, */
1426 },
1427 [EM2880_BOARD_EMPIRE_DUAL_TV] = {
1428 .name = "Empire dual TV",
1429 .tuner_type = TUNER_XC2028,
1430 .tuner_gpio = default_tuner_gpio,
1431 .has_dvb = 1,
1432 .dvb_gpio = default_digital,
1433 .mts_firmware = 1,
1434 .decoder = EM28XX_TVP5150,
1435 .input = { {
1436 .type = EM28XX_VMUX_TELEVISION,
1437 .vmux = TVP5150_COMPOSITE0,
1438 .amux = EM28XX_AMUX_VIDEO,
1439 .gpio = default_analog,
1440 }, {
1441 .type = EM28XX_VMUX_COMPOSITE1,
1442 .vmux = TVP5150_COMPOSITE1,
1443 .amux = EM28XX_AMUX_LINE_IN,
1444 .gpio = default_analog,
1445 }, {
1446 .type = EM28XX_VMUX_SVIDEO,
1447 .vmux = TVP5150_SVIDEO,
1448 .amux = EM28XX_AMUX_LINE_IN,
1449 .gpio = default_analog,
1450 } },
1451 },
1452 [EM2881_BOARD_DNT_DA2_HYBRID] = {
1453 .name = "DNT DA2 Hybrid",
1454 .valid = EM28XX_BOARD_NOT_VALIDATED,
1455 .tuner_type = TUNER_XC2028,
1456 .tuner_gpio = default_tuner_gpio,
1457 .decoder = EM28XX_TVP5150,
1458 .input = { {
1459 .type = EM28XX_VMUX_TELEVISION,
1460 .vmux = TVP5150_COMPOSITE0,
1461 .amux = EM28XX_AMUX_VIDEO,
1462 .gpio = default_analog,
1463 }, {
1464 .type = EM28XX_VMUX_COMPOSITE1,
1465 .vmux = TVP5150_COMPOSITE1,
1466 .amux = EM28XX_AMUX_LINE_IN,
1467 .gpio = default_analog,
1468 }, {
1469 .type = EM28XX_VMUX_SVIDEO,
1470 .vmux = TVP5150_SVIDEO,
1471 .amux = EM28XX_AMUX_LINE_IN,
1472 .gpio = default_analog,
1473 } },
1474 },
1475 [EM2881_BOARD_PINNACLE_HYBRID_PRO] = {
1476 .name = "Pinnacle Hybrid Pro",
1477 .tuner_type = TUNER_XC2028,
1478 .tuner_gpio = default_tuner_gpio,
1479 .decoder = EM28XX_TVP5150,
1480 .has_dvb = 1,
1481 .dvb_gpio = pinnacle_hybrid_pro_digital,
1482 .input = { {
1483 .type = EM28XX_VMUX_TELEVISION,
1484 .vmux = TVP5150_COMPOSITE0,
1485 .amux = EM28XX_AMUX_VIDEO,
1486 .gpio = pinnacle_hybrid_pro_analog,
1487 }, {
1488 .type = EM28XX_VMUX_COMPOSITE1,
1489 .vmux = TVP5150_COMPOSITE1,
1490 .amux = EM28XX_AMUX_LINE_IN,
1491 .gpio = pinnacle_hybrid_pro_analog,
1492 }, {
1493 .type = EM28XX_VMUX_SVIDEO,
1494 .vmux = TVP5150_SVIDEO,
1495 .amux = EM28XX_AMUX_LINE_IN,
1496 .gpio = pinnacle_hybrid_pro_analog,
1497 } },
1498 },
1499 [EM2882_BOARD_PINNACLE_HYBRID_PRO_330E] = {
1500 .name = "Pinnacle Hybrid Pro (330e)",
1501 .tuner_type = TUNER_XC2028,
1502 .tuner_gpio = default_tuner_gpio,
1503 .mts_firmware = 1,
1504 .has_dvb = 1,
1505 .dvb_gpio = hauppauge_wintv_hvr_900R2_digital,
1506 .ir_codes = RC_MAP_PINNACLE_PCTV_HD,
1507 .decoder = EM28XX_TVP5150,
1508 .input = { {
1509 .type = EM28XX_VMUX_TELEVISION,
1510 .vmux = TVP5150_COMPOSITE0,
1511 .amux = EM28XX_AMUX_VIDEO,
1512 .gpio = hauppauge_wintv_hvr_900_analog,
1513 }, {
1514 .type = EM28XX_VMUX_COMPOSITE1,
1515 .vmux = TVP5150_COMPOSITE1,
1516 .amux = EM28XX_AMUX_LINE_IN,
1517 .gpio = hauppauge_wintv_hvr_900_analog,
1518 }, {
1519 .type = EM28XX_VMUX_SVIDEO,
1520 .vmux = TVP5150_SVIDEO,
1521 .amux = EM28XX_AMUX_LINE_IN,
1522 .gpio = hauppauge_wintv_hvr_900_analog,
1523 } },
1524 },
1525 [EM2882_BOARD_KWORLD_VS_DVBT] = {
1526 .name = "Kworld VS-DVB-T 323UR",
1527 .tuner_type = TUNER_XC2028,
1528 .tuner_gpio = default_tuner_gpio,
1529 .decoder = EM28XX_TVP5150,
1530 .mts_firmware = 1,
1531 .has_dvb = 1,
1532 .dvb_gpio = kworld_330u_digital,
1533 .xclk = EM28XX_XCLK_FREQUENCY_12MHZ, /* NEC IR */
1534 .ir_codes = RC_MAP_KWORLD_315U,
1535 .input = { {
1536 .type = EM28XX_VMUX_TELEVISION,
1537 .vmux = TVP5150_COMPOSITE0,
1538 .amux = EM28XX_AMUX_VIDEO,
1539 }, {
1540 .type = EM28XX_VMUX_COMPOSITE1,
1541 .vmux = TVP5150_COMPOSITE1,
1542 .amux = EM28XX_AMUX_LINE_IN,
1543 }, {
1544 .type = EM28XX_VMUX_SVIDEO,
1545 .vmux = TVP5150_SVIDEO,
1546 .amux = EM28XX_AMUX_LINE_IN,
1547 } },
1548 },
1549 [EM2882_BOARD_TERRATEC_HYBRID_XS] = {
1550 .name = "Terratec Cinnergy Hybrid T USB XS (em2882)",
1551 .tuner_type = TUNER_XC2028,
1552 .tuner_gpio = default_tuner_gpio,
1553 .mts_firmware = 1,
1554 .decoder = EM28XX_TVP5150,
1555 .has_dvb = 1,
1556 .dvb_gpio = hauppauge_wintv_hvr_900_digital,
1557 .ir_codes = RC_MAP_TERRATEC_CINERGY_XS,
1558 .xclk = EM28XX_XCLK_FREQUENCY_12MHZ,
1559 .input = { {
1560 .type = EM28XX_VMUX_TELEVISION,
1561 .vmux = TVP5150_COMPOSITE0,
1562 .amux = EM28XX_AMUX_VIDEO,
1563 .gpio = hauppauge_wintv_hvr_900_analog,
1564 }, {
1565 .type = EM28XX_VMUX_COMPOSITE1,
1566 .vmux = TVP5150_COMPOSITE1,
1567 .amux = EM28XX_AMUX_LINE_IN,
1568 .gpio = hauppauge_wintv_hvr_900_analog,
1569 }, {
1570 .type = EM28XX_VMUX_SVIDEO,
1571 .vmux = TVP5150_SVIDEO,
1572 .amux = EM28XX_AMUX_LINE_IN,
1573 .gpio = hauppauge_wintv_hvr_900_analog,
1574 } },
1575 },
1576 [EM2882_BOARD_DIKOM_DK300] = {
1577 .name = "Dikom DK300",
1578 .tuner_type = TUNER_XC2028,
1579 .tuner_gpio = default_tuner_gpio,
1580 .decoder = EM28XX_TVP5150,
1581 .mts_firmware = 1,
1582 .has_dvb = 1,
1583 .dvb_gpio = dikom_dk300_digital,
1584 .input = { {
1585 .type = EM28XX_VMUX_TELEVISION,
1586 .vmux = TVP5150_COMPOSITE0,
1587 .amux = EM28XX_AMUX_VIDEO,
1588 .gpio = default_analog,
1589 } },
1590 },
1591 [EM2883_BOARD_KWORLD_HYBRID_330U] = {
1592 .name = "Kworld PlusTV HD Hybrid 330",
1593 .tuner_type = TUNER_XC2028,
1594 .tuner_gpio = default_tuner_gpio,
1595 .decoder = EM28XX_TVP5150,
1596 .mts_firmware = 1,
1597 .has_dvb = 1,
1598 .dvb_gpio = kworld_330u_digital,
1599 .xclk = EM28XX_XCLK_FREQUENCY_12MHZ,
1600 .i2c_speed = EM28XX_I2C_CLK_WAIT_ENABLE |
1601 EM28XX_I2C_EEPROM_ON_BOARD |
1602 EM28XX_I2C_EEPROM_KEY_VALID,
1603 .input = { {
1604 .type = EM28XX_VMUX_TELEVISION,
1605 .vmux = TVP5150_COMPOSITE0,
1606 .amux = EM28XX_AMUX_VIDEO,
1607 .gpio = kworld_330u_analog,
1608 .aout = EM28XX_AOUT_PCM_IN | EM28XX_AOUT_PCM_STEREO,
1609 }, {
1610 .type = EM28XX_VMUX_COMPOSITE1,
1611 .vmux = TVP5150_COMPOSITE1,
1612 .amux = EM28XX_AMUX_LINE_IN,
1613 .gpio = kworld_330u_analog,
1614 .aout = EM28XX_AOUT_PCM_IN | EM28XX_AOUT_PCM_STEREO,
1615 }, {
1616 .type = EM28XX_VMUX_SVIDEO,
1617 .vmux = TVP5150_SVIDEO,
1618 .amux = EM28XX_AMUX_LINE_IN,
1619 .gpio = kworld_330u_analog,
1620 } },
1621 },
1622 [EM2820_BOARD_COMPRO_VIDEOMATE_FORYOU] = {
1623 .name = "Compro VideoMate ForYou/Stereo",
1624 .tuner_type = TUNER_LG_PAL_NEW_TAPC,
1625 .tvaudio_addr = 0xb0,
1626 .tda9887_conf = TDA9887_PRESENT,
1627 .decoder = EM28XX_TVP5150,
1628 .adecoder = EM28XX_TVAUDIO,
1629 .mute_gpio = compro_mute_gpio,
1630 .input = { {
1631 .type = EM28XX_VMUX_TELEVISION,
1632 .vmux = TVP5150_COMPOSITE0,
1633 .amux = EM28XX_AMUX_VIDEO,
1634 .gpio = compro_unmute_tv_gpio,
1635 }, {
1636 .type = EM28XX_VMUX_SVIDEO,
1637 .vmux = TVP5150_SVIDEO,
1638 .amux = EM28XX_AMUX_LINE_IN,
1639 .gpio = compro_unmute_svid_gpio,
1640 } },
1641 },
1642 [EM2860_BOARD_KAIOMY_TVNPC_U2] = {
1643 .name = "Kaiomy TVnPC U2",
1644 .vchannels = 3,
1645 .tuner_type = TUNER_XC2028,
1646 .tuner_addr = 0x61,
1647 .mts_firmware = 1,
1648 .decoder = EM28XX_TVP5150,
1649 .tuner_gpio = default_tuner_gpio,
1650 .ir_codes = RC_MAP_KAIOMY,
1651 .input = { {
1652 .type = EM28XX_VMUX_TELEVISION,
1653 .vmux = TVP5150_COMPOSITE0,
1654 .amux = EM28XX_AMUX_VIDEO,
1655
1656 }, {
1657 .type = EM28XX_VMUX_COMPOSITE1,
1658 .vmux = TVP5150_COMPOSITE1,
1659 .amux = EM28XX_AMUX_LINE_IN,
1660 }, {
1661 .type = EM28XX_VMUX_SVIDEO,
1662 .vmux = TVP5150_SVIDEO,
1663 .amux = EM28XX_AMUX_LINE_IN,
1664 } },
1665 .radio = {
1666 .type = EM28XX_RADIO,
1667 .amux = EM28XX_AMUX_LINE_IN,
1668 }
1669 },
1670 [EM2860_BOARD_EASYCAP] = {
1671 .name = "Easy Cap Capture DC-60",
1672 .vchannels = 2,
1673 .tuner_type = TUNER_ABSENT,
1674 .decoder = EM28XX_SAA711X,
1675 .input = { {
1676 .type = EM28XX_VMUX_COMPOSITE1,
1677 .vmux = SAA7115_COMPOSITE0,
1678 .amux = EM28XX_AMUX_LINE_IN,
1679 }, {
1680 .type = EM28XX_VMUX_SVIDEO,
1681 .vmux = SAA7115_SVIDEO3,
1682 .amux = EM28XX_AMUX_LINE_IN,
1683 } },
1684 },
1685 [EM2820_BOARD_IODATA_GVMVP_SZ] = {
1686 .name = "IO-DATA GV-MVP/SZ",
1687 .tuner_type = TUNER_PHILIPS_FM1236_MK3,
1688 .tuner_gpio = default_tuner_gpio,
1689 .tda9887_conf = TDA9887_PRESENT,
1690 .decoder = EM28XX_TVP5150,
1691 .input = { {
1692 .type = EM28XX_VMUX_TELEVISION,
1693 .vmux = TVP5150_COMPOSITE0,
1694 .amux = EM28XX_AMUX_VIDEO,
1695 }, { /* Composite has not been tested yet */
1696 .type = EM28XX_VMUX_COMPOSITE1,
1697 .vmux = TVP5150_COMPOSITE1,
1698 .amux = EM28XX_AMUX_VIDEO,
1699 }, { /* S-video has not been tested yet */
1700 .type = EM28XX_VMUX_SVIDEO,
1701 .vmux = TVP5150_SVIDEO,
1702 .amux = EM28XX_AMUX_VIDEO,
1703 } },
1704 },
1705 [EM2860_BOARD_TERRATEC_GRABBY] = {
1706 .name = "Terratec Grabby",
1707 .vchannels = 2,
1708 .tuner_type = TUNER_ABSENT,
1709 .decoder = EM28XX_SAA711X,
1710 .xclk = EM28XX_XCLK_FREQUENCY_12MHZ,
1711 .input = { {
1712 .type = EM28XX_VMUX_COMPOSITE1,
1713 .vmux = SAA7115_COMPOSITE0,
1714 .amux = EM28XX_AMUX_LINE_IN,
1715 }, {
1716 .type = EM28XX_VMUX_SVIDEO,
1717 .vmux = SAA7115_SVIDEO3,
1718 .amux = EM28XX_AMUX_LINE_IN,
1719 } },
1720 },
1721 [EM2860_BOARD_TERRATEC_AV350] = {
1722 .name = "Terratec AV350",
1723 .vchannels = 2,
1724 .tuner_type = TUNER_ABSENT,
1725 .decoder = EM28XX_TVP5150,
1726 .xclk = EM28XX_XCLK_FREQUENCY_12MHZ,
1727 .mute_gpio = terratec_av350_mute_gpio,
1728 .input = { {
1729 .type = EM28XX_VMUX_COMPOSITE1,
1730 .vmux = TVP5150_COMPOSITE1,
1731 .amux = EM28XX_AUDIO_SRC_LINE,
1732 .gpio = terratec_av350_unmute_gpio,
1733
1734 }, {
1735 .type = EM28XX_VMUX_SVIDEO,
1736 .vmux = TVP5150_SVIDEO,
1737 .amux = EM28XX_AUDIO_SRC_LINE,
1738 .gpio = terratec_av350_unmute_gpio,
1739 } },
1740 },
1741
1742 [EM2860_BOARD_ELGATO_VIDEO_CAPTURE] = {
1743 .name = "Elgato Video Capture",
1744 .decoder = EM28XX_SAA711X,
1745 .tuner_type = TUNER_ABSENT, /* Capture only device */
1746 .input = { {
1747 .type = EM28XX_VMUX_COMPOSITE1,
1748 .vmux = SAA7115_COMPOSITE0,
1749 .amux = EM28XX_AMUX_LINE_IN,
1750 }, {
1751 .type = EM28XX_VMUX_SVIDEO,
1752 .vmux = SAA7115_SVIDEO3,
1753 .amux = EM28XX_AMUX_LINE_IN,
1754 } },
1755 },
1756
1757 [EM2882_BOARD_EVGA_INDTUBE] = {
1758 .name = "Evga inDtube",
1759 .tuner_type = TUNER_XC2028,
1760 .tuner_gpio = default_tuner_gpio,
1761 .decoder = EM28XX_TVP5150,
1762 .xclk = EM28XX_XCLK_FREQUENCY_12MHZ, /* NEC IR */
1763 .mts_firmware = 1,
1764 .has_dvb = 1,
1765 .dvb_gpio = evga_indtube_digital,
1766 .ir_codes = RC_MAP_EVGA_INDTUBE,
1767 .input = { {
1768 .type = EM28XX_VMUX_TELEVISION,
1769 .vmux = TVP5150_COMPOSITE0,
1770 .amux = EM28XX_AMUX_VIDEO,
1771 .gpio = evga_indtube_analog,
1772 }, {
1773 .type = EM28XX_VMUX_COMPOSITE1,
1774 .vmux = TVP5150_COMPOSITE1,
1775 .amux = EM28XX_AMUX_LINE_IN,
1776 .gpio = evga_indtube_analog,
1777 }, {
1778 .type = EM28XX_VMUX_SVIDEO,
1779 .vmux = TVP5150_SVIDEO,
1780 .amux = EM28XX_AMUX_LINE_IN,
1781 .gpio = evga_indtube_analog,
1782 } },
1783 },
1784 /* eb1a:2868 Empia EM2870 + Philips CU1216L NIM (Philips TDA10023 +
1785 Infineon TUA6034) */
1786 [EM2870_BOARD_REDDO_DVB_C_USB_BOX] = {
1787 .name = "Reddo DVB-C USB TV Box",
1788 .tuner_type = TUNER_ABSENT,
1789 .tuner_gpio = reddo_dvb_c_usb_box,
1790 .has_dvb = 1,
1791 },
1792 /* 1b80:a340 - Empia EM2870, NXP TDA18271HD and LG DT3304, sold
1793 * initially as the KWorld PlusTV 340U, then as the UB435-Q.
1794 * Early variants have a TDA18271HD/C1, later ones a TDA18271HD/C2 */
1795 [EM2870_BOARD_KWORLD_A340] = {
1796 .name = "KWorld PlusTV 340U or UB435-Q (ATSC)",
1797 .tuner_type = TUNER_ABSENT, /* Digital-only TDA18271HD */
1798 .has_dvb = 1,
1799 .dvb_gpio = kworld_a340_digital,
1800 .tuner_gpio = default_tuner_gpio,
1801 },
1802 /* 2013:024f PCTV nanoStick T2 290e.
1803 * Empia EM28174, Sony CXD2820R and NXP TDA18271HD/C2 */
1804 [EM28174_BOARD_PCTV_290E] = {
1805 .name = "PCTV nanoStick T2 290e",
1806 .i2c_speed = EM2874_I2C_SECONDARY_BUS_SELECT |
1807 EM28XX_I2C_CLK_WAIT_ENABLE | EM28XX_I2C_FREQ_100_KHZ,
1808 .tuner_type = TUNER_ABSENT,
1809 .tuner_gpio = pctv_290e,
1810 .has_dvb = 1,
1811 .ir_codes = RC_MAP_PINNACLE_PCTV_HD,
1812 },
1813};
1814const unsigned int em28xx_bcount = ARRAY_SIZE(em28xx_boards);
1815
1816/* table of devices that work with this driver */
1817struct usb_device_id em28xx_id_table[] = {
1818 { USB_DEVICE(0xeb1a, 0x2750),
1819 .driver_info = EM2750_BOARD_UNKNOWN },
1820 { USB_DEVICE(0xeb1a, 0x2751),
1821 .driver_info = EM2750_BOARD_UNKNOWN },
1822 { USB_DEVICE(0xeb1a, 0x2800),
1823 .driver_info = EM2800_BOARD_UNKNOWN },
1824 { USB_DEVICE(0xeb1a, 0x2710),
1825 .driver_info = EM2820_BOARD_UNKNOWN },
1826 { USB_DEVICE(0xeb1a, 0x2820),
1827 .driver_info = EM2820_BOARD_UNKNOWN },
1828 { USB_DEVICE(0xeb1a, 0x2821),
1829 .driver_info = EM2820_BOARD_UNKNOWN },
1830 { USB_DEVICE(0xeb1a, 0x2860),
1831 .driver_info = EM2820_BOARD_UNKNOWN },
1832 { USB_DEVICE(0xeb1a, 0x2861),
1833 .driver_info = EM2820_BOARD_UNKNOWN },
1834 { USB_DEVICE(0xeb1a, 0x2862),
1835 .driver_info = EM2820_BOARD_UNKNOWN },
1836 { USB_DEVICE(0xeb1a, 0x2863),
1837 .driver_info = EM2820_BOARD_UNKNOWN },
1838 { USB_DEVICE(0xeb1a, 0x2870),
1839 .driver_info = EM2820_BOARD_UNKNOWN },
1840 { USB_DEVICE(0xeb1a, 0x2881),
1841 .driver_info = EM2820_BOARD_UNKNOWN },
1842 { USB_DEVICE(0xeb1a, 0x2883),
1843 .driver_info = EM2820_BOARD_UNKNOWN },
1844 { USB_DEVICE(0xeb1a, 0x2868),
1845 .driver_info = EM2820_BOARD_UNKNOWN },
1846 { USB_DEVICE(0xeb1a, 0x2875),
1847 .driver_info = EM2820_BOARD_UNKNOWN },
1848 { USB_DEVICE(0xeb1a, 0xe300),
1849 .driver_info = EM2861_BOARD_KWORLD_PVRTV_300U },
1850 { USB_DEVICE(0xeb1a, 0xe303),
1851 .driver_info = EM2860_BOARD_KAIOMY_TVNPC_U2 },
1852 { USB_DEVICE(0xeb1a, 0xe305),
1853 .driver_info = EM2880_BOARD_KWORLD_DVB_305U },
1854 { USB_DEVICE(0xeb1a, 0xe310),
1855 .driver_info = EM2880_BOARD_MSI_DIGIVOX_AD },
1856 { USB_DEVICE(0xeb1a, 0xa313),
1857 .driver_info = EM2882_BOARD_KWORLD_ATSC_315U },
1858 { USB_DEVICE(0xeb1a, 0xa316),
1859 .driver_info = EM2883_BOARD_KWORLD_HYBRID_330U },
1860 { USB_DEVICE(0xeb1a, 0xe320),
1861 .driver_info = EM2880_BOARD_MSI_DIGIVOX_AD_II },
1862 { USB_DEVICE(0xeb1a, 0xe323),
1863 .driver_info = EM2882_BOARD_KWORLD_VS_DVBT },
1864 { USB_DEVICE(0xeb1a, 0xe350),
1865 .driver_info = EM2870_BOARD_KWORLD_350U },
1866 { USB_DEVICE(0xeb1a, 0xe355),
1867 .driver_info = EM2870_BOARD_KWORLD_355U },
1868 { USB_DEVICE(0xeb1a, 0x2801),
1869 .driver_info = EM2800_BOARD_GRABBEEX_USB2800 },
1870 { USB_DEVICE(0xeb1a, 0xe357),
1871 .driver_info = EM2870_BOARD_KWORLD_355U },
1872 { USB_DEVICE(0x1b80, 0xe302),
1873 .driver_info = EM2820_BOARD_PINNACLE_DVC_90 }, /* Kaiser Baas Video to DVD maker */
1874 { USB_DEVICE(0x1b80, 0xe304),
1875 .driver_info = EM2820_BOARD_PINNACLE_DVC_90 }, /* Kworld DVD Maker 2 */
1876 { USB_DEVICE(0x0ccd, 0x0036),
1877 .driver_info = EM2820_BOARD_TERRATEC_CINERGY_250 },
1878 { USB_DEVICE(0x0ccd, 0x004c),
1879 .driver_info = EM2880_BOARD_TERRATEC_HYBRID_XS_FR },
1880 { USB_DEVICE(0x0ccd, 0x004f),
1881 .driver_info = EM2860_BOARD_TERRATEC_HYBRID_XS },
1882 { USB_DEVICE(0x0ccd, 0x005e),
1883 .driver_info = EM2882_BOARD_TERRATEC_HYBRID_XS },
1884 { USB_DEVICE(0x0ccd, 0x0042),
1885 .driver_info = EM2882_BOARD_TERRATEC_HYBRID_XS },
1886 { USB_DEVICE(0x0ccd, 0x0043),
1887 .driver_info = EM2884_BOARD_TERRATEC_H5 },
1888 { USB_DEVICE(0x0ccd, 0x10a2), /* Rev. 1 */
1889 .driver_info = EM2884_BOARD_TERRATEC_H5 },
1890 { USB_DEVICE(0x0ccd, 0x10ad), /* Rev. 2 */
1891 .driver_info = EM2880_BOARD_TERRATEC_PRODIGY_XS },
1892 { USB_DEVICE(0x0ccd, 0x0084),
1893 .driver_info = EM2860_BOARD_TERRATEC_AV350 },
1894 { USB_DEVICE(0x0ccd, 0x0096),
1895 .driver_info = EM2860_BOARD_TERRATEC_GRABBY },
1896 { USB_DEVICE(0x0fd9, 0x0033),
1897 .driver_info = EM2860_BOARD_ELGATO_VIDEO_CAPTURE},
1898 { USB_DEVICE(0x185b, 0x2870),
1899 .driver_info = EM2870_BOARD_COMPRO_VIDEOMATE },
1900 { USB_DEVICE(0x185b, 0x2041),
1901 .driver_info = EM2820_BOARD_COMPRO_VIDEOMATE_FORYOU },
1902 { USB_DEVICE(0x2040, 0x4200),
1903 .driver_info = EM2820_BOARD_HAUPPAUGE_WINTV_USB_2 },
1904 { USB_DEVICE(0x2040, 0x4201),
1905 .driver_info = EM2820_BOARD_HAUPPAUGE_WINTV_USB_2 },
1906 { USB_DEVICE(0x2040, 0x6500),
1907 .driver_info = EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900 },
1908 { USB_DEVICE(0x2040, 0x6502),
1909 .driver_info = EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900_R2 },
1910 { USB_DEVICE(0x2040, 0x6513), /* HCW HVR-980 */
1911 .driver_info = EM2883_BOARD_HAUPPAUGE_WINTV_HVR_950 },
1912 { USB_DEVICE(0x2040, 0x6517), /* HP HVR-950 */
1913 .driver_info = EM2883_BOARD_HAUPPAUGE_WINTV_HVR_950 },
1914 { USB_DEVICE(0x2040, 0x651b), /* RP HVR-950 */
1915 .driver_info = EM2883_BOARD_HAUPPAUGE_WINTV_HVR_950 },
1916 { USB_DEVICE(0x2040, 0x651f),
1917 .driver_info = EM2883_BOARD_HAUPPAUGE_WINTV_HVR_850 },
1918 { USB_DEVICE(0x0438, 0xb002),
1919 .driver_info = EM2880_BOARD_AMD_ATI_TV_WONDER_HD_600 },
1920 { USB_DEVICE(0x2001, 0xf112),
1921 .driver_info = EM2820_BOARD_DLINK_USB_TV },
1922 { USB_DEVICE(0x2304, 0x0207),
1923 .driver_info = EM2820_BOARD_PINNACLE_DVC_90 },
1924 { USB_DEVICE(0x2304, 0x0208),
1925 .driver_info = EM2820_BOARD_PINNACLE_USB_2 },
1926 { USB_DEVICE(0x2304, 0x021a),
1927 .driver_info = EM2820_BOARD_PINNACLE_DVC_90 },
1928 { USB_DEVICE(0x2304, 0x0226),
1929 .driver_info = EM2882_BOARD_PINNACLE_HYBRID_PRO_330E },
1930 { USB_DEVICE(0x2304, 0x0227),
1931 .driver_info = EM2880_BOARD_PINNACLE_PCTV_HD_PRO },
1932 { USB_DEVICE(0x0413, 0x6023),
1933 .driver_info = EM2800_BOARD_LEADTEK_WINFAST_USBII },
1934 { USB_DEVICE(0x093b, 0xa005),
1935 .driver_info = EM2861_BOARD_PLEXTOR_PX_TV100U },
1936 { USB_DEVICE(0x04bb, 0x0515),
1937 .driver_info = EM2820_BOARD_IODATA_GVMVP_SZ },
1938 { USB_DEVICE(0xeb1a, 0x50a6),
1939 .driver_info = EM2860_BOARD_GADMEI_UTV330 },
1940 { USB_DEVICE(0x1b80, 0xa340),
1941 .driver_info = EM2870_BOARD_KWORLD_A340 },
1942 { USB_DEVICE(0x2013, 0x024f),
1943 .driver_info = EM28174_BOARD_PCTV_290E },
1944 { },
1945};
1946MODULE_DEVICE_TABLE(usb, em28xx_id_table);
1947
1948/*
1949 * EEPROM hash table for devices with generic USB IDs
1950 */
1951static struct em28xx_hash_table em28xx_eeprom_hash[] = {
1952 /* P/N: SA 60002070465 Tuner: TVF7533-MF */
1953 {0x6ce05a8f, EM2820_BOARD_PROLINK_PLAYTV_USB2, TUNER_YMEC_TVF_5533MF},
1954 {0x72cc5a8b, EM2820_BOARD_PROLINK_PLAYTV_BOX4_USB2, TUNER_YMEC_TVF_5533MF},
1955 {0x966a0441, EM2880_BOARD_KWORLD_DVB_310U, TUNER_XC2028},
1956 {0x166a0441, EM2880_BOARD_EMPIRE_DUAL_TV, TUNER_XC2028},
1957 {0xcee44a99, EM2882_BOARD_EVGA_INDTUBE, TUNER_XC2028},
1958 {0xb8846b20, EM2881_BOARD_PINNACLE_HYBRID_PRO, TUNER_XC2028},
1959 {0x63f653bd, EM2870_BOARD_REDDO_DVB_C_USB_BOX, TUNER_ABSENT},
1960 {0x4e913442, EM2882_BOARD_DIKOM_DK300, TUNER_XC2028},
1961};
1962
1963/* I2C devicelist hash table for devices with generic USB IDs */
1964static struct em28xx_hash_table em28xx_i2c_hash[] = {
1965 {0xb06a32c3, EM2800_BOARD_TERRATEC_CINERGY_200, TUNER_LG_PAL_NEW_TAPC},
1966 {0xf51200e3, EM2800_BOARD_VGEAR_POCKETTV, TUNER_LG_PAL_NEW_TAPC},
1967 {0x1ba50080, EM2860_BOARD_SAA711X_REFERENCE_DESIGN, TUNER_ABSENT},
1968 {0x77800080, EM2860_BOARD_TVP5150_REFERENCE_DESIGN, TUNER_ABSENT},
1969 {0xc51200e3, EM2820_BOARD_GADMEI_TVR200, TUNER_LG_PAL_NEW_TAPC},
1970 {0x4ba50080, EM2861_BOARD_GADMEI_UTV330PLUS, TUNER_TNF_5335MF},
1971 {0x6b800080, EM2874_BOARD_LEADERSHIP_ISDBT, TUNER_ABSENT},
1972};
1973
1974/* I2C possible address to saa7115, tvp5150, msp3400, tvaudio */
1975static unsigned short saa711x_addrs[] = {
1976 0x4a >> 1, 0x48 >> 1, /* SAA7111, SAA7111A and SAA7113 */
1977 0x42 >> 1, 0x40 >> 1, /* SAA7114, SAA7115 and SAA7118 */
1978 I2C_CLIENT_END };
1979
1980static unsigned short tvp5150_addrs[] = {
1981 0xb8 >> 1,
1982 0xba >> 1,
1983 I2C_CLIENT_END
1984};
1985
1986static unsigned short msp3400_addrs[] = {
1987 0x80 >> 1,
1988 0x88 >> 1,
1989 I2C_CLIENT_END
1990};
1991
1992int em28xx_tuner_callback(void *ptr, int component, int command, int arg)
1993{
1994 int rc = 0;
1995 struct em28xx *dev = ptr;
1996
1997 if (dev->tuner_type != TUNER_XC2028)
1998 return 0;
1999
2000 if (command != XC2028_TUNER_RESET)
2001 return 0;
2002
2003 rc = em28xx_gpio_set(dev, dev->board.tuner_gpio);
2004
2005 return rc;
2006}
2007EXPORT_SYMBOL_GPL(em28xx_tuner_callback);
2008
2009static inline void em28xx_set_model(struct em28xx *dev)
2010{
2011 memcpy(&dev->board, &em28xx_boards[dev->model], sizeof(dev->board));
2012
2013 /* Those are the default values for the majority of boards
2014 Use those values if not specified otherwise at boards entry
2015 */
2016 if (!dev->board.xclk)
2017 dev->board.xclk = EM28XX_XCLK_IR_RC5_MODE |
2018 EM28XX_XCLK_FREQUENCY_12MHZ;
2019
2020 if (!dev->board.i2c_speed)
2021 dev->board.i2c_speed = EM28XX_I2C_CLK_WAIT_ENABLE |
2022 EM28XX_I2C_FREQ_100_KHZ;
2023}
2024
2025
2026/* FIXME: Should be replaced by a proper mt9m111 driver */
2027static int em28xx_initialize_mt9m111(struct em28xx *dev)
2028{
2029 int i;
2030 unsigned char regs[][3] = {
2031 { 0x0d, 0x00, 0x01, }, /* reset and use defaults */
2032 { 0x0d, 0x00, 0x00, },
2033 { 0x0a, 0x00, 0x21, },
2034 { 0x21, 0x04, 0x00, }, /* full readout speed, no row/col skipping */
2035 };
2036
2037 for (i = 0; i < ARRAY_SIZE(regs); i++)
2038 i2c_master_send(&dev->i2c_client, &regs[i][0], 3);
2039
2040 return 0;
2041}
2042
2043
2044/* FIXME: Should be replaced by a proper mt9m001 driver */
2045static int em28xx_initialize_mt9m001(struct em28xx *dev)
2046{
2047 int i;
2048 unsigned char regs[][3] = {
2049 { 0x0d, 0x00, 0x01, },
2050 { 0x0d, 0x00, 0x00, },
2051 { 0x04, 0x05, 0x00, }, /* hres = 1280 */
2052 { 0x03, 0x04, 0x00, }, /* vres = 1024 */
2053 { 0x20, 0x11, 0x00, },
2054 { 0x06, 0x00, 0x10, },
2055 { 0x2b, 0x00, 0x24, },
2056 { 0x2e, 0x00, 0x24, },
2057 { 0x35, 0x00, 0x24, },
2058 { 0x2d, 0x00, 0x20, },
2059 { 0x2c, 0x00, 0x20, },
2060 { 0x09, 0x0a, 0xd4, },
2061 { 0x35, 0x00, 0x57, },
2062 };
2063
2064 for (i = 0; i < ARRAY_SIZE(regs); i++)
2065 i2c_master_send(&dev->i2c_client, &regs[i][0], 3);
2066
2067 return 0;
2068}
2069
2070/* HINT method: webcam I2C chips
2071 *
2072 * This method works for webcams with Micron sensors
2073 */
2074static int em28xx_hint_sensor(struct em28xx *dev)
2075{
2076 int rc;
2077 char *sensor_name;
2078 unsigned char cmd;
2079 __be16 version_be;
2080 u16 version;
2081
2082 /* Micron sensor detection */
2083 dev->i2c_client.addr = 0xba >> 1;
2084 cmd = 0;
2085 i2c_master_send(&dev->i2c_client, &cmd, 1);
2086 rc = i2c_master_recv(&dev->i2c_client, (char *)&version_be, 2);
2087 if (rc != 2)
2088 return -EINVAL;
2089
2090 version = be16_to_cpu(version_be);
2091 switch (version) {
2092 case 0x8232: /* mt9v011 640x480 1.3 Mpix sensor */
2093 case 0x8243: /* mt9v011 rev B 640x480 1.3 Mpix sensor */
2094 dev->model = EM2820_BOARD_SILVERCREST_WEBCAM;
2095 em28xx_set_model(dev);
2096
2097 sensor_name = "mt9v011";
2098 dev->em28xx_sensor = EM28XX_MT9V011;
2099 dev->sensor_xres = 640;
2100 dev->sensor_yres = 480;
2101 /*
2102 * FIXME: mt9v011 uses I2S speed as xtal clk - at least with
2103 * the Silvercrest cam I have here for testing - for higher
2104 * resolutions, a high clock cause horizontal artifacts, so we
2105 * need to use a lower xclk frequency.
2106 * Yet, it would be possible to adjust xclk depending on the
2107 * desired resolution, since this affects directly the
2108 * frame rate.
2109 */
2110 dev->board.xclk = EM28XX_XCLK_FREQUENCY_4_3MHZ;
2111 dev->sensor_xtal = 4300000;
2112
2113 /* probably means GRGB 16 bit bayer */
2114 dev->vinmode = 0x0d;
2115 dev->vinctl = 0x00;
2116
2117 break;
2118
2119 case 0x143a: /* MT9M111 as found in the ECS G200 */
2120 dev->model = EM2750_BOARD_UNKNOWN;
2121 em28xx_set_model(dev);
2122
2123 sensor_name = "mt9m111";
2124 dev->board.xclk = EM28XX_XCLK_FREQUENCY_48MHZ;
2125 dev->em28xx_sensor = EM28XX_MT9M111;
2126 em28xx_initialize_mt9m111(dev);
2127 dev->sensor_xres = 640;
2128 dev->sensor_yres = 512;
2129
2130 dev->vinmode = 0x0a;
2131 dev->vinctl = 0x00;
2132
2133 break;
2134
2135 case 0x8431:
2136 dev->model = EM2750_BOARD_UNKNOWN;
2137 em28xx_set_model(dev);
2138
2139 sensor_name = "mt9m001";
2140 dev->em28xx_sensor = EM28XX_MT9M001;
2141 em28xx_initialize_mt9m001(dev);
2142 dev->sensor_xres = 1280;
2143 dev->sensor_yres = 1024;
2144
2145 /* probably means BGGR 16 bit bayer */
2146 dev->vinmode = 0x0c;
2147 dev->vinctl = 0x00;
2148
2149 break;
2150 default:
2151 printk("Unknown Micron Sensor 0x%04x\n", version);
2152 return -EINVAL;
2153 }
2154
2155 /* Setup webcam defaults */
2156 em28xx_pre_card_setup(dev);
2157
2158 em28xx_errdev("Sensor is %s, using model %s entry.\n",
2159 sensor_name, em28xx_boards[dev->model].name);
2160
2161 return 0;
2162}
2163
2164/* Since em28xx_pre_card_setup() requires a proper dev->model,
2165 * this won't work for boards with generic PCI IDs
2166 */
2167void em28xx_pre_card_setup(struct em28xx *dev)
2168{
2169 /* Set the initial XCLK and I2C clock values based on the board
2170 definition */
2171 em28xx_write_reg(dev, EM28XX_R0F_XCLK, dev->board.xclk & 0x7f);
2172 em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, dev->board.i2c_speed);
2173 msleep(50);
2174
2175 /* request some modules */
2176 switch (dev->model) {
2177 case EM2861_BOARD_PLEXTOR_PX_TV100U:
2178 /* Sets the msp34xx I2S speed */
2179 dev->i2s_speed = 2048000;
2180 break;
2181 case EM2861_BOARD_KWORLD_PVRTV_300U:
2182 case EM2880_BOARD_KWORLD_DVB_305U:
2183 em28xx_write_reg(dev, EM28XX_R08_GPIO, 0x6d);
2184 msleep(10);
2185 em28xx_write_reg(dev, EM28XX_R08_GPIO, 0x7d);
2186 msleep(10);
2187 break;
2188 case EM2870_BOARD_COMPRO_VIDEOMATE:
2189 /* TODO: someone can do some cleanup here...
2190 not everything's needed */
2191 em28xx_write_reg(dev, EM2880_R04_GPO, 0x00);
2192 msleep(10);
2193 em28xx_write_reg(dev, EM2880_R04_GPO, 0x01);
2194 msleep(10);
2195 em28xx_write_reg(dev, EM28XX_R08_GPIO, 0xfd);
2196 mdelay(70);
2197 em28xx_write_reg(dev, EM28XX_R08_GPIO, 0xfc);
2198 mdelay(70);
2199 em28xx_write_reg(dev, EM28XX_R08_GPIO, 0xdc);
2200 mdelay(70);
2201 em28xx_write_reg(dev, EM28XX_R08_GPIO, 0xfc);
2202 mdelay(70);
2203 break;
2204 case EM2870_BOARD_TERRATEC_XS_MT2060:
2205 /* this device needs some gpio writes to get the DVB-T
2206 demod work */
2207 em28xx_write_reg(dev, EM28XX_R08_GPIO, 0xfe);
2208 mdelay(70);
2209 em28xx_write_reg(dev, EM28XX_R08_GPIO, 0xde);
2210 mdelay(70);
2211 em28xx_write_reg(dev, EM28XX_R08_GPIO, 0xfe);
2212 mdelay(70);
2213 break;
2214 case EM2870_BOARD_PINNACLE_PCTV_DVB:
2215 /* this device needs some gpio writes to get the
2216 DVB-T demod work */
2217 em28xx_write_reg(dev, EM28XX_R08_GPIO, 0xfe);
2218 mdelay(70);
2219 em28xx_write_reg(dev, EM28XX_R08_GPIO, 0xde);
2220 mdelay(70);
2221 em28xx_write_reg(dev, EM28XX_R08_GPIO, 0xfe);
2222 mdelay(70);
2223 break;
2224 case EM2820_BOARD_GADMEI_UTV310:
2225 case EM2820_BOARD_MSI_VOX_USB_2:
2226 /* enables audio for that devices */
2227 em28xx_write_reg(dev, EM28XX_R08_GPIO, 0xfd);
2228 break;
2229
2230 case EM2882_BOARD_KWORLD_ATSC_315U:
2231 em28xx_write_reg(dev, EM28XX_R08_GPIO, 0xff);
2232 msleep(10);
2233 em28xx_write_reg(dev, EM28XX_R08_GPIO, 0xfe);
2234 msleep(10);
2235 em28xx_write_reg(dev, EM2880_R04_GPO, 0x00);
2236 msleep(10);
2237 em28xx_write_reg(dev, EM2880_R04_GPO, 0x08);
2238 msleep(10);
2239 break;
2240
2241 case EM2860_BOARD_KAIOMY_TVNPC_U2:
2242 em28xx_write_regs(dev, EM28XX_R0F_XCLK, "\x07", 1);
2243 em28xx_write_regs(dev, EM28XX_R06_I2C_CLK, "\x40", 1);
2244 em28xx_write_regs(dev, 0x0d, "\x42", 1);
2245 em28xx_write_regs(dev, 0x08, "\xfd", 1);
2246 msleep(10);
2247 em28xx_write_regs(dev, 0x08, "\xff", 1);
2248 msleep(10);
2249 em28xx_write_regs(dev, 0x08, "\x7f", 1);
2250 msleep(10);
2251 em28xx_write_regs(dev, 0x08, "\x6b", 1);
2252
2253 break;
2254 case EM2860_BOARD_EASYCAP:
2255 em28xx_write_regs(dev, 0x08, "\xf8", 1);
2256 break;
2257
2258 case EM2820_BOARD_IODATA_GVMVP_SZ:
2259 em28xx_write_reg(dev, EM28XX_R08_GPIO, 0xff);
2260 msleep(70);
2261 em28xx_write_reg(dev, EM28XX_R08_GPIO, 0xf7);
2262 msleep(10);
2263 em28xx_write_reg(dev, EM28XX_R08_GPIO, 0xfe);
2264 msleep(70);
2265 em28xx_write_reg(dev, EM28XX_R08_GPIO, 0xfd);
2266 msleep(70);
2267 break;
2268 }
2269
2270 em28xx_gpio_set(dev, dev->board.tuner_gpio);
2271 em28xx_set_mode(dev, EM28XX_ANALOG_MODE);
2272
2273 /* Unlock device */
2274 em28xx_set_mode(dev, EM28XX_SUSPEND);
2275}
2276
2277static void em28xx_setup_xc3028(struct em28xx *dev, struct xc2028_ctrl *ctl)
2278{
2279 memset(ctl, 0, sizeof(*ctl));
2280
2281 ctl->fname = XC2028_DEFAULT_FIRMWARE;
2282 ctl->max_len = 64;
2283 ctl->mts = em28xx_boards[dev->model].mts_firmware;
2284
2285 switch (dev->model) {
2286 case EM2880_BOARD_EMPIRE_DUAL_TV:
2287 case EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900:
2288 case EM2882_BOARD_TERRATEC_HYBRID_XS:
2289 ctl->demod = XC3028_FE_ZARLINK456;
2290 break;
2291 case EM2880_BOARD_TERRATEC_HYBRID_XS:
2292 case EM2880_BOARD_TERRATEC_HYBRID_XS_FR:
2293 case EM2881_BOARD_PINNACLE_HYBRID_PRO:
2294 ctl->demod = XC3028_FE_ZARLINK456;
2295 break;
2296 case EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900_R2:
2297 case EM2882_BOARD_PINNACLE_HYBRID_PRO_330E:
2298 ctl->demod = XC3028_FE_DEFAULT;
2299 break;
2300 case EM2880_BOARD_AMD_ATI_TV_WONDER_HD_600:
2301 ctl->demod = XC3028_FE_DEFAULT;
2302 ctl->fname = XC3028L_DEFAULT_FIRMWARE;
2303 break;
2304 case EM2883_BOARD_HAUPPAUGE_WINTV_HVR_850:
2305 case EM2883_BOARD_HAUPPAUGE_WINTV_HVR_950:
2306 case EM2880_BOARD_PINNACLE_PCTV_HD_PRO:
2307 /* FIXME: Better to specify the needed IF */
2308 ctl->demod = XC3028_FE_DEFAULT;
2309 break;
2310 case EM2883_BOARD_KWORLD_HYBRID_330U:
2311 case EM2882_BOARD_DIKOM_DK300:
2312 case EM2882_BOARD_KWORLD_VS_DVBT:
2313 ctl->demod = XC3028_FE_CHINA;
2314 ctl->fname = XC2028_DEFAULT_FIRMWARE;
2315 break;
2316 case EM2882_BOARD_EVGA_INDTUBE:
2317 ctl->demod = XC3028_FE_CHINA;
2318 ctl->fname = XC3028L_DEFAULT_FIRMWARE;
2319 break;
2320 default:
2321 ctl->demod = XC3028_FE_OREN538;
2322 }
2323}
2324
2325static void em28xx_tuner_setup(struct em28xx *dev)
2326{
2327 struct tuner_setup tun_setup;
2328 struct v4l2_frequency f;
2329
2330 if (dev->tuner_type == TUNER_ABSENT)
2331 return;
2332
2333 memset(&tun_setup, 0, sizeof(tun_setup));
2334
2335 tun_setup.mode_mask = T_ANALOG_TV | T_RADIO;
2336 tun_setup.tuner_callback = em28xx_tuner_callback;
2337
2338 if (dev->board.radio.type) {
2339 tun_setup.type = dev->board.radio.type;
2340 tun_setup.addr = dev->board.radio_addr;
2341
2342 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_type_addr, &tun_setup);
2343 }
2344
2345 if ((dev->tuner_type != TUNER_ABSENT) && (dev->tuner_type)) {
2346 tun_setup.type = dev->tuner_type;
2347 tun_setup.addr = dev->tuner_addr;
2348
2349 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_type_addr, &tun_setup);
2350 }
2351
2352 if (dev->tda9887_conf) {
2353 struct v4l2_priv_tun_config tda9887_cfg;
2354
2355 tda9887_cfg.tuner = TUNER_TDA9887;
2356 tda9887_cfg.priv = &dev->tda9887_conf;
2357
2358 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_config, &tda9887_cfg);
2359 }
2360
2361 if (dev->tuner_type == TUNER_XC2028) {
2362 struct v4l2_priv_tun_config xc2028_cfg;
2363 struct xc2028_ctrl ctl;
2364
2365 memset(&xc2028_cfg, 0, sizeof(xc2028_cfg));
2366 memset(&ctl, 0, sizeof(ctl));
2367
2368 em28xx_setup_xc3028(dev, &ctl);
2369
2370 xc2028_cfg.tuner = TUNER_XC2028;
2371 xc2028_cfg.priv = &ctl;
2372
2373 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_config, &xc2028_cfg);
2374 }
2375
2376 /* configure tuner */
2377 f.tuner = 0;
2378 f.type = V4L2_TUNER_ANALOG_TV;
2379 f.frequency = 9076; /* just a magic number */
2380 dev->ctl_freq = f.frequency;
2381 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_frequency, &f);
2382}
2383
2384static int em28xx_hint_board(struct em28xx *dev)
2385{
2386 int i;
2387
2388 /* HINT method: EEPROM
2389 *
2390 * This method works only for boards with eeprom.
2391 * Uses a hash of all eeprom bytes. The hash should be
2392 * unique for a vendor/tuner pair.
2393 * There are a high chance that tuners for different
2394 * video standards produce different hashes.
2395 */
2396 for (i = 0; i < ARRAY_SIZE(em28xx_eeprom_hash); i++) {
2397 if (dev->hash == em28xx_eeprom_hash[i].hash) {
2398 dev->model = em28xx_eeprom_hash[i].model;
2399 dev->tuner_type = em28xx_eeprom_hash[i].tuner;
2400
2401 em28xx_errdev("Your board has no unique USB ID.\n");
2402 em28xx_errdev("A hint were successfully done, "
2403 "based on eeprom hash.\n");
2404 em28xx_errdev("This method is not 100%% failproof.\n");
2405 em28xx_errdev("If the board were missdetected, "
2406 "please email this log to:\n");
2407 em28xx_errdev("\tV4L Mailing List "
2408 " <linux-media@vger.kernel.org>\n");
2409 em28xx_errdev("Board detected as %s\n",
2410 em28xx_boards[dev->model].name);
2411
2412 return 0;
2413 }
2414 }
2415
2416 /* HINT method: I2C attached devices
2417 *
2418 * This method works for all boards.
2419 * Uses a hash of i2c scanned devices.
2420 * Devices with the same i2c attached chips will
2421 * be considered equal.
2422 * This method is less precise than the eeprom one.
2423 */
2424
2425 /* user did not request i2c scanning => do it now */
2426 if (!dev->i2c_hash)
2427 em28xx_do_i2c_scan(dev);
2428
2429 for (i = 0; i < ARRAY_SIZE(em28xx_i2c_hash); i++) {
2430 if (dev->i2c_hash == em28xx_i2c_hash[i].hash) {
2431 dev->model = em28xx_i2c_hash[i].model;
2432 dev->tuner_type = em28xx_i2c_hash[i].tuner;
2433 em28xx_errdev("Your board has no unique USB ID.\n");
2434 em28xx_errdev("A hint were successfully done, "
2435 "based on i2c devicelist hash.\n");
2436 em28xx_errdev("This method is not 100%% failproof.\n");
2437 em28xx_errdev("If the board were missdetected, "
2438 "please email this log to:\n");
2439 em28xx_errdev("\tV4L Mailing List "
2440 " <linux-media@vger.kernel.org>\n");
2441 em28xx_errdev("Board detected as %s\n",
2442 em28xx_boards[dev->model].name);
2443
2444 return 0;
2445 }
2446 }
2447
2448 em28xx_errdev("Your board has no unique USB ID and thus need a "
2449 "hint to be detected.\n");
2450 em28xx_errdev("You may try to use card=<n> insmod option to "
2451 "workaround that.\n");
2452 em28xx_errdev("Please send an email with this log to:\n");
2453 em28xx_errdev("\tV4L Mailing List <linux-media@vger.kernel.org>\n");
2454 em28xx_errdev("Board eeprom hash is 0x%08lx\n", dev->hash);
2455 em28xx_errdev("Board i2c devicelist hash is 0x%08lx\n", dev->i2c_hash);
2456
2457 em28xx_errdev("Here is a list of valid choices for the card=<n>"
2458 " insmod option:\n");
2459 for (i = 0; i < em28xx_bcount; i++) {
2460 em28xx_errdev(" card=%d -> %s\n",
2461 i, em28xx_boards[i].name);
2462 }
2463 return -1;
2464}
2465
2466/* ----------------------------------------------------------------------- */
2467void em28xx_register_i2c_ir(struct em28xx *dev)
2468{
2469 /* Leadtek winfast tv USBII deluxe can find a non working IR-device */
2470 /* at address 0x18, so if that address is needed for another board in */
2471 /* the future, please put it after 0x1f. */
2472 struct i2c_board_info info;
2473 const unsigned short addr_list[] = {
2474 0x1f, 0x30, 0x47, I2C_CLIENT_END
2475 };
2476
2477 if (disable_ir)
2478 return;
2479
2480 memset(&info, 0, sizeof(struct i2c_board_info));
2481 memset(&dev->init_data, 0, sizeof(dev->init_data));
2482 strlcpy(info.type, "ir_video", I2C_NAME_SIZE);
2483
2484 /* detect & configure */
2485 switch (dev->model) {
2486 case EM2800_BOARD_TERRATEC_CINERGY_200:
2487 case EM2820_BOARD_TERRATEC_CINERGY_250:
2488 dev->init_data.ir_codes = RC_MAP_EM_TERRATEC;
2489 dev->init_data.get_key = em28xx_get_key_terratec;
2490 dev->init_data.name = "i2c IR (EM28XX Terratec)";
2491 break;
2492 case EM2820_BOARD_PINNACLE_USB_2:
2493 dev->init_data.ir_codes = RC_MAP_PINNACLE_GREY;
2494 dev->init_data.get_key = em28xx_get_key_pinnacle_usb_grey;
2495 dev->init_data.name = "i2c IR (EM28XX Pinnacle PCTV)";
2496 break;
2497 case EM2820_BOARD_HAUPPAUGE_WINTV_USB_2:
2498 dev->init_data.ir_codes = RC_MAP_HAUPPAUGE;
2499 dev->init_data.get_key = em28xx_get_key_em_haup;
2500 dev->init_data.name = "i2c IR (EM2840 Hauppauge)";
2501 break;
2502 case EM2820_BOARD_LEADTEK_WINFAST_USBII_DELUXE:
2503 dev->init_data.ir_codes = RC_MAP_WINFAST_USBII_DELUXE;
2504 dev->init_data.get_key = em28xx_get_key_winfast_usbii_deluxe;
2505 dev->init_data.name = "i2c IR (EM2820 Winfast TV USBII Deluxe)";
2506 break;
2507 }
2508
2509 if (dev->init_data.name)
2510 info.platform_data = &dev->init_data;
2511 i2c_new_probed_device(&dev->i2c_adap, &info, addr_list, NULL);
2512}
2513
2514void em28xx_card_setup(struct em28xx *dev)
2515{
2516 /*
2517 * If the device can be a webcam, seek for a sensor.
2518 * If sensor is not found, then it isn't a webcam.
2519 */
2520 if (dev->board.is_webcam) {
2521 if (em28xx_hint_sensor(dev) < 0)
2522 dev->board.is_webcam = 0;
2523 else
2524 dev->progressive = 1;
2525 }
2526
2527 if (!dev->board.is_webcam) {
2528 switch (dev->model) {
2529 case EM2820_BOARD_UNKNOWN:
2530 case EM2800_BOARD_UNKNOWN:
2531 /*
2532 * The K-WORLD DVB-T 310U is detected as an MSI Digivox AD.
2533 *
2534 * This occurs because they share identical USB vendor and
2535 * product IDs.
2536 *
2537 * What we do here is look up the EEPROM hash of the K-WORLD
2538 * and if it is found then we decide that we do not have
2539 * a DIGIVOX and reset the device to the K-WORLD instead.
2540 *
2541 * This solution is only valid if they do not share eeprom
2542 * hash identities which has not been determined as yet.
2543 */
2544 if (em28xx_hint_board(dev) < 0)
2545 em28xx_errdev("Board not discovered\n");
2546 else {
2547 em28xx_set_model(dev);
2548 em28xx_pre_card_setup(dev);
2549 }
2550 break;
2551 default:
2552 em28xx_set_model(dev);
2553 }
2554 }
2555
2556 em28xx_info("Identified as %s (card=%d)\n",
2557 dev->board.name, dev->model);
2558
2559 dev->tuner_type = em28xx_boards[dev->model].tuner_type;
2560 if (em28xx_boards[dev->model].tuner_addr)
2561 dev->tuner_addr = em28xx_boards[dev->model].tuner_addr;
2562
2563 if (em28xx_boards[dev->model].tda9887_conf)
2564 dev->tda9887_conf = em28xx_boards[dev->model].tda9887_conf;
2565
2566 /* request some modules */
2567 switch (dev->model) {
2568 case EM2820_BOARD_HAUPPAUGE_WINTV_USB_2:
2569 case EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900:
2570 case EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900_R2:
2571 case EM2883_BOARD_HAUPPAUGE_WINTV_HVR_850:
2572 case EM2883_BOARD_HAUPPAUGE_WINTV_HVR_950:
2573 {
2574 struct tveeprom tv;
2575#if defined(CONFIG_MODULES) && defined(MODULE)
2576 request_module("tveeprom");
2577#endif
2578 /* Call first TVeeprom */
2579
2580 dev->i2c_client.addr = 0xa0 >> 1;
2581 tveeprom_hauppauge_analog(&dev->i2c_client, &tv, dev->eedata);
2582
2583 dev->tuner_type = tv.tuner_type;
2584
2585 if (tv.audio_processor == V4L2_IDENT_MSPX4XX) {
2586 dev->i2s_speed = 2048000;
2587 dev->board.has_msp34xx = 1;
2588 }
2589 break;
2590 }
2591 case EM2882_BOARD_KWORLD_ATSC_315U:
2592 em28xx_write_reg(dev, 0x0d, 0x42);
2593 msleep(10);
2594 em28xx_write_reg(dev, EM28XX_R08_GPIO, 0xfd);
2595 msleep(10);
2596 break;
2597 case EM2820_BOARD_KWORLD_PVRTV2800RF:
2598 /* GPIO enables sound on KWORLD PVR TV 2800RF */
2599 em28xx_write_reg(dev, EM28XX_R08_GPIO, 0xf9);
2600 break;
2601 case EM2820_BOARD_UNKNOWN:
2602 case EM2800_BOARD_UNKNOWN:
2603 /*
2604 * The K-WORLD DVB-T 310U is detected as an MSI Digivox AD.
2605 *
2606 * This occurs because they share identical USB vendor and
2607 * product IDs.
2608 *
2609 * What we do here is look up the EEPROM hash of the K-WORLD
2610 * and if it is found then we decide that we do not have
2611 * a DIGIVOX and reset the device to the K-WORLD instead.
2612 *
2613 * This solution is only valid if they do not share eeprom
2614 * hash identities which has not been determined as yet.
2615 */
2616 case EM2880_BOARD_MSI_DIGIVOX_AD:
2617 if (!em28xx_hint_board(dev))
2618 em28xx_set_model(dev);
2619
2620 /* In cases where we had to use a board hint, the call to
2621 em28xx_set_mode() in em28xx_pre_card_setup() was a no-op,
2622 so make the call now so the analog GPIOs are set properly
2623 before probing the i2c bus. */
2624 em28xx_gpio_set(dev, dev->board.tuner_gpio);
2625 em28xx_set_mode(dev, EM28XX_ANALOG_MODE);
2626 break;
2627
2628/*
2629 * The Dikom DK300 is detected as an Kworld VS-DVB-T 323UR.
2630 *
2631 * This occurs because they share identical USB vendor and
2632 * product IDs.
2633 *
2634 * What we do here is look up the EEPROM hash of the Dikom
2635 * and if it is found then we decide that we do not have
2636 * a Kworld and reset the device to the Dikom instead.
2637 *
2638 * This solution is only valid if they do not share eeprom
2639 * hash identities which has not been determined as yet.
2640 */
2641 case EM2882_BOARD_KWORLD_VS_DVBT:
2642 if (!em28xx_hint_board(dev))
2643 em28xx_set_model(dev);
2644
2645 /* In cases where we had to use a board hint, the call to
2646 em28xx_set_mode() in em28xx_pre_card_setup() was a no-op,
2647 so make the call now so the analog GPIOs are set properly
2648 before probing the i2c bus. */
2649 em28xx_gpio_set(dev, dev->board.tuner_gpio);
2650 em28xx_set_mode(dev, EM28XX_ANALOG_MODE);
2651 break;
2652 }
2653
2654#if defined(CONFIG_MODULES) && defined(MODULE)
2655 if (dev->board.has_ir_i2c && !disable_ir)
2656 request_module("ir-kbd-i2c");
2657#endif
2658 if (dev->board.has_snapshot_button)
2659 em28xx_register_snapshot_button(dev);
2660
2661 if (dev->board.valid == EM28XX_BOARD_NOT_VALIDATED) {
2662 em28xx_errdev("\n\n");
2663 em28xx_errdev("The support for this board weren't "
2664 "valid yet.\n");
2665 em28xx_errdev("Please send a report of having this working\n");
2666 em28xx_errdev("not to V4L mailing list (and/or to other "
2667 "addresses)\n\n");
2668 }
2669
2670 /* Allow override tuner type by a module parameter */
2671 if (tuner >= 0)
2672 dev->tuner_type = tuner;
2673
2674 /* request some modules */
2675 if (dev->board.has_msp34xx)
2676 v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap,
2677 "msp3400", 0, msp3400_addrs);
2678
2679 if (dev->board.decoder == EM28XX_SAA711X)
2680 v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap,
2681 "saa7115_auto", 0, saa711x_addrs);
2682
2683 if (dev->board.decoder == EM28XX_TVP5150)
2684 v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap,
2685 "tvp5150", 0, tvp5150_addrs);
2686
2687 if (dev->em28xx_sensor == EM28XX_MT9V011) {
2688 struct mt9v011_platform_data pdata;
2689 struct i2c_board_info mt9v011_info = {
2690 .type = "mt9v011",
2691 .addr = 0xba >> 1,
2692 .platform_data = &pdata,
2693 };
2694
2695 pdata.xtal = dev->sensor_xtal;
2696 v4l2_i2c_new_subdev_board(&dev->v4l2_dev, &dev->i2c_adap,
2697 &mt9v011_info, NULL);
2698 }
2699
2700
2701 if (dev->board.adecoder == EM28XX_TVAUDIO)
2702 v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap,
2703 "tvaudio", dev->board.tvaudio_addr, NULL);
2704
2705 if (dev->board.tuner_type != TUNER_ABSENT) {
2706 int has_demod = (dev->tda9887_conf & TDA9887_PRESENT);
2707
2708 if (dev->board.radio.type)
2709 v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap,
2710 "tuner", dev->board.radio_addr, NULL);
2711
2712 if (has_demod)
2713 v4l2_i2c_new_subdev(&dev->v4l2_dev,
2714 &dev->i2c_adap, "tuner",
2715 0, v4l2_i2c_tuner_addrs(ADDRS_DEMOD));
2716 if (dev->tuner_addr == 0) {
2717 enum v4l2_i2c_tuner_type type =
2718 has_demod ? ADDRS_TV_WITH_DEMOD : ADDRS_TV;
2719 struct v4l2_subdev *sd;
2720
2721 sd = v4l2_i2c_new_subdev(&dev->v4l2_dev,
2722 &dev->i2c_adap, "tuner",
2723 0, v4l2_i2c_tuner_addrs(type));
2724
2725 if (sd)
2726 dev->tuner_addr = v4l2_i2c_subdev_addr(sd);
2727 } else {
2728 v4l2_i2c_new_subdev(&dev->v4l2_dev, &dev->i2c_adap,
2729 "tuner", dev->tuner_addr, NULL);
2730 }
2731 }
2732
2733 em28xx_tuner_setup(dev);
2734
2735 if(!disable_ir)
2736 em28xx_ir_init(dev);
2737}
2738
2739
2740#if defined(CONFIG_MODULES) && defined(MODULE)
2741static void request_module_async(struct work_struct *work)
2742{
2743 struct em28xx *dev = container_of(work,
2744 struct em28xx, request_module_wk);
2745
2746 if (dev->has_audio_class)
2747 request_module("snd-usb-audio");
2748 else if (dev->has_alsa_audio)
2749 request_module("em28xx-alsa");
2750
2751 if (dev->board.has_dvb)
2752 request_module("em28xx-dvb");
2753}
2754
2755static void request_modules(struct em28xx *dev)
2756{
2757 INIT_WORK(&dev->request_module_wk, request_module_async);
2758 schedule_work(&dev->request_module_wk);
2759}
2760
2761static void flush_request_modules(struct em28xx *dev)
2762{
2763 flush_work_sync(&dev->request_module_wk);
2764}
2765#else
2766#define request_modules(dev)
2767#define flush_request_modules(dev)
2768#endif /* CONFIG_MODULES */
2769
2770/*
2771 * em28xx_realease_resources()
2772 * unregisters the v4l2,i2c and usb devices
2773 * called when the device gets disconected or at module unload
2774*/
2775void em28xx_release_resources(struct em28xx *dev)
2776{
2777 if (dev->sbutton_input_dev)
2778 em28xx_deregister_snapshot_button(dev);
2779
2780 if (dev->ir)
2781 em28xx_ir_fini(dev);
2782
2783 /*FIXME: I2C IR should be disconnected */
2784
2785 em28xx_release_analog_resources(dev);
2786
2787 em28xx_remove_from_devlist(dev);
2788
2789 em28xx_i2c_unregister(dev);
2790
2791 v4l2_device_unregister(&dev->v4l2_dev);
2792
2793 usb_put_dev(dev->udev);
2794
2795 /* Mark device as unused */
2796 em28xx_devused &= ~(1 << dev->devno);
2797};
2798
2799/*
2800 * em28xx_init_dev()
2801 * allocates and inits the device structs, registers i2c bus and v4l device
2802 */
2803static int em28xx_init_dev(struct em28xx **devhandle, struct usb_device *udev,
2804 struct usb_interface *interface,
2805 int minor)
2806{
2807 struct em28xx *dev = *devhandle;
2808 int retval;
2809 int errCode;
2810
2811 dev->udev = udev;
2812 mutex_init(&dev->ctrl_urb_lock);
2813 spin_lock_init(&dev->slock);
2814 init_waitqueue_head(&dev->open);
2815 init_waitqueue_head(&dev->wait_frame);
2816 init_waitqueue_head(&dev->wait_stream);
2817
2818 dev->em28xx_write_regs = em28xx_write_regs;
2819 dev->em28xx_read_reg = em28xx_read_reg;
2820 dev->em28xx_read_reg_req_len = em28xx_read_reg_req_len;
2821 dev->em28xx_write_regs_req = em28xx_write_regs_req;
2822 dev->em28xx_read_reg_req = em28xx_read_reg_req;
2823 dev->board.is_em2800 = em28xx_boards[dev->model].is_em2800;
2824
2825 em28xx_set_model(dev);
2826
2827 /* Set the default GPO/GPIO for legacy devices */
2828 dev->reg_gpo_num = EM2880_R04_GPO;
2829 dev->reg_gpio_num = EM28XX_R08_GPIO;
2830
2831 dev->wait_after_write = 5;
2832
2833 /* Based on the Chip ID, set the device configuration */
2834 retval = em28xx_read_reg(dev, EM28XX_R0A_CHIPID);
2835 if (retval > 0) {
2836 dev->chip_id = retval;
2837
2838 switch (dev->chip_id) {
2839 case CHIP_ID_EM2800:
2840 em28xx_info("chip ID is em2800\n");
2841 break;
2842 case CHIP_ID_EM2710:
2843 em28xx_info("chip ID is em2710\n");
2844 break;
2845 case CHIP_ID_EM2750:
2846 em28xx_info("chip ID is em2750\n");
2847 break;
2848 case CHIP_ID_EM2820:
2849 em28xx_info("chip ID is em2820 (or em2710)\n");
2850 break;
2851 case CHIP_ID_EM2840:
2852 em28xx_info("chip ID is em2840\n");
2853 break;
2854 case CHIP_ID_EM2860:
2855 em28xx_info("chip ID is em2860\n");
2856 break;
2857 case CHIP_ID_EM2870:
2858 em28xx_info("chip ID is em2870\n");
2859 dev->wait_after_write = 0;
2860 break;
2861 case CHIP_ID_EM2874:
2862 em28xx_info("chip ID is em2874\n");
2863 dev->reg_gpio_num = EM2874_R80_GPIO;
2864 dev->wait_after_write = 0;
2865 break;
2866 case CHIP_ID_EM28174:
2867 em28xx_info("chip ID is em28174\n");
2868 dev->reg_gpio_num = EM2874_R80_GPIO;
2869 dev->wait_after_write = 0;
2870 break;
2871 case CHIP_ID_EM2883:
2872 em28xx_info("chip ID is em2882/em2883\n");
2873 dev->wait_after_write = 0;
2874 break;
2875 case CHIP_ID_EM2884:
2876 em28xx_info("chip ID is em2884\n");
2877 dev->reg_gpio_num = EM2874_R80_GPIO;
2878 dev->wait_after_write = 0;
2879 break;
2880 default:
2881 em28xx_info("em28xx chip ID = %d\n", dev->chip_id);
2882 }
2883 }
2884
2885 if (dev->is_audio_only) {
2886 errCode = em28xx_audio_setup(dev);
2887 if (errCode)
2888 return -ENODEV;
2889 em28xx_add_into_devlist(dev);
2890 em28xx_init_extension(dev);
2891
2892 return 0;
2893 }
2894
2895 /* Prepopulate cached GPO register content */
2896 retval = em28xx_read_reg(dev, dev->reg_gpo_num);
2897 if (retval >= 0)
2898 dev->reg_gpo = retval;
2899
2900 em28xx_pre_card_setup(dev);
2901
2902 if (!dev->board.is_em2800) {
2903 /* Resets I2C speed */
2904 em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, dev->board.i2c_speed);
2905 if (retval < 0) {
2906 em28xx_errdev("%s: em28xx_write_regs_req failed!"
2907 " retval [%d]\n",
2908 __func__, retval);
2909 return retval;
2910 }
2911 }
2912
2913 retval = v4l2_device_register(&interface->dev, &dev->v4l2_dev);
2914 if (retval < 0) {
2915 em28xx_errdev("Call to v4l2_device_register() failed!\n");
2916 return retval;
2917 }
2918
2919 /* register i2c bus */
2920 errCode = em28xx_i2c_register(dev);
2921 if (errCode < 0) {
2922 v4l2_device_unregister(&dev->v4l2_dev);
2923 em28xx_errdev("%s: em28xx_i2c_register - errCode [%d]!\n",
2924 __func__, errCode);
2925 return errCode;
2926 }
2927
2928 /*
2929 * Default format, used for tvp5150 or saa711x output formats
2930 */
2931 dev->vinmode = 0x10;
2932 dev->vinctl = EM28XX_VINCTRL_INTERLACED |
2933 EM28XX_VINCTRL_CCIR656_ENABLE;
2934
2935 /* Do board specific init and eeprom reading */
2936 em28xx_card_setup(dev);
2937
2938 /* Configure audio */
2939 errCode = em28xx_audio_setup(dev);
2940 if (errCode < 0) {
2941 v4l2_device_unregister(&dev->v4l2_dev);
2942 em28xx_errdev("%s: Error while setting audio - errCode [%d]!\n",
2943 __func__, errCode);
2944 }
2945
2946 /* wake i2c devices */
2947 em28xx_wake_i2c(dev);
2948
2949 /* init video dma queues */
2950 INIT_LIST_HEAD(&dev->vidq.active);
2951 INIT_LIST_HEAD(&dev->vidq.queued);
2952 INIT_LIST_HEAD(&dev->vbiq.active);
2953 INIT_LIST_HEAD(&dev->vbiq.queued);
2954
2955 if (dev->board.has_msp34xx) {
2956 /* Send a reset to other chips via gpio */
2957 errCode = em28xx_write_reg(dev, EM28XX_R08_GPIO, 0xf7);
2958 if (errCode < 0) {
2959 em28xx_errdev("%s: em28xx_write_regs_req - "
2960 "msp34xx(1) failed! errCode [%d]\n",
2961 __func__, errCode);
2962 return errCode;
2963 }
2964 msleep(3);
2965
2966 errCode = em28xx_write_reg(dev, EM28XX_R08_GPIO, 0xff);
2967 if (errCode < 0) {
2968 em28xx_errdev("%s: em28xx_write_regs_req - "
2969 "msp34xx(2) failed! errCode [%d]\n",
2970 __func__, errCode);
2971 return errCode;
2972 }
2973 msleep(3);
2974 }
2975
2976 em28xx_add_into_devlist(dev);
2977
2978 retval = em28xx_register_analog_devices(dev);
2979 if (retval < 0) {
2980 em28xx_release_resources(dev);
2981 goto fail_reg_devices;
2982 }
2983
2984 em28xx_init_extension(dev);
2985
2986 /* Save some power by putting tuner to sleep */
2987 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_power, 0);
2988
2989 return 0;
2990
2991fail_reg_devices:
2992 return retval;
2993}
2994
2995/* high bandwidth multiplier, as encoded in highspeed endpoint descriptors */
2996#define hb_mult(wMaxPacketSize) (1 + (((wMaxPacketSize) >> 11) & 0x03))
2997
2998/*
2999 * em28xx_usb_probe()
3000 * checks for supported devices
3001 */
3002static int em28xx_usb_probe(struct usb_interface *interface,
3003 const struct usb_device_id *id)
3004{
3005 const struct usb_endpoint_descriptor *endpoint;
3006 struct usb_device *udev;
3007 struct em28xx *dev = NULL;
3008 int retval;
3009 bool is_audio_only = false, has_audio = false;
3010 int i, nr, isoc_pipe;
3011 const int ifnum = interface->altsetting[0].desc.bInterfaceNumber;
3012 char *speed;
3013 char descr[255] = "";
3014
3015 udev = usb_get_dev(interface_to_usbdev(interface));
3016
3017 /* Check to see next free device and mark as used */
3018 nr = find_first_zero_bit(&em28xx_devused, EM28XX_MAXBOARDS);
3019 em28xx_devused |= 1<<nr;
3020
3021 /* Don't register audio interfaces */
3022 if (interface->altsetting[0].desc.bInterfaceClass == USB_CLASS_AUDIO) {
3023 em28xx_err(DRIVER_NAME " audio device (%04x:%04x): "
3024 "interface %i, class %i\n",
3025 le16_to_cpu(udev->descriptor.idVendor),
3026 le16_to_cpu(udev->descriptor.idProduct),
3027 ifnum,
3028 interface->altsetting[0].desc.bInterfaceClass);
3029
3030 em28xx_devused &= ~(1<<nr);
3031 retval = -ENODEV;
3032 goto err;
3033 }
3034
3035 /* Get endpoints */
3036 for (i = 0; i < interface->num_altsetting; i++) {
3037 int ep;
3038
3039 for (ep = 0; ep < interface->altsetting[i].desc.bNumEndpoints; ep++) {
3040 struct usb_host_endpoint *e;
3041 e = &interface->altsetting[i].endpoint[ep];
3042
3043 if (e->desc.bEndpointAddress == 0x83)
3044 has_audio = true;
3045 }
3046 }
3047
3048 endpoint = &interface->cur_altsetting->endpoint[0].desc;
3049
3050 /* check if the device has the iso in endpoint at the correct place */
3051 if (usb_endpoint_xfer_isoc(endpoint)
3052 &&
3053 (interface->altsetting[1].endpoint[0].desc.wMaxPacketSize == 940)) {
3054 /* It's a newer em2874/em2875 device */
3055 isoc_pipe = 0;
3056 } else {
3057 int check_interface = 1;
3058 isoc_pipe = 1;
3059 endpoint = &interface->cur_altsetting->endpoint[1].desc;
3060 if (!usb_endpoint_xfer_isoc(endpoint))
3061 check_interface = 0;
3062
3063 if (usb_endpoint_dir_out(endpoint))
3064 check_interface = 0;
3065
3066 if (!check_interface) {
3067 if (has_audio) {
3068 is_audio_only = true;
3069 } else {
3070 em28xx_err(DRIVER_NAME " video device (%04x:%04x): "
3071 "interface %i, class %i found.\n",
3072 le16_to_cpu(udev->descriptor.idVendor),
3073 le16_to_cpu(udev->descriptor.idProduct),
3074 ifnum,
3075 interface->altsetting[0].desc.bInterfaceClass);
3076 em28xx_err(DRIVER_NAME " This is an anciliary "
3077 "interface not used by the driver\n");
3078
3079 em28xx_devused &= ~(1<<nr);
3080 retval = -ENODEV;
3081 goto err;
3082 }
3083 }
3084 }
3085
3086 switch (udev->speed) {
3087 case USB_SPEED_LOW:
3088 speed = "1.5";
3089 break;
3090 case USB_SPEED_UNKNOWN:
3091 case USB_SPEED_FULL:
3092 speed = "12";
3093 break;
3094 case USB_SPEED_HIGH:
3095 speed = "480";
3096 break;
3097 default:
3098 speed = "unknown";
3099 }
3100
3101 if (udev->manufacturer)
3102 strlcpy(descr, udev->manufacturer, sizeof(descr));
3103
3104 if (udev->product) {
3105 if (*descr)
3106 strlcat(descr, " ", sizeof(descr));
3107 strlcat(descr, udev->product, sizeof(descr));
3108 }
3109 if (*descr)
3110 strlcat(descr, " ", sizeof(descr));
3111
3112 printk(KERN_INFO DRIVER_NAME
3113 ": New device %s@ %s Mbps (%04x:%04x, interface %d, class %d)\n",
3114 descr,
3115 speed,
3116 le16_to_cpu(udev->descriptor.idVendor),
3117 le16_to_cpu(udev->descriptor.idProduct),
3118 ifnum,
3119 interface->altsetting->desc.bInterfaceNumber);
3120
3121 if (has_audio)
3122 printk(KERN_INFO DRIVER_NAME
3123 ": Audio Vendor Class interface %i found\n",
3124 ifnum);
3125
3126 /*
3127 * Make sure we have 480 Mbps of bandwidth, otherwise things like
3128 * video stream wouldn't likely work, since 12 Mbps is generally
3129 * not enough even for most Digital TV streams.
3130 */
3131 if (udev->speed != USB_SPEED_HIGH && disable_usb_speed_check == 0) {
3132 printk(DRIVER_NAME ": Device initialization failed.\n");
3133 printk(DRIVER_NAME ": Device must be connected to a high-speed"
3134 " USB 2.0 port.\n");
3135 em28xx_devused &= ~(1<<nr);
3136 retval = -ENODEV;
3137 goto err;
3138 }
3139
3140 if (nr >= EM28XX_MAXBOARDS) {
3141 printk(DRIVER_NAME ": Supports only %i em28xx boards.\n",
3142 EM28XX_MAXBOARDS);
3143 em28xx_devused &= ~(1<<nr);
3144 retval = -ENOMEM;
3145 goto err;
3146 }
3147
3148 /* allocate memory for our device state and initialize it */
3149 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
3150 if (dev == NULL) {
3151 em28xx_err(DRIVER_NAME ": out of memory!\n");
3152 em28xx_devused &= ~(1<<nr);
3153 retval = -ENOMEM;
3154 goto err;
3155 }
3156
3157 snprintf(dev->name, 29, "em28xx #%d", nr);
3158 dev->devno = nr;
3159 dev->model = id->driver_info;
3160 dev->alt = -1;
3161 dev->is_audio_only = is_audio_only;
3162 dev->has_alsa_audio = has_audio;
3163 dev->audio_ifnum = ifnum;
3164
3165 /* Checks if audio is provided by some interface */
3166 for (i = 0; i < udev->config->desc.bNumInterfaces; i++) {
3167 struct usb_interface *uif = udev->config->interface[i];
3168 if (uif->altsetting[0].desc.bInterfaceClass == USB_CLASS_AUDIO) {
3169 dev->has_audio_class = 1;
3170 break;
3171 }
3172 }
3173
3174 /* compute alternate max packet sizes */
3175 dev->num_alt = interface->num_altsetting;
3176 dev->alt_max_pkt_size = kmalloc(32 * dev->num_alt, GFP_KERNEL);
3177
3178 if (dev->alt_max_pkt_size == NULL) {
3179 em28xx_errdev("out of memory!\n");
3180 em28xx_devused &= ~(1<<nr);
3181 kfree(dev);
3182 retval = -ENOMEM;
3183 goto err;
3184 }
3185
3186 for (i = 0; i < dev->num_alt ; i++) {
3187 u16 tmp = le16_to_cpu(interface->altsetting[i].endpoint[isoc_pipe].desc.wMaxPacketSize);
3188 unsigned int size = tmp & 0x7ff;
3189
3190 if (udev->speed == USB_SPEED_HIGH)
3191 size = size * hb_mult(tmp);
3192
3193 dev->alt_max_pkt_size[i] = size;
3194 }
3195
3196 if ((card[nr] >= 0) && (card[nr] < em28xx_bcount))
3197 dev->model = card[nr];
3198
3199 /* save our data pointer in this interface device */
3200 usb_set_intfdata(interface, dev);
3201
3202 /* allocate device struct */
3203 mutex_init(&dev->lock);
3204 mutex_lock(&dev->lock);
3205 retval = em28xx_init_dev(&dev, udev, interface, nr);
3206 if (retval) {
3207 em28xx_devused &= ~(1<<dev->devno);
3208 mutex_unlock(&dev->lock);
3209 kfree(dev);
3210 goto err;
3211 }
3212
3213 request_modules(dev);
3214
3215 /* Should be the last thing to do, to avoid newer udev's to
3216 open the device before fully initializing it
3217 */
3218 mutex_unlock(&dev->lock);
3219
3220 return 0;
3221
3222err:
3223 return retval;
3224}
3225
3226/*
3227 * em28xx_usb_disconnect()
3228 * called when the device gets diconencted
3229 * video device will be unregistered on v4l2_close in case it is still open
3230 */
3231static void em28xx_usb_disconnect(struct usb_interface *interface)
3232{
3233 struct em28xx *dev;
3234
3235 dev = usb_get_intfdata(interface);
3236 usb_set_intfdata(interface, NULL);
3237
3238 if (!dev)
3239 return;
3240
3241 if (dev->is_audio_only) {
3242 mutex_lock(&dev->lock);
3243 em28xx_close_extension(dev);
3244 mutex_unlock(&dev->lock);
3245 return;
3246 }
3247
3248 em28xx_info("disconnecting %s\n", dev->vdev->name);
3249
3250 flush_request_modules(dev);
3251
3252 /* wait until all current v4l2 io is finished then deallocate
3253 resources */
3254 mutex_lock(&dev->lock);
3255
3256 wake_up_interruptible_all(&dev->open);
3257
3258 v4l2_device_disconnect(&dev->v4l2_dev);
3259
3260 if (dev->users) {
3261 em28xx_warn
3262 ("device %s is open! Deregistration and memory "
3263 "deallocation are deferred on close.\n",
3264 video_device_node_name(dev->vdev));
3265
3266 dev->state |= DEV_MISCONFIGURED;
3267 em28xx_uninit_isoc(dev);
3268 dev->state |= DEV_DISCONNECTED;
3269 wake_up_interruptible(&dev->wait_frame);
3270 wake_up_interruptible(&dev->wait_stream);
3271 } else {
3272 dev->state |= DEV_DISCONNECTED;
3273 em28xx_release_resources(dev);
3274 }
3275
3276 em28xx_close_extension(dev);
3277
3278 mutex_unlock(&dev->lock);
3279
3280 if (!dev->users) {
3281 kfree(dev->alt_max_pkt_size);
3282 kfree(dev);
3283 }
3284}
3285
3286static struct usb_driver em28xx_usb_driver = {
3287 .name = "em28xx",
3288 .probe = em28xx_usb_probe,
3289 .disconnect = em28xx_usb_disconnect,
3290 .id_table = em28xx_id_table,
3291};
3292
3293static int __init em28xx_module_init(void)
3294{
3295 int result;
3296
3297 /* register this driver with the USB subsystem */
3298 result = usb_register(&em28xx_usb_driver);
3299 if (result)
3300 em28xx_err(DRIVER_NAME
3301 " usb_register failed. Error number %d.\n", result);
3302
3303 printk(KERN_INFO DRIVER_NAME " driver loaded\n");
3304
3305 return result;
3306}
3307
3308static void __exit em28xx_module_exit(void)
3309{
3310 /* deregister this driver with the USB subsystem */
3311 usb_deregister(&em28xx_usb_driver);
3312}
3313
3314module_init(em28xx_module_init);
3315module_exit(em28xx_module_exit);
diff --git a/drivers/media/video/em28xx/em28xx-core.c b/drivers/media/video/em28xx/em28xx-core.c
new file mode 100644
index 00000000000..57b1b5c6d88
--- /dev/null
+++ b/drivers/media/video/em28xx/em28xx-core.c
@@ -0,0 +1,1266 @@
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
36static unsigned int core_debug;
37module_param(core_debug, int, 0644);
38MODULE_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
45static unsigned int reg_debug;
46module_param(reg_debug, int, 0644);
47MODULE_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
54static int alt;
55module_param(alt, int, 0644);
56MODULE_PARM_DESC(alt, "alternate setting to use for video endpoint");
57
58static unsigned int disable_vbi;
59module_param(disable_vbi, int, 0644);
60MODULE_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 */
72int 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 */
126int 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
138int 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 */
147int 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
188int 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 */
210int em28xx_write_reg(struct em28xx *dev, u16 reg, u8 val)
211{
212 return em28xx_write_regs(dev, reg, &val, 1);
213}
214EXPORT_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 */
221int 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 */
247static 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 */
269int 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}
290EXPORT_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 */
296int 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}
318EXPORT_SYMBOL_GPL(em28xx_write_ac97);
319
320struct em28xx_vol_itable {
321 enum em28xx_amux mux;
322 u8 reg;
323};
324
325static 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
335static 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
360static 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
409struct em28xx_vol_otable {
410 enum em28xx_aout mux;
411 u8 reg;
412};
413
414static 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
422int 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}
493EXPORT_SYMBOL_GPL(em28xx_audio_analog_set);
494
495int 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) && (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
576init_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}
598EXPORT_SYMBOL_GPL(em28xx_audio_setup);
599
600int 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
618int 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
670int 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
684int 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
716static 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
728static 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
746static 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 */
771int 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
807int 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
843set_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
860int 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}
893EXPORT_SYMBOL_GPL(em28xx_gpio_set);
894
895int 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}
915EXPORT_SYMBOL_GPL(em28xx_set_mode);
916
917/* ------------------------------------------------------------------
918 URB control
919 ------------------------------------------------------------------*/
920
921/*
922 * IRQ callback, called by URB callback
923 */
924static 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 */
964void 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}
1001EXPORT_SYMBOL_GPL(em28xx_uninit_isoc);
1002
1003/*
1004 * Allocate URBs and start IRQ
1005 */
1006int 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 ? 0x82 : 0x84);
1074
1075 usb_fill_int_urb(urb, dev->udev, pipe,
1076 dev->isoc_ctl.transfer_buffer[i], sb_size,
1077 em28xx_irq_callback, dev, 1);
1078
1079 urb->number_of_packets = max_packets;
1080 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
1081
1082 k = 0;
1083 for (j = 0; j < max_packets; j++) {
1084 urb->iso_frame_desc[j].offset = k;
1085 urb->iso_frame_desc[j].length =
1086 dev->isoc_ctl.max_pkt_size;
1087 k += dev->isoc_ctl.max_pkt_size;
1088 }
1089 }
1090
1091 init_waitqueue_head(&dma_q->wq);
1092 init_waitqueue_head(&vbi_dma_q->wq);
1093
1094 em28xx_capture_start(dev, 1);
1095
1096 /* submit urbs and enables IRQ */
1097 for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
1098 rc = usb_submit_urb(dev->isoc_ctl.urb[i], GFP_ATOMIC);
1099 if (rc) {
1100 em28xx_err("submit of urb %i failed (error=%i)\n", i,
1101 rc);
1102 em28xx_uninit_isoc(dev);
1103 return rc;
1104 }
1105 }
1106
1107 return 0;
1108}
1109EXPORT_SYMBOL_GPL(em28xx_init_isoc);
1110
1111/* Determine the packet size for the DVB stream for the given device
1112 (underlying value programmed into the eeprom) */
1113int em28xx_isoc_dvb_max_packetsize(struct em28xx *dev)
1114{
1115 unsigned int chip_cfg2;
1116 unsigned int packet_size;
1117
1118 switch (dev->chip_id) {
1119 case CHIP_ID_EM2710:
1120 case CHIP_ID_EM2750:
1121 case CHIP_ID_EM2800:
1122 case CHIP_ID_EM2820:
1123 case CHIP_ID_EM2840:
1124 case CHIP_ID_EM2860:
1125 /* No DVB support */
1126 return -EINVAL;
1127 case CHIP_ID_EM2870:
1128 case CHIP_ID_EM2883:
1129 /* TS max packet size stored in bits 1-0 of R01 */
1130 chip_cfg2 = em28xx_read_reg(dev, EM28XX_R01_CHIPCFG2);
1131 switch (chip_cfg2 & EM28XX_CHIPCFG2_TS_PACKETSIZE_MASK) {
1132 case EM28XX_CHIPCFG2_TS_PACKETSIZE_188:
1133 packet_size = 188;
1134 break;
1135 case EM28XX_CHIPCFG2_TS_PACKETSIZE_376:
1136 packet_size = 376;
1137 break;
1138 case EM28XX_CHIPCFG2_TS_PACKETSIZE_564:
1139 packet_size = 564;
1140 break;
1141 case EM28XX_CHIPCFG2_TS_PACKETSIZE_752:
1142 packet_size = 752;
1143 break;
1144 }
1145 break;
1146 case CHIP_ID_EM2874:
1147 /*
1148 * FIXME: for now assumes 564 like it was before, but the
1149 * em2874 code should be added to return the proper value
1150 */
1151 packet_size = 564;
1152 break;
1153 case CHIP_ID_EM2884:
1154 case CHIP_ID_EM28174:
1155 default:
1156 /*
1157 * FIXME: same as em2874. 564 was enough for 22 Mbit DVB-T
1158 * but not enough for 44 Mbit DVB-C.
1159 */
1160 packet_size = 752;
1161 }
1162
1163 return packet_size;
1164}
1165EXPORT_SYMBOL_GPL(em28xx_isoc_dvb_max_packetsize);
1166
1167/*
1168 * em28xx_wake_i2c()
1169 * configure i2c attached devices
1170 */
1171void em28xx_wake_i2c(struct em28xx *dev)
1172{
1173 v4l2_device_call_all(&dev->v4l2_dev, 0, core, reset, 0);
1174 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_routing,
1175 INPUT(dev->ctl_input)->vmux, 0, 0);
1176 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_stream, 0);
1177}
1178
1179/*
1180 * Device control list
1181 */
1182
1183static LIST_HEAD(em28xx_devlist);
1184static DEFINE_MUTEX(em28xx_devlist_mutex);
1185
1186/*
1187 * em28xx_realease_resources()
1188 * unregisters the v4l2,i2c and usb devices
1189 * called when the device gets disconected or at module unload
1190*/
1191void em28xx_remove_from_devlist(struct em28xx *dev)
1192{
1193 mutex_lock(&em28xx_devlist_mutex);
1194 list_del(&dev->devlist);
1195 mutex_unlock(&em28xx_devlist_mutex);
1196};
1197
1198void em28xx_add_into_devlist(struct em28xx *dev)
1199{
1200 mutex_lock(&em28xx_devlist_mutex);
1201 list_add_tail(&dev->devlist, &em28xx_devlist);
1202 mutex_unlock(&em28xx_devlist_mutex);
1203};
1204
1205/*
1206 * Extension interface
1207 */
1208
1209static LIST_HEAD(em28xx_extension_devlist);
1210
1211int em28xx_register_extension(struct em28xx_ops *ops)
1212{
1213 struct em28xx *dev = NULL;
1214
1215 mutex_lock(&em28xx_devlist_mutex);
1216 list_add_tail(&ops->next, &em28xx_extension_devlist);
1217 list_for_each_entry(dev, &em28xx_devlist, devlist) {
1218 ops->init(dev);
1219 }
1220 printk(KERN_INFO "Em28xx: Initialized (%s) extension\n", ops->name);
1221 mutex_unlock(&em28xx_devlist_mutex);
1222 return 0;
1223}
1224EXPORT_SYMBOL(em28xx_register_extension);
1225
1226void em28xx_unregister_extension(struct em28xx_ops *ops)
1227{
1228 struct em28xx *dev = NULL;
1229
1230 mutex_lock(&em28xx_devlist_mutex);
1231 list_for_each_entry(dev, &em28xx_devlist, devlist) {
1232 ops->fini(dev);
1233 }
1234 printk(KERN_INFO "Em28xx: Removed (%s) extension\n", ops->name);
1235 list_del(&ops->next);
1236 mutex_unlock(&em28xx_devlist_mutex);
1237}
1238EXPORT_SYMBOL(em28xx_unregister_extension);
1239
1240void em28xx_init_extension(struct em28xx *dev)
1241{
1242 struct em28xx_ops *ops = NULL;
1243
1244 mutex_lock(&em28xx_devlist_mutex);
1245 if (!list_empty(&em28xx_extension_devlist)) {
1246 list_for_each_entry(ops, &em28xx_extension_devlist, next) {
1247 if (ops->init)
1248 ops->init(dev);
1249 }
1250 }
1251 mutex_unlock(&em28xx_devlist_mutex);
1252}
1253
1254void em28xx_close_extension(struct em28xx *dev)
1255{
1256 struct em28xx_ops *ops = NULL;
1257
1258 mutex_lock(&em28xx_devlist_mutex);
1259 if (!list_empty(&em28xx_extension_devlist)) {
1260 list_for_each_entry(ops, &em28xx_extension_devlist, next) {
1261 if (ops->fini)
1262 ops->fini(dev);
1263 }
1264 }
1265 mutex_unlock(&em28xx_devlist_mutex);
1266}
diff --git a/drivers/media/video/em28xx/em28xx-dvb.c b/drivers/media/video/em28xx/em28xx-dvb.c
new file mode 100644
index 00000000000..e5916dee409
--- /dev/null
+++ b/drivers/media/video/em28xx/em28xx-dvb.c
@@ -0,0 +1,877 @@
1/*
2 DVB device driver for em28xx
3
4 (c) 2008-2011 Mauro Carvalho Chehab <mchehab@infradead.org>
5
6 (c) 2008 Devin Heitmueller <devin.heitmueller@gmail.com>
7 - Fixes for the driver to properly work with HVR-950
8 - Fixes for the driver to properly work with Pinnacle PCTV HD Pro Stick
9 - Fixes for the driver to properly work with AMD ATI TV Wonder HD 600
10
11 (c) 2008 Aidan Thornton <makosoft@googlemail.com>
12
13 Based on cx88-dvb, saa7134-dvb and videobuf-dvb originally written by:
14 (c) 2004, 2005 Chris Pascoe <c.pascoe@itee.uq.edu.au>
15 (c) 2004 Gerd Knorr <kraxel@bytesex.org> [SuSE Labs]
16
17 This program is free software; you can redistribute it and/or modify
18 it under the terms of the GNU General Public License as published by
19 the Free Software Foundation; either version 2 of the License.
20 */
21
22#include <linux/kernel.h>
23#include <linux/slab.h>
24#include <linux/usb.h>
25
26#include "em28xx.h"
27#include <media/v4l2-common.h>
28#include <media/videobuf-vmalloc.h>
29#include <media/tuner.h>
30#include "tuner-simple.h"
31
32#include "lgdt330x.h"
33#include "lgdt3305.h"
34#include "zl10353.h"
35#include "s5h1409.h"
36#include "mt352.h"
37#include "mt352_priv.h" /* FIXME */
38#include "tda1002x.h"
39#include "tda18271.h"
40#include "s921.h"
41#include "drxd.h"
42#include "cxd2820r.h"
43#include "tda18271c2dd.h"
44#include "drxk.h"
45
46MODULE_DESCRIPTION("driver for em28xx based DVB cards");
47MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@infradead.org>");
48MODULE_LICENSE("GPL");
49
50static unsigned int debug;
51module_param(debug, int, 0644);
52MODULE_PARM_DESC(debug, "enable debug messages [dvb]");
53
54DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
55
56#define dprintk(level, fmt, arg...) do { \
57if (debug >= level) \
58 printk(KERN_DEBUG "%s/2-dvb: " fmt, dev->name, ## arg); \
59} while (0)
60
61#define EM28XX_DVB_NUM_BUFS 5
62#define EM28XX_DVB_MAX_PACKETS 64
63
64struct em28xx_dvb {
65 struct dvb_frontend *fe[2];
66
67 /* feed count management */
68 struct mutex lock;
69 int nfeeds;
70
71 /* general boilerplate stuff */
72 struct dvb_adapter adapter;
73 struct dvb_demux demux;
74 struct dmxdev dmxdev;
75 struct dmx_frontend fe_hw;
76 struct dmx_frontend fe_mem;
77 struct dvb_net net;
78
79 /* Due to DRX-K - probably need changes */
80 int (*gate_ctrl)(struct dvb_frontend *, int);
81 struct semaphore pll_mutex;
82 bool dont_attach_fe1;
83};
84
85
86static inline void print_err_status(struct em28xx *dev,
87 int packet, int status)
88{
89 char *errmsg = "Unknown";
90
91 switch (status) {
92 case -ENOENT:
93 errmsg = "unlinked synchronuously";
94 break;
95 case -ECONNRESET:
96 errmsg = "unlinked asynchronuously";
97 break;
98 case -ENOSR:
99 errmsg = "Buffer error (overrun)";
100 break;
101 case -EPIPE:
102 errmsg = "Stalled (device not responding)";
103 break;
104 case -EOVERFLOW:
105 errmsg = "Babble (bad cable?)";
106 break;
107 case -EPROTO:
108 errmsg = "Bit-stuff error (bad cable?)";
109 break;
110 case -EILSEQ:
111 errmsg = "CRC/Timeout (could be anything)";
112 break;
113 case -ETIME:
114 errmsg = "Device does not respond";
115 break;
116 }
117 if (packet < 0) {
118 dprintk(1, "URB status %d [%s].\n", status, errmsg);
119 } else {
120 dprintk(1, "URB packet %d, status %d [%s].\n",
121 packet, status, errmsg);
122 }
123}
124
125static inline int dvb_isoc_copy(struct em28xx *dev, struct urb *urb)
126{
127 int i;
128
129 if (!dev)
130 return 0;
131
132 if ((dev->state & DEV_DISCONNECTED) || (dev->state & DEV_MISCONFIGURED))
133 return 0;
134
135 if (urb->status < 0) {
136 print_err_status(dev, -1, urb->status);
137 if (urb->status == -ENOENT)
138 return 0;
139 }
140
141 for (i = 0; i < urb->number_of_packets; i++) {
142 int status = urb->iso_frame_desc[i].status;
143
144 if (status < 0) {
145 print_err_status(dev, i, status);
146 if (urb->iso_frame_desc[i].status != -EPROTO)
147 continue;
148 }
149
150 dvb_dmx_swfilter(&dev->dvb->demux, urb->transfer_buffer +
151 urb->iso_frame_desc[i].offset,
152 urb->iso_frame_desc[i].actual_length);
153 }
154
155 return 0;
156}
157
158static int start_streaming(struct em28xx_dvb *dvb)
159{
160 int rc;
161 struct em28xx *dev = dvb->adapter.priv;
162 int max_dvb_packet_size;
163
164 usb_set_interface(dev->udev, 0, 1);
165 rc = em28xx_set_mode(dev, EM28XX_DIGITAL_MODE);
166 if (rc < 0)
167 return rc;
168
169 max_dvb_packet_size = em28xx_isoc_dvb_max_packetsize(dev);
170 if (max_dvb_packet_size < 0)
171 return max_dvb_packet_size;
172 dprintk(1, "Using %d buffers each with %d bytes\n",
173 EM28XX_DVB_NUM_BUFS,
174 max_dvb_packet_size);
175
176 return em28xx_init_isoc(dev, EM28XX_DVB_MAX_PACKETS,
177 EM28XX_DVB_NUM_BUFS, max_dvb_packet_size,
178 dvb_isoc_copy);
179}
180
181static int stop_streaming(struct em28xx_dvb *dvb)
182{
183 struct em28xx *dev = dvb->adapter.priv;
184
185 em28xx_uninit_isoc(dev);
186
187 em28xx_set_mode(dev, EM28XX_SUSPEND);
188
189 return 0;
190}
191
192static int start_feed(struct dvb_demux_feed *feed)
193{
194 struct dvb_demux *demux = feed->demux;
195 struct em28xx_dvb *dvb = demux->priv;
196 int rc, ret;
197
198 if (!demux->dmx.frontend)
199 return -EINVAL;
200
201 mutex_lock(&dvb->lock);
202 dvb->nfeeds++;
203 rc = dvb->nfeeds;
204
205 if (dvb->nfeeds == 1) {
206 ret = start_streaming(dvb);
207 if (ret < 0)
208 rc = ret;
209 }
210
211 mutex_unlock(&dvb->lock);
212 return rc;
213}
214
215static int stop_feed(struct dvb_demux_feed *feed)
216{
217 struct dvb_demux *demux = feed->demux;
218 struct em28xx_dvb *dvb = demux->priv;
219 int err = 0;
220
221 mutex_lock(&dvb->lock);
222 dvb->nfeeds--;
223
224 if (0 == dvb->nfeeds)
225 err = stop_streaming(dvb);
226
227 mutex_unlock(&dvb->lock);
228 return err;
229}
230
231
232
233/* ------------------------------------------------------------------ */
234static int em28xx_dvb_bus_ctrl(struct dvb_frontend *fe, int acquire)
235{
236 struct em28xx *dev = fe->dvb->priv;
237
238 if (acquire)
239 return em28xx_set_mode(dev, EM28XX_DIGITAL_MODE);
240 else
241 return em28xx_set_mode(dev, EM28XX_SUSPEND);
242}
243
244/* ------------------------------------------------------------------ */
245
246static struct lgdt330x_config em2880_lgdt3303_dev = {
247 .demod_address = 0x0e,
248 .demod_chip = LGDT3303,
249};
250
251static struct lgdt3305_config em2870_lgdt3304_dev = {
252 .i2c_addr = 0x0e,
253 .demod_chip = LGDT3304,
254 .spectral_inversion = 1,
255 .deny_i2c_rptr = 1,
256 .mpeg_mode = LGDT3305_MPEG_PARALLEL,
257 .tpclk_edge = LGDT3305_TPCLK_FALLING_EDGE,
258 .tpvalid_polarity = LGDT3305_TP_VALID_HIGH,
259 .vsb_if_khz = 3250,
260 .qam_if_khz = 4000,
261};
262
263static struct s921_config sharp_isdbt = {
264 .demod_address = 0x30 >> 1
265};
266
267static struct zl10353_config em28xx_zl10353_with_xc3028 = {
268 .demod_address = (0x1e >> 1),
269 .no_tuner = 1,
270 .parallel_ts = 1,
271 .if2 = 45600,
272};
273
274static struct s5h1409_config em28xx_s5h1409_with_xc3028 = {
275 .demod_address = 0x32 >> 1,
276 .output_mode = S5H1409_PARALLEL_OUTPUT,
277 .gpio = S5H1409_GPIO_OFF,
278 .inversion = S5H1409_INVERSION_OFF,
279 .status_mode = S5H1409_DEMODLOCKING,
280 .mpeg_timing = S5H1409_MPEGTIMING_CONTINOUS_NONINVERTING_CLOCK
281};
282
283static struct tda18271_std_map kworld_a340_std_map = {
284 .atsc_6 = { .if_freq = 3250, .agc_mode = 3, .std = 0,
285 .if_lvl = 1, .rfagc_top = 0x37, },
286 .qam_6 = { .if_freq = 4000, .agc_mode = 3, .std = 1,
287 .if_lvl = 1, .rfagc_top = 0x37, },
288};
289
290static struct tda18271_config kworld_a340_config = {
291 .std_map = &kworld_a340_std_map,
292};
293
294static struct zl10353_config em28xx_zl10353_xc3028_no_i2c_gate = {
295 .demod_address = (0x1e >> 1),
296 .no_tuner = 1,
297 .disable_i2c_gate_ctrl = 1,
298 .parallel_ts = 1,
299 .if2 = 45600,
300};
301
302static struct drxd_config em28xx_drxd = {
303 .index = 0, .demod_address = 0x70, .demod_revision = 0xa2,
304 .demoda_address = 0x00, .pll_address = 0x00,
305 .pll_type = DRXD_PLL_NONE, .clock = 12000, .insert_rs_byte = 1,
306 .pll_set = NULL, .osc_deviation = NULL, .IF = 42800000,
307 .disable_i2c_gate_ctrl = 1,
308};
309
310struct drxk_config terratec_h5_drxk = {
311 .adr = 0x29,
312 .single_master = 1,
313 .no_i2c_bridge = 1,
314 .microcode_name = "dvb-usb-terratec-h5-drxk.fw",
315};
316
317static int drxk_gate_ctrl(struct dvb_frontend *fe, int enable)
318{
319 struct em28xx_dvb *dvb = fe->sec_priv;
320 int status;
321
322 if (!dvb)
323 return -EINVAL;
324
325 if (enable) {
326 down(&dvb->pll_mutex);
327 status = dvb->gate_ctrl(fe, 1);
328 } else {
329 status = dvb->gate_ctrl(fe, 0);
330 up(&dvb->pll_mutex);
331 }
332 return status;
333}
334
335static void terratec_h5_init(struct em28xx *dev)
336{
337 int i;
338 struct em28xx_reg_seq terratec_h5_init[] = {
339 {EM28XX_R08_GPIO, 0xff, 0xff, 10},
340 {EM2874_R80_GPIO, 0xf6, 0xff, 100},
341 {EM2874_R80_GPIO, 0xf2, 0xff, 50},
342 {EM2874_R80_GPIO, 0xf6, 0xff, 100},
343 { -1, -1, -1, -1},
344 };
345 struct em28xx_reg_seq terratec_h5_end[] = {
346 {EM2874_R80_GPIO, 0xe6, 0xff, 100},
347 {EM2874_R80_GPIO, 0xa6, 0xff, 50},
348 {EM2874_R80_GPIO, 0xe6, 0xff, 100},
349 { -1, -1, -1, -1},
350 };
351 struct {
352 unsigned char r[4];
353 int len;
354 } regs[] = {
355 {{ 0x06, 0x02, 0x00, 0x31 }, 4},
356 {{ 0x01, 0x02 }, 2},
357 {{ 0x01, 0x02, 0x00, 0xc6 }, 4},
358 {{ 0x01, 0x00 }, 2},
359 {{ 0x01, 0x00, 0xff, 0xaf }, 4},
360 {{ 0x01, 0x00, 0x03, 0xa0 }, 4},
361 {{ 0x01, 0x00 }, 2},
362 {{ 0x01, 0x00, 0x73, 0xaf }, 4},
363 {{ 0x04, 0x00 }, 2},
364 {{ 0x00, 0x04 }, 2},
365 {{ 0x00, 0x04, 0x00, 0x0a }, 4},
366 {{ 0x04, 0x14 }, 2},
367 {{ 0x04, 0x14, 0x00, 0x00 }, 4},
368 };
369
370 em28xx_gpio_set(dev, terratec_h5_init);
371 em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x40);
372 msleep(10);
373 em28xx_write_reg(dev, EM28XX_R06_I2C_CLK, 0x45);
374 msleep(10);
375
376 dev->i2c_client.addr = 0x82 >> 1;
377
378 for (i = 0; i < ARRAY_SIZE(regs); i++)
379 i2c_master_send(&dev->i2c_client, regs[i].r, regs[i].len);
380 em28xx_gpio_set(dev, terratec_h5_end);
381};
382
383static int mt352_terratec_xs_init(struct dvb_frontend *fe)
384{
385 /* Values extracted from a USB trace of the Terratec Windows driver */
386 static u8 clock_config[] = { CLOCK_CTL, 0x38, 0x2c };
387 static u8 reset[] = { RESET, 0x80 };
388 static u8 adc_ctl_1_cfg[] = { ADC_CTL_1, 0x40 };
389 static u8 agc_cfg[] = { AGC_TARGET, 0x28, 0xa0 };
390 static u8 input_freq_cfg[] = { INPUT_FREQ_1, 0x31, 0xb8 };
391 static u8 rs_err_cfg[] = { RS_ERR_PER_1, 0x00, 0x4d };
392 static u8 capt_range_cfg[] = { CAPT_RANGE, 0x32 };
393 static u8 trl_nom_cfg[] = { TRL_NOMINAL_RATE_1, 0x64, 0x00 };
394 static u8 tps_given_cfg[] = { TPS_GIVEN_1, 0x40, 0x80, 0x50 };
395 static u8 tuner_go[] = { TUNER_GO, 0x01};
396
397 mt352_write(fe, clock_config, sizeof(clock_config));
398 udelay(200);
399 mt352_write(fe, reset, sizeof(reset));
400 mt352_write(fe, adc_ctl_1_cfg, sizeof(adc_ctl_1_cfg));
401 mt352_write(fe, agc_cfg, sizeof(agc_cfg));
402 mt352_write(fe, input_freq_cfg, sizeof(input_freq_cfg));
403 mt352_write(fe, rs_err_cfg, sizeof(rs_err_cfg));
404 mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg));
405 mt352_write(fe, trl_nom_cfg, sizeof(trl_nom_cfg));
406 mt352_write(fe, tps_given_cfg, sizeof(tps_given_cfg));
407 mt352_write(fe, tuner_go, sizeof(tuner_go));
408 return 0;
409}
410
411static struct mt352_config terratec_xs_mt352_cfg = {
412 .demod_address = (0x1e >> 1),
413 .no_tuner = 1,
414 .if2 = 45600,
415 .demod_init = mt352_terratec_xs_init,
416};
417
418static struct tda10023_config em28xx_tda10023_config = {
419 .demod_address = 0x0c,
420 .invert = 1,
421};
422
423static struct cxd2820r_config em28xx_cxd2820r_config = {
424 .i2c_address = (0xd8 >> 1),
425 .ts_mode = CXD2820R_TS_SERIAL,
426 .if_dvbt_6 = 3300,
427 .if_dvbt_7 = 3500,
428 .if_dvbt_8 = 4000,
429 .if_dvbt2_6 = 3300,
430 .if_dvbt2_7 = 3500,
431 .if_dvbt2_8 = 4000,
432 .if_dvbc = 5000,
433
434 /* enable LNA for DVB-T2 and DVB-C */
435 .gpio_dvbt2[0] = CXD2820R_GPIO_E | CXD2820R_GPIO_O | CXD2820R_GPIO_L,
436 .gpio_dvbc[0] = CXD2820R_GPIO_E | CXD2820R_GPIO_O | CXD2820R_GPIO_L,
437};
438
439static struct tda18271_config em28xx_cxd2820r_tda18271_config = {
440 .output_opt = TDA18271_OUTPUT_LT_OFF,
441};
442
443/* ------------------------------------------------------------------ */
444
445static int attach_xc3028(u8 addr, struct em28xx *dev)
446{
447 struct dvb_frontend *fe;
448 struct xc2028_config cfg;
449
450 memset(&cfg, 0, sizeof(cfg));
451 cfg.i2c_adap = &dev->i2c_adap;
452 cfg.i2c_addr = addr;
453
454 if (!dev->dvb->fe[0]) {
455 em28xx_errdev("/2: dvb frontend not attached. "
456 "Can't attach xc3028\n");
457 return -EINVAL;
458 }
459
460 fe = dvb_attach(xc2028_attach, dev->dvb->fe[0], &cfg);
461 if (!fe) {
462 em28xx_errdev("/2: xc3028 attach failed\n");
463 dvb_frontend_detach(dev->dvb->fe[0]);
464 dev->dvb->fe[0] = NULL;
465 return -EINVAL;
466 }
467
468 em28xx_info("%s/2: xc3028 attached\n", dev->name);
469
470 return 0;
471}
472
473/* ------------------------------------------------------------------ */
474
475static int register_dvb(struct em28xx_dvb *dvb,
476 struct module *module,
477 struct em28xx *dev,
478 struct device *device)
479{
480 int result;
481
482 mutex_init(&dvb->lock);
483
484 /* register adapter */
485 result = dvb_register_adapter(&dvb->adapter, dev->name, module, device,
486 adapter_nr);
487 if (result < 0) {
488 printk(KERN_WARNING "%s: dvb_register_adapter failed (errno = %d)\n",
489 dev->name, result);
490 goto fail_adapter;
491 }
492
493 /* Ensure all frontends negotiate bus access */
494 dvb->fe[0]->ops.ts_bus_ctrl = em28xx_dvb_bus_ctrl;
495 if (dvb->fe[1])
496 dvb->fe[1]->ops.ts_bus_ctrl = em28xx_dvb_bus_ctrl;
497
498 dvb->adapter.priv = dev;
499
500 /* register frontend */
501 result = dvb_register_frontend(&dvb->adapter, dvb->fe[0]);
502 if (result < 0) {
503 printk(KERN_WARNING "%s: dvb_register_frontend failed (errno = %d)\n",
504 dev->name, result);
505 goto fail_frontend0;
506 }
507
508 /* register 2nd frontend */
509 if (dvb->fe[1]) {
510 result = dvb_register_frontend(&dvb->adapter, dvb->fe[1]);
511 if (result < 0) {
512 printk(KERN_WARNING "%s: 2nd dvb_register_frontend failed (errno = %d)\n",
513 dev->name, result);
514 goto fail_frontend1;
515 }
516 }
517
518 /* register demux stuff */
519 dvb->demux.dmx.capabilities =
520 DMX_TS_FILTERING | DMX_SECTION_FILTERING |
521 DMX_MEMORY_BASED_FILTERING;
522 dvb->demux.priv = dvb;
523 dvb->demux.filternum = 256;
524 dvb->demux.feednum = 256;
525 dvb->demux.start_feed = start_feed;
526 dvb->demux.stop_feed = stop_feed;
527
528 result = dvb_dmx_init(&dvb->demux);
529 if (result < 0) {
530 printk(KERN_WARNING "%s: dvb_dmx_init failed (errno = %d)\n",
531 dev->name, result);
532 goto fail_dmx;
533 }
534
535 dvb->dmxdev.filternum = 256;
536 dvb->dmxdev.demux = &dvb->demux.dmx;
537 dvb->dmxdev.capabilities = 0;
538 result = dvb_dmxdev_init(&dvb->dmxdev, &dvb->adapter);
539 if (result < 0) {
540 printk(KERN_WARNING "%s: dvb_dmxdev_init failed (errno = %d)\n",
541 dev->name, result);
542 goto fail_dmxdev;
543 }
544
545 dvb->fe_hw.source = DMX_FRONTEND_0;
546 result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_hw);
547 if (result < 0) {
548 printk(KERN_WARNING "%s: add_frontend failed (DMX_FRONTEND_0, errno = %d)\n",
549 dev->name, result);
550 goto fail_fe_hw;
551 }
552
553 dvb->fe_mem.source = DMX_MEMORY_FE;
554 result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_mem);
555 if (result < 0) {
556 printk(KERN_WARNING "%s: add_frontend failed (DMX_MEMORY_FE, errno = %d)\n",
557 dev->name, result);
558 goto fail_fe_mem;
559 }
560
561 result = dvb->demux.dmx.connect_frontend(&dvb->demux.dmx, &dvb->fe_hw);
562 if (result < 0) {
563 printk(KERN_WARNING "%s: connect_frontend failed (errno = %d)\n",
564 dev->name, result);
565 goto fail_fe_conn;
566 }
567
568 /* register network adapter */
569 dvb_net_init(&dvb->adapter, &dvb->net, &dvb->demux.dmx);
570 return 0;
571
572fail_fe_conn:
573 dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
574fail_fe_mem:
575 dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
576fail_fe_hw:
577 dvb_dmxdev_release(&dvb->dmxdev);
578fail_dmxdev:
579 dvb_dmx_release(&dvb->demux);
580fail_dmx:
581 if (dvb->fe[1])
582 dvb_unregister_frontend(dvb->fe[1]);
583 dvb_unregister_frontend(dvb->fe[0]);
584fail_frontend1:
585 if (dvb->fe[1])
586 dvb_frontend_detach(dvb->fe[1]);
587fail_frontend0:
588 dvb_frontend_detach(dvb->fe[0]);
589 dvb_unregister_adapter(&dvb->adapter);
590fail_adapter:
591 return result;
592}
593
594static void unregister_dvb(struct em28xx_dvb *dvb)
595{
596 dvb_net_release(&dvb->net);
597 dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
598 dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
599 dvb_dmxdev_release(&dvb->dmxdev);
600 dvb_dmx_release(&dvb->demux);
601 if (dvb->fe[1])
602 dvb_unregister_frontend(dvb->fe[1]);
603 dvb_unregister_frontend(dvb->fe[0]);
604 if (dvb->fe[1] && !dvb->dont_attach_fe1)
605 dvb_frontend_detach(dvb->fe[1]);
606 dvb_frontend_detach(dvb->fe[0]);
607 dvb_unregister_adapter(&dvb->adapter);
608}
609
610static int dvb_init(struct em28xx *dev)
611{
612 int result = 0;
613 struct em28xx_dvb *dvb;
614
615 if (!dev->board.has_dvb) {
616 /* This device does not support the extension */
617 printk(KERN_INFO "em28xx_dvb: This device does not support the extension\n");
618 return 0;
619 }
620
621 dvb = kzalloc(sizeof(struct em28xx_dvb), GFP_KERNEL);
622
623 if (dvb == NULL) {
624 em28xx_info("em28xx_dvb: memory allocation failed\n");
625 return -ENOMEM;
626 }
627 dev->dvb = dvb;
628 dvb->fe[0] = dvb->fe[1] = NULL;
629
630 mutex_lock(&dev->lock);
631 em28xx_set_mode(dev, EM28XX_DIGITAL_MODE);
632 /* init frontend */
633 switch (dev->model) {
634 case EM2874_BOARD_LEADERSHIP_ISDBT:
635 dvb->fe[0] = dvb_attach(s921_attach,
636 &sharp_isdbt, &dev->i2c_adap);
637
638 if (!dvb->fe[0]) {
639 result = -EINVAL;
640 goto out_free;
641 }
642
643 break;
644 case EM2883_BOARD_HAUPPAUGE_WINTV_HVR_850:
645 case EM2883_BOARD_HAUPPAUGE_WINTV_HVR_950:
646 case EM2880_BOARD_PINNACLE_PCTV_HD_PRO:
647 case EM2880_BOARD_AMD_ATI_TV_WONDER_HD_600:
648 dvb->fe[0] = dvb_attach(lgdt330x_attach,
649 &em2880_lgdt3303_dev,
650 &dev->i2c_adap);
651 if (attach_xc3028(0x61, dev) < 0) {
652 result = -EINVAL;
653 goto out_free;
654 }
655 break;
656 case EM2880_BOARD_KWORLD_DVB_310U:
657 dvb->fe[0] = dvb_attach(zl10353_attach,
658 &em28xx_zl10353_with_xc3028,
659 &dev->i2c_adap);
660 if (attach_xc3028(0x61, dev) < 0) {
661 result = -EINVAL;
662 goto out_free;
663 }
664 break;
665 case EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900:
666 case EM2882_BOARD_TERRATEC_HYBRID_XS:
667 case EM2880_BOARD_EMPIRE_DUAL_TV:
668 dvb->fe[0] = dvb_attach(zl10353_attach,
669 &em28xx_zl10353_xc3028_no_i2c_gate,
670 &dev->i2c_adap);
671 if (attach_xc3028(0x61, dev) < 0) {
672 result = -EINVAL;
673 goto out_free;
674 }
675 break;
676 case EM2880_BOARD_TERRATEC_HYBRID_XS:
677 case EM2880_BOARD_TERRATEC_HYBRID_XS_FR:
678 case EM2881_BOARD_PINNACLE_HYBRID_PRO:
679 case EM2882_BOARD_DIKOM_DK300:
680 case EM2882_BOARD_KWORLD_VS_DVBT:
681 dvb->fe[0] = dvb_attach(zl10353_attach,
682 &em28xx_zl10353_xc3028_no_i2c_gate,
683 &dev->i2c_adap);
684 if (dvb->fe[0] == NULL) {
685 /* This board could have either a zl10353 or a mt352.
686 If the chip id isn't for zl10353, try mt352 */
687 dvb->fe[0] = dvb_attach(mt352_attach,
688 &terratec_xs_mt352_cfg,
689 &dev->i2c_adap);
690 }
691
692 if (attach_xc3028(0x61, dev) < 0) {
693 result = -EINVAL;
694 goto out_free;
695 }
696 break;
697 case EM2883_BOARD_KWORLD_HYBRID_330U:
698 case EM2882_BOARD_EVGA_INDTUBE:
699 dvb->fe[0] = dvb_attach(s5h1409_attach,
700 &em28xx_s5h1409_with_xc3028,
701 &dev->i2c_adap);
702 if (attach_xc3028(0x61, dev) < 0) {
703 result = -EINVAL;
704 goto out_free;
705 }
706 break;
707 case EM2882_BOARD_KWORLD_ATSC_315U:
708 dvb->fe[0] = dvb_attach(lgdt330x_attach,
709 &em2880_lgdt3303_dev,
710 &dev->i2c_adap);
711 if (dvb->fe[0] != NULL) {
712 if (!dvb_attach(simple_tuner_attach, dvb->fe[0],
713 &dev->i2c_adap, 0x61, TUNER_THOMSON_DTT761X)) {
714 result = -EINVAL;
715 goto out_free;
716 }
717 }
718 break;
719 case EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900_R2:
720 case EM2882_BOARD_PINNACLE_HYBRID_PRO_330E:
721 dvb->fe[0] = dvb_attach(drxd_attach, &em28xx_drxd, NULL,
722 &dev->i2c_adap, &dev->udev->dev);
723 if (attach_xc3028(0x61, dev) < 0) {
724 result = -EINVAL;
725 goto out_free;
726 }
727 break;
728 case EM2870_BOARD_REDDO_DVB_C_USB_BOX:
729 /* Philips CU1216L NIM (Philips TDA10023 + Infineon TUA6034) */
730 dvb->fe[0] = dvb_attach(tda10023_attach,
731 &em28xx_tda10023_config,
732 &dev->i2c_adap, 0x48);
733 if (dvb->fe[0]) {
734 if (!dvb_attach(simple_tuner_attach, dvb->fe[0],
735 &dev->i2c_adap, 0x60, TUNER_PHILIPS_CU1216L)) {
736 result = -EINVAL;
737 goto out_free;
738 }
739 }
740 break;
741 case EM2870_BOARD_KWORLD_A340:
742 dvb->fe[0] = dvb_attach(lgdt3305_attach,
743 &em2870_lgdt3304_dev,
744 &dev->i2c_adap);
745 if (dvb->fe[0] != NULL)
746 dvb_attach(tda18271_attach, dvb->fe[0], 0x60,
747 &dev->i2c_adap, &kworld_a340_config);
748 break;
749 case EM28174_BOARD_PCTV_290E:
750 /* MFE
751 * FE 0 = DVB-T/T2 + FE 1 = DVB-C, both sharing same tuner. */
752 /* FE 0 */
753 dvb->fe[0] = dvb_attach(cxd2820r_attach,
754 &em28xx_cxd2820r_config, &dev->i2c_adap, NULL);
755 if (dvb->fe[0]) {
756 struct i2c_adapter *i2c_tuner;
757 i2c_tuner = cxd2820r_get_tuner_i2c_adapter(dvb->fe[0]);
758 /* FE 0 attach tuner */
759 if (!dvb_attach(tda18271_attach, dvb->fe[0], 0x60,
760 i2c_tuner, &em28xx_cxd2820r_tda18271_config)) {
761 dvb_frontend_detach(dvb->fe[0]);
762 result = -EINVAL;
763 goto out_free;
764 }
765 /* FE 1. This dvb_attach() cannot fail. */
766 dvb->fe[1] = dvb_attach(cxd2820r_attach, NULL, NULL,
767 dvb->fe[0]);
768 dvb->fe[1]->id = 1;
769 /* FE 1 attach tuner */
770 if (!dvb_attach(tda18271_attach, dvb->fe[1], 0x60,
771 i2c_tuner, &em28xx_cxd2820r_tda18271_config)) {
772 dvb_frontend_detach(dvb->fe[1]);
773 /* leave FE 0 still active */
774 }
775 }
776 break;
777 case EM2884_BOARD_TERRATEC_H5:
778 terratec_h5_init(dev);
779
780 dvb->dont_attach_fe1 = 1;
781
782 dvb->fe[0] = dvb_attach(drxk_attach, &terratec_h5_drxk, &dev->i2c_adap, &dvb->fe[1]);
783 if (!dvb->fe[0]) {
784 result = -EINVAL;
785 goto out_free;
786 }
787
788 /* FIXME: do we need a pll semaphore? */
789 dvb->fe[0]->sec_priv = dvb;
790 sema_init(&dvb->pll_mutex, 1);
791 dvb->gate_ctrl = dvb->fe[0]->ops.i2c_gate_ctrl;
792 dvb->fe[0]->ops.i2c_gate_ctrl = drxk_gate_ctrl;
793 dvb->fe[1]->id = 1;
794
795 /* Attach tda18271 to DVB-C frontend */
796 if (dvb->fe[0]->ops.i2c_gate_ctrl)
797 dvb->fe[0]->ops.i2c_gate_ctrl(dvb->fe[0], 1);
798 if (!dvb_attach(tda18271c2dd_attach, dvb->fe[0], &dev->i2c_adap, 0x60)) {
799 result = -EINVAL;
800 goto out_free;
801 }
802 if (dvb->fe[0]->ops.i2c_gate_ctrl)
803 dvb->fe[0]->ops.i2c_gate_ctrl(dvb->fe[0], 0);
804
805 /* Hack - needed by drxk/tda18271c2dd */
806 dvb->fe[1]->tuner_priv = dvb->fe[0]->tuner_priv;
807 memcpy(&dvb->fe[1]->ops.tuner_ops,
808 &dvb->fe[0]->ops.tuner_ops,
809 sizeof(dvb->fe[0]->ops.tuner_ops));
810
811 break;
812 default:
813 em28xx_errdev("/2: The frontend of your DVB/ATSC card"
814 " isn't supported yet\n");
815 break;
816 }
817 if (NULL == dvb->fe[0]) {
818 em28xx_errdev("/2: frontend initialization failed\n");
819 result = -EINVAL;
820 goto out_free;
821 }
822 /* define general-purpose callback pointer */
823 dvb->fe[0]->callback = em28xx_tuner_callback;
824
825 /* register everything */
826 result = register_dvb(dvb, THIS_MODULE, dev, &dev->udev->dev);
827
828 if (result < 0)
829 goto out_free;
830
831 em28xx_info("Successfully loaded em28xx-dvb\n");
832ret:
833 em28xx_set_mode(dev, EM28XX_SUSPEND);
834 mutex_unlock(&dev->lock);
835 return result;
836
837out_free:
838 kfree(dvb);
839 dev->dvb = NULL;
840 goto ret;
841}
842
843static int dvb_fini(struct em28xx *dev)
844{
845 if (!dev->board.has_dvb) {
846 /* This device does not support the extension */
847 return 0;
848 }
849
850 if (dev->dvb) {
851 unregister_dvb(dev->dvb);
852 kfree(dev->dvb);
853 dev->dvb = NULL;
854 }
855
856 return 0;
857}
858
859static struct em28xx_ops dvb_ops = {
860 .id = EM28XX_DVB,
861 .name = "Em28xx dvb Extension",
862 .init = dvb_init,
863 .fini = dvb_fini,
864};
865
866static int __init em28xx_dvb_register(void)
867{
868 return em28xx_register_extension(&dvb_ops);
869}
870
871static void __exit em28xx_dvb_unregister(void)
872{
873 em28xx_unregister_extension(&dvb_ops);
874}
875
876module_init(em28xx_dvb_register);
877module_exit(em28xx_dvb_unregister);
diff --git a/drivers/media/video/em28xx/em28xx-i2c.c b/drivers/media/video/em28xx/em28xx-i2c.c
new file mode 100644
index 00000000000..36f5a9bc8b7
--- /dev/null
+++ b/drivers/media/video/em28xx/em28xx-i2c.c
@@ -0,0 +1,578 @@
1/*
2 em28xx-i2c.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/module.h>
25#include <linux/kernel.h>
26#include <linux/usb.h>
27#include <linux/i2c.h>
28
29#include "em28xx.h"
30#include "tuner-xc2028.h"
31#include <media/v4l2-common.h>
32#include <media/tuner.h>
33
34/* ----------------------------------------------------------- */
35
36static unsigned int i2c_scan;
37module_param(i2c_scan, int, 0444);
38MODULE_PARM_DESC(i2c_scan, "scan i2c bus at insmod time");
39
40static unsigned int i2c_debug;
41module_param(i2c_debug, int, 0644);
42MODULE_PARM_DESC(i2c_debug, "enable debug messages [i2c]");
43
44
45#define dprintk1(lvl, fmt, args...) \
46do { \
47 if (i2c_debug >= lvl) { \
48 printk(fmt, ##args); \
49 } \
50} while (0)
51
52#define dprintk2(lvl, fmt, args...) \
53do { \
54 if (i2c_debug >= lvl) { \
55 printk(KERN_DEBUG "%s at %s: " fmt, \
56 dev->name, __func__ , ##args); \
57 } \
58} while (0)
59
60/*
61 * em2800_i2c_send_max4()
62 * send up to 4 bytes to the i2c device
63 */
64static int em2800_i2c_send_max4(struct em28xx *dev, unsigned char addr,
65 char *buf, int len)
66{
67 int ret;
68 int write_timeout;
69 unsigned char b2[6];
70 BUG_ON(len < 1 || len > 4);
71 b2[5] = 0x80 + len - 1;
72 b2[4] = addr;
73 b2[3] = buf[0];
74 if (len > 1)
75 b2[2] = buf[1];
76 if (len > 2)
77 b2[1] = buf[2];
78 if (len > 3)
79 b2[0] = buf[3];
80
81 ret = dev->em28xx_write_regs(dev, 4 - len, &b2[4 - len], 2 + len);
82 if (ret != 2 + len) {
83 em28xx_warn("writing to i2c device failed (error=%i)\n", ret);
84 return -EIO;
85 }
86 for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0;
87 write_timeout -= 5) {
88 ret = dev->em28xx_read_reg(dev, 0x05);
89 if (ret == 0x80 + len - 1)
90 return len;
91 msleep(5);
92 }
93 em28xx_warn("i2c write timed out\n");
94 return -EIO;
95}
96
97/*
98 * em2800_i2c_send_bytes()
99 */
100static int em2800_i2c_send_bytes(void *data, unsigned char addr, char *buf,
101 short len)
102{
103 char *bufPtr = buf;
104 int ret;
105 int wrcount = 0;
106 int count;
107 int maxLen = 4;
108 struct em28xx *dev = (struct em28xx *)data;
109 while (len > 0) {
110 count = (len > maxLen) ? maxLen : len;
111 ret = em2800_i2c_send_max4(dev, addr, bufPtr, count);
112 if (ret > 0) {
113 len -= count;
114 bufPtr += count;
115 wrcount += count;
116 } else
117 return (ret < 0) ? ret : -EFAULT;
118 }
119 return wrcount;
120}
121
122/*
123 * em2800_i2c_check_for_device()
124 * check if there is a i2c_device at the supplied address
125 */
126static int em2800_i2c_check_for_device(struct em28xx *dev, unsigned char addr)
127{
128 char msg;
129 int ret;
130 int write_timeout;
131 msg = addr;
132 ret = dev->em28xx_write_regs(dev, 0x04, &msg, 1);
133 if (ret < 0) {
134 em28xx_warn("setting i2c device address failed (error=%i)\n",
135 ret);
136 return ret;
137 }
138 msg = 0x84;
139 ret = dev->em28xx_write_regs(dev, 0x05, &msg, 1);
140 if (ret < 0) {
141 em28xx_warn("preparing i2c read failed (error=%i)\n", ret);
142 return ret;
143 }
144 for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0;
145 write_timeout -= 5) {
146 unsigned reg = dev->em28xx_read_reg(dev, 0x5);
147
148 if (reg == 0x94)
149 return -ENODEV;
150 else if (reg == 0x84)
151 return 0;
152 msleep(5);
153 }
154 return -ENODEV;
155}
156
157/*
158 * em2800_i2c_recv_bytes()
159 * read from the i2c device
160 */
161static int em2800_i2c_recv_bytes(struct em28xx *dev, unsigned char addr,
162 char *buf, int len)
163{
164 int ret;
165 /* check for the device and set i2c read address */
166 ret = em2800_i2c_check_for_device(dev, addr);
167 if (ret) {
168 em28xx_warn
169 ("preparing read at i2c address 0x%x failed (error=%i)\n",
170 addr, ret);
171 return ret;
172 }
173 ret = dev->em28xx_read_reg_req_len(dev, 0x0, 0x3, buf, len);
174 if (ret < 0) {
175 em28xx_warn("reading from i2c device at 0x%x failed (error=%i)",
176 addr, ret);
177 return ret;
178 }
179 return ret;
180}
181
182/*
183 * em28xx_i2c_send_bytes()
184 */
185static int em28xx_i2c_send_bytes(void *data, unsigned char addr, char *buf,
186 short len, int stop)
187{
188 int wrcount = 0;
189 struct em28xx *dev = (struct em28xx *)data;
190 int write_timeout, ret;
191
192 wrcount = dev->em28xx_write_regs_req(dev, stop ? 2 : 3, addr, buf, len);
193
194 /* Seems to be required after a write */
195 for (write_timeout = EM2800_I2C_WRITE_TIMEOUT; write_timeout > 0;
196 write_timeout -= 5) {
197 ret = dev->em28xx_read_reg(dev, 0x05);
198 if (!ret)
199 break;
200 msleep(5);
201 }
202
203 return wrcount;
204}
205
206/*
207 * em28xx_i2c_recv_bytes()
208 * read a byte from the i2c device
209 */
210static int em28xx_i2c_recv_bytes(struct em28xx *dev, unsigned char addr,
211 char *buf, int len)
212{
213 int ret;
214 ret = dev->em28xx_read_reg_req_len(dev, 2, addr, buf, len);
215 if (ret < 0) {
216 em28xx_warn("reading i2c device failed (error=%i)\n", ret);
217 return ret;
218 }
219 if (dev->em28xx_read_reg(dev, 0x5) != 0)
220 return -ENODEV;
221 return ret;
222}
223
224/*
225 * em28xx_i2c_check_for_device()
226 * check if there is a i2c_device at the supplied address
227 */
228static int em28xx_i2c_check_for_device(struct em28xx *dev, unsigned char addr)
229{
230 int ret;
231
232 ret = dev->em28xx_read_reg_req(dev, 2, addr);
233 if (ret < 0) {
234 em28xx_warn("reading from i2c device failed (error=%i)\n", ret);
235 return ret;
236 }
237 if (dev->em28xx_read_reg(dev, 0x5) != 0)
238 return -ENODEV;
239 return 0;
240}
241
242/*
243 * em28xx_i2c_xfer()
244 * the main i2c transfer function
245 */
246static int em28xx_i2c_xfer(struct i2c_adapter *i2c_adap,
247 struct i2c_msg msgs[], int num)
248{
249 struct em28xx *dev = i2c_adap->algo_data;
250 int addr, rc, i, byte;
251
252 if (num <= 0)
253 return 0;
254 for (i = 0; i < num; i++) {
255 addr = msgs[i].addr << 1;
256 dprintk2(2, "%s %s addr=%x len=%d:",
257 (msgs[i].flags & I2C_M_RD) ? "read" : "write",
258 i == num - 1 ? "stop" : "nonstop", addr, msgs[i].len);
259 if (!msgs[i].len) { /* no len: check only for device presence */
260 if (dev->board.is_em2800)
261 rc = em2800_i2c_check_for_device(dev, addr);
262 else
263 rc = em28xx_i2c_check_for_device(dev, addr);
264 if (rc < 0) {
265 dprintk2(2, " no device\n");
266 return rc;
267 }
268
269 } else if (msgs[i].flags & I2C_M_RD) {
270 /* read bytes */
271 if (dev->board.is_em2800)
272 rc = em2800_i2c_recv_bytes(dev, addr,
273 msgs[i].buf,
274 msgs[i].len);
275 else
276 rc = em28xx_i2c_recv_bytes(dev, addr,
277 msgs[i].buf,
278 msgs[i].len);
279 if (i2c_debug >= 2) {
280 for (byte = 0; byte < msgs[i].len; byte++)
281 printk(" %02x", msgs[i].buf[byte]);
282 }
283 } else {
284 /* write bytes */
285 if (i2c_debug >= 2) {
286 for (byte = 0; byte < msgs[i].len; byte++)
287 printk(" %02x", msgs[i].buf[byte]);
288 }
289 if (dev->board.is_em2800)
290 rc = em2800_i2c_send_bytes(dev, addr,
291 msgs[i].buf,
292 msgs[i].len);
293 else
294 rc = em28xx_i2c_send_bytes(dev, addr,
295 msgs[i].buf,
296 msgs[i].len,
297 i == num - 1);
298 }
299 if (rc < 0)
300 goto err;
301 if (i2c_debug >= 2)
302 printk("\n");
303 }
304
305 return num;
306err:
307 dprintk2(2, " ERROR: %i\n", rc);
308 return rc;
309}
310
311/* based on linux/sunrpc/svcauth.h and linux/hash.h
312 * The original hash function returns a different value, if arch is x86_64
313 * or i386.
314 */
315static inline unsigned long em28xx_hash_mem(char *buf, int length, int bits)
316{
317 unsigned long hash = 0;
318 unsigned long l = 0;
319 int len = 0;
320 unsigned char c;
321 do {
322 if (len == length) {
323 c = (char)len;
324 len = -1;
325 } else
326 c = *buf++;
327 l = (l << 8) | c;
328 len++;
329 if ((len & (32 / 8 - 1)) == 0)
330 hash = ((hash^l) * 0x9e370001UL);
331 } while (len);
332
333 return (hash >> (32 - bits)) & 0xffffffffUL;
334}
335
336static int em28xx_i2c_eeprom(struct em28xx *dev, unsigned char *eedata, int len)
337{
338 unsigned char buf, *p = eedata;
339 struct em28xx_eeprom *em_eeprom = (void *)eedata;
340 int i, err, size = len, block;
341
342 if (dev->chip_id == CHIP_ID_EM2874 ||
343 dev->chip_id == CHIP_ID_EM28174 ||
344 dev->chip_id == CHIP_ID_EM2884) {
345 /* Empia switched to a 16-bit addressable eeprom in newer
346 devices. While we could certainly write a routine to read
347 the eeprom, there is nothing of use in there that cannot be
348 accessed through registers, and there is the risk that we
349 could corrupt the eeprom (since a 16-bit read call is
350 interpreted as a write call by 8-bit eeproms).
351 */
352 return 0;
353 }
354
355 dev->i2c_client.addr = 0xa0 >> 1;
356
357 /* Check if board has eeprom */
358 err = i2c_master_recv(&dev->i2c_client, &buf, 0);
359 if (err < 0) {
360 em28xx_errdev("board has no eeprom\n");
361 memset(eedata, 0, len);
362 return -ENODEV;
363 }
364
365 buf = 0;
366
367 err = i2c_master_send(&dev->i2c_client, &buf, 1);
368 if (err != 1) {
369 printk(KERN_INFO "%s: Huh, no eeprom present (err=%d)?\n",
370 dev->name, err);
371 return err;
372 }
373 while (size > 0) {
374 if (size > 16)
375 block = 16;
376 else
377 block = size;
378
379 if (block !=
380 (err = i2c_master_recv(&dev->i2c_client, p, block))) {
381 printk(KERN_WARNING
382 "%s: i2c eeprom read error (err=%d)\n",
383 dev->name, err);
384 return err;
385 }
386 size -= block;
387 p += block;
388 }
389 for (i = 0; i < len; i++) {
390 if (0 == (i % 16))
391 printk(KERN_INFO "%s: i2c eeprom %02x:", dev->name, i);
392 printk(" %02x", eedata[i]);
393 if (15 == (i % 16))
394 printk("\n");
395 }
396
397 if (em_eeprom->id == 0x9567eb1a)
398 dev->hash = em28xx_hash_mem(eedata, len, 32);
399
400 printk(KERN_INFO "%s: EEPROM ID= 0x%08x, EEPROM hash = 0x%08lx\n",
401 dev->name, em_eeprom->id, dev->hash);
402
403 printk(KERN_INFO "%s: EEPROM info:\n", dev->name);
404
405 switch (em_eeprom->chip_conf >> 4 & 0x3) {
406 case 0:
407 printk(KERN_INFO "%s:\tNo audio on board.\n", dev->name);
408 break;
409 case 1:
410 printk(KERN_INFO "%s:\tAC97 audio (5 sample rates)\n",
411 dev->name);
412 break;
413 case 2:
414 printk(KERN_INFO "%s:\tI2S audio, sample rate=32k\n",
415 dev->name);
416 break;
417 case 3:
418 printk(KERN_INFO "%s:\tI2S audio, 3 sample rates\n",
419 dev->name);
420 break;
421 }
422
423 if (em_eeprom->chip_conf & 1 << 3)
424 printk(KERN_INFO "%s:\tUSB Remote wakeup capable\n", dev->name);
425
426 if (em_eeprom->chip_conf & 1 << 2)
427 printk(KERN_INFO "%s:\tUSB Self power capable\n", dev->name);
428
429 switch (em_eeprom->chip_conf & 0x3) {
430 case 0:
431 printk(KERN_INFO "%s:\t500mA max power\n", dev->name);
432 break;
433 case 1:
434 printk(KERN_INFO "%s:\t400mA max power\n", dev->name);
435 break;
436 case 2:
437 printk(KERN_INFO "%s:\t300mA max power\n", dev->name);
438 break;
439 case 3:
440 printk(KERN_INFO "%s:\t200mA max power\n", dev->name);
441 break;
442 }
443 printk(KERN_INFO "%s:\tTable at 0x%02x, strings=0x%04x, 0x%04x, 0x%04x\n",
444 dev->name,
445 em_eeprom->string_idx_table,
446 em_eeprom->string1,
447 em_eeprom->string2,
448 em_eeprom->string3);
449
450 return 0;
451}
452
453/* ----------------------------------------------------------- */
454
455/*
456 * functionality()
457 */
458static u32 functionality(struct i2c_adapter *adap)
459{
460 return I2C_FUNC_SMBUS_EMUL;
461}
462
463static struct i2c_algorithm em28xx_algo = {
464 .master_xfer = em28xx_i2c_xfer,
465 .functionality = functionality,
466};
467
468static struct i2c_adapter em28xx_adap_template = {
469 .owner = THIS_MODULE,
470 .name = "em28xx",
471 .algo = &em28xx_algo,
472};
473
474static struct i2c_client em28xx_client_template = {
475 .name = "em28xx internal",
476};
477
478/* ----------------------------------------------------------- */
479
480/*
481 * i2c_devs
482 * incomplete list of known devices
483 */
484static char *i2c_devs[128] = {
485 [0x4a >> 1] = "saa7113h",
486 [0x60 >> 1] = "remote IR sensor",
487 [0x8e >> 1] = "remote IR sensor",
488 [0x86 >> 1] = "tda9887",
489 [0x80 >> 1] = "msp34xx",
490 [0x88 >> 1] = "msp34xx",
491 [0xa0 >> 1] = "eeprom",
492 [0xb0 >> 1] = "tda9874",
493 [0xb8 >> 1] = "tvp5150a",
494 [0xba >> 1] = "webcam sensor or tvp5150a",
495 [0xc0 >> 1] = "tuner (analog)",
496 [0xc2 >> 1] = "tuner (analog)",
497 [0xc4 >> 1] = "tuner (analog)",
498 [0xc6 >> 1] = "tuner (analog)",
499};
500
501/*
502 * do_i2c_scan()
503 * check i2c address range for devices
504 */
505void em28xx_do_i2c_scan(struct em28xx *dev)
506{
507 u8 i2c_devicelist[128];
508 unsigned char buf;
509 int i, rc;
510
511 memset(i2c_devicelist, 0, ARRAY_SIZE(i2c_devicelist));
512
513 for (i = 0; i < ARRAY_SIZE(i2c_devs); i++) {
514 dev->i2c_client.addr = i;
515 rc = i2c_master_recv(&dev->i2c_client, &buf, 0);
516 if (rc < 0)
517 continue;
518 i2c_devicelist[i] = i;
519 printk(KERN_INFO "%s: found i2c device @ 0x%x [%s]\n",
520 dev->name, i << 1, i2c_devs[i] ? i2c_devs[i] : "???");
521 }
522
523 dev->i2c_hash = em28xx_hash_mem(i2c_devicelist,
524 ARRAY_SIZE(i2c_devicelist), 32);
525}
526
527/*
528 * em28xx_i2c_register()
529 * register i2c bus
530 */
531int em28xx_i2c_register(struct em28xx *dev)
532{
533 int retval;
534
535 BUG_ON(!dev->em28xx_write_regs || !dev->em28xx_read_reg);
536 BUG_ON(!dev->em28xx_write_regs_req || !dev->em28xx_read_reg_req);
537 dev->i2c_adap = em28xx_adap_template;
538 dev->i2c_adap.dev.parent = &dev->udev->dev;
539 strcpy(dev->i2c_adap.name, dev->name);
540 dev->i2c_adap.algo_data = dev;
541 i2c_set_adapdata(&dev->i2c_adap, &dev->v4l2_dev);
542
543 retval = i2c_add_adapter(&dev->i2c_adap);
544 if (retval < 0) {
545 em28xx_errdev("%s: i2c_add_adapter failed! retval [%d]\n",
546 __func__, retval);
547 return retval;
548 }
549
550 dev->i2c_client = em28xx_client_template;
551 dev->i2c_client.adapter = &dev->i2c_adap;
552
553 retval = em28xx_i2c_eeprom(dev, dev->eedata, sizeof(dev->eedata));
554 if ((retval < 0) && (retval != -ENODEV)) {
555 em28xx_errdev("%s: em28xx_i2_eeprom failed! retval [%d]\n",
556 __func__, retval);
557
558 return retval;
559 }
560
561 if (i2c_scan)
562 em28xx_do_i2c_scan(dev);
563
564 /* Instantiate the IR receiver device, if present */
565 em28xx_register_i2c_ir(dev);
566
567 return 0;
568}
569
570/*
571 * em28xx_i2c_unregister()
572 * unregister i2c_bus
573 */
574int em28xx_i2c_unregister(struct em28xx *dev)
575{
576 i2c_del_adapter(&dev->i2c_adap);
577 return 0;
578}
diff --git a/drivers/media/video/em28xx/em28xx-input.c b/drivers/media/video/em28xx/em28xx-input.c
new file mode 100644
index 00000000000..5d12b14282e
--- /dev/null
+++ b/drivers/media/video/em28xx/em28xx-input.c
@@ -0,0 +1,560 @@
1/*
2 handle em28xx IR remotes via linux kernel input layer.
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 */
23
24#include <linux/module.h>
25#include <linux/init.h>
26#include <linux/delay.h>
27#include <linux/interrupt.h>
28#include <linux/usb.h>
29#include <linux/slab.h>
30
31#include "em28xx.h"
32
33#define EM28XX_SNAPSHOT_KEY KEY_CAMERA
34#define EM28XX_SBUTTON_QUERY_INTERVAL 500
35#define EM28XX_R0C_USBSUSP_SNAPSHOT 0x20
36
37static unsigned int ir_debug;
38module_param(ir_debug, int, 0644);
39MODULE_PARM_DESC(ir_debug, "enable debug messages [IR]");
40
41#define MODULE_NAME "em28xx"
42
43#define i2cdprintk(fmt, arg...) \
44 if (ir_debug) { \
45 printk(KERN_DEBUG "%s/ir: " fmt, ir->name , ## arg); \
46 }
47
48#define dprintk(fmt, arg...) \
49 if (ir_debug) { \
50 printk(KERN_DEBUG "%s/ir: " fmt, ir->name , ## arg); \
51 }
52
53/**********************************************************
54 Polling structure used by em28xx IR's
55 **********************************************************/
56
57struct em28xx_ir_poll_result {
58 unsigned int toggle_bit:1;
59 unsigned int read_count:7;
60 u8 rc_address;
61 u8 rc_data[4]; /* 1 byte on em2860/2880, 4 on em2874 */
62};
63
64struct em28xx_IR {
65 struct em28xx *dev;
66 struct rc_dev *rc;
67 char name[32];
68 char phys[32];
69
70 /* poll external decoder */
71 int polling;
72 struct delayed_work work;
73 unsigned int full_code:1;
74 unsigned int last_readcount;
75
76 int (*get_key)(struct em28xx_IR *, struct em28xx_ir_poll_result *);
77};
78
79/**********************************************************
80 I2C IR based get keycodes - should be used with ir-kbd-i2c
81 **********************************************************/
82
83int em28xx_get_key_terratec(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
84{
85 unsigned char b;
86
87 /* poll IR chip */
88 if (1 != i2c_master_recv(ir->c, &b, 1)) {
89 i2cdprintk("read error\n");
90 return -EIO;
91 }
92
93 /* it seems that 0xFE indicates that a button is still hold
94 down, while 0xff indicates that no button is hold
95 down. 0xfe sequences are sometimes interrupted by 0xFF */
96
97 i2cdprintk("key %02x\n", b);
98
99 if (b == 0xff)
100 return 0;
101
102 if (b == 0xfe)
103 /* keep old data */
104 return 1;
105
106 *ir_key = b;
107 *ir_raw = b;
108 return 1;
109}
110
111int em28xx_get_key_em_haup(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
112{
113 unsigned char buf[2];
114 u16 code;
115 int size;
116
117 /* poll IR chip */
118 size = i2c_master_recv(ir->c, buf, sizeof(buf));
119
120 if (size != 2)
121 return -EIO;
122
123 /* Does eliminate repeated parity code */
124 if (buf[1] == 0xff)
125 return 0;
126
127 ir->old = buf[1];
128
129 /*
130 * Rearranges bits to the right order.
131 * The bit order were determined experimentally by using
132 * The original Hauppauge Grey IR and another RC5 that uses addr=0x08
133 * The RC5 code has 14 bits, but we've experimentally determined
134 * the meaning for only 11 bits.
135 * So, the code translation is not complete. Yet, it is enough to
136 * work with the provided RC5 IR.
137 */
138 code =
139 ((buf[0] & 0x01) ? 0x0020 : 0) | /* 0010 0000 */
140 ((buf[0] & 0x02) ? 0x0010 : 0) | /* 0001 0000 */
141 ((buf[0] & 0x04) ? 0x0008 : 0) | /* 0000 1000 */
142 ((buf[0] & 0x08) ? 0x0004 : 0) | /* 0000 0100 */
143 ((buf[0] & 0x10) ? 0x0002 : 0) | /* 0000 0010 */
144 ((buf[0] & 0x20) ? 0x0001 : 0) | /* 0000 0001 */
145 ((buf[1] & 0x08) ? 0x1000 : 0) | /* 0001 0000 */
146 ((buf[1] & 0x10) ? 0x0800 : 0) | /* 0000 1000 */
147 ((buf[1] & 0x20) ? 0x0400 : 0) | /* 0000 0100 */
148 ((buf[1] & 0x40) ? 0x0200 : 0) | /* 0000 0010 */
149 ((buf[1] & 0x80) ? 0x0100 : 0); /* 0000 0001 */
150
151 i2cdprintk("ir hauppauge (em2840): code=0x%02x (rcv=0x%02x%02x)\n",
152 code, buf[1], buf[0]);
153
154 /* return key */
155 *ir_key = code;
156 *ir_raw = code;
157 return 1;
158}
159
160int em28xx_get_key_pinnacle_usb_grey(struct IR_i2c *ir, u32 *ir_key,
161 u32 *ir_raw)
162{
163 unsigned char buf[3];
164
165 /* poll IR chip */
166
167 if (3 != i2c_master_recv(ir->c, buf, 3)) {
168 i2cdprintk("read error\n");
169 return -EIO;
170 }
171
172 i2cdprintk("key %02x\n", buf[2]&0x3f);
173 if (buf[0] != 0x00)
174 return 0;
175
176 *ir_key = buf[2]&0x3f;
177 *ir_raw = buf[2]&0x3f;
178
179 return 1;
180}
181
182int em28xx_get_key_winfast_usbii_deluxe(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw)
183{
184 unsigned char subaddr, keydetect, key;
185
186 struct i2c_msg msg[] = { { .addr = ir->c->addr, .flags = 0, .buf = &subaddr, .len = 1},
187
188 { .addr = ir->c->addr, .flags = I2C_M_RD, .buf = &keydetect, .len = 1} };
189
190 subaddr = 0x10;
191 if (2 != i2c_transfer(ir->c->adapter, msg, 2)) {
192 i2cdprintk("read error\n");
193 return -EIO;
194 }
195 if (keydetect == 0x00)
196 return 0;
197
198 subaddr = 0x00;
199 msg[1].buf = &key;
200 if (2 != i2c_transfer(ir->c->adapter, msg, 2)) {
201 i2cdprintk("read error\n");
202 return -EIO;
203 }
204 if (key == 0x00)
205 return 0;
206
207 *ir_key = key;
208 *ir_raw = key;
209 return 1;
210}
211
212/**********************************************************
213 Poll based get keycode functions
214 **********************************************************/
215
216/* This is for the em2860/em2880 */
217static int default_polling_getkey(struct em28xx_IR *ir,
218 struct em28xx_ir_poll_result *poll_result)
219{
220 struct em28xx *dev = ir->dev;
221 int rc;
222 u8 msg[3] = { 0, 0, 0 };
223
224 /* Read key toggle, brand, and key code
225 on registers 0x45, 0x46 and 0x47
226 */
227 rc = dev->em28xx_read_reg_req_len(dev, 0, EM28XX_R45_IR,
228 msg, sizeof(msg));
229 if (rc < 0)
230 return rc;
231
232 /* Infrared toggle (Reg 0x45[7]) */
233 poll_result->toggle_bit = (msg[0] >> 7);
234
235 /* Infrared read count (Reg 0x45[6:0] */
236 poll_result->read_count = (msg[0] & 0x7f);
237
238 /* Remote Control Address (Reg 0x46) */
239 poll_result->rc_address = msg[1];
240
241 /* Remote Control Data (Reg 0x47) */
242 poll_result->rc_data[0] = msg[2];
243
244 return 0;
245}
246
247static int em2874_polling_getkey(struct em28xx_IR *ir,
248 struct em28xx_ir_poll_result *poll_result)
249{
250 struct em28xx *dev = ir->dev;
251 int rc;
252 u8 msg[5] = { 0, 0, 0, 0, 0 };
253
254 /* Read key toggle, brand, and key code
255 on registers 0x51-55
256 */
257 rc = dev->em28xx_read_reg_req_len(dev, 0, EM2874_R51_IR,
258 msg, sizeof(msg));
259 if (rc < 0)
260 return rc;
261
262 /* Infrared toggle (Reg 0x51[7]) */
263 poll_result->toggle_bit = (msg[0] >> 7);
264
265 /* Infrared read count (Reg 0x51[6:0] */
266 poll_result->read_count = (msg[0] & 0x7f);
267
268 /* Remote Control Address (Reg 0x52) */
269 poll_result->rc_address = msg[1];
270
271 /* Remote Control Data (Reg 0x53-55) */
272 poll_result->rc_data[0] = msg[2];
273 poll_result->rc_data[1] = msg[3];
274 poll_result->rc_data[2] = msg[4];
275
276 return 0;
277}
278
279/**********************************************************
280 Polling code for em28xx
281 **********************************************************/
282
283static void em28xx_ir_handle_key(struct em28xx_IR *ir)
284{
285 int result;
286 struct em28xx_ir_poll_result poll_result;
287
288 /* read the registers containing the IR status */
289 result = ir->get_key(ir, &poll_result);
290 if (unlikely(result < 0)) {
291 dprintk("ir->get_key() failed %d\n", result);
292 return;
293 }
294
295 if (unlikely(poll_result.read_count != ir->last_readcount)) {
296 dprintk("%s: toggle: %d, count: %d, key 0x%02x%02x\n", __func__,
297 poll_result.toggle_bit, poll_result.read_count,
298 poll_result.rc_address, poll_result.rc_data[0]);
299 if (ir->full_code)
300 rc_keydown(ir->rc,
301 poll_result.rc_address << 8 |
302 poll_result.rc_data[0],
303 poll_result.toggle_bit);
304 else
305 rc_keydown(ir->rc,
306 poll_result.rc_data[0],
307 poll_result.toggle_bit);
308
309 if (ir->dev->chip_id == CHIP_ID_EM2874)
310 /* The em2874 clears the readcount field every time the
311 register is read. The em2860/2880 datasheet says that it
312 is supposed to clear the readcount, but it doesn't. So with
313 the em2874, we are looking for a non-zero read count as
314 opposed to a readcount that is incrementing */
315 ir->last_readcount = 0;
316 else
317 ir->last_readcount = poll_result.read_count;
318 }
319}
320
321static void em28xx_ir_work(struct work_struct *work)
322{
323 struct em28xx_IR *ir = container_of(work, struct em28xx_IR, work.work);
324
325 em28xx_ir_handle_key(ir);
326 schedule_delayed_work(&ir->work, msecs_to_jiffies(ir->polling));
327}
328
329static int em28xx_ir_start(struct rc_dev *rc)
330{
331 struct em28xx_IR *ir = rc->priv;
332
333 INIT_DELAYED_WORK(&ir->work, em28xx_ir_work);
334 schedule_delayed_work(&ir->work, 0);
335
336 return 0;
337}
338
339static void em28xx_ir_stop(struct rc_dev *rc)
340{
341 struct em28xx_IR *ir = rc->priv;
342
343 cancel_delayed_work_sync(&ir->work);
344}
345
346int em28xx_ir_change_protocol(struct rc_dev *rc_dev, u64 rc_type)
347{
348 int rc = 0;
349 struct em28xx_IR *ir = rc_dev->priv;
350 struct em28xx *dev = ir->dev;
351 u8 ir_config = EM2874_IR_RC5;
352
353 /* Adjust xclk based o IR table for RC5/NEC tables */
354
355 if (rc_type == RC_TYPE_RC5) {
356 dev->board.xclk |= EM28XX_XCLK_IR_RC5_MODE;
357 ir->full_code = 1;
358 } else if (rc_type == RC_TYPE_NEC) {
359 dev->board.xclk &= ~EM28XX_XCLK_IR_RC5_MODE;
360 ir_config = EM2874_IR_NEC;
361 ir->full_code = 1;
362 } else if (rc_type != RC_TYPE_UNKNOWN)
363 rc = -EINVAL;
364
365 em28xx_write_reg_bits(dev, EM28XX_R0F_XCLK, dev->board.xclk,
366 EM28XX_XCLK_IR_RC5_MODE);
367
368 /* Setup the proper handler based on the chip */
369 switch (dev->chip_id) {
370 case CHIP_ID_EM2860:
371 case CHIP_ID_EM2883:
372 ir->get_key = default_polling_getkey;
373 break;
374 case CHIP_ID_EM2874:
375 case CHIP_ID_EM28174:
376 ir->get_key = em2874_polling_getkey;
377 em28xx_write_regs(dev, EM2874_R50_IR_CONFIG, &ir_config, 1);
378 break;
379 default:
380 printk("Unrecognized em28xx chip id: IR not supported\n");
381 rc = -EINVAL;
382 }
383
384 return rc;
385}
386
387int em28xx_ir_init(struct em28xx *dev)
388{
389 struct em28xx_IR *ir;
390 struct rc_dev *rc;
391 int err = -ENOMEM;
392
393 if (dev->board.ir_codes == NULL) {
394 /* No remote control support */
395 return 0;
396 }
397
398 ir = kzalloc(sizeof(*ir), GFP_KERNEL);
399 rc = rc_allocate_device();
400 if (!ir || !rc)
401 goto err_out_free;
402
403 /* record handles to ourself */
404 ir->dev = dev;
405 dev->ir = ir;
406 ir->rc = rc;
407
408 /*
409 * em2874 supports more protocols. For now, let's just announce
410 * the two protocols that were already tested
411 */
412 rc->allowed_protos = RC_TYPE_RC5 | RC_TYPE_NEC;
413 rc->priv = ir;
414 rc->change_protocol = em28xx_ir_change_protocol;
415 rc->open = em28xx_ir_start;
416 rc->close = em28xx_ir_stop;
417
418 /* By default, keep protocol field untouched */
419 err = em28xx_ir_change_protocol(rc, RC_TYPE_UNKNOWN);
420 if (err)
421 goto err_out_free;
422
423 /* This is how often we ask the chip for IR information */
424 ir->polling = 100; /* ms */
425
426 /* init input device */
427 snprintf(ir->name, sizeof(ir->name), "em28xx IR (%s)",
428 dev->name);
429
430 usb_make_path(dev->udev, ir->phys, sizeof(ir->phys));
431 strlcat(ir->phys, "/input0", sizeof(ir->phys));
432
433 rc->input_name = ir->name;
434 rc->input_phys = ir->phys;
435 rc->input_id.bustype = BUS_USB;
436 rc->input_id.version = 1;
437 rc->input_id.vendor = le16_to_cpu(dev->udev->descriptor.idVendor);
438 rc->input_id.product = le16_to_cpu(dev->udev->descriptor.idProduct);
439 rc->dev.parent = &dev->udev->dev;
440 rc->map_name = dev->board.ir_codes;
441 rc->driver_name = MODULE_NAME;
442
443 /* all done */
444 err = rc_register_device(rc);
445 if (err)
446 goto err_out_stop;
447
448 return 0;
449
450 err_out_stop:
451 dev->ir = NULL;
452 err_out_free:
453 rc_free_device(rc);
454 kfree(ir);
455 return err;
456}
457
458int em28xx_ir_fini(struct em28xx *dev)
459{
460 struct em28xx_IR *ir = dev->ir;
461
462 /* skip detach on non attached boards */
463 if (!ir)
464 return 0;
465
466 em28xx_ir_stop(ir->rc);
467 rc_unregister_device(ir->rc);
468 kfree(ir);
469
470 /* done */
471 dev->ir = NULL;
472 return 0;
473}
474
475/**********************************************************
476 Handle Webcam snapshot button
477 **********************************************************/
478
479static void em28xx_query_sbutton(struct work_struct *work)
480{
481 /* Poll the register and see if the button is depressed */
482 struct em28xx *dev =
483 container_of(work, struct em28xx, sbutton_query_work.work);
484 int ret;
485
486 ret = em28xx_read_reg(dev, EM28XX_R0C_USBSUSP);
487
488 if (ret & EM28XX_R0C_USBSUSP_SNAPSHOT) {
489 u8 cleared;
490 /* Button is depressed, clear the register */
491 cleared = ((u8) ret) & ~EM28XX_R0C_USBSUSP_SNAPSHOT;
492 em28xx_write_regs(dev, EM28XX_R0C_USBSUSP, &cleared, 1);
493
494 /* Not emulate the keypress */
495 input_report_key(dev->sbutton_input_dev, EM28XX_SNAPSHOT_KEY,
496 1);
497 /* Now unpress the key */
498 input_report_key(dev->sbutton_input_dev, EM28XX_SNAPSHOT_KEY,
499 0);
500 }
501
502 /* Schedule next poll */
503 schedule_delayed_work(&dev->sbutton_query_work,
504 msecs_to_jiffies(EM28XX_SBUTTON_QUERY_INTERVAL));
505}
506
507void em28xx_register_snapshot_button(struct em28xx *dev)
508{
509 struct input_dev *input_dev;
510 int err;
511
512 em28xx_info("Registering snapshot button...\n");
513 input_dev = input_allocate_device();
514 if (!input_dev) {
515 em28xx_errdev("input_allocate_device failed\n");
516 return;
517 }
518
519 usb_make_path(dev->udev, dev->snapshot_button_path,
520 sizeof(dev->snapshot_button_path));
521 strlcat(dev->snapshot_button_path, "/sbutton",
522 sizeof(dev->snapshot_button_path));
523 INIT_DELAYED_WORK(&dev->sbutton_query_work, em28xx_query_sbutton);
524
525 input_dev->name = "em28xx snapshot button";
526 input_dev->phys = dev->snapshot_button_path;
527 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP);
528 set_bit(EM28XX_SNAPSHOT_KEY, input_dev->keybit);
529 input_dev->keycodesize = 0;
530 input_dev->keycodemax = 0;
531 input_dev->id.bustype = BUS_USB;
532 input_dev->id.vendor = le16_to_cpu(dev->udev->descriptor.idVendor);
533 input_dev->id.product = le16_to_cpu(dev->udev->descriptor.idProduct);
534 input_dev->id.version = 1;
535 input_dev->dev.parent = &dev->udev->dev;
536
537 err = input_register_device(input_dev);
538 if (err) {
539 em28xx_errdev("input_register_device failed\n");
540 input_free_device(input_dev);
541 return;
542 }
543
544 dev->sbutton_input_dev = input_dev;
545 schedule_delayed_work(&dev->sbutton_query_work,
546 msecs_to_jiffies(EM28XX_SBUTTON_QUERY_INTERVAL));
547 return;
548
549}
550
551void em28xx_deregister_snapshot_button(struct em28xx *dev)
552{
553 if (dev->sbutton_input_dev != NULL) {
554 em28xx_info("Deregistering snapshot button\n");
555 cancel_delayed_work_sync(&dev->sbutton_query_work);
556 input_unregister_device(dev->sbutton_input_dev);
557 dev->sbutton_input_dev = NULL;
558 }
559 return;
560}
diff --git a/drivers/media/video/em28xx/em28xx-reg.h b/drivers/media/video/em28xx/em28xx-reg.h
new file mode 100644
index 00000000000..66f792361b9
--- /dev/null
+++ b/drivers/media/video/em28xx/em28xx-reg.h
@@ -0,0 +1,270 @@
1#define EM_GPIO_0 (1 << 0)
2#define EM_GPIO_1 (1 << 1)
3#define EM_GPIO_2 (1 << 2)
4#define EM_GPIO_3 (1 << 3)
5#define EM_GPIO_4 (1 << 4)
6#define EM_GPIO_5 (1 << 5)
7#define EM_GPIO_6 (1 << 6)
8#define EM_GPIO_7 (1 << 7)
9
10#define EM_GPO_0 (1 << 0)
11#define EM_GPO_1 (1 << 1)
12#define EM_GPO_2 (1 << 2)
13#define EM_GPO_3 (1 << 3)
14
15/* em2800 registers */
16#define EM2800_R08_AUDIOSRC 0x08
17
18/* em28xx registers */
19
20#define EM28XX_R00_CHIPCFG 0x00
21
22/* em28xx Chip Configuration 0x00 */
23#define EM28XX_CHIPCFG_VENDOR_AUDIO 0x80
24#define EM28XX_CHIPCFG_I2S_VOLUME_CAPABLE 0x40
25#define EM28XX_CHIPCFG_I2S_5_SAMPRATES 0x30
26#define EM28XX_CHIPCFG_I2S_3_SAMPRATES 0x20
27#define EM28XX_CHIPCFG_AC97 0x10
28#define EM28XX_CHIPCFG_AUDIOMASK 0x30
29
30#define EM28XX_R01_CHIPCFG2 0x01
31
32/* em28xx Chip Configuration 2 0x01 */
33#define EM28XX_CHIPCFG2_TS_PRESENT 0x10
34#define EM28XX_CHIPCFG2_TS_REQ_INTERVAL_MASK 0x0c /* bits 3-2 */
35#define EM28XX_CHIPCFG2_TS_REQ_INTERVAL_1MF 0x00
36#define EM28XX_CHIPCFG2_TS_REQ_INTERVAL_2MF 0x04
37#define EM28XX_CHIPCFG2_TS_REQ_INTERVAL_4MF 0x08
38#define EM28XX_CHIPCFG2_TS_REQ_INTERVAL_8MF 0x0c
39#define EM28XX_CHIPCFG2_TS_PACKETSIZE_MASK 0x03 /* bits 0-1 */
40#define EM28XX_CHIPCFG2_TS_PACKETSIZE_188 0x00
41#define EM28XX_CHIPCFG2_TS_PACKETSIZE_376 0x01
42#define EM28XX_CHIPCFG2_TS_PACKETSIZE_564 0x02
43#define EM28XX_CHIPCFG2_TS_PACKETSIZE_752 0x03
44
45
46 /* GPIO/GPO registers */
47#define EM2880_R04_GPO 0x04 /* em2880-em2883 only */
48#define EM28XX_R08_GPIO 0x08 /* em2820 or upper */
49
50#define EM28XX_R06_I2C_CLK 0x06
51
52/* em28xx I2C Clock Register (0x06) */
53#define EM28XX_I2C_CLK_ACK_LAST_READ 0x80
54#define EM28XX_I2C_CLK_WAIT_ENABLE 0x40
55#define EM28XX_I2C_EEPROM_ON_BOARD 0x08
56#define EM28XX_I2C_EEPROM_KEY_VALID 0x04
57#define EM2874_I2C_SECONDARY_BUS_SELECT 0x04 /* em2874 has two i2c busses */
58#define EM28XX_I2C_FREQ_1_5_MHZ 0x03 /* bus frequency (bits [1-0]) */
59#define EM28XX_I2C_FREQ_25_KHZ 0x02
60#define EM28XX_I2C_FREQ_400_KHZ 0x01
61#define EM28XX_I2C_FREQ_100_KHZ 0x00
62
63
64#define EM28XX_R0A_CHIPID 0x0a
65#define EM28XX_R0C_USBSUSP 0x0c /* */
66
67#define EM28XX_R0E_AUDIOSRC 0x0e
68#define EM28XX_R0F_XCLK 0x0f
69
70/* em28xx XCLK Register (0x0f) */
71#define EM28XX_XCLK_AUDIO_UNMUTE 0x80 /* otherwise audio muted */
72#define EM28XX_XCLK_I2S_MSB_TIMING 0x40 /* otherwise standard timing */
73#define EM28XX_XCLK_IR_RC5_MODE 0x20 /* otherwise NEC mode */
74#define EM28XX_XCLK_IR_NEC_CHK_PARITY 0x10
75#define EM28XX_XCLK_FREQUENCY_30MHZ 0x00 /* Freq. select (bits [3-0]) */
76#define EM28XX_XCLK_FREQUENCY_15MHZ 0x01
77#define EM28XX_XCLK_FREQUENCY_10MHZ 0x02
78#define EM28XX_XCLK_FREQUENCY_7_5MHZ 0x03
79#define EM28XX_XCLK_FREQUENCY_6MHZ 0x04
80#define EM28XX_XCLK_FREQUENCY_5MHZ 0x05
81#define EM28XX_XCLK_FREQUENCY_4_3MHZ 0x06
82#define EM28XX_XCLK_FREQUENCY_12MHZ 0x07
83#define EM28XX_XCLK_FREQUENCY_20MHZ 0x08
84#define EM28XX_XCLK_FREQUENCY_20MHZ_2 0x09
85#define EM28XX_XCLK_FREQUENCY_48MHZ 0x0a
86#define EM28XX_XCLK_FREQUENCY_24MHZ 0x0b
87
88#define EM28XX_R10_VINMODE 0x10
89
90#define EM28XX_R11_VINCTRL 0x11
91
92/* em28xx Video Input Control Register 0x11 */
93#define EM28XX_VINCTRL_VBI_SLICED 0x80
94#define EM28XX_VINCTRL_VBI_RAW 0x40
95#define EM28XX_VINCTRL_VOUT_MODE_IN 0x20 /* HREF,VREF,VACT in output */
96#define EM28XX_VINCTRL_CCIR656_ENABLE 0x10
97#define EM28XX_VINCTRL_VBI_16BIT_RAW 0x08 /* otherwise 8-bit raw */
98#define EM28XX_VINCTRL_FID_ON_HREF 0x04
99#define EM28XX_VINCTRL_DUAL_EDGE_STROBE 0x02
100#define EM28XX_VINCTRL_INTERLACED 0x01
101
102#define EM28XX_R12_VINENABLE 0x12 /* */
103
104#define EM28XX_R14_GAMMA 0x14
105#define EM28XX_R15_RGAIN 0x15
106#define EM28XX_R16_GGAIN 0x16
107#define EM28XX_R17_BGAIN 0x17
108#define EM28XX_R18_ROFFSET 0x18
109#define EM28XX_R19_GOFFSET 0x19
110#define EM28XX_R1A_BOFFSET 0x1a
111
112#define EM28XX_R1B_OFLOW 0x1b
113#define EM28XX_R1C_HSTART 0x1c
114#define EM28XX_R1D_VSTART 0x1d
115#define EM28XX_R1E_CWIDTH 0x1e
116#define EM28XX_R1F_CHEIGHT 0x1f
117
118#define EM28XX_R20_YGAIN 0x20
119#define EM28XX_R21_YOFFSET 0x21
120#define EM28XX_R22_UVGAIN 0x22
121#define EM28XX_R23_UOFFSET 0x23
122#define EM28XX_R24_VOFFSET 0x24
123#define EM28XX_R25_SHARPNESS 0x25
124
125#define EM28XX_R26_COMPR 0x26
126#define EM28XX_R27_OUTFMT 0x27
127
128/* em28xx Output Format Register (0x27) */
129#define EM28XX_OUTFMT_RGB_8_RGRG 0x00
130#define EM28XX_OUTFMT_RGB_8_GRGR 0x01
131#define EM28XX_OUTFMT_RGB_8_GBGB 0x02
132#define EM28XX_OUTFMT_RGB_8_BGBG 0x03
133#define EM28XX_OUTFMT_RGB_16_656 0x04
134#define EM28XX_OUTFMT_RGB_8_BAYER 0x08 /* Pattern in Reg 0x10[1-0] */
135#define EM28XX_OUTFMT_YUV211 0x10
136#define EM28XX_OUTFMT_YUV422_Y0UY1V 0x14
137#define EM28XX_OUTFMT_YUV422_Y1UY0V 0x15
138#define EM28XX_OUTFMT_YUV411 0x18
139
140
141#define EM28XX_R28_XMIN 0x28
142#define EM28XX_R29_XMAX 0x29
143#define EM28XX_R2A_YMIN 0x2a
144#define EM28XX_R2B_YMAX 0x2b
145
146#define EM28XX_R30_HSCALELOW 0x30
147#define EM28XX_R31_HSCALEHIGH 0x31
148#define EM28XX_R32_VSCALELOW 0x32
149#define EM28XX_R33_VSCALEHIGH 0x33
150#define EM28XX_R34_VBI_START_H 0x34
151#define EM28XX_R35_VBI_START_V 0x35
152#define EM28XX_R36_VBI_WIDTH 0x36
153#define EM28XX_R37_VBI_HEIGHT 0x37
154
155#define EM28XX_R40_AC97LSB 0x40
156#define EM28XX_R41_AC97MSB 0x41
157#define EM28XX_R42_AC97ADDR 0x42
158#define EM28XX_R43_AC97BUSY 0x43
159
160#define EM28XX_R45_IR 0x45
161 /* 0x45 bit 7 - parity bit
162 bits 6-0 - count
163 0x46 IR brand
164 0x47 IR data
165 */
166
167/* em2874 registers */
168#define EM2874_R50_IR_CONFIG 0x50
169#define EM2874_R51_IR 0x51
170#define EM2874_R5F_TS_ENABLE 0x5f
171#define EM2874_R80_GPIO 0x80
172
173/* em2874 IR config register (0x50) */
174#define EM2874_IR_NEC 0x00
175#define EM2874_IR_RC5 0x04
176#define EM2874_IR_RC6_MODE_0 0x08
177#define EM2874_IR_RC6_MODE_6A 0x0b
178
179/* em2874 Transport Stream Enable Register (0x5f) */
180#define EM2874_TS1_CAPTURE_ENABLE (1 << 0)
181#define EM2874_TS1_FILTER_ENABLE (1 << 1)
182#define EM2874_TS1_NULL_DISCARD (1 << 2)
183#define EM2874_TS2_CAPTURE_ENABLE (1 << 4)
184#define EM2874_TS2_FILTER_ENABLE (1 << 5)
185#define EM2874_TS2_NULL_DISCARD (1 << 6)
186
187/* register settings */
188#define EM2800_AUDIO_SRC_TUNER 0x0d
189#define EM2800_AUDIO_SRC_LINE 0x0c
190#define EM28XX_AUDIO_SRC_TUNER 0xc0
191#define EM28XX_AUDIO_SRC_LINE 0x80
192
193/* FIXME: Need to be populated with the other chip ID's */
194enum em28xx_chip_id {
195 CHIP_ID_EM2800 = 7,
196 CHIP_ID_EM2710 = 17,
197 CHIP_ID_EM2820 = 18, /* Also used by some em2710 */
198 CHIP_ID_EM2840 = 20,
199 CHIP_ID_EM2750 = 33,
200 CHIP_ID_EM2860 = 34,
201 CHIP_ID_EM2870 = 35,
202 CHIP_ID_EM2883 = 36,
203 CHIP_ID_EM2874 = 65,
204 CHIP_ID_EM2884 = 68,
205 CHIP_ID_EM28174 = 113,
206};
207
208/*
209 * Registers used by em202 and other AC97 chips
210 */
211
212/* Standard AC97 registers */
213#define AC97_RESET 0x00
214
215 /* Output volumes */
216#define AC97_MASTER_VOL 0x02
217#define AC97_LINE_LEVEL_VOL 0x04 /* Some devices use for headphones */
218#define AC97_MASTER_MONO_VOL 0x06
219
220 /* Input volumes */
221#define AC97_PC_BEEP_VOL 0x0a
222#define AC97_PHONE_VOL 0x0c
223#define AC97_MIC_VOL 0x0e
224#define AC97_LINEIN_VOL 0x10
225#define AC97_CD_VOL 0x12
226#define AC97_VIDEO_VOL 0x14
227#define AC97_AUX_VOL 0x16
228#define AC97_PCM_OUT_VOL 0x18
229
230 /* capture registers */
231#define AC97_RECORD_SELECT 0x1a
232#define AC97_RECORD_GAIN 0x1c
233
234 /* control registers */
235#define AC97_GENERAL_PURPOSE 0x20
236#define AC97_3D_CTRL 0x22
237#define AC97_AUD_INT_AND_PAG 0x24
238#define AC97_POWER_DOWN_CTRL 0x26
239#define AC97_EXT_AUD_ID 0x28
240#define AC97_EXT_AUD_CTRL 0x2a
241
242/* Supported rate varies for each AC97 device
243 if write an unsupported value, it will return the closest one
244 */
245#define AC97_PCM_OUT_FRONT_SRATE 0x2c
246#define AC97_PCM_OUT_SURR_SRATE 0x2e
247#define AC97_PCM_OUT_LFE_SRATE 0x30
248#define AC97_PCM_IN_SRATE 0x32
249
250 /* For devices with more than 2 channels, extra output volumes */
251#define AC97_LFE_MASTER_VOL 0x36
252#define AC97_SURR_MASTER_VOL 0x38
253
254 /* Digital SPDIF output control */
255#define AC97_SPDIF_OUT_CTRL 0x3a
256
257 /* Vendor ID identifier */
258#define AC97_VENDOR_ID1 0x7c
259#define AC97_VENDOR_ID2 0x7e
260
261/* EMP202 vendor registers */
262#define EM202_EXT_MODEM_CTRL 0x3e
263#define EM202_GPIO_CONF 0x4c
264#define EM202_GPIO_POLARITY 0x4e
265#define EM202_GPIO_STICKY 0x50
266#define EM202_GPIO_MASK 0x52
267#define EM202_GPIO_STATUS 0x54
268#define EM202_SPDIF_OUT_SEL 0x6a
269#define EM202_ANTIPOP 0x72
270#define EM202_EAPD_GPIO_ACCESS 0x74
diff --git a/drivers/media/video/em28xx/em28xx-vbi.c b/drivers/media/video/em28xx/em28xx-vbi.c
new file mode 100644
index 00000000000..2b4c9cba2d6
--- /dev/null
+++ b/drivers/media/video/em28xx/em28xx-vbi.c
@@ -0,0 +1,145 @@
1/*
2 em28xx-vbi.c - VBI driver for em28xx
3
4 Copyright (C) 2009 Devin Heitmueller <dheitmueller@kernellabs.com>
5
6 This work was sponsored by EyeMagnet Limited.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
21 02110-1301, USA.
22 */
23
24#include <linux/kernel.h>
25#include <linux/module.h>
26#include <linux/hardirq.h>
27#include <linux/init.h>
28
29#include "em28xx.h"
30
31static unsigned int vbibufs = 5;
32module_param(vbibufs, int, 0644);
33MODULE_PARM_DESC(vbibufs, "number of vbi buffers, range 2-32");
34
35static unsigned int vbi_debug;
36module_param(vbi_debug, int, 0644);
37MODULE_PARM_DESC(vbi_debug, "enable debug messages [vbi]");
38
39#define dprintk(level, fmt, arg...) if (vbi_debug >= level) \
40 printk(KERN_DEBUG "%s: " fmt, dev->core->name , ## arg)
41
42/* ------------------------------------------------------------------ */
43
44static void
45free_buffer(struct videobuf_queue *vq, struct em28xx_buffer *buf)
46{
47 struct em28xx_fh *fh = vq->priv_data;
48 struct em28xx *dev = fh->dev;
49 unsigned long flags = 0;
50 if (in_interrupt())
51 BUG();
52
53 /* We used to wait for the buffer to finish here, but this didn't work
54 because, as we were keeping the state as VIDEOBUF_QUEUED,
55 videobuf_queue_cancel marked it as finished for us.
56 (Also, it could wedge forever if the hardware was misconfigured.)
57
58 This should be safe; by the time we get here, the buffer isn't
59 queued anymore. If we ever start marking the buffers as
60 VIDEOBUF_ACTIVE, it won't be, though.
61 */
62 spin_lock_irqsave(&dev->slock, flags);
63 if (dev->isoc_ctl.vbi_buf == buf)
64 dev->isoc_ctl.vbi_buf = NULL;
65 spin_unlock_irqrestore(&dev->slock, flags);
66
67 videobuf_vmalloc_free(&buf->vb);
68 buf->vb.state = VIDEOBUF_NEEDS_INIT;
69}
70
71static int
72vbi_setup(struct videobuf_queue *q, unsigned int *count, unsigned int *size)
73{
74 struct em28xx_fh *fh = q->priv_data;
75 struct em28xx *dev = fh->dev;
76
77 *size = dev->vbi_width * dev->vbi_height * 2;
78
79 if (0 == *count)
80 *count = vbibufs;
81 if (*count < 2)
82 *count = 2;
83 if (*count > 32)
84 *count = 32;
85 return 0;
86}
87
88static int
89vbi_prepare(struct videobuf_queue *q, struct videobuf_buffer *vb,
90 enum v4l2_field field)
91{
92 struct em28xx_fh *fh = q->priv_data;
93 struct em28xx *dev = fh->dev;
94 struct em28xx_buffer *buf = container_of(vb, struct em28xx_buffer, vb);
95 int rc = 0;
96
97 buf->vb.size = dev->vbi_width * dev->vbi_height * 2;
98
99 if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size)
100 return -EINVAL;
101
102 buf->vb.width = dev->vbi_width;
103 buf->vb.height = dev->vbi_height;
104 buf->vb.field = field;
105
106 if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
107 rc = videobuf_iolock(q, &buf->vb, NULL);
108 if (rc < 0)
109 goto fail;
110 }
111
112 buf->vb.state = VIDEOBUF_PREPARED;
113 return 0;
114
115fail:
116 free_buffer(q, buf);
117 return rc;
118}
119
120static void
121vbi_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
122{
123 struct em28xx_buffer *buf = container_of(vb,
124 struct em28xx_buffer,
125 vb);
126 struct em28xx_fh *fh = vq->priv_data;
127 struct em28xx *dev = fh->dev;
128 struct em28xx_dmaqueue *vbiq = &dev->vbiq;
129
130 buf->vb.state = VIDEOBUF_QUEUED;
131 list_add_tail(&buf->vb.queue, &vbiq->active);
132}
133
134static void vbi_release(struct videobuf_queue *q, struct videobuf_buffer *vb)
135{
136 struct em28xx_buffer *buf = container_of(vb, struct em28xx_buffer, vb);
137 free_buffer(q, buf);
138}
139
140struct videobuf_queue_ops em28xx_vbi_qops = {
141 .buf_setup = vbi_setup,
142 .buf_prepare = vbi_prepare,
143 .buf_queue = vbi_queue,
144 .buf_release = vbi_release,
145};
diff --git a/drivers/media/video/em28xx/em28xx-video.c b/drivers/media/video/em28xx/em28xx-video.c
new file mode 100644
index 00000000000..d176dc0394e
--- /dev/null
+++ b/drivers/media/video/em28xx/em28xx-video.c
@@ -0,0 +1,2535 @@
1/*
2 em28xx-video.c - driver for Empia EM2800/EM2820/2840 USB
3 video capture devices
4
5 Copyright (C) 2005 Ludovico Cavedon <cavedon@sssup.it>
6 Markus Rechberger <mrechberger@gmail.com>
7 Mauro Carvalho Chehab <mchehab@infradead.org>
8 Sascha Sommer <saschasommer@freenet.de>
9
10 Some parts based on SN9C10x PC Camera Controllers GPL driver made
11 by Luca Risolia <luca.risolia@studio.unibo.it>
12
13 This program is free software; you can redistribute it and/or modify
14 it under the terms of the GNU General Public License as published by
15 the Free Software Foundation; either version 2 of the License, or
16 (at your option) any later version.
17
18 This program is distributed in the hope that it will be useful,
19 but WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 GNU General Public License for more details.
22
23 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software
25 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 */
27
28#include <linux/init.h>
29#include <linux/list.h>
30#include <linux/module.h>
31#include <linux/kernel.h>
32#include <linux/bitmap.h>
33#include <linux/usb.h>
34#include <linux/i2c.h>
35#include <linux/mm.h>
36#include <linux/mutex.h>
37#include <linux/slab.h>
38
39#include "em28xx.h"
40#include <media/v4l2-common.h>
41#include <media/v4l2-ioctl.h>
42#include <media/v4l2-chip-ident.h>
43#include <media/msp3400.h>
44#include <media/tuner.h>
45
46#define DRIVER_AUTHOR "Ludovico Cavedon <cavedon@sssup.it>, " \
47 "Markus Rechberger <mrechberger@gmail.com>, " \
48 "Mauro Carvalho Chehab <mchehab@infradead.org>, " \
49 "Sascha Sommer <saschasommer@freenet.de>"
50
51#define DRIVER_DESC "Empia em28xx based USB video device driver"
52
53#define EM28XX_VERSION "0.1.3"
54
55#define em28xx_videodbg(fmt, arg...) do {\
56 if (video_debug) \
57 printk(KERN_INFO "%s %s :"fmt, \
58 dev->name, __func__ , ##arg); } while (0)
59
60static unsigned int isoc_debug;
61module_param(isoc_debug, int, 0644);
62MODULE_PARM_DESC(isoc_debug, "enable debug messages [isoc transfers]");
63
64#define em28xx_isocdbg(fmt, arg...) \
65do {\
66 if (isoc_debug) { \
67 printk(KERN_INFO "%s %s :"fmt, \
68 dev->name, __func__ , ##arg); \
69 } \
70 } while (0)
71
72MODULE_AUTHOR(DRIVER_AUTHOR);
73MODULE_DESCRIPTION(DRIVER_DESC);
74MODULE_LICENSE("GPL");
75MODULE_VERSION(EM28XX_VERSION);
76
77static unsigned int video_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = UNSET };
78static unsigned int vbi_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = UNSET };
79static unsigned int radio_nr[] = {[0 ... (EM28XX_MAXBOARDS - 1)] = UNSET };
80
81module_param_array(video_nr, int, NULL, 0444);
82module_param_array(vbi_nr, int, NULL, 0444);
83module_param_array(radio_nr, int, NULL, 0444);
84MODULE_PARM_DESC(video_nr, "video device numbers");
85MODULE_PARM_DESC(vbi_nr, "vbi device numbers");
86MODULE_PARM_DESC(radio_nr, "radio device numbers");
87
88static unsigned int video_debug;
89module_param(video_debug, int, 0644);
90MODULE_PARM_DESC(video_debug, "enable debug messages [video]");
91
92/* supported video standards */
93static struct em28xx_fmt format[] = {
94 {
95 .name = "16 bpp YUY2, 4:2:2, packed",
96 .fourcc = V4L2_PIX_FMT_YUYV,
97 .depth = 16,
98 .reg = EM28XX_OUTFMT_YUV422_Y0UY1V,
99 }, {
100 .name = "16 bpp RGB 565, LE",
101 .fourcc = V4L2_PIX_FMT_RGB565,
102 .depth = 16,
103 .reg = EM28XX_OUTFMT_RGB_16_656,
104 }, {
105 .name = "8 bpp Bayer BGBG..GRGR",
106 .fourcc = V4L2_PIX_FMT_SBGGR8,
107 .depth = 8,
108 .reg = EM28XX_OUTFMT_RGB_8_BGBG,
109 }, {
110 .name = "8 bpp Bayer GRGR..BGBG",
111 .fourcc = V4L2_PIX_FMT_SGRBG8,
112 .depth = 8,
113 .reg = EM28XX_OUTFMT_RGB_8_GRGR,
114 }, {
115 .name = "8 bpp Bayer GBGB..RGRG",
116 .fourcc = V4L2_PIX_FMT_SGBRG8,
117 .depth = 8,
118 .reg = EM28XX_OUTFMT_RGB_8_GBGB,
119 }, {
120 .name = "12 bpp YUV411",
121 .fourcc = V4L2_PIX_FMT_YUV411P,
122 .depth = 12,
123 .reg = EM28XX_OUTFMT_YUV411,
124 },
125};
126
127/* supported controls */
128/* Common to all boards */
129static struct v4l2_queryctrl ac97_qctrl[] = {
130 {
131 .id = V4L2_CID_AUDIO_VOLUME,
132 .type = V4L2_CTRL_TYPE_INTEGER,
133 .name = "Volume",
134 .minimum = 0x0,
135 .maximum = 0x1f,
136 .step = 0x1,
137 .default_value = 0x1f,
138 .flags = V4L2_CTRL_FLAG_SLIDER,
139 }, {
140 .id = V4L2_CID_AUDIO_MUTE,
141 .type = V4L2_CTRL_TYPE_BOOLEAN,
142 .name = "Mute",
143 .minimum = 0,
144 .maximum = 1,
145 .step = 1,
146 .default_value = 1,
147 .flags = 0,
148 }
149};
150
151/* ------------------------------------------------------------------
152 DMA and thread functions
153 ------------------------------------------------------------------*/
154
155/*
156 * Announces that a buffer were filled and request the next
157 */
158static inline void buffer_filled(struct em28xx *dev,
159 struct em28xx_dmaqueue *dma_q,
160 struct em28xx_buffer *buf)
161{
162 /* Advice that buffer was filled */
163 em28xx_isocdbg("[%p/%d] wakeup\n", buf, buf->vb.i);
164 buf->vb.state = VIDEOBUF_DONE;
165 buf->vb.field_count++;
166 do_gettimeofday(&buf->vb.ts);
167
168 dev->isoc_ctl.vid_buf = NULL;
169
170 list_del(&buf->vb.queue);
171 wake_up(&buf->vb.done);
172}
173
174static inline void vbi_buffer_filled(struct em28xx *dev,
175 struct em28xx_dmaqueue *dma_q,
176 struct em28xx_buffer *buf)
177{
178 /* Advice that buffer was filled */
179 em28xx_isocdbg("[%p/%d] wakeup\n", buf, buf->vb.i);
180
181 buf->vb.state = VIDEOBUF_DONE;
182 buf->vb.field_count++;
183 do_gettimeofday(&buf->vb.ts);
184
185 dev->isoc_ctl.vbi_buf = NULL;
186
187 list_del(&buf->vb.queue);
188 wake_up(&buf->vb.done);
189}
190
191/*
192 * Identify the buffer header type and properly handles
193 */
194static void em28xx_copy_video(struct em28xx *dev,
195 struct em28xx_dmaqueue *dma_q,
196 struct em28xx_buffer *buf,
197 unsigned char *p,
198 unsigned char *outp, unsigned long len)
199{
200 void *fieldstart, *startwrite, *startread;
201 int linesdone, currlinedone, offset, lencopy, remain;
202 int bytesperline = dev->width << 1;
203
204 if (dma_q->pos + len > buf->vb.size)
205 len = buf->vb.size - dma_q->pos;
206
207 startread = p;
208 remain = len;
209
210 if (dev->progressive)
211 fieldstart = outp;
212 else {
213 /* Interlaces two half frames */
214 if (buf->top_field)
215 fieldstart = outp;
216 else
217 fieldstart = outp + bytesperline;
218 }
219
220 linesdone = dma_q->pos / bytesperline;
221 currlinedone = dma_q->pos % bytesperline;
222
223 if (dev->progressive)
224 offset = linesdone * bytesperline + currlinedone;
225 else
226 offset = linesdone * bytesperline * 2 + currlinedone;
227
228 startwrite = fieldstart + offset;
229 lencopy = bytesperline - currlinedone;
230 lencopy = lencopy > remain ? remain : lencopy;
231
232 if ((char *)startwrite + lencopy > (char *)outp + buf->vb.size) {
233 em28xx_isocdbg("Overflow of %zi bytes past buffer end (1)\n",
234 ((char *)startwrite + lencopy) -
235 ((char *)outp + buf->vb.size));
236 remain = (char *)outp + buf->vb.size - (char *)startwrite;
237 lencopy = remain;
238 }
239 if (lencopy <= 0)
240 return;
241 memcpy(startwrite, startread, lencopy);
242
243 remain -= lencopy;
244
245 while (remain > 0) {
246 startwrite += lencopy + bytesperline;
247 startread += lencopy;
248 if (bytesperline > remain)
249 lencopy = remain;
250 else
251 lencopy = bytesperline;
252
253 if ((char *)startwrite + lencopy > (char *)outp +
254 buf->vb.size) {
255 em28xx_isocdbg("Overflow of %zi bytes past buffer end"
256 "(2)\n",
257 ((char *)startwrite + lencopy) -
258 ((char *)outp + buf->vb.size));
259 lencopy = remain = (char *)outp + buf->vb.size -
260 (char *)startwrite;
261 }
262 if (lencopy <= 0)
263 break;
264
265 memcpy(startwrite, startread, lencopy);
266
267 remain -= lencopy;
268 }
269
270 dma_q->pos += len;
271}
272
273static void em28xx_copy_vbi(struct em28xx *dev,
274 struct em28xx_dmaqueue *dma_q,
275 struct em28xx_buffer *buf,
276 unsigned char *p,
277 unsigned char *outp, unsigned long len)
278{
279 void *startwrite, *startread;
280 int offset;
281 int bytesperline;
282
283 if (dev == NULL) {
284 em28xx_isocdbg("dev is null\n");
285 return;
286 }
287 bytesperline = dev->vbi_width;
288
289 if (dma_q == NULL) {
290 em28xx_isocdbg("dma_q is null\n");
291 return;
292 }
293 if (buf == NULL) {
294 return;
295 }
296 if (p == NULL) {
297 em28xx_isocdbg("p is null\n");
298 return;
299 }
300 if (outp == NULL) {
301 em28xx_isocdbg("outp is null\n");
302 return;
303 }
304
305 if (dma_q->pos + len > buf->vb.size)
306 len = buf->vb.size - dma_q->pos;
307
308 startread = p;
309
310 startwrite = outp + dma_q->pos;
311 offset = dma_q->pos;
312
313 /* Make sure the bottom field populates the second half of the frame */
314 if (buf->top_field == 0) {
315 startwrite += bytesperline * dev->vbi_height;
316 offset += bytesperline * dev->vbi_height;
317 }
318
319 memcpy(startwrite, startread, len);
320 dma_q->pos += len;
321}
322
323static inline void print_err_status(struct em28xx *dev,
324 int packet, int status)
325{
326 char *errmsg = "Unknown";
327
328 switch (status) {
329 case -ENOENT:
330 errmsg = "unlinked synchronuously";
331 break;
332 case -ECONNRESET:
333 errmsg = "unlinked asynchronuously";
334 break;
335 case -ENOSR:
336 errmsg = "Buffer error (overrun)";
337 break;
338 case -EPIPE:
339 errmsg = "Stalled (device not responding)";
340 break;
341 case -EOVERFLOW:
342 errmsg = "Babble (bad cable?)";
343 break;
344 case -EPROTO:
345 errmsg = "Bit-stuff error (bad cable?)";
346 break;
347 case -EILSEQ:
348 errmsg = "CRC/Timeout (could be anything)";
349 break;
350 case -ETIME:
351 errmsg = "Device does not respond";
352 break;
353 }
354 if (packet < 0) {
355 em28xx_isocdbg("URB status %d [%s].\n", status, errmsg);
356 } else {
357 em28xx_isocdbg("URB packet %d, status %d [%s].\n",
358 packet, status, errmsg);
359 }
360}
361
362/*
363 * video-buf generic routine to get the next available buffer
364 */
365static inline void get_next_buf(struct em28xx_dmaqueue *dma_q,
366 struct em28xx_buffer **buf)
367{
368 struct em28xx *dev = container_of(dma_q, struct em28xx, vidq);
369 char *outp;
370
371 if (list_empty(&dma_q->active)) {
372 em28xx_isocdbg("No active queue to serve\n");
373 dev->isoc_ctl.vid_buf = NULL;
374 *buf = NULL;
375 return;
376 }
377
378 /* Get the next buffer */
379 *buf = list_entry(dma_q->active.next, struct em28xx_buffer, vb.queue);
380
381 /* Cleans up buffer - Useful for testing for frame/URB loss */
382 outp = videobuf_to_vmalloc(&(*buf)->vb);
383 memset(outp, 0, (*buf)->vb.size);
384
385 dev->isoc_ctl.vid_buf = *buf;
386
387 return;
388}
389
390/*
391 * video-buf generic routine to get the next available VBI buffer
392 */
393static inline void vbi_get_next_buf(struct em28xx_dmaqueue *dma_q,
394 struct em28xx_buffer **buf)
395{
396 struct em28xx *dev = container_of(dma_q, struct em28xx, vbiq);
397 char *outp;
398
399 if (list_empty(&dma_q->active)) {
400 em28xx_isocdbg("No active queue to serve\n");
401 dev->isoc_ctl.vbi_buf = NULL;
402 *buf = NULL;
403 return;
404 }
405
406 /* Get the next buffer */
407 *buf = list_entry(dma_q->active.next, struct em28xx_buffer, vb.queue);
408 /* Cleans up buffer - Useful for testing for frame/URB loss */
409 outp = videobuf_to_vmalloc(&(*buf)->vb);
410 memset(outp, 0x00, (*buf)->vb.size);
411
412 dev->isoc_ctl.vbi_buf = *buf;
413
414 return;
415}
416
417/*
418 * Controls the isoc copy of each urb packet
419 */
420static inline int em28xx_isoc_copy(struct em28xx *dev, struct urb *urb)
421{
422 struct em28xx_buffer *buf;
423 struct em28xx_dmaqueue *dma_q = &dev->vidq;
424 unsigned char *outp = NULL;
425 int i, len = 0, rc = 1;
426 unsigned char *p;
427
428 if (!dev)
429 return 0;
430
431 if ((dev->state & DEV_DISCONNECTED) || (dev->state & DEV_MISCONFIGURED))
432 return 0;
433
434 if (urb->status < 0) {
435 print_err_status(dev, -1, urb->status);
436 if (urb->status == -ENOENT)
437 return 0;
438 }
439
440 buf = dev->isoc_ctl.vid_buf;
441 if (buf != NULL)
442 outp = videobuf_to_vmalloc(&buf->vb);
443
444 for (i = 0; i < urb->number_of_packets; i++) {
445 int status = urb->iso_frame_desc[i].status;
446
447 if (status < 0) {
448 print_err_status(dev, i, status);
449 if (urb->iso_frame_desc[i].status != -EPROTO)
450 continue;
451 }
452
453 len = urb->iso_frame_desc[i].actual_length - 4;
454
455 if (urb->iso_frame_desc[i].actual_length <= 0) {
456 /* em28xx_isocdbg("packet %d is empty",i); - spammy */
457 continue;
458 }
459 if (urb->iso_frame_desc[i].actual_length >
460 dev->max_pkt_size) {
461 em28xx_isocdbg("packet bigger than packet size");
462 continue;
463 }
464
465 p = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
466
467 /* FIXME: incomplete buffer checks where removed to make
468 logic simpler. Impacts of those changes should be evaluated
469 */
470 if (p[0] == 0x33 && p[1] == 0x95 && p[2] == 0x00) {
471 em28xx_isocdbg("VBI HEADER!!!\n");
472 /* FIXME: Should add vbi copy */
473 continue;
474 }
475 if (p[0] == 0x22 && p[1] == 0x5a) {
476 em28xx_isocdbg("Video frame %d, length=%i, %s\n", p[2],
477 len, (p[2] & 1) ? "odd" : "even");
478
479 if (dev->progressive || !(p[2] & 1)) {
480 if (buf != NULL)
481 buffer_filled(dev, dma_q, buf);
482 get_next_buf(dma_q, &buf);
483 if (buf == NULL)
484 outp = NULL;
485 else
486 outp = videobuf_to_vmalloc(&buf->vb);
487 }
488
489 if (buf != NULL) {
490 if (p[2] & 1)
491 buf->top_field = 0;
492 else
493 buf->top_field = 1;
494 }
495
496 dma_q->pos = 0;
497 }
498 if (buf != NULL) {
499 if (p[0] != 0x88 && p[0] != 0x22) {
500 em28xx_isocdbg("frame is not complete\n");
501 len += 4;
502 } else {
503 p += 4;
504 }
505 em28xx_copy_video(dev, dma_q, buf, p, outp, len);
506 }
507 }
508 return rc;
509}
510
511/* Version of isoc handler that takes into account a mixture of video and
512 VBI data */
513static inline int em28xx_isoc_copy_vbi(struct em28xx *dev, struct urb *urb)
514{
515 struct em28xx_buffer *buf, *vbi_buf;
516 struct em28xx_dmaqueue *dma_q = &dev->vidq;
517 struct em28xx_dmaqueue *vbi_dma_q = &dev->vbiq;
518 unsigned char *outp = NULL;
519 unsigned char *vbioutp = NULL;
520 int i, len = 0, rc = 1;
521 unsigned char *p;
522 int vbi_size;
523
524 if (!dev)
525 return 0;
526
527 if ((dev->state & DEV_DISCONNECTED) || (dev->state & DEV_MISCONFIGURED))
528 return 0;
529
530 if (urb->status < 0) {
531 print_err_status(dev, -1, urb->status);
532 if (urb->status == -ENOENT)
533 return 0;
534 }
535
536 buf = dev->isoc_ctl.vid_buf;
537 if (buf != NULL)
538 outp = videobuf_to_vmalloc(&buf->vb);
539
540 vbi_buf = dev->isoc_ctl.vbi_buf;
541 if (vbi_buf != NULL)
542 vbioutp = videobuf_to_vmalloc(&vbi_buf->vb);
543
544 for (i = 0; i < urb->number_of_packets; i++) {
545 int status = urb->iso_frame_desc[i].status;
546
547 if (status < 0) {
548 print_err_status(dev, i, status);
549 if (urb->iso_frame_desc[i].status != -EPROTO)
550 continue;
551 }
552
553 len = urb->iso_frame_desc[i].actual_length;
554 if (urb->iso_frame_desc[i].actual_length <= 0) {
555 /* em28xx_isocdbg("packet %d is empty",i); - spammy */
556 continue;
557 }
558 if (urb->iso_frame_desc[i].actual_length >
559 dev->max_pkt_size) {
560 em28xx_isocdbg("packet bigger than packet size");
561 continue;
562 }
563
564 p = urb->transfer_buffer + urb->iso_frame_desc[i].offset;
565
566 /* capture type 0 = vbi start
567 capture type 1 = video start
568 capture type 2 = video in progress */
569 if (p[0] == 0x33 && p[1] == 0x95) {
570 dev->capture_type = 0;
571 dev->vbi_read = 0;
572 em28xx_isocdbg("VBI START HEADER!!!\n");
573 dev->cur_field = p[2];
574 p += 4;
575 len -= 4;
576 } else if (p[0] == 0x88 && p[1] == 0x88 &&
577 p[2] == 0x88 && p[3] == 0x88) {
578 /* continuation */
579 p += 4;
580 len -= 4;
581 } else if (p[0] == 0x22 && p[1] == 0x5a) {
582 /* start video */
583 p += 4;
584 len -= 4;
585 }
586
587 vbi_size = dev->vbi_width * dev->vbi_height;
588
589 if (dev->capture_type == 0) {
590 if (dev->vbi_read >= vbi_size) {
591 /* We've already read all the VBI data, so
592 treat the rest as video */
593 em28xx_isocdbg("dev->vbi_read > vbi_size\n");
594 } else if ((dev->vbi_read + len) < vbi_size) {
595 /* This entire frame is VBI data */
596 if (dev->vbi_read == 0 &&
597 (!(dev->cur_field & 1))) {
598 /* Brand new frame */
599 if (vbi_buf != NULL)
600 vbi_buffer_filled(dev,
601 vbi_dma_q,
602 vbi_buf);
603 vbi_get_next_buf(vbi_dma_q, &vbi_buf);
604 if (vbi_buf == NULL)
605 vbioutp = NULL;
606 else
607 vbioutp = videobuf_to_vmalloc(
608 &vbi_buf->vb);
609 }
610
611 if (dev->vbi_read == 0) {
612 vbi_dma_q->pos = 0;
613 if (vbi_buf != NULL) {
614 if (dev->cur_field & 1)
615 vbi_buf->top_field = 0;
616 else
617 vbi_buf->top_field = 1;
618 }
619 }
620
621 dev->vbi_read += len;
622 em28xx_copy_vbi(dev, vbi_dma_q, vbi_buf, p,
623 vbioutp, len);
624 } else {
625 /* Some of this frame is VBI data and some is
626 video data */
627 int vbi_data_len = vbi_size - dev->vbi_read;
628 dev->vbi_read += vbi_data_len;
629 em28xx_copy_vbi(dev, vbi_dma_q, vbi_buf, p,
630 vbioutp, vbi_data_len);
631 dev->capture_type = 1;
632 p += vbi_data_len;
633 len -= vbi_data_len;
634 }
635 }
636
637 if (dev->capture_type == 1) {
638 dev->capture_type = 2;
639 if (dev->progressive || !(dev->cur_field & 1)) {
640 if (buf != NULL)
641 buffer_filled(dev, dma_q, buf);
642 get_next_buf(dma_q, &buf);
643 if (buf == NULL)
644 outp = NULL;
645 else
646 outp = videobuf_to_vmalloc(&buf->vb);
647 }
648 if (buf != NULL) {
649 if (dev->cur_field & 1)
650 buf->top_field = 0;
651 else
652 buf->top_field = 1;
653 }
654
655 dma_q->pos = 0;
656 }
657
658 if (buf != NULL && dev->capture_type == 2) {
659 if (len >= 4 && p[0] == 0x88 && p[1] == 0x88 &&
660 p[2] == 0x88 && p[3] == 0x88) {
661 p += 4;
662 len -= 4;
663 }
664 if (len >= 4 && p[0] == 0x22 && p[1] == 0x5a) {
665 em28xx_isocdbg("Video frame %d, len=%i, %s\n",
666 p[2], len, (p[2] & 1) ?
667 "odd" : "even");
668 p += 4;
669 len -= 4;
670 }
671
672 if (len > 0)
673 em28xx_copy_video(dev, dma_q, buf, p, outp,
674 len);
675 }
676 }
677 return rc;
678}
679
680
681/* ------------------------------------------------------------------
682 Videobuf operations
683 ------------------------------------------------------------------*/
684
685static int
686buffer_setup(struct videobuf_queue *vq, unsigned int *count, unsigned int *size)
687{
688 struct em28xx_fh *fh = vq->priv_data;
689 struct em28xx *dev = fh->dev;
690 struct v4l2_frequency f;
691
692 *size = (fh->dev->width * fh->dev->height * dev->format->depth + 7)
693 >> 3;
694
695 if (0 == *count)
696 *count = EM28XX_DEF_BUF;
697
698 if (*count < EM28XX_MIN_BUF)
699 *count = EM28XX_MIN_BUF;
700
701 /* Ask tuner to go to analog or radio mode */
702 memset(&f, 0, sizeof(f));
703 f.frequency = dev->ctl_freq;
704 f.type = fh->radio ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
705
706 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_frequency, &f);
707
708 return 0;
709}
710
711/* This is called *without* dev->slock held; please keep it that way */
712static void free_buffer(struct videobuf_queue *vq, struct em28xx_buffer *buf)
713{
714 struct em28xx_fh *fh = vq->priv_data;
715 struct em28xx *dev = fh->dev;
716 unsigned long flags = 0;
717 if (in_interrupt())
718 BUG();
719
720 /* We used to wait for the buffer to finish here, but this didn't work
721 because, as we were keeping the state as VIDEOBUF_QUEUED,
722 videobuf_queue_cancel marked it as finished for us.
723 (Also, it could wedge forever if the hardware was misconfigured.)
724
725 This should be safe; by the time we get here, the buffer isn't
726 queued anymore. If we ever start marking the buffers as
727 VIDEOBUF_ACTIVE, it won't be, though.
728 */
729 spin_lock_irqsave(&dev->slock, flags);
730 if (dev->isoc_ctl.vid_buf == buf)
731 dev->isoc_ctl.vid_buf = NULL;
732 spin_unlock_irqrestore(&dev->slock, flags);
733
734 videobuf_vmalloc_free(&buf->vb);
735 buf->vb.state = VIDEOBUF_NEEDS_INIT;
736}
737
738static int
739buffer_prepare(struct videobuf_queue *vq, struct videobuf_buffer *vb,
740 enum v4l2_field field)
741{
742 struct em28xx_fh *fh = vq->priv_data;
743 struct em28xx_buffer *buf = container_of(vb, struct em28xx_buffer, vb);
744 struct em28xx *dev = fh->dev;
745 int rc = 0, urb_init = 0;
746
747 buf->vb.size = (fh->dev->width * fh->dev->height * dev->format->depth
748 + 7) >> 3;
749
750 if (0 != buf->vb.baddr && buf->vb.bsize < buf->vb.size)
751 return -EINVAL;
752
753 buf->vb.width = dev->width;
754 buf->vb.height = dev->height;
755 buf->vb.field = field;
756
757 if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
758 rc = videobuf_iolock(vq, &buf->vb, NULL);
759 if (rc < 0)
760 goto fail;
761 }
762
763 if (!dev->isoc_ctl.num_bufs)
764 urb_init = 1;
765
766 if (urb_init) {
767 if (em28xx_vbi_supported(dev) == 1)
768 rc = em28xx_init_isoc(dev, EM28XX_NUM_PACKETS,
769 EM28XX_NUM_BUFS,
770 dev->max_pkt_size,
771 em28xx_isoc_copy_vbi);
772 else
773 rc = em28xx_init_isoc(dev, EM28XX_NUM_PACKETS,
774 EM28XX_NUM_BUFS,
775 dev->max_pkt_size,
776 em28xx_isoc_copy);
777 if (rc < 0)
778 goto fail;
779 }
780
781 buf->vb.state = VIDEOBUF_PREPARED;
782 return 0;
783
784fail:
785 free_buffer(vq, buf);
786 return rc;
787}
788
789static void
790buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
791{
792 struct em28xx_buffer *buf = container_of(vb,
793 struct em28xx_buffer,
794 vb);
795 struct em28xx_fh *fh = vq->priv_data;
796 struct em28xx *dev = fh->dev;
797 struct em28xx_dmaqueue *vidq = &dev->vidq;
798
799 buf->vb.state = VIDEOBUF_QUEUED;
800 list_add_tail(&buf->vb.queue, &vidq->active);
801
802}
803
804static void buffer_release(struct videobuf_queue *vq,
805 struct videobuf_buffer *vb)
806{
807 struct em28xx_buffer *buf = container_of(vb,
808 struct em28xx_buffer,
809 vb);
810 struct em28xx_fh *fh = vq->priv_data;
811 struct em28xx *dev = (struct em28xx *)fh->dev;
812
813 em28xx_isocdbg("em28xx: called buffer_release\n");
814
815 free_buffer(vq, buf);
816}
817
818static struct videobuf_queue_ops em28xx_video_qops = {
819 .buf_setup = buffer_setup,
820 .buf_prepare = buffer_prepare,
821 .buf_queue = buffer_queue,
822 .buf_release = buffer_release,
823};
824
825/********************* v4l2 interface **************************************/
826
827static void video_mux(struct em28xx *dev, int index)
828{
829 dev->ctl_input = index;
830 dev->ctl_ainput = INPUT(index)->amux;
831 dev->ctl_aoutput = INPUT(index)->aout;
832
833 if (!dev->ctl_aoutput)
834 dev->ctl_aoutput = EM28XX_AOUT_MASTER;
835
836 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_routing,
837 INPUT(index)->vmux, 0, 0);
838
839 if (dev->board.has_msp34xx) {
840 if (dev->i2s_speed) {
841 v4l2_device_call_all(&dev->v4l2_dev, 0, audio,
842 s_i2s_clock_freq, dev->i2s_speed);
843 }
844 /* Note: this is msp3400 specific */
845 v4l2_device_call_all(&dev->v4l2_dev, 0, audio, s_routing,
846 dev->ctl_ainput, MSP_OUTPUT(MSP_SC_IN_DSP_SCART1), 0);
847 }
848
849 if (dev->board.adecoder != EM28XX_NOADECODER) {
850 v4l2_device_call_all(&dev->v4l2_dev, 0, audio, s_routing,
851 dev->ctl_ainput, dev->ctl_aoutput, 0);
852 }
853
854 em28xx_audio_analog_set(dev);
855}
856
857/* Usage lock check functions */
858static int res_get(struct em28xx_fh *fh, unsigned int bit)
859{
860 struct em28xx *dev = fh->dev;
861
862 if (fh->resources & bit)
863 /* have it already allocated */
864 return 1;
865
866 /* is it free? */
867 if (dev->resources & bit) {
868 /* no, someone else uses it */
869 return 0;
870 }
871 /* it's free, grab it */
872 fh->resources |= bit;
873 dev->resources |= bit;
874 em28xx_videodbg("res: get %d\n", bit);
875 return 1;
876}
877
878static int res_check(struct em28xx_fh *fh, unsigned int bit)
879{
880 return fh->resources & bit;
881}
882
883static int res_locked(struct em28xx *dev, unsigned int bit)
884{
885 return dev->resources & bit;
886}
887
888static void res_free(struct em28xx_fh *fh, unsigned int bits)
889{
890 struct em28xx *dev = fh->dev;
891
892 BUG_ON((fh->resources & bits) != bits);
893
894 fh->resources &= ~bits;
895 dev->resources &= ~bits;
896 em28xx_videodbg("res: put %d\n", bits);
897}
898
899static int get_ressource(struct em28xx_fh *fh)
900{
901 switch (fh->type) {
902 case V4L2_BUF_TYPE_VIDEO_CAPTURE:
903 return EM28XX_RESOURCE_VIDEO;
904 case V4L2_BUF_TYPE_VBI_CAPTURE:
905 return EM28XX_RESOURCE_VBI;
906 default:
907 BUG();
908 return 0;
909 }
910}
911
912/*
913 * ac97_queryctrl()
914 * return the ac97 supported controls
915 */
916static int ac97_queryctrl(struct v4l2_queryctrl *qc)
917{
918 int i;
919
920 for (i = 0; i < ARRAY_SIZE(ac97_qctrl); i++) {
921 if (qc->id && qc->id == ac97_qctrl[i].id) {
922 memcpy(qc, &(ac97_qctrl[i]), sizeof(*qc));
923 return 0;
924 }
925 }
926
927 /* Control is not ac97 related */
928 return 1;
929}
930
931/*
932 * ac97_get_ctrl()
933 * return the current values for ac97 mute and volume
934 */
935static int ac97_get_ctrl(struct em28xx *dev, struct v4l2_control *ctrl)
936{
937 switch (ctrl->id) {
938 case V4L2_CID_AUDIO_MUTE:
939 ctrl->value = dev->mute;
940 return 0;
941 case V4L2_CID_AUDIO_VOLUME:
942 ctrl->value = dev->volume;
943 return 0;
944 default:
945 /* Control is not ac97 related */
946 return 1;
947 }
948}
949
950/*
951 * ac97_set_ctrl()
952 * set values for ac97 mute and volume
953 */
954static int ac97_set_ctrl(struct em28xx *dev, const struct v4l2_control *ctrl)
955{
956 int i;
957
958 for (i = 0; i < ARRAY_SIZE(ac97_qctrl); i++)
959 if (ctrl->id == ac97_qctrl[i].id)
960 goto handle;
961
962 /* Announce that hasn't handle it */
963 return 1;
964
965handle:
966 if (ctrl->value < ac97_qctrl[i].minimum ||
967 ctrl->value > ac97_qctrl[i].maximum)
968 return -ERANGE;
969
970 switch (ctrl->id) {
971 case V4L2_CID_AUDIO_MUTE:
972 dev->mute = ctrl->value;
973 break;
974 case V4L2_CID_AUDIO_VOLUME:
975 dev->volume = ctrl->value;
976 break;
977 }
978
979 return em28xx_audio_analog_set(dev);
980}
981
982static int check_dev(struct em28xx *dev)
983{
984 if (dev->state & DEV_DISCONNECTED) {
985 em28xx_errdev("v4l2 ioctl: device not present\n");
986 return -ENODEV;
987 }
988
989 if (dev->state & DEV_MISCONFIGURED) {
990 em28xx_errdev("v4l2 ioctl: device is misconfigured; "
991 "close and open it again\n");
992 return -EIO;
993 }
994 return 0;
995}
996
997static void get_scale(struct em28xx *dev,
998 unsigned int width, unsigned int height,
999 unsigned int *hscale, unsigned int *vscale)
1000{
1001 unsigned int maxw = norm_maxw(dev);
1002 unsigned int maxh = norm_maxh(dev);
1003
1004 *hscale = (((unsigned long)maxw) << 12) / width - 4096L;
1005 if (*hscale >= 0x4000)
1006 *hscale = 0x3fff;
1007
1008 *vscale = (((unsigned long)maxh) << 12) / height - 4096L;
1009 if (*vscale >= 0x4000)
1010 *vscale = 0x3fff;
1011}
1012
1013/* ------------------------------------------------------------------
1014 IOCTL vidioc handling
1015 ------------------------------------------------------------------*/
1016
1017static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
1018 struct v4l2_format *f)
1019{
1020 struct em28xx_fh *fh = priv;
1021 struct em28xx *dev = fh->dev;
1022
1023 f->fmt.pix.width = dev->width;
1024 f->fmt.pix.height = dev->height;
1025 f->fmt.pix.pixelformat = dev->format->fourcc;
1026 f->fmt.pix.bytesperline = (dev->width * dev->format->depth + 7) >> 3;
1027 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * dev->height;
1028 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
1029
1030 /* FIXME: TOP? NONE? BOTTOM? ALTENATE? */
1031 if (dev->progressive)
1032 f->fmt.pix.field = V4L2_FIELD_NONE;
1033 else
1034 f->fmt.pix.field = dev->interlaced ?
1035 V4L2_FIELD_INTERLACED : V4L2_FIELD_TOP;
1036 return 0;
1037}
1038
1039static struct em28xx_fmt *format_by_fourcc(unsigned int fourcc)
1040{
1041 unsigned int i;
1042
1043 for (i = 0; i < ARRAY_SIZE(format); i++)
1044 if (format[i].fourcc == fourcc)
1045 return &format[i];
1046
1047 return NULL;
1048}
1049
1050static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
1051 struct v4l2_format *f)
1052{
1053 struct em28xx_fh *fh = priv;
1054 struct em28xx *dev = fh->dev;
1055 unsigned int width = f->fmt.pix.width;
1056 unsigned int height = f->fmt.pix.height;
1057 unsigned int maxw = norm_maxw(dev);
1058 unsigned int maxh = norm_maxh(dev);
1059 unsigned int hscale, vscale;
1060 struct em28xx_fmt *fmt;
1061
1062 fmt = format_by_fourcc(f->fmt.pix.pixelformat);
1063 if (!fmt) {
1064 em28xx_videodbg("Fourcc format (%08x) invalid.\n",
1065 f->fmt.pix.pixelformat);
1066 return -EINVAL;
1067 }
1068
1069 if (dev->board.is_em2800) {
1070 /* the em2800 can only scale down to 50% */
1071 height = height > (3 * maxh / 4) ? maxh : maxh / 2;
1072 width = width > (3 * maxw / 4) ? maxw : maxw / 2;
1073 } else {
1074 /* width must even because of the YUYV format
1075 height must be even because of interlacing */
1076 v4l_bound_align_image(&width, 48, maxw, 1, &height, 32, maxh,
1077 1, 0);
1078 }
1079
1080 get_scale(dev, width, height, &hscale, &vscale);
1081
1082 width = (((unsigned long)maxw) << 12) / (hscale + 4096L);
1083 height = (((unsigned long)maxh) << 12) / (vscale + 4096L);
1084
1085 f->fmt.pix.width = width;
1086 f->fmt.pix.height = height;
1087 f->fmt.pix.pixelformat = fmt->fourcc;
1088 f->fmt.pix.bytesperline = (dev->width * fmt->depth + 7) >> 3;
1089 f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * height;
1090 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
1091 if (dev->progressive)
1092 f->fmt.pix.field = V4L2_FIELD_NONE;
1093 else
1094 f->fmt.pix.field = dev->interlaced ?
1095 V4L2_FIELD_INTERLACED : V4L2_FIELD_TOP;
1096
1097 return 0;
1098}
1099
1100static int em28xx_set_video_format(struct em28xx *dev, unsigned int fourcc,
1101 unsigned width, unsigned height)
1102{
1103 struct em28xx_fmt *fmt;
1104
1105 fmt = format_by_fourcc(fourcc);
1106 if (!fmt)
1107 return -EINVAL;
1108
1109 dev->format = fmt;
1110 dev->width = width;
1111 dev->height = height;
1112
1113 /* set new image size */
1114 get_scale(dev, dev->width, dev->height, &dev->hscale, &dev->vscale);
1115
1116 em28xx_set_alternate(dev);
1117 em28xx_resolution_set(dev);
1118
1119 return 0;
1120}
1121
1122static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
1123 struct v4l2_format *f)
1124{
1125 struct em28xx_fh *fh = priv;
1126 struct em28xx *dev = fh->dev;
1127 int rc;
1128
1129 rc = check_dev(dev);
1130 if (rc < 0)
1131 return rc;
1132
1133 vidioc_try_fmt_vid_cap(file, priv, f);
1134
1135 if (videobuf_queue_is_busy(&fh->vb_vidq)) {
1136 em28xx_errdev("%s queue busy\n", __func__);
1137 return -EBUSY;
1138 }
1139
1140 return em28xx_set_video_format(dev, f->fmt.pix.pixelformat,
1141 f->fmt.pix.width, f->fmt.pix.height);
1142}
1143
1144static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *norm)
1145{
1146 struct em28xx_fh *fh = priv;
1147 struct em28xx *dev = fh->dev;
1148 int rc;
1149
1150 rc = check_dev(dev);
1151 if (rc < 0)
1152 return rc;
1153
1154 *norm = dev->norm;
1155
1156 return 0;
1157}
1158
1159static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *norm)
1160{
1161 struct em28xx_fh *fh = priv;
1162 struct em28xx *dev = fh->dev;
1163 struct v4l2_format f;
1164 int rc;
1165
1166 rc = check_dev(dev);
1167 if (rc < 0)
1168 return rc;
1169
1170 dev->norm = *norm;
1171
1172 /* Adjusts width/height, if needed */
1173 f.fmt.pix.width = dev->width;
1174 f.fmt.pix.height = dev->height;
1175 vidioc_try_fmt_vid_cap(file, priv, &f);
1176
1177 /* set new image size */
1178 dev->width = f.fmt.pix.width;
1179 dev->height = f.fmt.pix.height;
1180 get_scale(dev, dev->width, dev->height, &dev->hscale, &dev->vscale);
1181
1182 em28xx_resolution_set(dev);
1183 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_std, dev->norm);
1184
1185 return 0;
1186}
1187
1188static int vidioc_g_parm(struct file *file, void *priv,
1189 struct v4l2_streamparm *p)
1190{
1191 struct em28xx_fh *fh = priv;
1192 struct em28xx *dev = fh->dev;
1193 int rc = 0;
1194
1195 if (p->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1196 return -EINVAL;
1197
1198 if (dev->board.is_webcam)
1199 rc = v4l2_device_call_until_err(&dev->v4l2_dev, 0,
1200 video, g_parm, p);
1201 else
1202 v4l2_video_std_frame_period(dev->norm,
1203 &p->parm.capture.timeperframe);
1204
1205 return rc;
1206}
1207
1208static int vidioc_s_parm(struct file *file, void *priv,
1209 struct v4l2_streamparm *p)
1210{
1211 struct em28xx_fh *fh = priv;
1212 struct em28xx *dev = fh->dev;
1213
1214 if (!dev->board.is_webcam)
1215 return -EINVAL;
1216
1217 if (p->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1218 return -EINVAL;
1219
1220 return v4l2_device_call_until_err(&dev->v4l2_dev, 0, video, s_parm, p);
1221}
1222
1223static const char *iname[] = {
1224 [EM28XX_VMUX_COMPOSITE1] = "Composite1",
1225 [EM28XX_VMUX_COMPOSITE2] = "Composite2",
1226 [EM28XX_VMUX_COMPOSITE3] = "Composite3",
1227 [EM28XX_VMUX_COMPOSITE4] = "Composite4",
1228 [EM28XX_VMUX_SVIDEO] = "S-Video",
1229 [EM28XX_VMUX_TELEVISION] = "Television",
1230 [EM28XX_VMUX_CABLE] = "Cable TV",
1231 [EM28XX_VMUX_DVB] = "DVB",
1232 [EM28XX_VMUX_DEBUG] = "for debug only",
1233};
1234
1235static int vidioc_enum_input(struct file *file, void *priv,
1236 struct v4l2_input *i)
1237{
1238 struct em28xx_fh *fh = priv;
1239 struct em28xx *dev = fh->dev;
1240 unsigned int n;
1241
1242 n = i->index;
1243 if (n >= MAX_EM28XX_INPUT)
1244 return -EINVAL;
1245 if (0 == INPUT(n)->type)
1246 return -EINVAL;
1247
1248 i->index = n;
1249 i->type = V4L2_INPUT_TYPE_CAMERA;
1250
1251 strcpy(i->name, iname[INPUT(n)->type]);
1252
1253 if ((EM28XX_VMUX_TELEVISION == INPUT(n)->type) ||
1254 (EM28XX_VMUX_CABLE == INPUT(n)->type))
1255 i->type = V4L2_INPUT_TYPE_TUNER;
1256
1257 i->std = dev->vdev->tvnorms;
1258
1259 return 0;
1260}
1261
1262static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
1263{
1264 struct em28xx_fh *fh = priv;
1265 struct em28xx *dev = fh->dev;
1266
1267 *i = dev->ctl_input;
1268
1269 return 0;
1270}
1271
1272static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
1273{
1274 struct em28xx_fh *fh = priv;
1275 struct em28xx *dev = fh->dev;
1276 int rc;
1277
1278 rc = check_dev(dev);
1279 if (rc < 0)
1280 return rc;
1281
1282 if (i >= MAX_EM28XX_INPUT)
1283 return -EINVAL;
1284 if (0 == INPUT(i)->type)
1285 return -EINVAL;
1286
1287 dev->ctl_input = i;
1288
1289 video_mux(dev, dev->ctl_input);
1290 return 0;
1291}
1292
1293static int vidioc_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
1294{
1295 struct em28xx_fh *fh = priv;
1296 struct em28xx *dev = fh->dev;
1297
1298 if (!dev->audio_mode.has_audio)
1299 return -EINVAL;
1300
1301 switch (a->index) {
1302 case EM28XX_AMUX_VIDEO:
1303 strcpy(a->name, "Television");
1304 break;
1305 case EM28XX_AMUX_LINE_IN:
1306 strcpy(a->name, "Line In");
1307 break;
1308 case EM28XX_AMUX_VIDEO2:
1309 strcpy(a->name, "Television alt");
1310 break;
1311 case EM28XX_AMUX_PHONE:
1312 strcpy(a->name, "Phone");
1313 break;
1314 case EM28XX_AMUX_MIC:
1315 strcpy(a->name, "Mic");
1316 break;
1317 case EM28XX_AMUX_CD:
1318 strcpy(a->name, "CD");
1319 break;
1320 case EM28XX_AMUX_AUX:
1321 strcpy(a->name, "Aux");
1322 break;
1323 case EM28XX_AMUX_PCM_OUT:
1324 strcpy(a->name, "PCM");
1325 break;
1326 default:
1327 return -EINVAL;
1328 }
1329
1330 a->index = dev->ctl_ainput;
1331 a->capability = V4L2_AUDCAP_STEREO;
1332
1333 return 0;
1334}
1335
1336static int vidioc_s_audio(struct file *file, void *priv, struct v4l2_audio *a)
1337{
1338 struct em28xx_fh *fh = priv;
1339 struct em28xx *dev = fh->dev;
1340
1341
1342 if (!dev->audio_mode.has_audio)
1343 return -EINVAL;
1344
1345 if (a->index >= MAX_EM28XX_INPUT)
1346 return -EINVAL;
1347 if (0 == INPUT(a->index)->type)
1348 return -EINVAL;
1349
1350 dev->ctl_ainput = INPUT(a->index)->amux;
1351 dev->ctl_aoutput = INPUT(a->index)->aout;
1352
1353 if (!dev->ctl_aoutput)
1354 dev->ctl_aoutput = EM28XX_AOUT_MASTER;
1355
1356 return 0;
1357}
1358
1359static int vidioc_queryctrl(struct file *file, void *priv,
1360 struct v4l2_queryctrl *qc)
1361{
1362 struct em28xx_fh *fh = priv;
1363 struct em28xx *dev = fh->dev;
1364 int id = qc->id;
1365 int rc;
1366
1367 rc = check_dev(dev);
1368 if (rc < 0)
1369 return rc;
1370
1371 memset(qc, 0, sizeof(*qc));
1372
1373 qc->id = id;
1374
1375 /* enumerate AC97 controls */
1376 if (dev->audio_mode.ac97 != EM28XX_NO_AC97) {
1377 rc = ac97_queryctrl(qc);
1378 if (!rc)
1379 return 0;
1380 }
1381
1382 /* enumerate V4L2 device controls */
1383 v4l2_device_call_all(&dev->v4l2_dev, 0, core, queryctrl, qc);
1384
1385 if (qc->type)
1386 return 0;
1387 else
1388 return -EINVAL;
1389}
1390
1391/*
1392 * FIXME: This is an indirect way to check if a control exists at a
1393 * subdev. Instead of that hack, maybe the better would be to change all
1394 * subdevs to return -ENOIOCTLCMD, if an ioctl is not supported.
1395 */
1396static int check_subdev_ctrl(struct em28xx *dev, int id)
1397{
1398 struct v4l2_queryctrl qc;
1399
1400 memset(&qc, 0, sizeof(qc));
1401 qc.id = id;
1402
1403 /* enumerate V4L2 device controls */
1404 v4l2_device_call_all(&dev->v4l2_dev, 0, core, queryctrl, &qc);
1405
1406 if (qc.type)
1407 return 0;
1408 else
1409 return -EINVAL;
1410}
1411
1412static int vidioc_g_ctrl(struct file *file, void *priv,
1413 struct v4l2_control *ctrl)
1414{
1415 struct em28xx_fh *fh = priv;
1416 struct em28xx *dev = fh->dev;
1417 int rc;
1418
1419 rc = check_dev(dev);
1420 if (rc < 0)
1421 return rc;
1422 rc = 0;
1423
1424 /* Set an AC97 control */
1425 if (dev->audio_mode.ac97 != EM28XX_NO_AC97)
1426 rc = ac97_get_ctrl(dev, ctrl);
1427 else
1428 rc = 1;
1429
1430 /* It were not an AC97 control. Sends it to the v4l2 dev interface */
1431 if (rc == 1) {
1432 if (check_subdev_ctrl(dev, ctrl->id))
1433 return -EINVAL;
1434
1435 v4l2_device_call_all(&dev->v4l2_dev, 0, core, g_ctrl, ctrl);
1436 rc = 0;
1437 }
1438
1439 return rc;
1440}
1441
1442static int vidioc_s_ctrl(struct file *file, void *priv,
1443 struct v4l2_control *ctrl)
1444{
1445 struct em28xx_fh *fh = priv;
1446 struct em28xx *dev = fh->dev;
1447 int rc;
1448
1449 rc = check_dev(dev);
1450 if (rc < 0)
1451 return rc;
1452
1453 /* Set an AC97 control */
1454 if (dev->audio_mode.ac97 != EM28XX_NO_AC97)
1455 rc = ac97_set_ctrl(dev, ctrl);
1456 else
1457 rc = 1;
1458
1459 /* It isn't an AC97 control. Sends it to the v4l2 dev interface */
1460 if (rc == 1) {
1461 rc = check_subdev_ctrl(dev, ctrl->id);
1462 if (!rc)
1463 v4l2_device_call_all(&dev->v4l2_dev, 0,
1464 core, s_ctrl, ctrl);
1465 /*
1466 * In the case of non-AC97 volume controls, we still need
1467 * to do some setups at em28xx, in order to mute/unmute
1468 * and to adjust audio volume. However, the value ranges
1469 * should be checked by the corresponding V4L subdriver.
1470 */
1471 switch (ctrl->id) {
1472 case V4L2_CID_AUDIO_MUTE:
1473 dev->mute = ctrl->value;
1474 rc = em28xx_audio_analog_set(dev);
1475 break;
1476 case V4L2_CID_AUDIO_VOLUME:
1477 dev->volume = ctrl->value;
1478 rc = em28xx_audio_analog_set(dev);
1479 }
1480 }
1481 return (rc < 0) ? rc : 0;
1482}
1483
1484static int vidioc_g_tuner(struct file *file, void *priv,
1485 struct v4l2_tuner *t)
1486{
1487 struct em28xx_fh *fh = priv;
1488 struct em28xx *dev = fh->dev;
1489 int rc;
1490
1491 rc = check_dev(dev);
1492 if (rc < 0)
1493 return rc;
1494
1495 if (0 != t->index)
1496 return -EINVAL;
1497
1498 strcpy(t->name, "Tuner");
1499 t->type = V4L2_TUNER_ANALOG_TV;
1500
1501 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_tuner, t);
1502 return 0;
1503}
1504
1505static int vidioc_s_tuner(struct file *file, void *priv,
1506 struct v4l2_tuner *t)
1507{
1508 struct em28xx_fh *fh = priv;
1509 struct em28xx *dev = fh->dev;
1510 int rc;
1511
1512 rc = check_dev(dev);
1513 if (rc < 0)
1514 return rc;
1515
1516 if (0 != t->index)
1517 return -EINVAL;
1518
1519 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_tuner, t);
1520 return 0;
1521}
1522
1523static int vidioc_g_frequency(struct file *file, void *priv,
1524 struct v4l2_frequency *f)
1525{
1526 struct em28xx_fh *fh = priv;
1527 struct em28xx *dev = fh->dev;
1528
1529 f->type = fh->radio ? V4L2_TUNER_RADIO : V4L2_TUNER_ANALOG_TV;
1530 f->frequency = dev->ctl_freq;
1531 return 0;
1532}
1533
1534static int vidioc_s_frequency(struct file *file, void *priv,
1535 struct v4l2_frequency *f)
1536{
1537 struct em28xx_fh *fh = priv;
1538 struct em28xx *dev = fh->dev;
1539 int rc;
1540
1541 rc = check_dev(dev);
1542 if (rc < 0)
1543 return rc;
1544
1545 if (0 != f->tuner)
1546 return -EINVAL;
1547
1548 if (unlikely(0 == fh->radio && f->type != V4L2_TUNER_ANALOG_TV))
1549 return -EINVAL;
1550 if (unlikely(1 == fh->radio && f->type != V4L2_TUNER_RADIO))
1551 return -EINVAL;
1552
1553 dev->ctl_freq = f->frequency;
1554 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_frequency, f);
1555
1556 return 0;
1557}
1558
1559#ifdef CONFIG_VIDEO_ADV_DEBUG
1560static int em28xx_reg_len(int reg)
1561{
1562 switch (reg) {
1563 case EM28XX_R40_AC97LSB:
1564 case EM28XX_R30_HSCALELOW:
1565 case EM28XX_R32_VSCALELOW:
1566 return 2;
1567 default:
1568 return 1;
1569 }
1570}
1571
1572static int vidioc_g_chip_ident(struct file *file, void *priv,
1573 struct v4l2_dbg_chip_ident *chip)
1574{
1575 struct em28xx_fh *fh = priv;
1576 struct em28xx *dev = fh->dev;
1577
1578 chip->ident = V4L2_IDENT_NONE;
1579 chip->revision = 0;
1580
1581 v4l2_device_call_all(&dev->v4l2_dev, 0, core, g_chip_ident, chip);
1582
1583 return 0;
1584}
1585
1586
1587static int vidioc_g_register(struct file *file, void *priv,
1588 struct v4l2_dbg_register *reg)
1589{
1590 struct em28xx_fh *fh = priv;
1591 struct em28xx *dev = fh->dev;
1592 int ret;
1593
1594 switch (reg->match.type) {
1595 case V4L2_CHIP_MATCH_AC97:
1596 ret = em28xx_read_ac97(dev, reg->reg);
1597 if (ret < 0)
1598 return ret;
1599
1600 reg->val = ret;
1601 reg->size = 1;
1602 return 0;
1603 case V4L2_CHIP_MATCH_I2C_DRIVER:
1604 v4l2_device_call_all(&dev->v4l2_dev, 0, core, g_register, reg);
1605 return 0;
1606 case V4L2_CHIP_MATCH_I2C_ADDR:
1607 /* TODO: is this correct? */
1608 v4l2_device_call_all(&dev->v4l2_dev, 0, core, g_register, reg);
1609 return 0;
1610 default:
1611 if (!v4l2_chip_match_host(&reg->match))
1612 return -EINVAL;
1613 }
1614
1615 /* Match host */
1616 reg->size = em28xx_reg_len(reg->reg);
1617 if (reg->size == 1) {
1618 ret = em28xx_read_reg(dev, reg->reg);
1619
1620 if (ret < 0)
1621 return ret;
1622
1623 reg->val = ret;
1624 } else {
1625 __le16 val = 0;
1626 ret = em28xx_read_reg_req_len(dev, USB_REQ_GET_STATUS,
1627 reg->reg, (char *)&val, 2);
1628 if (ret < 0)
1629 return ret;
1630
1631 reg->val = le16_to_cpu(val);
1632 }
1633
1634 return 0;
1635}
1636
1637static int vidioc_s_register(struct file *file, void *priv,
1638 struct v4l2_dbg_register *reg)
1639{
1640 struct em28xx_fh *fh = priv;
1641 struct em28xx *dev = fh->dev;
1642 __le16 buf;
1643
1644 switch (reg->match.type) {
1645 case V4L2_CHIP_MATCH_AC97:
1646 return em28xx_write_ac97(dev, reg->reg, reg->val);
1647 case V4L2_CHIP_MATCH_I2C_DRIVER:
1648 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_register, reg);
1649 return 0;
1650 case V4L2_CHIP_MATCH_I2C_ADDR:
1651 /* TODO: is this correct? */
1652 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_register, reg);
1653 return 0;
1654 default:
1655 if (!v4l2_chip_match_host(&reg->match))
1656 return -EINVAL;
1657 }
1658
1659 /* Match host */
1660 buf = cpu_to_le16(reg->val);
1661
1662 return em28xx_write_regs(dev, reg->reg, (char *)&buf,
1663 em28xx_reg_len(reg->reg));
1664}
1665#endif
1666
1667
1668static int vidioc_cropcap(struct file *file, void *priv,
1669 struct v4l2_cropcap *cc)
1670{
1671 struct em28xx_fh *fh = priv;
1672 struct em28xx *dev = fh->dev;
1673
1674 if (cc->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1675 return -EINVAL;
1676
1677 cc->bounds.left = 0;
1678 cc->bounds.top = 0;
1679 cc->bounds.width = dev->width;
1680 cc->bounds.height = dev->height;
1681 cc->defrect = cc->bounds;
1682 cc->pixelaspect.numerator = 54; /* 4:3 FIXME: remove magic numbers */
1683 cc->pixelaspect.denominator = 59;
1684
1685 return 0;
1686}
1687
1688static int vidioc_streamon(struct file *file, void *priv,
1689 enum v4l2_buf_type type)
1690{
1691 struct em28xx_fh *fh = priv;
1692 struct em28xx *dev = fh->dev;
1693 int rc = -EINVAL;
1694
1695 rc = check_dev(dev);
1696 if (rc < 0)
1697 return rc;
1698
1699 if (unlikely(type != fh->type))
1700 return -EINVAL;
1701
1702 em28xx_videodbg("vidioc_streamon fh=%p t=%d fh->res=%d dev->res=%d\n",
1703 fh, type, fh->resources, dev->resources);
1704
1705 if (unlikely(!res_get(fh, get_ressource(fh))))
1706 return -EBUSY;
1707
1708 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1709 rc = videobuf_streamon(&fh->vb_vidq);
1710 else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
1711 rc = videobuf_streamon(&fh->vb_vbiq);
1712
1713 return rc;
1714}
1715
1716static int vidioc_streamoff(struct file *file, void *priv,
1717 enum v4l2_buf_type type)
1718{
1719 struct em28xx_fh *fh = priv;
1720 struct em28xx *dev = fh->dev;
1721 int rc;
1722
1723 rc = check_dev(dev);
1724 if (rc < 0)
1725 return rc;
1726
1727 if (fh->type != V4L2_BUF_TYPE_VIDEO_CAPTURE &&
1728 fh->type != V4L2_BUF_TYPE_VBI_CAPTURE)
1729 return -EINVAL;
1730 if (type != fh->type)
1731 return -EINVAL;
1732
1733 em28xx_videodbg("vidioc_streamoff fh=%p t=%d fh->res=%d dev->res=%d\n",
1734 fh, type, fh->resources, dev->resources);
1735
1736 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1737 if (res_check(fh, EM28XX_RESOURCE_VIDEO)) {
1738 videobuf_streamoff(&fh->vb_vidq);
1739 res_free(fh, EM28XX_RESOURCE_VIDEO);
1740 }
1741 } else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
1742 if (res_check(fh, EM28XX_RESOURCE_VBI)) {
1743 videobuf_streamoff(&fh->vb_vbiq);
1744 res_free(fh, EM28XX_RESOURCE_VBI);
1745 }
1746 }
1747
1748 return 0;
1749}
1750
1751static int vidioc_querycap(struct file *file, void *priv,
1752 struct v4l2_capability *cap)
1753{
1754 struct em28xx_fh *fh = priv;
1755 struct em28xx *dev = fh->dev;
1756
1757 strlcpy(cap->driver, "em28xx", sizeof(cap->driver));
1758 strlcpy(cap->card, em28xx_boards[dev->model].name, sizeof(cap->card));
1759 usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
1760
1761 cap->capabilities =
1762 V4L2_CAP_SLICED_VBI_CAPTURE |
1763 V4L2_CAP_VIDEO_CAPTURE |
1764 V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
1765
1766 if (dev->vbi_dev)
1767 cap->capabilities |= V4L2_CAP_VBI_CAPTURE;
1768
1769 if (dev->audio_mode.has_audio)
1770 cap->capabilities |= V4L2_CAP_AUDIO;
1771
1772 if (dev->tuner_type != TUNER_ABSENT)
1773 cap->capabilities |= V4L2_CAP_TUNER;
1774
1775 return 0;
1776}
1777
1778static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
1779 struct v4l2_fmtdesc *f)
1780{
1781 if (unlikely(f->index >= ARRAY_SIZE(format)))
1782 return -EINVAL;
1783
1784 strlcpy(f->description, format[f->index].name, sizeof(f->description));
1785 f->pixelformat = format[f->index].fourcc;
1786
1787 return 0;
1788}
1789
1790/* Sliced VBI ioctls */
1791static int vidioc_g_fmt_sliced_vbi_cap(struct file *file, void *priv,
1792 struct v4l2_format *f)
1793{
1794 struct em28xx_fh *fh = priv;
1795 struct em28xx *dev = fh->dev;
1796 int rc;
1797
1798 rc = check_dev(dev);
1799 if (rc < 0)
1800 return rc;
1801
1802 f->fmt.sliced.service_set = 0;
1803 v4l2_device_call_all(&dev->v4l2_dev, 0, vbi, g_sliced_fmt, &f->fmt.sliced);
1804
1805 if (f->fmt.sliced.service_set == 0)
1806 rc = -EINVAL;
1807
1808 return rc;
1809}
1810
1811static int vidioc_try_set_sliced_vbi_cap(struct file *file, void *priv,
1812 struct v4l2_format *f)
1813{
1814 struct em28xx_fh *fh = priv;
1815 struct em28xx *dev = fh->dev;
1816 int rc;
1817
1818 rc = check_dev(dev);
1819 if (rc < 0)
1820 return rc;
1821
1822 v4l2_device_call_all(&dev->v4l2_dev, 0, vbi, g_sliced_fmt, &f->fmt.sliced);
1823
1824 if (f->fmt.sliced.service_set == 0)
1825 return -EINVAL;
1826
1827 return 0;
1828}
1829
1830/* RAW VBI ioctls */
1831
1832static int vidioc_g_fmt_vbi_cap(struct file *file, void *priv,
1833 struct v4l2_format *format)
1834{
1835 struct em28xx_fh *fh = priv;
1836 struct em28xx *dev = fh->dev;
1837
1838 format->fmt.vbi.samples_per_line = dev->vbi_width;
1839 format->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
1840 format->fmt.vbi.offset = 0;
1841 format->fmt.vbi.flags = 0;
1842 format->fmt.vbi.sampling_rate = 6750000 * 4 / 2;
1843 format->fmt.vbi.count[0] = dev->vbi_height;
1844 format->fmt.vbi.count[1] = dev->vbi_height;
1845
1846 /* Varies by video standard (NTSC, PAL, etc.) */
1847 if (dev->norm & V4L2_STD_525_60) {
1848 /* NTSC */
1849 format->fmt.vbi.start[0] = 10;
1850 format->fmt.vbi.start[1] = 273;
1851 } else if (dev->norm & V4L2_STD_625_50) {
1852 /* PAL */
1853 format->fmt.vbi.start[0] = 6;
1854 format->fmt.vbi.start[1] = 318;
1855 }
1856
1857 return 0;
1858}
1859
1860static int vidioc_s_fmt_vbi_cap(struct file *file, void *priv,
1861 struct v4l2_format *format)
1862{
1863 struct em28xx_fh *fh = priv;
1864 struct em28xx *dev = fh->dev;
1865
1866 format->fmt.vbi.samples_per_line = dev->vbi_width;
1867 format->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
1868 format->fmt.vbi.offset = 0;
1869 format->fmt.vbi.flags = 0;
1870 format->fmt.vbi.sampling_rate = 6750000 * 4 / 2;
1871 format->fmt.vbi.count[0] = dev->vbi_height;
1872 format->fmt.vbi.count[1] = dev->vbi_height;
1873
1874 /* Varies by video standard (NTSC, PAL, etc.) */
1875 if (dev->norm & V4L2_STD_525_60) {
1876 /* NTSC */
1877 format->fmt.vbi.start[0] = 10;
1878 format->fmt.vbi.start[1] = 273;
1879 } else if (dev->norm & V4L2_STD_625_50) {
1880 /* PAL */
1881 format->fmt.vbi.start[0] = 6;
1882 format->fmt.vbi.start[1] = 318;
1883 }
1884
1885 return 0;
1886}
1887
1888static int vidioc_reqbufs(struct file *file, void *priv,
1889 struct v4l2_requestbuffers *rb)
1890{
1891 struct em28xx_fh *fh = priv;
1892 struct em28xx *dev = fh->dev;
1893 int rc;
1894
1895 rc = check_dev(dev);
1896 if (rc < 0)
1897 return rc;
1898
1899 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1900 return videobuf_reqbufs(&fh->vb_vidq, rb);
1901 else
1902 return videobuf_reqbufs(&fh->vb_vbiq, rb);
1903}
1904
1905static int vidioc_querybuf(struct file *file, void *priv,
1906 struct v4l2_buffer *b)
1907{
1908 struct em28xx_fh *fh = priv;
1909 struct em28xx *dev = fh->dev;
1910 int rc;
1911
1912 rc = check_dev(dev);
1913 if (rc < 0)
1914 return rc;
1915
1916 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1917 return videobuf_querybuf(&fh->vb_vidq, b);
1918 else {
1919 /* FIXME: I'm not sure yet whether this is a bug in zvbi or
1920 the videobuf framework, but we probably shouldn't be
1921 returning a buffer larger than that which was asked for.
1922 At a minimum, it causes a crash in zvbi since it does
1923 a memcpy based on the source buffer length */
1924 int result = videobuf_querybuf(&fh->vb_vbiq, b);
1925 b->length = dev->vbi_width * dev->vbi_height * 2;
1926
1927 return result;
1928 }
1929}
1930
1931static int vidioc_qbuf(struct file *file, void *priv, struct v4l2_buffer *b)
1932{
1933 struct em28xx_fh *fh = priv;
1934 struct em28xx *dev = fh->dev;
1935 int rc;
1936
1937 rc = check_dev(dev);
1938 if (rc < 0)
1939 return rc;
1940
1941 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1942 return videobuf_qbuf(&fh->vb_vidq, b);
1943 else
1944 return videobuf_qbuf(&fh->vb_vbiq, b);
1945}
1946
1947static int vidioc_dqbuf(struct file *file, void *priv, struct v4l2_buffer *b)
1948{
1949 struct em28xx_fh *fh = priv;
1950 struct em28xx *dev = fh->dev;
1951 int rc;
1952
1953 rc = check_dev(dev);
1954 if (rc < 0)
1955 return rc;
1956
1957 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
1958 return videobuf_dqbuf(&fh->vb_vidq, b, file->f_flags &
1959 O_NONBLOCK);
1960 else
1961 return videobuf_dqbuf(&fh->vb_vbiq, b, file->f_flags &
1962 O_NONBLOCK);
1963}
1964
1965/* ----------------------------------------------------------- */
1966/* RADIO ESPECIFIC IOCTLS */
1967/* ----------------------------------------------------------- */
1968
1969static int radio_querycap(struct file *file, void *priv,
1970 struct v4l2_capability *cap)
1971{
1972 struct em28xx *dev = ((struct em28xx_fh *)priv)->dev;
1973
1974 strlcpy(cap->driver, "em28xx", sizeof(cap->driver));
1975 strlcpy(cap->card, em28xx_boards[dev->model].name, sizeof(cap->card));
1976 usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
1977
1978 cap->capabilities = V4L2_CAP_TUNER;
1979 return 0;
1980}
1981
1982static int radio_g_tuner(struct file *file, void *priv,
1983 struct v4l2_tuner *t)
1984{
1985 struct em28xx *dev = ((struct em28xx_fh *)priv)->dev;
1986
1987 if (unlikely(t->index > 0))
1988 return -EINVAL;
1989
1990 strcpy(t->name, "Radio");
1991 t->type = V4L2_TUNER_RADIO;
1992
1993 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_tuner, t);
1994
1995 return 0;
1996}
1997
1998static int radio_enum_input(struct file *file, void *priv,
1999 struct v4l2_input *i)
2000{
2001 if (i->index != 0)
2002 return -EINVAL;
2003 strcpy(i->name, "Radio");
2004 i->type = V4L2_INPUT_TYPE_TUNER;
2005
2006 return 0;
2007}
2008
2009static int radio_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
2010{
2011 if (unlikely(a->index))
2012 return -EINVAL;
2013
2014 strcpy(a->name, "Radio");
2015 return 0;
2016}
2017
2018static int radio_s_tuner(struct file *file, void *priv,
2019 struct v4l2_tuner *t)
2020{
2021 struct em28xx *dev = ((struct em28xx_fh *)priv)->dev;
2022
2023 if (0 != t->index)
2024 return -EINVAL;
2025
2026 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_tuner, t);
2027
2028 return 0;
2029}
2030
2031static int radio_s_audio(struct file *file, void *fh,
2032 struct v4l2_audio *a)
2033{
2034 return 0;
2035}
2036
2037static int radio_s_input(struct file *file, void *fh, unsigned int i)
2038{
2039 return 0;
2040}
2041
2042static int radio_queryctrl(struct file *file, void *priv,
2043 struct v4l2_queryctrl *qc)
2044{
2045 int i;
2046
2047 if (qc->id < V4L2_CID_BASE ||
2048 qc->id >= V4L2_CID_LASTP1)
2049 return -EINVAL;
2050
2051 for (i = 0; i < ARRAY_SIZE(ac97_qctrl); i++) {
2052 if (qc->id && qc->id == ac97_qctrl[i].id) {
2053 memcpy(qc, &(ac97_qctrl[i]), sizeof(*qc));
2054 return 0;
2055 }
2056 }
2057
2058 return -EINVAL;
2059}
2060
2061/*
2062 * em28xx_v4l2_open()
2063 * inits the device and starts isoc transfer
2064 */
2065static int em28xx_v4l2_open(struct file *filp)
2066{
2067 int errCode = 0, radio = 0;
2068 struct video_device *vdev = video_devdata(filp);
2069 struct em28xx *dev = video_drvdata(filp);
2070 enum v4l2_buf_type fh_type = 0;
2071 struct em28xx_fh *fh;
2072 enum v4l2_field field;
2073
2074 switch (vdev->vfl_type) {
2075 case VFL_TYPE_GRABBER:
2076 fh_type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
2077 break;
2078 case VFL_TYPE_VBI:
2079 fh_type = V4L2_BUF_TYPE_VBI_CAPTURE;
2080 break;
2081 case VFL_TYPE_RADIO:
2082 radio = 1;
2083 break;
2084 }
2085
2086 em28xx_videodbg("open dev=%s type=%s users=%d\n",
2087 video_device_node_name(vdev), v4l2_type_names[fh_type],
2088 dev->users);
2089
2090
2091 fh = kzalloc(sizeof(struct em28xx_fh), GFP_KERNEL);
2092 if (!fh) {
2093 em28xx_errdev("em28xx-video.c: Out of memory?!\n");
2094 return -ENOMEM;
2095 }
2096 fh->dev = dev;
2097 fh->radio = radio;
2098 fh->type = fh_type;
2099 filp->private_data = fh;
2100
2101 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE && dev->users == 0) {
2102 em28xx_set_mode(dev, EM28XX_ANALOG_MODE);
2103 em28xx_set_alternate(dev);
2104 em28xx_resolution_set(dev);
2105
2106 /* Needed, since GPIO might have disabled power of
2107 some i2c device
2108 */
2109 em28xx_wake_i2c(dev);
2110
2111 }
2112 if (fh->radio) {
2113 em28xx_videodbg("video_open: setting radio device\n");
2114 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_radio);
2115 }
2116
2117 dev->users++;
2118
2119 if (dev->progressive)
2120 field = V4L2_FIELD_NONE;
2121 else
2122 field = V4L2_FIELD_INTERLACED;
2123
2124 videobuf_queue_vmalloc_init(&fh->vb_vidq, &em28xx_video_qops,
2125 NULL, &dev->slock,
2126 V4L2_BUF_TYPE_VIDEO_CAPTURE, field,
2127 sizeof(struct em28xx_buffer), fh, &dev->lock);
2128
2129 videobuf_queue_vmalloc_init(&fh->vb_vbiq, &em28xx_vbi_qops,
2130 NULL, &dev->slock,
2131 V4L2_BUF_TYPE_VBI_CAPTURE,
2132 V4L2_FIELD_SEQ_TB,
2133 sizeof(struct em28xx_buffer), fh, &dev->lock);
2134
2135 return errCode;
2136}
2137
2138/*
2139 * em28xx_realease_resources()
2140 * unregisters the v4l2,i2c and usb devices
2141 * called when the device gets disconected or at module unload
2142*/
2143void em28xx_release_analog_resources(struct em28xx *dev)
2144{
2145
2146 /*FIXME: I2C IR should be disconnected */
2147
2148 if (dev->radio_dev) {
2149 if (video_is_registered(dev->radio_dev))
2150 video_unregister_device(dev->radio_dev);
2151 else
2152 video_device_release(dev->radio_dev);
2153 dev->radio_dev = NULL;
2154 }
2155 if (dev->vbi_dev) {
2156 em28xx_info("V4L2 device %s deregistered\n",
2157 video_device_node_name(dev->vbi_dev));
2158 if (video_is_registered(dev->vbi_dev))
2159 video_unregister_device(dev->vbi_dev);
2160 else
2161 video_device_release(dev->vbi_dev);
2162 dev->vbi_dev = NULL;
2163 }
2164 if (dev->vdev) {
2165 em28xx_info("V4L2 device %s deregistered\n",
2166 video_device_node_name(dev->vdev));
2167 if (video_is_registered(dev->vdev))
2168 video_unregister_device(dev->vdev);
2169 else
2170 video_device_release(dev->vdev);
2171 dev->vdev = NULL;
2172 }
2173}
2174
2175/*
2176 * em28xx_v4l2_close()
2177 * stops streaming and deallocates all resources allocated by the v4l2
2178 * calls and ioctls
2179 */
2180static int em28xx_v4l2_close(struct file *filp)
2181{
2182 struct em28xx_fh *fh = filp->private_data;
2183 struct em28xx *dev = fh->dev;
2184 int errCode;
2185
2186 em28xx_videodbg("users=%d\n", dev->users);
2187
2188 if (res_check(fh, EM28XX_RESOURCE_VIDEO)) {
2189 videobuf_stop(&fh->vb_vidq);
2190 res_free(fh, EM28XX_RESOURCE_VIDEO);
2191 }
2192
2193 if (res_check(fh, EM28XX_RESOURCE_VBI)) {
2194 videobuf_stop(&fh->vb_vbiq);
2195 res_free(fh, EM28XX_RESOURCE_VBI);
2196 }
2197
2198 if (dev->users == 1) {
2199 /* the device is already disconnect,
2200 free the remaining resources */
2201 if (dev->state & DEV_DISCONNECTED) {
2202 em28xx_release_resources(dev);
2203 kfree(dev);
2204 return 0;
2205 }
2206
2207 /* Save some power by putting tuner to sleep */
2208 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_power, 0);
2209
2210 /* do this before setting alternate! */
2211 em28xx_uninit_isoc(dev);
2212 em28xx_set_mode(dev, EM28XX_SUSPEND);
2213
2214 /* set alternate 0 */
2215 dev->alt = 0;
2216 em28xx_videodbg("setting alternate 0\n");
2217 errCode = usb_set_interface(dev->udev, 0, 0);
2218 if (errCode < 0) {
2219 em28xx_errdev("cannot change alternate number to "
2220 "0 (error=%i)\n", errCode);
2221 }
2222 }
2223
2224 videobuf_mmap_free(&fh->vb_vidq);
2225 videobuf_mmap_free(&fh->vb_vbiq);
2226 kfree(fh);
2227 dev->users--;
2228 wake_up_interruptible_nr(&dev->open, 1);
2229 return 0;
2230}
2231
2232/*
2233 * em28xx_v4l2_read()
2234 * will allocate buffers when called for the first time
2235 */
2236static ssize_t
2237em28xx_v4l2_read(struct file *filp, char __user *buf, size_t count,
2238 loff_t *pos)
2239{
2240 struct em28xx_fh *fh = filp->private_data;
2241 struct em28xx *dev = fh->dev;
2242 int rc;
2243
2244 rc = check_dev(dev);
2245 if (rc < 0)
2246 return rc;
2247
2248 /* FIXME: read() is not prepared to allow changing the video
2249 resolution while streaming. Seems a bug at em28xx_set_fmt
2250 */
2251
2252 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
2253 if (res_locked(dev, EM28XX_RESOURCE_VIDEO))
2254 return -EBUSY;
2255
2256 return videobuf_read_stream(&fh->vb_vidq, buf, count, pos, 0,
2257 filp->f_flags & O_NONBLOCK);
2258 }
2259
2260
2261 if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
2262 if (!res_get(fh, EM28XX_RESOURCE_VBI))
2263 return -EBUSY;
2264
2265 return videobuf_read_stream(&fh->vb_vbiq, buf, count, pos, 0,
2266 filp->f_flags & O_NONBLOCK);
2267 }
2268
2269 return 0;
2270}
2271
2272/*
2273 * em28xx_v4l2_poll()
2274 * will allocate buffers when called for the first time
2275 */
2276static unsigned int em28xx_v4l2_poll(struct file *filp, poll_table *wait)
2277{
2278 struct em28xx_fh *fh = filp->private_data;
2279 struct em28xx *dev = fh->dev;
2280 int rc;
2281
2282 rc = check_dev(dev);
2283 if (rc < 0)
2284 return rc;
2285
2286 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE) {
2287 if (!res_get(fh, EM28XX_RESOURCE_VIDEO))
2288 return POLLERR;
2289 return videobuf_poll_stream(filp, &fh->vb_vidq, wait);
2290 } else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE) {
2291 if (!res_get(fh, EM28XX_RESOURCE_VBI))
2292 return POLLERR;
2293 return videobuf_poll_stream(filp, &fh->vb_vbiq, wait);
2294 } else {
2295 return POLLERR;
2296 }
2297}
2298
2299/*
2300 * em28xx_v4l2_mmap()
2301 */
2302static int em28xx_v4l2_mmap(struct file *filp, struct vm_area_struct *vma)
2303{
2304 struct em28xx_fh *fh = filp->private_data;
2305 struct em28xx *dev = fh->dev;
2306 int rc;
2307
2308 rc = check_dev(dev);
2309 if (rc < 0)
2310 return rc;
2311
2312 if (fh->type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
2313 rc = videobuf_mmap_mapper(&fh->vb_vidq, vma);
2314 else if (fh->type == V4L2_BUF_TYPE_VBI_CAPTURE)
2315 rc = videobuf_mmap_mapper(&fh->vb_vbiq, vma);
2316
2317 em28xx_videodbg("vma start=0x%08lx, size=%ld, ret=%d\n",
2318 (unsigned long)vma->vm_start,
2319 (unsigned long)vma->vm_end-(unsigned long)vma->vm_start,
2320 rc);
2321
2322 return rc;
2323}
2324
2325static const struct v4l2_file_operations em28xx_v4l_fops = {
2326 .owner = THIS_MODULE,
2327 .open = em28xx_v4l2_open,
2328 .release = em28xx_v4l2_close,
2329 .read = em28xx_v4l2_read,
2330 .poll = em28xx_v4l2_poll,
2331 .mmap = em28xx_v4l2_mmap,
2332 .unlocked_ioctl = video_ioctl2,
2333};
2334
2335static const struct v4l2_ioctl_ops video_ioctl_ops = {
2336 .vidioc_querycap = vidioc_querycap,
2337 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
2338 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
2339 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
2340 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
2341 .vidioc_g_fmt_vbi_cap = vidioc_g_fmt_vbi_cap,
2342 .vidioc_s_fmt_vbi_cap = vidioc_s_fmt_vbi_cap,
2343 .vidioc_g_audio = vidioc_g_audio,
2344 .vidioc_s_audio = vidioc_s_audio,
2345 .vidioc_cropcap = vidioc_cropcap,
2346
2347 .vidioc_g_fmt_sliced_vbi_cap = vidioc_g_fmt_sliced_vbi_cap,
2348 .vidioc_try_fmt_sliced_vbi_cap = vidioc_try_set_sliced_vbi_cap,
2349 .vidioc_s_fmt_sliced_vbi_cap = vidioc_try_set_sliced_vbi_cap,
2350
2351 .vidioc_reqbufs = vidioc_reqbufs,
2352 .vidioc_querybuf = vidioc_querybuf,
2353 .vidioc_qbuf = vidioc_qbuf,
2354 .vidioc_dqbuf = vidioc_dqbuf,
2355 .vidioc_g_std = vidioc_g_std,
2356 .vidioc_s_std = vidioc_s_std,
2357 .vidioc_g_parm = vidioc_g_parm,
2358 .vidioc_s_parm = vidioc_s_parm,
2359 .vidioc_enum_input = vidioc_enum_input,
2360 .vidioc_g_input = vidioc_g_input,
2361 .vidioc_s_input = vidioc_s_input,
2362 .vidioc_queryctrl = vidioc_queryctrl,
2363 .vidioc_g_ctrl = vidioc_g_ctrl,
2364 .vidioc_s_ctrl = vidioc_s_ctrl,
2365 .vidioc_streamon = vidioc_streamon,
2366 .vidioc_streamoff = vidioc_streamoff,
2367 .vidioc_g_tuner = vidioc_g_tuner,
2368 .vidioc_s_tuner = vidioc_s_tuner,
2369 .vidioc_g_frequency = vidioc_g_frequency,
2370 .vidioc_s_frequency = vidioc_s_frequency,
2371#ifdef CONFIG_VIDEO_ADV_DEBUG
2372 .vidioc_g_register = vidioc_g_register,
2373 .vidioc_s_register = vidioc_s_register,
2374 .vidioc_g_chip_ident = vidioc_g_chip_ident,
2375#endif
2376};
2377
2378static const struct video_device em28xx_video_template = {
2379 .fops = &em28xx_v4l_fops,
2380 .release = video_device_release,
2381 .ioctl_ops = &video_ioctl_ops,
2382
2383 .tvnorms = V4L2_STD_ALL,
2384 .current_norm = V4L2_STD_PAL,
2385};
2386
2387static const struct v4l2_file_operations radio_fops = {
2388 .owner = THIS_MODULE,
2389 .open = em28xx_v4l2_open,
2390 .release = em28xx_v4l2_close,
2391 .unlocked_ioctl = video_ioctl2,
2392};
2393
2394static const struct v4l2_ioctl_ops radio_ioctl_ops = {
2395 .vidioc_querycap = radio_querycap,
2396 .vidioc_g_tuner = radio_g_tuner,
2397 .vidioc_enum_input = radio_enum_input,
2398 .vidioc_g_audio = radio_g_audio,
2399 .vidioc_s_tuner = radio_s_tuner,
2400 .vidioc_s_audio = radio_s_audio,
2401 .vidioc_s_input = radio_s_input,
2402 .vidioc_queryctrl = radio_queryctrl,
2403 .vidioc_g_ctrl = vidioc_g_ctrl,
2404 .vidioc_s_ctrl = vidioc_s_ctrl,
2405 .vidioc_g_frequency = vidioc_g_frequency,
2406 .vidioc_s_frequency = vidioc_s_frequency,
2407#ifdef CONFIG_VIDEO_ADV_DEBUG
2408 .vidioc_g_register = vidioc_g_register,
2409 .vidioc_s_register = vidioc_s_register,
2410#endif
2411};
2412
2413static struct video_device em28xx_radio_template = {
2414 .name = "em28xx-radio",
2415 .fops = &radio_fops,
2416 .ioctl_ops = &radio_ioctl_ops,
2417};
2418
2419/******************************** usb interface ******************************/
2420
2421
2422
2423static struct video_device *em28xx_vdev_init(struct em28xx *dev,
2424 const struct video_device *template,
2425 const char *type_name)
2426{
2427 struct video_device *vfd;
2428
2429 vfd = video_device_alloc();
2430 if (NULL == vfd)
2431 return NULL;
2432
2433 *vfd = *template;
2434 vfd->v4l2_dev = &dev->v4l2_dev;
2435 vfd->release = video_device_release;
2436 vfd->debug = video_debug;
2437 vfd->lock = &dev->lock;
2438
2439 snprintf(vfd->name, sizeof(vfd->name), "%s %s",
2440 dev->name, type_name);
2441
2442 video_set_drvdata(vfd, dev);
2443 return vfd;
2444}
2445
2446int em28xx_register_analog_devices(struct em28xx *dev)
2447{
2448 u8 val;
2449 int ret;
2450
2451 printk(KERN_INFO "%s: v4l2 driver version %s\n",
2452 dev->name, EM28XX_VERSION);
2453
2454 /* set default norm */
2455 dev->norm = em28xx_video_template.current_norm;
2456 v4l2_device_call_all(&dev->v4l2_dev, 0, core, s_std, dev->norm);
2457 dev->interlaced = EM28XX_INTERLACED_DEFAULT;
2458 dev->ctl_input = 0;
2459
2460 /* Analog specific initialization */
2461 dev->format = &format[0];
2462 em28xx_set_video_format(dev, format[0].fourcc,
2463 norm_maxw(dev), norm_maxh(dev));
2464
2465 video_mux(dev, dev->ctl_input);
2466
2467 /* Audio defaults */
2468 dev->mute = 1;
2469 dev->volume = 0x1f;
2470
2471/* em28xx_write_reg(dev, EM28XX_R0E_AUDIOSRC, 0xc0); audio register */
2472 val = (u8)em28xx_read_reg(dev, EM28XX_R0F_XCLK);
2473 em28xx_write_reg(dev, EM28XX_R0F_XCLK,
2474 (EM28XX_XCLK_AUDIO_UNMUTE | val));
2475
2476 em28xx_set_outfmt(dev);
2477 em28xx_colorlevels_set_default(dev);
2478 em28xx_compression_disable(dev);
2479
2480 /* allocate and fill video video_device struct */
2481 dev->vdev = em28xx_vdev_init(dev, &em28xx_video_template, "video");
2482 if (!dev->vdev) {
2483 em28xx_errdev("cannot allocate video_device.\n");
2484 return -ENODEV;
2485 }
2486
2487 /* register v4l2 video video_device */
2488 ret = video_register_device(dev->vdev, VFL_TYPE_GRABBER,
2489 video_nr[dev->devno]);
2490 if (ret) {
2491 em28xx_errdev("unable to register video device (error=%i).\n",
2492 ret);
2493 return ret;
2494 }
2495
2496 /* Allocate and fill vbi video_device struct */
2497 if (em28xx_vbi_supported(dev) == 1) {
2498 dev->vbi_dev = em28xx_vdev_init(dev, &em28xx_video_template,
2499 "vbi");
2500
2501 /* register v4l2 vbi video_device */
2502 ret = video_register_device(dev->vbi_dev, VFL_TYPE_VBI,
2503 vbi_nr[dev->devno]);
2504 if (ret < 0) {
2505 em28xx_errdev("unable to register vbi device\n");
2506 return ret;
2507 }
2508 }
2509
2510 if (em28xx_boards[dev->model].radio.type == EM28XX_RADIO) {
2511 dev->radio_dev = em28xx_vdev_init(dev, &em28xx_radio_template,
2512 "radio");
2513 if (!dev->radio_dev) {
2514 em28xx_errdev("cannot allocate video_device.\n");
2515 return -ENODEV;
2516 }
2517 ret = video_register_device(dev->radio_dev, VFL_TYPE_RADIO,
2518 radio_nr[dev->devno]);
2519 if (ret < 0) {
2520 em28xx_errdev("can't register radio device\n");
2521 return ret;
2522 }
2523 em28xx_info("Registered radio device as %s\n",
2524 video_device_node_name(dev->radio_dev));
2525 }
2526
2527 em28xx_info("V4L2 video device registered as %s\n",
2528 video_device_node_name(dev->vdev));
2529
2530 if (dev->vbi_dev)
2531 em28xx_info("V4L2 VBI device registered as %s\n",
2532 video_device_node_name(dev->vbi_dev));
2533
2534 return 0;
2535}
diff --git a/drivers/media/video/em28xx/em28xx.h b/drivers/media/video/em28xx/em28xx.h
new file mode 100644
index 00000000000..d80658bf3da
--- /dev/null
+++ b/drivers/media/video/em28xx/em28xx.h
@@ -0,0 +1,845 @@
1/*
2 em28xx.h - driver for Empia EM2800/EM2820/2840 USB video capture devices
3
4 Copyright (C) 2005 Markus Rechberger <mrechberger@gmail.com>
5 Ludovico Cavedon <cavedon@sssup.it>
6 Mauro Carvalho Chehab <mchehab@infradead.org>
7
8 Based on the em2800 driver from Sascha Sommer <saschasommer@freenet.de>
9
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 */
24
25#ifndef _EM28XX_H
26#define _EM28XX_H
27
28#include <linux/workqueue.h>
29#include <linux/i2c.h>
30#include <linux/mutex.h>
31#include <linux/videodev2.h>
32
33#include <media/videobuf-vmalloc.h>
34#include <media/v4l2-device.h>
35#include <media/ir-kbd-i2c.h>
36#include <media/rc-core.h>
37#if defined(CONFIG_VIDEO_EM28XX_DVB) || defined(CONFIG_VIDEO_EM28XX_DVB_MODULE)
38#include <media/videobuf-dvb.h>
39#endif
40#include "tuner-xc2028.h"
41#include "em28xx-reg.h"
42
43/* Boards supported by driver */
44#define EM2800_BOARD_UNKNOWN 0
45#define EM2820_BOARD_UNKNOWN 1
46#define EM2820_BOARD_TERRATEC_CINERGY_250 2
47#define EM2820_BOARD_PINNACLE_USB_2 3
48#define EM2820_BOARD_HAUPPAUGE_WINTV_USB_2 4
49#define EM2820_BOARD_MSI_VOX_USB_2 5
50#define EM2800_BOARD_TERRATEC_CINERGY_200 6
51#define EM2800_BOARD_LEADTEK_WINFAST_USBII 7
52#define EM2800_BOARD_KWORLD_USB2800 8
53#define EM2820_BOARD_PINNACLE_DVC_90 9
54#define EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900 10
55#define EM2880_BOARD_TERRATEC_HYBRID_XS 11
56#define EM2820_BOARD_KWORLD_PVRTV2800RF 12
57#define EM2880_BOARD_TERRATEC_PRODIGY_XS 13
58#define EM2820_BOARD_PROLINK_PLAYTV_USB2 14
59#define EM2800_BOARD_VGEAR_POCKETTV 15
60#define EM2883_BOARD_HAUPPAUGE_WINTV_HVR_950 16
61#define EM2880_BOARD_PINNACLE_PCTV_HD_PRO 17
62#define EM2880_BOARD_HAUPPAUGE_WINTV_HVR_900_R2 18
63#define EM2860_BOARD_SAA711X_REFERENCE_DESIGN 19
64#define EM2880_BOARD_AMD_ATI_TV_WONDER_HD_600 20
65#define EM2800_BOARD_GRABBEEX_USB2800 21
66#define EM2750_BOARD_UNKNOWN 22
67#define EM2750_BOARD_DLCW_130 23
68#define EM2820_BOARD_DLINK_USB_TV 24
69#define EM2820_BOARD_GADMEI_UTV310 25
70#define EM2820_BOARD_HERCULES_SMART_TV_USB2 26
71#define EM2820_BOARD_PINNACLE_USB_2_FM1216ME 27
72#define EM2820_BOARD_LEADTEK_WINFAST_USBII_DELUXE 28
73#define EM2860_BOARD_TVP5150_REFERENCE_DESIGN 29
74#define EM2820_BOARD_VIDEOLOGY_20K14XUSB 30
75#define EM2821_BOARD_USBGEAR_VD204 31
76#define EM2821_BOARD_SUPERCOMP_USB_2 32
77#define EM2860_BOARD_ELGATO_VIDEO_CAPTURE 33
78#define EM2860_BOARD_TERRATEC_HYBRID_XS 34
79#define EM2860_BOARD_TYPHOON_DVD_MAKER 35
80#define EM2860_BOARD_NETGMBH_CAM 36
81#define EM2860_BOARD_GADMEI_UTV330 37
82#define EM2861_BOARD_YAKUMO_MOVIE_MIXER 38
83#define EM2861_BOARD_KWORLD_PVRTV_300U 39
84#define EM2861_BOARD_PLEXTOR_PX_TV100U 40
85#define EM2870_BOARD_KWORLD_350U 41
86#define EM2870_BOARD_KWORLD_355U 42
87#define EM2870_BOARD_TERRATEC_XS 43
88#define EM2870_BOARD_TERRATEC_XS_MT2060 44
89#define EM2870_BOARD_PINNACLE_PCTV_DVB 45
90#define EM2870_BOARD_COMPRO_VIDEOMATE 46
91#define EM2880_BOARD_KWORLD_DVB_305U 47
92#define EM2880_BOARD_KWORLD_DVB_310U 48
93#define EM2880_BOARD_MSI_DIGIVOX_AD 49
94#define EM2880_BOARD_MSI_DIGIVOX_AD_II 50
95#define EM2880_BOARD_TERRATEC_HYBRID_XS_FR 51
96#define EM2881_BOARD_DNT_DA2_HYBRID 52
97#define EM2881_BOARD_PINNACLE_HYBRID_PRO 53
98#define EM2882_BOARD_KWORLD_VS_DVBT 54
99#define EM2882_BOARD_TERRATEC_HYBRID_XS 55
100#define EM2882_BOARD_PINNACLE_HYBRID_PRO_330E 56
101#define EM2883_BOARD_KWORLD_HYBRID_330U 57
102#define EM2820_BOARD_COMPRO_VIDEOMATE_FORYOU 58
103#define EM2883_BOARD_HAUPPAUGE_WINTV_HVR_850 60
104#define EM2820_BOARD_PROLINK_PLAYTV_BOX4_USB2 61
105#define EM2820_BOARD_GADMEI_TVR200 62
106#define EM2860_BOARD_KAIOMY_TVNPC_U2 63
107#define EM2860_BOARD_EASYCAP 64
108#define EM2820_BOARD_IODATA_GVMVP_SZ 65
109#define EM2880_BOARD_EMPIRE_DUAL_TV 66
110#define EM2860_BOARD_TERRATEC_GRABBY 67
111#define EM2860_BOARD_TERRATEC_AV350 68
112#define EM2882_BOARD_KWORLD_ATSC_315U 69
113#define EM2882_BOARD_EVGA_INDTUBE 70
114#define EM2820_BOARD_SILVERCREST_WEBCAM 71
115#define EM2861_BOARD_GADMEI_UTV330PLUS 72
116#define EM2870_BOARD_REDDO_DVB_C_USB_BOX 73
117#define EM2800_BOARD_VC211A 74
118#define EM2882_BOARD_DIKOM_DK300 75
119#define EM2870_BOARD_KWORLD_A340 76
120#define EM2874_BOARD_LEADERSHIP_ISDBT 77
121#define EM28174_BOARD_PCTV_290E 78
122#define EM2884_BOARD_TERRATEC_H5 79
123
124/* Limits minimum and default number of buffers */
125#define EM28XX_MIN_BUF 4
126#define EM28XX_DEF_BUF 8
127
128/*Limits the max URB message size */
129#define URB_MAX_CTRL_SIZE 80
130
131/* Params for validated field */
132#define EM28XX_BOARD_NOT_VALIDATED 1
133#define EM28XX_BOARD_VALIDATED 0
134
135/* Params for em28xx_cmd() audio */
136#define EM28XX_START_AUDIO 1
137#define EM28XX_STOP_AUDIO 0
138
139/* maximum number of em28xx boards */
140#define EM28XX_MAXBOARDS 4 /*FIXME: should be bigger */
141
142/* maximum number of frames that can be queued */
143#define EM28XX_NUM_FRAMES 5
144/* number of frames that get used for v4l2_read() */
145#define EM28XX_NUM_READ_FRAMES 2
146
147/* number of buffers for isoc transfers */
148#define EM28XX_NUM_BUFS 5
149
150/* number of packets for each buffer
151 windows requests only 64 packets .. so we better do the same
152 this is what I found out for all alternate numbers there!
153 */
154#define EM28XX_NUM_PACKETS 64
155
156#define EM28XX_INTERLACED_DEFAULT 1
157
158/*
159#define (use usbview if you want to get the other alternate number infos)
160#define
161#define alternate number 2
162#define Endpoint Address: 82
163 Direction: in
164 Attribute: 1
165 Type: Isoc
166 Max Packet Size: 1448
167 Interval: 125us
168
169 alternate number 7
170
171 Endpoint Address: 82
172 Direction: in
173 Attribute: 1
174 Type: Isoc
175 Max Packet Size: 3072
176 Interval: 125us
177*/
178
179/* time to wait when stopping the isoc transfer */
180#define EM28XX_URB_TIMEOUT \
181 msecs_to_jiffies(EM28XX_NUM_BUFS * EM28XX_NUM_PACKETS)
182
183/* time in msecs to wait for i2c writes to finish */
184#define EM2800_I2C_WRITE_TIMEOUT 20
185
186enum em28xx_mode {
187 EM28XX_SUSPEND,
188 EM28XX_ANALOG_MODE,
189 EM28XX_DIGITAL_MODE,
190};
191
192
193struct em28xx;
194
195struct em28xx_usb_isoc_ctl {
196 /* max packet size of isoc transaction */
197 int max_pkt_size;
198
199 /* number of allocated urbs */
200 int num_bufs;
201
202 /* urb for isoc transfers */
203 struct urb **urb;
204
205 /* transfer buffers for isoc transfer */
206 char **transfer_buffer;
207
208 /* Last buffer command and region */
209 u8 cmd;
210 int pos, size, pktsize;
211
212 /* Last field: ODD or EVEN? */
213 int field;
214
215 /* Stores incomplete commands */
216 u32 tmp_buf;
217 int tmp_buf_len;
218
219 /* Stores already requested buffers */
220 struct em28xx_buffer *vid_buf;
221 struct em28xx_buffer *vbi_buf;
222
223 /* Stores the number of received fields */
224 int nfields;
225
226 /* isoc urb callback */
227 int (*isoc_copy) (struct em28xx *dev, struct urb *urb);
228
229};
230
231/* Struct to enumberate video formats */
232struct em28xx_fmt {
233 char *name;
234 u32 fourcc; /* v4l2 format id */
235 int depth;
236 int reg;
237};
238
239/* buffer for one video frame */
240struct em28xx_buffer {
241 /* common v4l buffer stuff -- must be first */
242 struct videobuf_buffer vb;
243
244 struct list_head frame;
245 int top_field;
246 int receiving;
247};
248
249struct em28xx_dmaqueue {
250 struct list_head active;
251 struct list_head queued;
252
253 wait_queue_head_t wq;
254
255 /* Counters to control buffer fill */
256 int pos;
257};
258
259/* io methods */
260enum em28xx_io_method {
261 IO_NONE,
262 IO_READ,
263 IO_MMAP,
264};
265
266/* inputs */
267
268#define MAX_EM28XX_INPUT 4
269enum enum28xx_itype {
270 EM28XX_VMUX_COMPOSITE1 = 1,
271 EM28XX_VMUX_COMPOSITE2,
272 EM28XX_VMUX_COMPOSITE3,
273 EM28XX_VMUX_COMPOSITE4,
274 EM28XX_VMUX_SVIDEO,
275 EM28XX_VMUX_TELEVISION,
276 EM28XX_VMUX_CABLE,
277 EM28XX_VMUX_DVB,
278 EM28XX_VMUX_DEBUG,
279 EM28XX_RADIO,
280};
281
282enum em28xx_ac97_mode {
283 EM28XX_NO_AC97 = 0,
284 EM28XX_AC97_EM202,
285 EM28XX_AC97_SIGMATEL,
286 EM28XX_AC97_OTHER,
287};
288
289struct em28xx_audio_mode {
290 enum em28xx_ac97_mode ac97;
291
292 u16 ac97_feat;
293 u32 ac97_vendor_id;
294
295 unsigned int has_audio:1;
296
297 unsigned int i2s_3rates:1;
298 unsigned int i2s_5rates:1;
299};
300
301/* em28xx has two audio inputs: tuner and line in.
302 However, on most devices, an auxiliary AC97 codec device is used.
303 The AC97 device may have several different inputs and outputs,
304 depending on their model. So, it is possible to use AC97 mixer to
305 address more than two different entries.
306 */
307enum em28xx_amux {
308 /* This is the only entry for em28xx tuner input */
309 EM28XX_AMUX_VIDEO, /* em28xx tuner, AC97 mixer Video */
310
311 EM28XX_AMUX_LINE_IN, /* AC97 mixer Line In */
312
313 /* Some less-common mixer setups */
314 EM28XX_AMUX_VIDEO2, /* em28xx Line in, AC97 mixer Video */
315 EM28XX_AMUX_PHONE,
316 EM28XX_AMUX_MIC,
317 EM28XX_AMUX_CD,
318 EM28XX_AMUX_AUX,
319 EM28XX_AMUX_PCM_OUT,
320};
321
322enum em28xx_aout {
323 /* AC97 outputs */
324 EM28XX_AOUT_MASTER = 1 << 0,
325 EM28XX_AOUT_LINE = 1 << 1,
326 EM28XX_AOUT_MONO = 1 << 2,
327 EM28XX_AOUT_LFE = 1 << 3,
328 EM28XX_AOUT_SURR = 1 << 4,
329
330 /* PCM IN Mixer - used by AC97_RECORD_SELECT register */
331 EM28XX_AOUT_PCM_IN = 1 << 7,
332
333 /* Bits 10-8 are used to indicate the PCM IN record select */
334 EM28XX_AOUT_PCM_MIC_PCM = 0 << 8,
335 EM28XX_AOUT_PCM_CD = 1 << 8,
336 EM28XX_AOUT_PCM_VIDEO = 2 << 8,
337 EM28XX_AOUT_PCM_AUX = 3 << 8,
338 EM28XX_AOUT_PCM_LINE = 4 << 8,
339 EM28XX_AOUT_PCM_STEREO = 5 << 8,
340 EM28XX_AOUT_PCM_MONO = 6 << 8,
341 EM28XX_AOUT_PCM_PHONE = 7 << 8,
342};
343
344static inline int ac97_return_record_select(int a_out)
345{
346 return (a_out & 0x700) >> 8;
347}
348
349struct em28xx_reg_seq {
350 int reg;
351 unsigned char val, mask;
352 int sleep;
353};
354
355struct em28xx_input {
356 enum enum28xx_itype type;
357 unsigned int vmux;
358 enum em28xx_amux amux;
359 enum em28xx_aout aout;
360 struct em28xx_reg_seq *gpio;
361};
362
363#define INPUT(nr) (&em28xx_boards[dev->model].input[nr])
364
365enum em28xx_decoder {
366 EM28XX_NODECODER = 0,
367 EM28XX_TVP5150,
368 EM28XX_SAA711X,
369};
370
371enum em28xx_sensor {
372 EM28XX_NOSENSOR = 0,
373 EM28XX_MT9V011,
374 EM28XX_MT9M001,
375 EM28XX_MT9M111,
376};
377
378enum em28xx_adecoder {
379 EM28XX_NOADECODER = 0,
380 EM28XX_TVAUDIO,
381};
382
383struct em28xx_board {
384 char *name;
385 int vchannels;
386 int tuner_type;
387 int tuner_addr;
388
389 /* i2c flags */
390 unsigned int tda9887_conf;
391
392 /* GPIO sequences */
393 struct em28xx_reg_seq *dvb_gpio;
394 struct em28xx_reg_seq *suspend_gpio;
395 struct em28xx_reg_seq *tuner_gpio;
396 struct em28xx_reg_seq *mute_gpio;
397
398 unsigned int is_em2800:1;
399 unsigned int has_msp34xx:1;
400 unsigned int mts_firmware:1;
401 unsigned int max_range_640_480:1;
402 unsigned int has_dvb:1;
403 unsigned int has_snapshot_button:1;
404 unsigned int is_webcam:1;
405 unsigned int valid:1;
406 unsigned int has_ir_i2c:1;
407
408 unsigned char xclk, i2c_speed;
409 unsigned char radio_addr;
410 unsigned short tvaudio_addr;
411
412 enum em28xx_decoder decoder;
413 enum em28xx_adecoder adecoder;
414
415 struct em28xx_input input[MAX_EM28XX_INPUT];
416 struct em28xx_input radio;
417 char *ir_codes;
418};
419
420struct em28xx_eeprom {
421 u32 id; /* 0x9567eb1a */
422 u16 vendor_ID;
423 u16 product_ID;
424
425 u16 chip_conf;
426
427 u16 board_conf;
428
429 u16 string1, string2, string3;
430
431 u8 string_idx_table;
432};
433
434/* device states */
435enum em28xx_dev_state {
436 DEV_INITIALIZED = 0x01,
437 DEV_DISCONNECTED = 0x02,
438 DEV_MISCONFIGURED = 0x04,
439};
440
441#define EM28XX_AUDIO_BUFS 5
442#define EM28XX_NUM_AUDIO_PACKETS 64
443#define EM28XX_AUDIO_MAX_PACKET_SIZE 196 /* static value */
444#define EM28XX_CAPTURE_STREAM_EN 1
445
446/* em28xx extensions */
447#define EM28XX_AUDIO 0x10
448#define EM28XX_DVB 0x20
449
450/* em28xx resource types (used for res_get/res_lock etc */
451#define EM28XX_RESOURCE_VIDEO 0x01
452#define EM28XX_RESOURCE_VBI 0x02
453
454struct em28xx_audio {
455 char name[50];
456 char *transfer_buffer[EM28XX_AUDIO_BUFS];
457 struct urb *urb[EM28XX_AUDIO_BUFS];
458 struct usb_device *udev;
459 unsigned int capture_transfer_done;
460 struct snd_pcm_substream *capture_pcm_substream;
461
462 unsigned int hwptr_done_capture;
463 struct snd_card *sndcard;
464
465 int users;
466 spinlock_t slock;
467};
468
469struct em28xx;
470
471struct em28xx_fh {
472 struct em28xx *dev;
473 int radio;
474 unsigned int resources;
475
476 struct videobuf_queue vb_vidq;
477 struct videobuf_queue vb_vbiq;
478
479 enum v4l2_buf_type type;
480};
481
482/* main device struct */
483struct em28xx {
484 /* generic device properties */
485 char name[30]; /* name (including minor) of the device */
486 int model; /* index in the device_data struct */
487 int devno; /* marks the number of this device */
488 enum em28xx_chip_id chip_id;
489
490 int audio_ifnum;
491
492 struct v4l2_device v4l2_dev;
493 struct em28xx_board board;
494
495 /* Webcam specific fields */
496 enum em28xx_sensor em28xx_sensor;
497 int sensor_xres, sensor_yres;
498 int sensor_xtal;
499
500 /* Allows progressive (e. g. non-interlaced) mode */
501 int progressive;
502
503 /* Vinmode/Vinctl used at the driver */
504 int vinmode, vinctl;
505
506 unsigned int has_audio_class:1;
507 unsigned int has_alsa_audio:1;
508 unsigned int is_audio_only:1;
509
510 /* Controls audio streaming */
511 struct work_struct wq_trigger; /* Trigger to start/stop audio for alsa module */
512 atomic_t stream_started; /* stream should be running if true */
513
514 struct em28xx_fmt *format;
515
516 struct em28xx_IR *ir;
517
518 /* Some older em28xx chips needs a waiting time after writing */
519 unsigned int wait_after_write;
520
521 struct list_head devlist;
522
523 u32 i2s_speed; /* I2S speed for audio digital stream */
524
525 struct em28xx_audio_mode audio_mode;
526
527 int tuner_type; /* type of the tuner */
528 int tuner_addr; /* tuner address */
529 int tda9887_conf;
530 /* i2c i/o */
531 struct i2c_adapter i2c_adap;
532 struct i2c_client i2c_client;
533 /* video for linux */
534 int users; /* user count for exclusive use */
535 struct video_device *vdev; /* video for linux device struct */
536 v4l2_std_id norm; /* selected tv norm */
537 int ctl_freq; /* selected frequency */
538 unsigned int ctl_input; /* selected input */
539 unsigned int ctl_ainput;/* selected audio input */
540 unsigned int ctl_aoutput;/* selected audio output */
541 int mute;
542 int volume;
543 /* frame properties */
544 int width; /* current frame width */
545 int height; /* current frame height */
546 unsigned hscale; /* horizontal scale factor (see datasheet) */
547 unsigned vscale; /* vertical scale factor (see datasheet) */
548 int interlaced; /* 1=interlace fileds, 0=just top fileds */
549 unsigned int video_bytesread; /* Number of bytes read */
550
551 unsigned long hash; /* eeprom hash - for boards with generic ID */
552 unsigned long i2c_hash; /* i2c devicelist hash -
553 for boards with generic ID */
554
555 struct em28xx_audio adev;
556
557 /* states */
558 enum em28xx_dev_state state;
559 enum em28xx_io_method io;
560
561 /* vbi related state tracking */
562 int capture_type;
563 int vbi_read;
564 unsigned char cur_field;
565 unsigned int vbi_width;
566 unsigned int vbi_height; /* lines per field */
567
568 struct work_struct request_module_wk;
569
570 /* locks */
571 struct mutex lock;
572 struct mutex ctrl_urb_lock; /* protects urb_buf */
573 /* spinlock_t queue_lock; */
574 struct list_head inqueue, outqueue;
575 wait_queue_head_t open, wait_frame, wait_stream;
576 struct video_device *vbi_dev;
577 struct video_device *radio_dev;
578
579 /* resources in use */
580 unsigned int resources;
581
582 unsigned char eedata[256];
583
584 /* Isoc control struct */
585 struct em28xx_dmaqueue vidq;
586 struct em28xx_dmaqueue vbiq;
587 struct em28xx_usb_isoc_ctl isoc_ctl;
588 spinlock_t slock;
589
590 /* usb transfer */
591 struct usb_device *udev; /* the usb device */
592 int alt; /* alternate */
593 int max_pkt_size; /* max packet size of isoc transaction */
594 int num_alt; /* Number of alternative settings */
595 unsigned int *alt_max_pkt_size; /* array of wMaxPacketSize */
596 struct urb *urb[EM28XX_NUM_BUFS]; /* urb for isoc transfers */
597 char *transfer_buffer[EM28XX_NUM_BUFS]; /* transfer buffers for isoc
598 transfer */
599 char urb_buf[URB_MAX_CTRL_SIZE]; /* urb control msg buffer */
600
601 /* helper funcs that call usb_control_msg */
602 int (*em28xx_write_regs) (struct em28xx *dev, u16 reg,
603 char *buf, int len);
604 int (*em28xx_read_reg) (struct em28xx *dev, u16 reg);
605 int (*em28xx_read_reg_req_len) (struct em28xx *dev, u8 req, u16 reg,
606 char *buf, int len);
607 int (*em28xx_write_regs_req) (struct em28xx *dev, u8 req, u16 reg,
608 char *buf, int len);
609 int (*em28xx_read_reg_req) (struct em28xx *dev, u8 req, u16 reg);
610
611 enum em28xx_mode mode;
612
613 /* register numbers for GPO/GPIO registers */
614 u16 reg_gpo_num, reg_gpio_num;
615
616 /* Caches GPO and GPIO registers */
617 unsigned char reg_gpo, reg_gpio;
618
619 /* Snapshot button */
620 char snapshot_button_path[30]; /* path of the input dev */
621 struct input_dev *sbutton_input_dev;
622 struct delayed_work sbutton_query_work;
623
624 struct em28xx_dvb *dvb;
625
626 /* I2C keyboard data */
627 struct IR_i2c_init_data init_data;
628};
629
630struct em28xx_ops {
631 struct list_head next;
632 char *name;
633 int id;
634 int (*init)(struct em28xx *);
635 int (*fini)(struct em28xx *);
636};
637
638/* Provided by em28xx-i2c.c */
639void em28xx_do_i2c_scan(struct em28xx *dev);
640int em28xx_i2c_register(struct em28xx *dev);
641int em28xx_i2c_unregister(struct em28xx *dev);
642
643/* Provided by em28xx-core.c */
644
645u32 em28xx_request_buffers(struct em28xx *dev, u32 count);
646void em28xx_queue_unusedframes(struct em28xx *dev);
647void em28xx_release_buffers(struct em28xx *dev);
648
649int em28xx_read_reg_req_len(struct em28xx *dev, u8 req, u16 reg,
650 char *buf, int len);
651int em28xx_read_reg_req(struct em28xx *dev, u8 req, u16 reg);
652int em28xx_read_reg(struct em28xx *dev, u16 reg);
653int em28xx_write_regs_req(struct em28xx *dev, u8 req, u16 reg, char *buf,
654 int len);
655int em28xx_write_regs(struct em28xx *dev, u16 reg, char *buf, int len);
656int em28xx_write_reg(struct em28xx *dev, u16 reg, u8 val);
657int em28xx_write_reg_bits(struct em28xx *dev, u16 reg, u8 val,
658 u8 bitmask);
659
660int em28xx_read_ac97(struct em28xx *dev, u8 reg);
661int em28xx_write_ac97(struct em28xx *dev, u8 reg, u16 val);
662
663int em28xx_audio_analog_set(struct em28xx *dev);
664int em28xx_audio_setup(struct em28xx *dev);
665
666int em28xx_colorlevels_set_default(struct em28xx *dev);
667int em28xx_capture_start(struct em28xx *dev, int start);
668int em28xx_vbi_supported(struct em28xx *dev);
669int em28xx_set_outfmt(struct em28xx *dev);
670int em28xx_resolution_set(struct em28xx *dev);
671int em28xx_set_alternate(struct em28xx *dev);
672int em28xx_init_isoc(struct em28xx *dev, int max_packets,
673 int num_bufs, int max_pkt_size,
674 int (*isoc_copy) (struct em28xx *dev, struct urb *urb));
675void em28xx_uninit_isoc(struct em28xx *dev);
676int em28xx_isoc_dvb_max_packetsize(struct em28xx *dev);
677int em28xx_set_mode(struct em28xx *dev, enum em28xx_mode set_mode);
678int em28xx_gpio_set(struct em28xx *dev, struct em28xx_reg_seq *gpio);
679void em28xx_wake_i2c(struct em28xx *dev);
680void em28xx_remove_from_devlist(struct em28xx *dev);
681void em28xx_add_into_devlist(struct em28xx *dev);
682int em28xx_register_extension(struct em28xx_ops *dev);
683void em28xx_unregister_extension(struct em28xx_ops *dev);
684void em28xx_init_extension(struct em28xx *dev);
685void em28xx_close_extension(struct em28xx *dev);
686
687/* Provided by em28xx-video.c */
688int em28xx_register_analog_devices(struct em28xx *dev);
689void em28xx_release_analog_resources(struct em28xx *dev);
690
691/* Provided by em28xx-cards.c */
692extern int em2800_variant_detect(struct usb_device *udev, int model);
693extern void em28xx_pre_card_setup(struct em28xx *dev);
694extern void em28xx_card_setup(struct em28xx *dev);
695extern struct em28xx_board em28xx_boards[];
696extern struct usb_device_id em28xx_id_table[];
697extern const unsigned int em28xx_bcount;
698void em28xx_register_i2c_ir(struct em28xx *dev);
699int em28xx_tuner_callback(void *ptr, int component, int command, int arg);
700void em28xx_release_resources(struct em28xx *dev);
701
702/* Provided by em28xx-input.c */
703
704#ifdef CONFIG_VIDEO_EM28XX_RC
705
706int em28xx_get_key_terratec(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw);
707int em28xx_get_key_em_haup(struct IR_i2c *ir, u32 *ir_key, u32 *ir_raw);
708int em28xx_get_key_pinnacle_usb_grey(struct IR_i2c *ir, u32 *ir_key,
709 u32 *ir_raw);
710int em28xx_get_key_winfast_usbii_deluxe(struct IR_i2c *ir, u32 *ir_key,
711 u32 *ir_raw);
712void em28xx_register_snapshot_button(struct em28xx *dev);
713void em28xx_deregister_snapshot_button(struct em28xx *dev);
714
715int em28xx_ir_init(struct em28xx *dev);
716int em28xx_ir_fini(struct em28xx *dev);
717
718#else
719
720#define em28xx_get_key_terratec NULL
721#define em28xx_get_key_em_haup NULL
722#define em28xx_get_key_pinnacle_usb_grey NULL
723#define em28xx_get_key_winfast_usbii_deluxe NULL
724
725static inline void em28xx_register_snapshot_button(struct em28xx *dev) {}
726static inline void em28xx_deregister_snapshot_button(struct em28xx *dev) {}
727static inline int em28xx_ir_init(struct em28xx *dev) { return 0; }
728static inline int em28xx_ir_fini(struct em28xx *dev) { return 0; }
729
730#endif
731
732/* Provided by em28xx-vbi.c */
733extern struct videobuf_queue_ops em28xx_vbi_qops;
734
735/* printk macros */
736
737#define em28xx_err(fmt, arg...) do {\
738 printk(KERN_ERR fmt , ##arg); } while (0)
739
740#define em28xx_errdev(fmt, arg...) do {\
741 printk(KERN_ERR "%s: "fmt,\
742 dev->name , ##arg); } while (0)
743
744#define em28xx_info(fmt, arg...) do {\
745 printk(KERN_INFO "%s: "fmt,\
746 dev->name , ##arg); } while (0)
747#define em28xx_warn(fmt, arg...) do {\
748 printk(KERN_WARNING "%s: "fmt,\
749 dev->name , ##arg); } while (0)
750
751static inline int em28xx_compression_disable(struct em28xx *dev)
752{
753 /* side effect of disabling scaler and mixer */
754 return em28xx_write_reg(dev, EM28XX_R26_COMPR, 0x00);
755}
756
757static inline int em28xx_contrast_get(struct em28xx *dev)
758{
759 return em28xx_read_reg(dev, EM28XX_R20_YGAIN) & 0x1f;
760}
761
762static inline int em28xx_brightness_get(struct em28xx *dev)
763{
764 return em28xx_read_reg(dev, EM28XX_R21_YOFFSET);
765}
766
767static inline int em28xx_saturation_get(struct em28xx *dev)
768{
769 return em28xx_read_reg(dev, EM28XX_R22_UVGAIN) & 0x1f;
770}
771
772static inline int em28xx_u_balance_get(struct em28xx *dev)
773{
774 return em28xx_read_reg(dev, EM28XX_R23_UOFFSET);
775}
776
777static inline int em28xx_v_balance_get(struct em28xx *dev)
778{
779 return em28xx_read_reg(dev, EM28XX_R24_VOFFSET);
780}
781
782static inline int em28xx_gamma_get(struct em28xx *dev)
783{
784 return em28xx_read_reg(dev, EM28XX_R14_GAMMA) & 0x3f;
785}
786
787static inline int em28xx_contrast_set(struct em28xx *dev, s32 val)
788{
789 u8 tmp = (u8) val;
790 return em28xx_write_regs(dev, EM28XX_R20_YGAIN, &tmp, 1);
791}
792
793static inline int em28xx_brightness_set(struct em28xx *dev, s32 val)
794{
795 u8 tmp = (u8) val;
796 return em28xx_write_regs(dev, EM28XX_R21_YOFFSET, &tmp, 1);
797}
798
799static inline int em28xx_saturation_set(struct em28xx *dev, s32 val)
800{
801 u8 tmp = (u8) val;
802 return em28xx_write_regs(dev, EM28XX_R22_UVGAIN, &tmp, 1);
803}
804
805static inline int em28xx_u_balance_set(struct em28xx *dev, s32 val)
806{
807 u8 tmp = (u8) val;
808 return em28xx_write_regs(dev, EM28XX_R23_UOFFSET, &tmp, 1);
809}
810
811static inline int em28xx_v_balance_set(struct em28xx *dev, s32 val)
812{
813 u8 tmp = (u8) val;
814 return em28xx_write_regs(dev, EM28XX_R24_VOFFSET, &tmp, 1);
815}
816
817static inline int em28xx_gamma_set(struct em28xx *dev, s32 val)
818{
819 u8 tmp = (u8) val;
820 return em28xx_write_regs(dev, EM28XX_R14_GAMMA, &tmp, 1);
821}
822
823/*FIXME: maxw should be dependent of alt mode */
824static inline unsigned int norm_maxw(struct em28xx *dev)
825{
826 if (dev->board.is_webcam)
827 return dev->sensor_xres;
828
829 if (dev->board.max_range_640_480 || dev->board.is_em2800)
830 return 640;
831
832 return 720;
833}
834
835static inline unsigned int norm_maxh(struct em28xx *dev)
836{
837 if (dev->board.is_webcam)
838 return dev->sensor_yres;
839
840 if (dev->board.max_range_640_480)
841 return 480;
842
843 return (dev->norm & V4L2_STD_625_50) ? 576 : 480;
844}
845#endif
generated by cgit v1.2.2 (git 2.25.0) at 2025-04-24 03:22:41 -0400