2017-12-01 13:47:12 +00:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
|
|
|
|
//
|
|
|
|
|
// tvp5150 - Texas Instruments TVP5150A/AM1 and TVP5151 video decoder driver
|
|
|
|
|
//
|
|
|
|
|
// Copyright (c) 2005,2006 Mauro Carvalho Chehab <mchehab@infradead.org>
|
2005-11-09 05:36:40 +00:00
|
|
|
|
2016-02-05 19:09:56 +00:00
|
|
|
#include <dt-bindings/media/tvp5150.h>
|
2005-11-09 05:36:40 +00:00
|
|
|
#include <linux/i2c.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 08:04:11 +00:00
|
|
|
#include <linux/slab.h>
|
2008-07-25 08:32:50 +00:00
|
|
|
#include <linux/videodev2.h>
|
2005-11-09 05:36:40 +00:00
|
|
|
#include <linux/delay.h>
|
2016-01-07 12:46:49 +00:00
|
|
|
#include <linux/gpio/consumer.h>
|
2011-07-03 18:03:12 +00:00
|
|
|
#include <linux/module.h>
|
2016-08-26 23:17:25 +00:00
|
|
|
#include <linux/of_graph.h>
|
2015-09-21 11:23:09 +00:00
|
|
|
#include <media/v4l2-async.h>
|
2008-12-18 14:17:25 +00:00
|
|
|
#include <media/v4l2-device.h>
|
2010-12-12 11:45:43 +00:00
|
|
|
#include <media/v4l2-ctrls.h>
|
2016-08-26 23:17:25 +00:00
|
|
|
#include <media/v4l2-fwnode.h>
|
2016-01-27 14:08:13 +00:00
|
|
|
#include <media/v4l2-mc.h>
|
2005-11-09 05:36:40 +00:00
|
|
|
|
|
|
|
|
#include "tvp5150_reg.h"
|
|
|
|
|
|
2014-02-27 16:44:47 +00:00
|
|
|
#define TVP5150_H_MAX 720U
|
|
|
|
|
#define TVP5150_V_MAX_525_60 480U
|
|
|
|
|
#define TVP5150_V_MAX_OTHERS 576U
|
2012-01-31 08:23:46 +00:00
|
|
|
#define TVP5150_MAX_CROP_LEFT 511
|
|
|
|
|
#define TVP5150_MAX_CROP_TOP 127
|
|
|
|
|
#define TVP5150_CROP_SHIFT 2
|
|
|
|
|
|
2016-02-12 17:42:02 +00:00
|
|
|
MODULE_DESCRIPTION("Texas Instruments TVP5150A/TVP5150AM1/TVP5151 video decoder driver");
|
2005-11-09 05:36:40 +00:00
|
|
|
MODULE_AUTHOR("Mauro Carvalho Chehab");
|
2017-12-01 13:47:12 +00:00
|
|
|
MODULE_LICENSE("GPL v2");
|
2005-11-09 05:36:40 +00:00
|
|
|
|
|
|
|
|
|
2008-04-22 17:41:48 +00:00
|
|
|
static int debug;
|
2014-02-27 16:44:48 +00:00
|
|
|
module_param(debug, int, 0644);
|
2008-12-18 14:17:25 +00:00
|
|
|
MODULE_PARM_DESC(debug, "Debug level (0-2)");
|
2005-11-09 05:36:40 +00:00
|
|
|
|
2016-11-13 07:34:12 +00:00
|
|
|
#define dprintk0(__dev, __arg...) dev_dbg_lvl(__dev, 0, 0, __arg)
|
|
|
|
|
|
2005-11-09 05:36:40 +00:00
|
|
|
struct tvp5150 {
|
2008-12-18 14:17:25 +00:00
|
|
|
struct v4l2_subdev sd;
|
2016-01-27 14:08:13 +00:00
|
|
|
#ifdef CONFIG_MEDIA_CONTROLLER
|
|
|
|
|
struct media_pad pads[DEMOD_NUM_PADS];
|
2016-02-05 19:09:58 +00:00
|
|
|
struct media_entity input_ent[TVP5150_INPUT_NUM];
|
|
|
|
|
struct media_pad input_pad[TVP5150_INPUT_NUM];
|
2016-01-27 14:08:13 +00:00
|
|
|
#endif
|
2010-12-12 11:45:43 +00:00
|
|
|
struct v4l2_ctrl_handler hdl;
|
2012-01-31 08:23:46 +00:00
|
|
|
struct v4l2_rect rect;
|
2005-11-09 05:36:41 +00:00
|
|
|
|
2006-01-23 19:11:05 +00:00
|
|
|
v4l2_std_id norm; /* Current set standard */
|
2009-04-02 14:26:22 +00:00
|
|
|
u32 input;
|
|
|
|
|
u32 output;
|
2005-11-09 05:36:41 +00:00
|
|
|
int enable;
|
2016-01-07 12:46:50 +00:00
|
|
|
|
2016-02-05 19:09:54 +00:00
|
|
|
u16 dev_id;
|
|
|
|
|
u16 rom_ver;
|
|
|
|
|
|
2016-01-07 12:46:50 +00:00
|
|
|
enum v4l2_mbus_type mbus_type;
|
2005-11-09 05:36:40 +00:00
|
|
|
};
|
|
|
|
|
|
2008-12-18 14:17:25 +00:00
|
|
|
static inline struct tvp5150 *to_tvp5150(struct v4l2_subdev *sd)
|
2005-11-09 05:36:40 +00:00
|
|
|
{
|
2008-12-18 14:17:25 +00:00
|
|
|
return container_of(sd, struct tvp5150, sd);
|
|
|
|
|
}
|
|
|
|
|
|
2010-12-12 11:45:43 +00:00
|
|
|
static inline struct v4l2_subdev *to_sd(struct v4l2_ctrl *ctrl)
|
|
|
|
|
{
|
|
|
|
|
return &container_of(ctrl->handler, struct tvp5150, hdl)->sd;
|
|
|
|
|
}
|
|
|
|
|
|
2008-12-18 14:17:25 +00:00
|
|
|
static int tvp5150_read(struct v4l2_subdev *sd, unsigned char addr)
|
|
|
|
|
{
|
|
|
|
|
struct i2c_client *c = v4l2_get_subdevdata(sd);
|
2005-11-09 05:36:40 +00:00
|
|
|
int rc;
|
2014-05-26 19:31:28 +00:00
|
|
|
|
|
|
|
|
rc = i2c_smbus_read_byte_data(c, addr);
|
|
|
|
|
if (rc < 0) {
|
2016-11-16 10:58:05 +00:00
|
|
|
dev_err(sd->dev, "i2c i/o error: rc == %d\n", rc);
|
2014-05-26 19:31:28 +00:00
|
|
|
return rc;
|
2012-06-13 10:49:30 +00:00
|
|
|
}
|
2006-01-09 17:25:36 +00:00
|
|
|
|
2016-11-16 10:58:05 +00:00
|
|
|
dev_dbg_lvl(sd->dev, 2, debug, "tvp5150: read 0x%02x = %02x\n", addr, rc);
|
2005-11-09 05:36:40 +00:00
|
|
|
|
2014-05-26 19:31:28 +00:00
|
|
|
return rc;
|
2005-11-09 05:36:40 +00:00
|
|
|
}
|
|
|
|
|
|
2016-04-15 01:00:07 +00:00
|
|
|
static int tvp5150_write(struct v4l2_subdev *sd, unsigned char addr,
|
2005-11-09 05:36:41 +00:00
|
|
|
unsigned char value)
|
2005-11-09 05:36:40 +00:00
|
|
|
{
|
2008-12-18 14:17:25 +00:00
|
|
|
struct i2c_client *c = v4l2_get_subdevdata(sd);
|
2005-11-09 05:36:40 +00:00
|
|
|
int rc;
|
|
|
|
|
|
2016-11-16 10:58:05 +00:00
|
|
|
dev_dbg_lvl(sd->dev, 2, debug, "tvp5150: writing %02x %02x\n", addr, value);
|
2014-05-26 19:31:28 +00:00
|
|
|
rc = i2c_smbus_write_byte_data(c, addr, value);
|
|
|
|
|
if (rc < 0)
|
2016-11-16 10:58:05 +00:00
|
|
|
dev_err(sd->dev, "i2c i/o error: rc == %d\n", rc);
|
2016-04-15 01:00:07 +00:00
|
|
|
|
|
|
|
|
return rc;
|
2005-11-09 05:36:40 +00:00
|
|
|
}
|
|
|
|
|
|
2008-12-18 14:17:25 +00:00
|
|
|
static void dump_reg_range(struct v4l2_subdev *sd, char *s, u8 init,
|
|
|
|
|
const u8 end, int max_line)
|
2006-01-23 19:11:05 +00:00
|
|
|
{
|
2016-10-20 13:36:42 +00:00
|
|
|
u8 buf[16];
|
|
|
|
|
int i = 0, j, len;
|
|
|
|
|
|
|
|
|
|
if (max_line > 16) {
|
|
|
|
|
dprintk0(sd->dev, "too much data to dump\n");
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (i = init; i < end; i += max_line) {
|
|
|
|
|
len = (end - i > max_line) ? max_line : end - i;
|
|
|
|
|
|
|
|
|
|
for (j = 0; j < len; j++)
|
|
|
|
|
buf[j] = tvp5150_read(sd, i + j);
|
|
|
|
|
|
|
|
|
|
dprintk0(sd->dev, "%s reg %02x = %*ph\n", s, i, len, buf);
|
2006-01-23 19:11:05 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2008-12-18 14:17:25 +00:00
|
|
|
static int tvp5150_log_status(struct v4l2_subdev *sd)
|
2005-11-09 05:36:40 +00:00
|
|
|
{
|
2016-11-13 07:34:12 +00:00
|
|
|
dprintk0(sd->dev, "tvp5150: Video input source selection #1 = 0x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_VD_IN_SRC_SEL_1));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: Analog channel controls = 0x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_ANAL_CHL_CTL));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: Operation mode controls = 0x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_OP_MODE_CTL));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: Miscellaneous controls = 0x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_MISC_CTL));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: Autoswitch mask= 0x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_AUTOSW_MSK));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: Color killer threshold control = 0x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_COLOR_KIL_THSH_CTL));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: Luminance processing controls #1 #2 and #3 = %02x %02x %02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_LUMA_PROC_CTL_1),
|
|
|
|
|
tvp5150_read(sd, TVP5150_LUMA_PROC_CTL_2),
|
|
|
|
|
tvp5150_read(sd, TVP5150_LUMA_PROC_CTL_3));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: Brightness control = 0x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_BRIGHT_CTL));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: Color saturation control = 0x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_SATURATION_CTL));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: Hue control = 0x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_HUE_CTL));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: Contrast control = 0x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_CONTRAST_CTL));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: Outputs and data rates select = 0x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_DATA_RATE_SEL));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: Configuration shared pins = 0x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_CONF_SHARED_PIN));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: Active video cropping start = 0x%02x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_ACT_VD_CROP_ST_MSB),
|
|
|
|
|
tvp5150_read(sd, TVP5150_ACT_VD_CROP_ST_LSB));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: Active video cropping stop = 0x%02x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_ACT_VD_CROP_STP_MSB),
|
|
|
|
|
tvp5150_read(sd, TVP5150_ACT_VD_CROP_STP_LSB));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: Genlock/RTC = 0x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_GENLOCK));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: Horizontal sync start = 0x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_HORIZ_SYNC_START));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: Vertical blanking start = 0x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_VERT_BLANKING_START));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: Vertical blanking stop = 0x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_VERT_BLANKING_STOP));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: Chrominance processing control #1 and #2 = %02x %02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_CHROMA_PROC_CTL_1),
|
|
|
|
|
tvp5150_read(sd, TVP5150_CHROMA_PROC_CTL_2));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: Interrupt reset register B = 0x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_INT_RESET_REG_B));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: Interrupt enable register B = 0x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_INT_ENABLE_REG_B));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: Interrupt configuration register B = 0x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_INTT_CONFIG_REG_B));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: Video standard = 0x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_VIDEO_STD));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: Chroma gain factor: Cb=0x%02x Cr=0x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_CB_GAIN_FACT),
|
|
|
|
|
tvp5150_read(sd, TVP5150_CR_GAIN_FACTOR));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: Macrovision on counter = 0x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_MACROVISION_ON_CTR));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: Macrovision off counter = 0x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_MACROVISION_OFF_CTR));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: ITU-R BT.656.%d timing(TVP5150AM1 only)\n",
|
|
|
|
|
(tvp5150_read(sd, TVP5150_REV_SELECT) & 1) ? 3 : 4);
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: Device ID = %02x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_MSB_DEV_ID),
|
|
|
|
|
tvp5150_read(sd, TVP5150_LSB_DEV_ID));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: ROM version = (hex) %02x.%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_ROM_MAJOR_VER),
|
|
|
|
|
tvp5150_read(sd, TVP5150_ROM_MINOR_VER));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: Vertical line count = 0x%02x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_VERT_LN_COUNT_MSB),
|
|
|
|
|
tvp5150_read(sd, TVP5150_VERT_LN_COUNT_LSB));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: Interrupt status register B = 0x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_INT_STATUS_REG_B));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: Interrupt active register B = 0x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_INT_ACTIVE_REG_B));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: Status regs #1 to #5 = %02x %02x %02x %02x %02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_STATUS_REG_1),
|
|
|
|
|
tvp5150_read(sd, TVP5150_STATUS_REG_2),
|
|
|
|
|
tvp5150_read(sd, TVP5150_STATUS_REG_3),
|
|
|
|
|
tvp5150_read(sd, TVP5150_STATUS_REG_4),
|
|
|
|
|
tvp5150_read(sd, TVP5150_STATUS_REG_5));
|
2006-01-23 19:11:05 +00:00
|
|
|
|
2008-12-18 14:17:25 +00:00
|
|
|
dump_reg_range(sd, "Teletext filter 1", TVP5150_TELETEXT_FIL1_INI,
|
|
|
|
|
TVP5150_TELETEXT_FIL1_END, 8);
|
|
|
|
|
dump_reg_range(sd, "Teletext filter 2", TVP5150_TELETEXT_FIL2_INI,
|
|
|
|
|
TVP5150_TELETEXT_FIL2_END, 8);
|
2006-01-23 19:11:05 +00:00
|
|
|
|
2016-11-13 07:34:12 +00:00
|
|
|
dprintk0(sd->dev, "tvp5150: Teletext filter enable = 0x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_TELETEXT_FIL_ENA));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: Interrupt status register A = 0x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_INT_STATUS_REG_A));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: Interrupt enable register A = 0x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_INT_ENABLE_REG_A));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: Interrupt configuration = 0x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_INT_CONF));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: VDP status register = 0x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_VDP_STATUS_REG));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: FIFO word count = 0x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_FIFO_WORD_COUNT));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: FIFO interrupt threshold = 0x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_FIFO_INT_THRESHOLD));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: FIFO reset = 0x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_FIFO_RESET));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: Line number interrupt = 0x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_LINE_NUMBER_INT));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: Pixel alignment register = 0x%02x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_PIX_ALIGN_REG_HIGH),
|
|
|
|
|
tvp5150_read(sd, TVP5150_PIX_ALIGN_REG_LOW));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: FIFO output control = 0x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_FIFO_OUT_CTRL));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: Full field enable = 0x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_FULL_FIELD_ENA));
|
|
|
|
|
dprintk0(sd->dev, "tvp5150: Full field mode register = 0x%02x\n",
|
|
|
|
|
tvp5150_read(sd, TVP5150_FULL_FIELD_MODE_REG));
|
2006-01-23 19:11:05 +00:00
|
|
|
|
2008-12-18 14:17:25 +00:00
|
|
|
dump_reg_range(sd, "CC data", TVP5150_CC_DATA_INI,
|
|
|
|
|
TVP5150_CC_DATA_END, 8);
|
2006-01-23 19:11:05 +00:00
|
|
|
|
2008-12-18 14:17:25 +00:00
|
|
|
dump_reg_range(sd, "WSS data", TVP5150_WSS_DATA_INI,
|
|
|
|
|
TVP5150_WSS_DATA_END, 8);
|
2006-01-23 19:11:05 +00:00
|
|
|
|
2008-12-18 14:17:25 +00:00
|
|
|
dump_reg_range(sd, "VPS data", TVP5150_VPS_DATA_INI,
|
|
|
|
|
TVP5150_VPS_DATA_END, 8);
|
2006-01-23 19:11:05 +00:00
|
|
|
|
2008-12-18 14:17:25 +00:00
|
|
|
dump_reg_range(sd, "VITC data", TVP5150_VITC_DATA_INI,
|
|
|
|
|
TVP5150_VITC_DATA_END, 10);
|
2006-01-23 19:11:05 +00:00
|
|
|
|
2008-12-18 14:17:25 +00:00
|
|
|
dump_reg_range(sd, "Line mode", TVP5150_LINE_MODE_INI,
|
|
|
|
|
TVP5150_LINE_MODE_END, 8);
|
|
|
|
|
return 0;
|
2005-11-09 05:36:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
|
|
|
Basic functions
|
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
2016-12-08 22:22:42 +00:00
|
|
|
static void tvp5150_selmux(struct v4l2_subdev *sd)
|
2005-11-09 05:36:40 +00:00
|
|
|
{
|
[media] tvp5150: COMPOSITE0 input should not force-enable TV mode
When digitizing composite video from a analog videotape source using the
TVP5150's first composite input channel, the captured stream exhibits
tearing and synchronization problems[1].
It turns out that commit c0477ad9feca01bd8eff95d7482c33753d05c700 caused
"TV mode" (as opposed to "VCR mode" or "auto-detect") to be forcibly
enabled for both composite inputs. According to the chip
documentation[2], "TV mode" disables a "chrominance trap" input filter,
which appears to be necessary for high-quality video capture from an
analog videotape source. [ Commit
c7c0b34c27bbf0671807e902fbfea6270c8f138d subsequently restricted the
problem to the first composite input, apparently inadvertently. ]
Since any type of composite signal source can be connected to the
TVP5150's first composite input, unconditionally forcing "TV mode" isn't
correct. There doesn't appear to be a good way for applications to tell
the driver what is connected. Fortunately, the TVP5150 has an operating
mode auto-detection feature, which, when enabled, should cause the TVP5150
to auto-detect whether it should use "VCR mode" or "TV mode". Enabling
operating mode auto-detection improved video capture quality
significantly[3].
Therefore, fix this bug by using operating mode auto-detection. (Also,
while here, fix a CodingStyle issue.)
For those users who may find this patch via a mailing list archive but who
are not able to upgrade to a kernel with a fixed driver: the TVP5150's
S-Video and second composite input sources have auto-detection enabled, so
you may wish to try using those -- if available on your device -- until
this fix makes it a downstream distribution near you.
1. Pre-patch tvtime snapshot using a Pinnacle PCTV HD Pro as the
capture device and a Sony EV-S2000 as a video source:
http://www.booyaka.com/~paul/tvp5150/1a.png
2. Section 3.21.3, "Operation Mode Control Register", _TVP5150AM1
Ultralow-Power NTSC/PAL/SECAM Video Decoder (Rev. D)_ [SLES209D],
downloaded 8 October 2010, available via
http://focus.ti.com/lit/ds/symlink/tvp5150am1.pdf
3. Post-patch tvtime snapshot (same signal chain as #1, above):
http://www.booyaka.com/~paul/tvp5150/1b.png
Signed-off-by: Paul Walmsley <paul@booyaka.com>
Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>
2010-10-09 04:31:40 +00:00
|
|
|
int opmode = 0;
|
2008-12-18 14:17:25 +00:00
|
|
|
struct tvp5150 *decoder = to_tvp5150(sd);
|
2006-04-02 16:35:00 +00:00
|
|
|
int input = 0;
|
2012-07-12 13:47:28 +00:00
|
|
|
int val;
|
2005-11-09 05:36:41 +00:00
|
|
|
|
2016-02-12 17:42:02 +00:00
|
|
|
/* Only tvp5150am1 and tvp5151 have signal generator support */
|
|
|
|
|
if ((decoder->dev_id == 0x5150 && decoder->rom_ver == 0x0400) ||
|
|
|
|
|
(decoder->dev_id == 0x5151 && decoder->rom_ver == 0x0100)) {
|
|
|
|
|
if (!decoder->enable)
|
|
|
|
|
input = 8;
|
|
|
|
|
}
|
2005-11-09 05:36:43 +00:00
|
|
|
|
2009-04-02 14:26:22 +00:00
|
|
|
switch (decoder->input) {
|
2006-04-02 16:35:00 +00:00
|
|
|
case TVP5150_COMPOSITE1:
|
|
|
|
|
input |= 2;
|
|
|
|
|
/* fall through */
|
|
|
|
|
case TVP5150_COMPOSITE0:
|
2006-01-09 17:25:14 +00:00
|
|
|
break;
|
2006-04-02 16:35:00 +00:00
|
|
|
case TVP5150_SVIDEO:
|
2006-01-09 17:25:14 +00:00
|
|
|
default:
|
2006-04-02 16:35:00 +00:00
|
|
|
input |= 1;
|
2006-01-09 17:25:14 +00:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2016-11-16 10:58:05 +00:00
|
|
|
dev_dbg_lvl(sd->dev, 1, debug, "Selecting video route: route input=%i, output=%i => tvp5150 input=%i, opmode=%i\n",
|
2009-04-02 14:26:22 +00:00
|
|
|
decoder->input, decoder->output,
|
|
|
|
|
input, opmode);
|
2006-08-18 10:31:10 +00:00
|
|
|
|
2008-12-18 14:17:25 +00:00
|
|
|
tvp5150_write(sd, TVP5150_OP_MODE_CTL, opmode);
|
|
|
|
|
tvp5150_write(sd, TVP5150_VD_IN_SRC_SEL_1, input);
|
2007-11-04 01:40:24 +00:00
|
|
|
|
2016-12-09 11:47:18 +00:00
|
|
|
/*
|
|
|
|
|
* Setup the FID/GLCO/VLK/HVLK and INTREQ/GPCL/VBLK output signals. For
|
|
|
|
|
* S-Video we output the vertical lock (VLK) signal on FID/GLCO/VLK/HVLK
|
|
|
|
|
* and set INTREQ/GPCL/VBLK to logic 0. For composite we output the
|
|
|
|
|
* field indicator (FID) signal on FID/GLCO/VLK/HVLK and set
|
|
|
|
|
* INTREQ/GPCL/VBLK to logic 1.
|
2007-11-04 01:40:24 +00:00
|
|
|
*/
|
2008-12-18 14:17:25 +00:00
|
|
|
val = tvp5150_read(sd, TVP5150_MISC_CTL);
|
2012-06-13 10:49:30 +00:00
|
|
|
if (val < 0) {
|
2016-11-16 10:58:05 +00:00
|
|
|
dev_err(sd->dev, "%s: failed with error = %d\n", __func__, val);
|
2012-06-13 10:49:30 +00:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2009-04-02 14:26:22 +00:00
|
|
|
if (decoder->input == TVP5150_SVIDEO)
|
2016-12-09 11:47:18 +00:00
|
|
|
val = (val & ~TVP5150_MISC_CTL_GPCL) | TVP5150_MISC_CTL_HVLK;
|
2007-11-04 01:40:24 +00:00
|
|
|
else
|
2016-12-09 11:47:18 +00:00
|
|
|
val = (val & ~TVP5150_MISC_CTL_HVLK) | TVP5150_MISC_CTL_GPCL;
|
2008-12-18 14:17:25 +00:00
|
|
|
tvp5150_write(sd, TVP5150_MISC_CTL, val);
|
2005-11-09 05:36:40 +00:00
|
|
|
};
|
|
|
|
|
|
2006-01-09 17:25:36 +00:00
|
|
|
struct i2c_reg_value {
|
|
|
|
|
unsigned char reg;
|
|
|
|
|
unsigned char value;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* Default values as sugested at TVP5150AM1 datasheet */
|
|
|
|
|
static const struct i2c_reg_value tvp5150_init_default[] = {
|
|
|
|
|
{ /* 0x00 */
|
|
|
|
|
TVP5150_VD_IN_SRC_SEL_1,0x00
|
|
|
|
|
},
|
|
|
|
|
{ /* 0x01 */
|
|
|
|
|
TVP5150_ANAL_CHL_CTL,0x15
|
|
|
|
|
},
|
|
|
|
|
{ /* 0x02 */
|
|
|
|
|
TVP5150_OP_MODE_CTL,0x00
|
|
|
|
|
},
|
|
|
|
|
{ /* 0x03 */
|
|
|
|
|
TVP5150_MISC_CTL,0x01
|
|
|
|
|
},
|
|
|
|
|
{ /* 0x06 */
|
|
|
|
|
TVP5150_COLOR_KIL_THSH_CTL,0x10
|
|
|
|
|
},
|
|
|
|
|
{ /* 0x07 */
|
|
|
|
|
TVP5150_LUMA_PROC_CTL_1,0x60
|
|
|
|
|
},
|
|
|
|
|
{ /* 0x08 */
|
|
|
|
|
TVP5150_LUMA_PROC_CTL_2,0x00
|
|
|
|
|
},
|
|
|
|
|
{ /* 0x09 */
|
|
|
|
|
TVP5150_BRIGHT_CTL,0x80
|
|
|
|
|
},
|
|
|
|
|
{ /* 0x0a */
|
|
|
|
|
TVP5150_SATURATION_CTL,0x80
|
|
|
|
|
},
|
|
|
|
|
{ /* 0x0b */
|
|
|
|
|
TVP5150_HUE_CTL,0x00
|
|
|
|
|
},
|
|
|
|
|
{ /* 0x0c */
|
|
|
|
|
TVP5150_CONTRAST_CTL,0x80
|
|
|
|
|
},
|
|
|
|
|
{ /* 0x0d */
|
|
|
|
|
TVP5150_DATA_RATE_SEL,0x47
|
|
|
|
|
},
|
|
|
|
|
{ /* 0x0e */
|
|
|
|
|
TVP5150_LUMA_PROC_CTL_3,0x00
|
|
|
|
|
},
|
|
|
|
|
{ /* 0x0f */
|
|
|
|
|
TVP5150_CONF_SHARED_PIN,0x08
|
|
|
|
|
},
|
|
|
|
|
{ /* 0x11 */
|
|
|
|
|
TVP5150_ACT_VD_CROP_ST_MSB,0x00
|
|
|
|
|
},
|
|
|
|
|
{ /* 0x12 */
|
|
|
|
|
TVP5150_ACT_VD_CROP_ST_LSB,0x00
|
|
|
|
|
},
|
|
|
|
|
{ /* 0x13 */
|
|
|
|
|
TVP5150_ACT_VD_CROP_STP_MSB,0x00
|
|
|
|
|
},
|
|
|
|
|
{ /* 0x14 */
|
|
|
|
|
TVP5150_ACT_VD_CROP_STP_LSB,0x00
|
|
|
|
|
},
|
|
|
|
|
{ /* 0x15 */
|
|
|
|
|
TVP5150_GENLOCK,0x01
|
|
|
|
|
},
|
|
|
|
|
{ /* 0x16 */
|
|
|
|
|
TVP5150_HORIZ_SYNC_START,0x80
|
|
|
|
|
},
|
|
|
|
|
{ /* 0x18 */
|
|
|
|
|
TVP5150_VERT_BLANKING_START,0x00
|
|
|
|
|
},
|
|
|
|
|
{ /* 0x19 */
|
|
|
|
|
TVP5150_VERT_BLANKING_STOP,0x00
|
|
|
|
|
},
|
|
|
|
|
{ /* 0x1a */
|
|
|
|
|
TVP5150_CHROMA_PROC_CTL_1,0x0c
|
|
|
|
|
},
|
|
|
|
|
{ /* 0x1b */
|
|
|
|
|
TVP5150_CHROMA_PROC_CTL_2,0x14
|
|
|
|
|
},
|
|
|
|
|
{ /* 0x1c */
|
|
|
|
|
TVP5150_INT_RESET_REG_B,0x00
|
|
|
|
|
},
|
|
|
|
|
{ /* 0x1d */
|
|
|
|
|
TVP5150_INT_ENABLE_REG_B,0x00
|
|
|
|
|
},
|
|
|
|
|
{ /* 0x1e */
|
|
|
|
|
TVP5150_INTT_CONFIG_REG_B,0x00
|
|
|
|
|
},
|
|
|
|
|
{ /* 0x28 */
|
|
|
|
|
TVP5150_VIDEO_STD,0x00
|
|
|
|
|
},
|
|
|
|
|
{ /* 0x2e */
|
|
|
|
|
TVP5150_MACROVISION_ON_CTR,0x0f
|
|
|
|
|
},
|
|
|
|
|
{ /* 0x2f */
|
|
|
|
|
TVP5150_MACROVISION_OFF_CTR,0x01
|
|
|
|
|
},
|
|
|
|
|
{ /* 0xbb */
|
|
|
|
|
TVP5150_TELETEXT_FIL_ENA,0x00
|
|
|
|
|
},
|
|
|
|
|
{ /* 0xc0 */
|
|
|
|
|
TVP5150_INT_STATUS_REG_A,0x00
|
|
|
|
|
},
|
|
|
|
|
{ /* 0xc1 */
|
|
|
|
|
TVP5150_INT_ENABLE_REG_A,0x00
|
|
|
|
|
},
|
|
|
|
|
{ /* 0xc2 */
|
|
|
|
|
TVP5150_INT_CONF,0x04
|
|
|
|
|
},
|
|
|
|
|
{ /* 0xc8 */
|
|
|
|
|
TVP5150_FIFO_INT_THRESHOLD,0x80
|
|
|
|
|
},
|
|
|
|
|
{ /* 0xc9 */
|
|
|
|
|
TVP5150_FIFO_RESET,0x00
|
|
|
|
|
},
|
|
|
|
|
{ /* 0xca */
|
|
|
|
|
TVP5150_LINE_NUMBER_INT,0x00
|
|
|
|
|
},
|
|
|
|
|
{ /* 0xcb */
|
|
|
|
|
TVP5150_PIX_ALIGN_REG_LOW,0x4e
|
|
|
|
|
},
|
|
|
|
|
{ /* 0xcc */
|
|
|
|
|
TVP5150_PIX_ALIGN_REG_HIGH,0x00
|
|
|
|
|
},
|
|
|
|
|
{ /* 0xcd */
|
|
|
|
|
TVP5150_FIFO_OUT_CTRL,0x01
|
|
|
|
|
},
|
|
|
|
|
{ /* 0xcf */
|
2006-01-23 19:11:05 +00:00
|
|
|
TVP5150_FULL_FIELD_ENA,0x00
|
2006-01-09 17:25:36 +00:00
|
|
|
},
|
|
|
|
|
{ /* 0xd0 */
|
2006-01-23 19:11:05 +00:00
|
|
|
TVP5150_LINE_MODE_INI,0x00
|
2006-01-09 17:25:36 +00:00
|
|
|
},
|
|
|
|
|
{ /* 0xfc */
|
|
|
|
|
TVP5150_FULL_FIELD_MODE_REG,0x7f
|
|
|
|
|
},
|
|
|
|
|
{ /* end of data */
|
|
|
|
|
0xff,0xff
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* Default values as sugested at TVP5150AM1 datasheet */
|
|
|
|
|
static const struct i2c_reg_value tvp5150_init_enable[] = {
|
|
|
|
|
{
|
|
|
|
|
TVP5150_CONF_SHARED_PIN, 2
|
|
|
|
|
},{ /* Automatic offset and AGC enabled */
|
|
|
|
|
TVP5150_ANAL_CHL_CTL, 0x15
|
|
|
|
|
},{ /* Activate YCrCb output 0x9 or 0xd ? */
|
2016-12-09 11:47:18 +00:00
|
|
|
TVP5150_MISC_CTL, TVP5150_MISC_CTL_GPCL |
|
|
|
|
|
TVP5150_MISC_CTL_INTREQ_OE |
|
|
|
|
|
TVP5150_MISC_CTL_YCBCR_OE |
|
|
|
|
|
TVP5150_MISC_CTL_SYNC_OE |
|
|
|
|
|
TVP5150_MISC_CTL_VBLANK |
|
|
|
|
|
TVP5150_MISC_CTL_CLOCK_OE,
|
2006-01-09 17:25:36 +00:00
|
|
|
},{ /* Activates video std autodetection for all standards */
|
|
|
|
|
TVP5150_AUTOSW_MSK, 0x0
|
|
|
|
|
},{ /* Default format: 0x47. For 4:2:2: 0x40 */
|
|
|
|
|
TVP5150_DATA_RATE_SEL, 0x47
|
|
|
|
|
},{
|
|
|
|
|
TVP5150_CHROMA_PROC_CTL_1, 0x0c
|
|
|
|
|
},{
|
|
|
|
|
TVP5150_CHROMA_PROC_CTL_2, 0x54
|
|
|
|
|
},{ /* Non documented, but initialized on WinTV USB2 */
|
|
|
|
|
0x27, 0x20
|
|
|
|
|
},{
|
|
|
|
|
0xff,0xff
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
2006-01-23 19:11:05 +00:00
|
|
|
struct tvp5150_vbi_type {
|
|
|
|
|
unsigned int vbi_type;
|
|
|
|
|
unsigned int ini_line;
|
|
|
|
|
unsigned int end_line;
|
|
|
|
|
unsigned int by_field :1;
|
|
|
|
|
};
|
|
|
|
|
|
2006-01-09 17:25:36 +00:00
|
|
|
struct i2c_vbi_ram_value {
|
|
|
|
|
u16 reg;
|
2006-01-23 19:11:05 +00:00
|
|
|
struct tvp5150_vbi_type type;
|
|
|
|
|
unsigned char values[16];
|
2006-01-09 17:25:36 +00:00
|
|
|
};
|
|
|
|
|
|
2006-01-23 19:11:05 +00:00
|
|
|
/* This struct have the values for each supported VBI Standard
|
|
|
|
|
* by
|
|
|
|
|
tvp5150_vbi_types should follow the same order as vbi_ram_default
|
2006-01-23 19:11:05 +00:00
|
|
|
* value 0 means rom position 0x10, value 1 means rom position 0x30
|
|
|
|
|
* and so on. There are 16 possible locations from 0 to 15.
|
|
|
|
|
*/
|
|
|
|
|
|
2006-01-15 08:56:15 +00:00
|
|
|
static struct i2c_vbi_ram_value vbi_ram_default[] =
|
2005-11-09 05:36:40 +00:00
|
|
|
{
|
2006-03-29 21:02:51 +00:00
|
|
|
/* FIXME: Current api doesn't handle all VBI types, those not
|
|
|
|
|
yet supported are placed under #if 0 */
|
|
|
|
|
#if 0
|
2018-02-19 18:23:39 +00:00
|
|
|
[0] = {0x010, /* Teletext, SECAM, WST System A */
|
2006-01-23 19:11:05 +00:00
|
|
|
{V4L2_SLICED_TELETEXT_SECAM,6,23,1},
|
|
|
|
|
{ 0xaa, 0xaa, 0xff, 0xff, 0xe7, 0x2e, 0x20, 0x26,
|
|
|
|
|
0xe6, 0xb4, 0x0e, 0x00, 0x00, 0x00, 0x10, 0x00 }
|
2006-01-09 17:25:36 +00:00
|
|
|
},
|
2006-03-29 21:02:51 +00:00
|
|
|
#endif
|
2018-02-19 18:23:39 +00:00
|
|
|
[1] = {0x030, /* Teletext, PAL, WST System B */
|
2006-03-29 21:02:51 +00:00
|
|
|
{V4L2_SLICED_TELETEXT_B,6,22,1},
|
2006-01-23 19:11:05 +00:00
|
|
|
{ 0xaa, 0xaa, 0xff, 0xff, 0x27, 0x2e, 0x20, 0x2b,
|
|
|
|
|
0xa6, 0x72, 0x10, 0x00, 0x00, 0x00, 0x10, 0x00 }
|
2006-01-09 17:25:36 +00:00
|
|
|
},
|
2006-03-29 21:02:51 +00:00
|
|
|
#if 0
|
2018-02-19 18:23:39 +00:00
|
|
|
[2] = {0x050, /* Teletext, PAL, WST System C */
|
2006-01-23 19:11:05 +00:00
|
|
|
{V4L2_SLICED_TELETEXT_PAL_C,6,22,1},
|
|
|
|
|
{ 0xaa, 0xaa, 0xff, 0xff, 0xe7, 0x2e, 0x20, 0x22,
|
|
|
|
|
0xa6, 0x98, 0x0d, 0x00, 0x00, 0x00, 0x10, 0x00 }
|
2006-01-09 17:25:36 +00:00
|
|
|
},
|
2018-02-19 18:23:39 +00:00
|
|
|
[3] = {0x070, /* Teletext, NTSC, WST System B */
|
2006-01-23 19:11:05 +00:00
|
|
|
{V4L2_SLICED_TELETEXT_NTSC_B,10,21,1},
|
|
|
|
|
{ 0xaa, 0xaa, 0xff, 0xff, 0x27, 0x2e, 0x20, 0x23,
|
|
|
|
|
0x69, 0x93, 0x0d, 0x00, 0x00, 0x00, 0x10, 0x00 }
|
2006-01-09 17:25:36 +00:00
|
|
|
},
|
2018-02-19 18:23:39 +00:00
|
|
|
[4] = {0x090, /* Tetetext, NTSC NABTS System C */
|
2006-01-23 19:11:05 +00:00
|
|
|
{V4L2_SLICED_TELETEXT_NTSC_C,10,21,1},
|
|
|
|
|
{ 0xaa, 0xaa, 0xff, 0xff, 0xe7, 0x2e, 0x20, 0x22,
|
|
|
|
|
0x69, 0x93, 0x0d, 0x00, 0x00, 0x00, 0x15, 0x00 }
|
2006-01-09 17:25:36 +00:00
|
|
|
},
|
2018-02-19 18:23:39 +00:00
|
|
|
[5] = {0x0b0, /* Teletext, NTSC-J, NABTS System D */
|
2006-01-23 19:11:05 +00:00
|
|
|
{V4L2_SLICED_TELETEXT_NTSC_D,10,21,1},
|
|
|
|
|
{ 0xaa, 0xaa, 0xff, 0xff, 0xa7, 0x2e, 0x20, 0x23,
|
|
|
|
|
0x69, 0x93, 0x0d, 0x00, 0x00, 0x00, 0x10, 0x00 }
|
2006-01-09 17:25:36 +00:00
|
|
|
},
|
2018-02-19 18:23:39 +00:00
|
|
|
[6] = {0x0d0, /* Closed Caption, PAL/SECAM */
|
2006-01-23 19:11:05 +00:00
|
|
|
{V4L2_SLICED_CAPTION_625,22,22,1},
|
|
|
|
|
{ 0xaa, 0x2a, 0xff, 0x3f, 0x04, 0x51, 0x6e, 0x02,
|
|
|
|
|
0xa6, 0x7b, 0x09, 0x00, 0x00, 0x00, 0x27, 0x00 }
|
2006-01-09 17:25:36 +00:00
|
|
|
},
|
2006-03-29 21:02:51 +00:00
|
|
|
#endif
|
2018-02-19 18:23:39 +00:00
|
|
|
[7] = {0x0f0, /* Closed Caption, NTSC */
|
2006-01-23 19:11:05 +00:00
|
|
|
{V4L2_SLICED_CAPTION_525,21,21,1},
|
|
|
|
|
{ 0xaa, 0x2a, 0xff, 0x3f, 0x04, 0x51, 0x6e, 0x02,
|
|
|
|
|
0x69, 0x8c, 0x09, 0x00, 0x00, 0x00, 0x27, 0x00 }
|
2006-01-09 17:25:36 +00:00
|
|
|
},
|
2018-02-19 18:23:39 +00:00
|
|
|
[8] = {0x110, /* Wide Screen Signal, PAL/SECAM */
|
2006-01-23 19:11:08 +00:00
|
|
|
{V4L2_SLICED_WSS_625,23,23,1},
|
2006-01-23 19:11:05 +00:00
|
|
|
{ 0x5b, 0x55, 0xc5, 0xff, 0x00, 0x71, 0x6e, 0x42,
|
|
|
|
|
0xa6, 0xcd, 0x0f, 0x00, 0x00, 0x00, 0x3a, 0x00 }
|
2006-01-09 17:25:36 +00:00
|
|
|
},
|
2006-03-29 21:02:51 +00:00
|
|
|
#if 0
|
2018-02-19 18:23:39 +00:00
|
|
|
[9] = {0x130, /* Wide Screen Signal, NTSC C */
|
2006-01-23 19:11:05 +00:00
|
|
|
{V4L2_SLICED_WSS_525,20,20,1},
|
|
|
|
|
{ 0x38, 0x00, 0x3f, 0x00, 0x00, 0x71, 0x6e, 0x43,
|
|
|
|
|
0x69, 0x7c, 0x08, 0x00, 0x00, 0x00, 0x39, 0x00 }
|
2006-01-09 17:25:36 +00:00
|
|
|
},
|
2018-02-19 18:23:39 +00:00
|
|
|
[10] = {0x150, /* Vertical Interval Timecode (VITC), PAL/SECAM */
|
2006-01-23 19:11:05 +00:00
|
|
|
{V4l2_SLICED_VITC_625,6,22,0},
|
|
|
|
|
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x8f, 0x6d, 0x49,
|
|
|
|
|
0xa6, 0x85, 0x08, 0x00, 0x00, 0x00, 0x4c, 0x00 }
|
2006-01-09 17:25:36 +00:00
|
|
|
},
|
2018-02-19 18:23:39 +00:00
|
|
|
[11] = {0x170, /* Vertical Interval Timecode (VITC), NTSC */
|
2006-01-23 19:11:05 +00:00
|
|
|
{V4l2_SLICED_VITC_525,10,20,0},
|
|
|
|
|
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x8f, 0x6d, 0x49,
|
|
|
|
|
0x69, 0x94, 0x08, 0x00, 0x00, 0x00, 0x4c, 0x00 }
|
2006-01-09 17:25:36 +00:00
|
|
|
},
|
2006-03-29 21:02:51 +00:00
|
|
|
#endif
|
2018-02-19 18:23:39 +00:00
|
|
|
[12] = {0x190, /* Video Program System (VPS), PAL */
|
2006-01-23 19:11:05 +00:00
|
|
|
{V4L2_SLICED_VPS,16,16,0},
|
|
|
|
|
{ 0xaa, 0xaa, 0xff, 0xff, 0xba, 0xce, 0x2b, 0x0d,
|
|
|
|
|
0xa6, 0xda, 0x0b, 0x00, 0x00, 0x00, 0x60, 0x00 }
|
2006-01-23 19:11:05 +00:00
|
|
|
},
|
2006-01-23 19:11:05 +00:00
|
|
|
/* 0x1d0 User programmable */
|
2006-01-09 17:25:36 +00:00
|
|
|
};
|
2005-11-09 05:36:43 +00:00
|
|
|
|
2008-12-18 14:17:25 +00:00
|
|
|
static int tvp5150_write_inittab(struct v4l2_subdev *sd,
|
2006-01-23 19:11:05 +00:00
|
|
|
const struct i2c_reg_value *regs)
|
2006-01-09 17:25:36 +00:00
|
|
|
{
|
|
|
|
|
while (regs->reg != 0xff) {
|
2008-12-18 14:17:25 +00:00
|
|
|
tvp5150_write(sd, regs->reg, regs->value);
|
2006-01-09 17:25:36 +00:00
|
|
|
regs++;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2005-11-09 05:36:41 +00:00
|
|
|
|
2018-02-19 18:23:39 +00:00
|
|
|
static int tvp5150_vdp_init(struct v4l2_subdev *sd)
|
2006-01-09 17:25:36 +00:00
|
|
|
{
|
|
|
|
|
unsigned int i;
|
2018-02-19 18:23:39 +00:00
|
|
|
int j;
|
2005-11-09 05:36:40 +00:00
|
|
|
|
2006-01-09 17:25:36 +00:00
|
|
|
/* Disable Full Field */
|
2008-12-18 14:17:25 +00:00
|
|
|
tvp5150_write(sd, TVP5150_FULL_FIELD_ENA, 0);
|
2005-11-09 05:36:40 +00:00
|
|
|
|
2006-01-09 17:25:36 +00:00
|
|
|
/* Before programming, Line mode should be at 0xff */
|
2008-12-18 14:17:25 +00:00
|
|
|
for (i = TVP5150_LINE_MODE_INI; i <= TVP5150_LINE_MODE_END; i++)
|
|
|
|
|
tvp5150_write(sd, i, 0xff);
|
2005-11-09 05:36:40 +00:00
|
|
|
|
2006-01-09 17:25:36 +00:00
|
|
|
/* Load Ram Table */
|
2018-02-19 18:23:39 +00:00
|
|
|
for (j = 0; j < ARRAY_SIZE(vbi_ram_default); j++) {
|
|
|
|
|
const struct i2c_vbi_ram_value *regs = &vbi_ram_default[j];
|
|
|
|
|
|
|
|
|
|
if (!regs->type.vbi_type)
|
|
|
|
|
continue;
|
|
|
|
|
|
2008-12-18 14:17:25 +00:00
|
|
|
tvp5150_write(sd, TVP5150_CONF_RAM_ADDR_HIGH, regs->reg >> 8);
|
|
|
|
|
tvp5150_write(sd, TVP5150_CONF_RAM_ADDR_LOW, regs->reg);
|
2005-11-09 05:36:40 +00:00
|
|
|
|
2008-12-18 14:17:25 +00:00
|
|
|
for (i = 0; i < 16; i++)
|
|
|
|
|
tvp5150_write(sd, TVP5150_VDP_CONF_RAM_DATA, regs->values[i]);
|
2006-01-09 17:25:36 +00:00
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2005-11-09 05:36:40 +00:00
|
|
|
|
2006-01-23 19:11:05 +00:00
|
|
|
/* Fills VBI capabilities based on i2c_vbi_ram_value struct */
|
2008-12-18 14:17:25 +00:00
|
|
|
static int tvp5150_g_sliced_vbi_cap(struct v4l2_subdev *sd,
|
2006-01-23 19:11:05 +00:00
|
|
|
struct v4l2_sliced_vbi_cap *cap)
|
|
|
|
|
{
|
2018-02-19 18:23:39 +00:00
|
|
|
int line, i;
|
2006-01-23 19:11:05 +00:00
|
|
|
|
2016-11-16 10:58:05 +00:00
|
|
|
dev_dbg_lvl(sd->dev, 1, debug, "g_sliced_vbi_cap\n");
|
2006-01-23 19:11:05 +00:00
|
|
|
memset(cap, 0, sizeof *cap);
|
|
|
|
|
|
2018-02-19 18:23:39 +00:00
|
|
|
for (i = 0; i < ARRAY_SIZE(vbi_ram_default); i++) {
|
|
|
|
|
const struct i2c_vbi_ram_value *regs = &vbi_ram_default[i];
|
|
|
|
|
|
|
|
|
|
if (!regs->type.vbi_type)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
for (line = regs->type.ini_line;
|
|
|
|
|
line <= regs->type.end_line;
|
|
|
|
|
line++) {
|
2006-01-23 19:11:05 +00:00
|
|
|
cap->service_lines[0][line] |= regs->type.vbi_type;
|
|
|
|
|
}
|
|
|
|
|
cap->service_set |= regs->type.vbi_type;
|
|
|
|
|
}
|
2008-12-18 14:17:25 +00:00
|
|
|
return 0;
|
2006-01-23 19:11:05 +00:00
|
|
|
}
|
|
|
|
|
|
2006-01-23 19:11:05 +00:00
|
|
|
/* Set vbi processing
|
|
|
|
|
* type - one of tvp5150_vbi_types
|
|
|
|
|
* line - line to gather data
|
|
|
|
|
* fields: bit 0 field1, bit 1, field2
|
|
|
|
|
* flags (default=0xf0) is a bitmask, were set means:
|
|
|
|
|
* bit 7: enable filtering null bytes on CC
|
|
|
|
|
* bit 6: send data also to FIFO
|
|
|
|
|
* bit 5: don't allow data with errors on FIFO
|
|
|
|
|
* bit 4: enable ECC when possible
|
|
|
|
|
* pix_align = pix alignment:
|
|
|
|
|
* LSB = field1
|
|
|
|
|
* MSB = field2
|
|
|
|
|
*/
|
2008-12-18 14:17:25 +00:00
|
|
|
static int tvp5150_set_vbi(struct v4l2_subdev *sd,
|
2006-01-23 19:11:06 +00:00
|
|
|
unsigned int type,u8 flags, int line,
|
|
|
|
|
const int fields)
|
2006-01-23 19:11:05 +00:00
|
|
|
{
|
2008-12-18 14:17:25 +00:00
|
|
|
struct tvp5150 *decoder = to_tvp5150(sd);
|
|
|
|
|
v4l2_std_id std = decoder->norm;
|
2006-01-23 19:11:05 +00:00
|
|
|
u8 reg;
|
2018-02-19 18:23:39 +00:00
|
|
|
int i, pos = 0;
|
2006-01-23 19:11:05 +00:00
|
|
|
|
|
|
|
|
if (std == V4L2_STD_ALL) {
|
2016-11-16 10:58:05 +00:00
|
|
|
dev_err(sd->dev, "VBI can't be configured without knowing number of lines\n");
|
2006-01-23 19:11:08 +00:00
|
|
|
return 0;
|
2008-03-10 00:19:13 +00:00
|
|
|
} else if (std & V4L2_STD_625_50) {
|
2006-01-23 19:11:05 +00:00
|
|
|
/* Don't follow NTSC Line number convension */
|
|
|
|
|
line += 3;
|
|
|
|
|
}
|
|
|
|
|
|
2017-06-23 22:37:00 +00:00
|
|
|
if (line < 6 || line > 27)
|
2006-01-23 19:11:06 +00:00
|
|
|
return 0;
|
|
|
|
|
|
2018-02-19 18:23:39 +00:00
|
|
|
for (i = 0; i < ARRAY_SIZE(vbi_ram_default); i++) {
|
|
|
|
|
const struct i2c_vbi_ram_value *regs = &vbi_ram_default[i];
|
|
|
|
|
|
|
|
|
|
if (!regs->type.vbi_type)
|
|
|
|
|
continue;
|
|
|
|
|
|
2006-01-23 19:11:06 +00:00
|
|
|
if ((type & regs->type.vbi_type) &&
|
2017-06-23 22:37:00 +00:00
|
|
|
(line >= regs->type.ini_line) &&
|
|
|
|
|
(line <= regs->type.end_line))
|
2006-01-23 19:11:06 +00:00
|
|
|
break;
|
|
|
|
|
pos++;
|
|
|
|
|
}
|
2017-06-23 22:37:00 +00:00
|
|
|
|
|
|
|
|
type = pos | (flags & 0xf0);
|
|
|
|
|
reg = ((line - 6) << 1) + TVP5150_LINE_MODE_INI;
|
2006-01-23 19:11:05 +00:00
|
|
|
|
2017-06-23 22:37:00 +00:00
|
|
|
if (fields & 1)
|
2008-12-18 14:17:25 +00:00
|
|
|
tvp5150_write(sd, reg, type);
|
2006-01-23 19:11:05 +00:00
|
|
|
|
2017-06-23 22:37:00 +00:00
|
|
|
if (fields & 2)
|
|
|
|
|
tvp5150_write(sd, reg + 1, type);
|
2006-01-23 19:11:05 +00:00
|
|
|
|
2006-01-23 19:11:06 +00:00
|
|
|
return type;
|
2006-01-23 19:11:05 +00:00
|
|
|
}
|
|
|
|
|
|
2018-02-19 18:23:39 +00:00
|
|
|
static int tvp5150_get_vbi(struct v4l2_subdev *sd, int line)
|
2006-01-23 19:11:08 +00:00
|
|
|
{
|
2008-12-18 14:17:25 +00:00
|
|
|
struct tvp5150 *decoder = to_tvp5150(sd);
|
|
|
|
|
v4l2_std_id std = decoder->norm;
|
2006-01-23 19:11:08 +00:00
|
|
|
u8 reg;
|
2008-12-18 14:17:25 +00:00
|
|
|
int pos, type = 0;
|
2012-06-13 10:49:30 +00:00
|
|
|
int i, ret = 0;
|
2006-01-23 19:11:08 +00:00
|
|
|
|
|
|
|
|
if (std == V4L2_STD_ALL) {
|
2016-11-16 10:58:05 +00:00
|
|
|
dev_err(sd->dev, "VBI can't be configured without knowing number of lines\n");
|
2006-01-23 19:11:08 +00:00
|
|
|
return 0;
|
2008-03-10 00:19:13 +00:00
|
|
|
} else if (std & V4L2_STD_625_50) {
|
2006-01-23 19:11:08 +00:00
|
|
|
/* Don't follow NTSC Line number convension */
|
|
|
|
|
line += 3;
|
|
|
|
|
}
|
|
|
|
|
|
2008-12-18 14:17:25 +00:00
|
|
|
if (line < 6 || line > 27)
|
2006-01-23 19:11:08 +00:00
|
|
|
return 0;
|
|
|
|
|
|
2008-12-18 14:17:25 +00:00
|
|
|
reg = ((line - 6) << 1) + TVP5150_LINE_MODE_INI;
|
2006-01-23 19:11:08 +00:00
|
|
|
|
2012-06-13 10:49:30 +00:00
|
|
|
for (i = 0; i <= 1; i++) {
|
|
|
|
|
ret = tvp5150_read(sd, reg + i);
|
|
|
|
|
if (ret < 0) {
|
2016-11-16 10:58:05 +00:00
|
|
|
dev_err(sd->dev, "%s: failed with error = %d\n",
|
2012-06-13 10:49:30 +00:00
|
|
|
__func__, ret);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
pos = ret & 0x0f;
|
2018-02-19 18:23:39 +00:00
|
|
|
if (pos < ARRAY_SIZE(vbi_ram_default))
|
|
|
|
|
type |= vbi_ram_default[pos].type.vbi_type;
|
2012-06-13 10:49:30 +00:00
|
|
|
}
|
2006-01-23 19:11:08 +00:00
|
|
|
|
|
|
|
|
return type;
|
|
|
|
|
}
|
2008-12-18 14:17:25 +00:00
|
|
|
|
|
|
|
|
static int tvp5150_set_std(struct v4l2_subdev *sd, v4l2_std_id std)
|
2006-01-09 17:25:36 +00:00
|
|
|
{
|
2008-12-18 14:17:25 +00:00
|
|
|
struct tvp5150 *decoder = to_tvp5150(sd);
|
|
|
|
|
int fmt = 0;
|
2006-01-09 17:25:36 +00:00
|
|
|
|
2008-12-18 14:17:25 +00:00
|
|
|
decoder->norm = std;
|
2006-01-09 17:25:36 +00:00
|
|
|
|
|
|
|
|
/* First tests should be against specific std */
|
|
|
|
|
|
2013-05-29 13:19:06 +00:00
|
|
|
if (std == V4L2_STD_NTSC_443) {
|
2011-11-04 16:23:21 +00:00
|
|
|
fmt = VIDEO_STD_NTSC_4_43_BIT;
|
2013-05-29 13:19:06 +00:00
|
|
|
} else if (std == V4L2_STD_PAL_M) {
|
2011-11-04 16:23:21 +00:00
|
|
|
fmt = VIDEO_STD_PAL_M_BIT;
|
2013-05-29 13:19:06 +00:00
|
|
|
} else if (std == V4L2_STD_PAL_N || std == V4L2_STD_PAL_Nc) {
|
2011-11-04 16:23:21 +00:00
|
|
|
fmt = VIDEO_STD_PAL_COMBINATION_N_BIT;
|
2006-01-09 17:25:36 +00:00
|
|
|
} else {
|
|
|
|
|
/* Then, test against generic ones */
|
2008-12-18 14:17:25 +00:00
|
|
|
if (std & V4L2_STD_NTSC)
|
2011-11-04 16:23:21 +00:00
|
|
|
fmt = VIDEO_STD_NTSC_MJ_BIT;
|
2008-12-18 14:17:25 +00:00
|
|
|
else if (std & V4L2_STD_PAL)
|
2011-11-04 16:23:21 +00:00
|
|
|
fmt = VIDEO_STD_PAL_BDGHIN_BIT;
|
2008-12-18 14:17:25 +00:00
|
|
|
else if (std & V4L2_STD_SECAM)
|
2011-11-04 16:23:21 +00:00
|
|
|
fmt = VIDEO_STD_SECAM_BIT;
|
2006-01-09 17:25:36 +00:00
|
|
|
}
|
2005-11-09 05:36:41 +00:00
|
|
|
|
2016-11-16 10:58:05 +00:00
|
|
|
dev_dbg_lvl(sd->dev, 1, debug, "Set video std register to %d.\n", fmt);
|
2008-12-18 14:17:25 +00:00
|
|
|
tvp5150_write(sd, TVP5150_VIDEO_STD, fmt);
|
2006-01-09 17:25:36 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2008-12-18 14:17:25 +00:00
|
|
|
static int tvp5150_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
|
|
|
|
|
{
|
|
|
|
|
struct tvp5150 *decoder = to_tvp5150(sd);
|
|
|
|
|
|
|
|
|
|
if (decoder->norm == std)
|
|
|
|
|
return 0;
|
|
|
|
|
|
2012-01-31 08:23:46 +00:00
|
|
|
/* Change cropping height limits */
|
|
|
|
|
if (std & V4L2_STD_525_60)
|
|
|
|
|
decoder->rect.height = TVP5150_V_MAX_525_60;
|
|
|
|
|
else
|
|
|
|
|
decoder->rect.height = TVP5150_V_MAX_OTHERS;
|
|
|
|
|
|
|
|
|
|
|
2008-12-18 14:17:25 +00:00
|
|
|
return tvp5150_set_std(sd, std);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int tvp5150_reset(struct v4l2_subdev *sd, u32 val)
|
2006-01-09 17:25:36 +00:00
|
|
|
{
|
2008-12-18 14:17:25 +00:00
|
|
|
struct tvp5150 *decoder = to_tvp5150(sd);
|
2005-11-09 05:36:41 +00:00
|
|
|
|
2006-01-09 17:25:36 +00:00
|
|
|
/* Initializes TVP5150 to its default values */
|
2008-12-18 14:17:25 +00:00
|
|
|
tvp5150_write_inittab(sd, tvp5150_init_default);
|
2006-01-09 17:25:36 +00:00
|
|
|
|
|
|
|
|
/* Initializes VDP registers */
|
2018-02-19 18:23:39 +00:00
|
|
|
tvp5150_vdp_init(sd);
|
2006-01-09 17:25:36 +00:00
|
|
|
|
|
|
|
|
/* Selects decoder input */
|
2008-12-18 14:17:25 +00:00
|
|
|
tvp5150_selmux(sd);
|
2006-01-09 17:25:36 +00:00
|
|
|
|
|
|
|
|
/* Initializes TVP5150 to stream enabled values */
|
2008-12-18 14:17:25 +00:00
|
|
|
tvp5150_write_inittab(sd, tvp5150_init_enable);
|
2006-01-09 17:25:36 +00:00
|
|
|
|
|
|
|
|
/* Initialize image preferences */
|
2010-12-12 11:45:43 +00:00
|
|
|
v4l2_ctrl_handler_setup(&decoder->hdl);
|
2006-01-09 17:25:36 +00:00
|
|
|
|
2008-12-18 14:17:25 +00:00
|
|
|
tvp5150_set_std(sd, decoder->norm);
|
2016-01-07 12:46:50 +00:00
|
|
|
|
|
|
|
|
if (decoder->mbus_type == V4L2_MBUS_PARALLEL)
|
|
|
|
|
tvp5150_write(sd, TVP5150_DATA_RATE_SEL, 0x40);
|
|
|
|
|
|
2008-12-18 14:17:25 +00:00
|
|
|
return 0;
|
2005-11-09 05:36:40 +00:00
|
|
|
};
|
|
|
|
|
|
2010-12-12 11:45:43 +00:00
|
|
|
static int tvp5150_s_ctrl(struct v4l2_ctrl *ctrl)
|
2005-11-09 05:37:07 +00:00
|
|
|
{
|
2010-12-12 11:45:43 +00:00
|
|
|
struct v4l2_subdev *sd = to_sd(ctrl);
|
2016-02-12 17:42:02 +00:00
|
|
|
struct tvp5150 *decoder = to_tvp5150(sd);
|
2005-11-09 05:37:07 +00:00
|
|
|
|
|
|
|
|
switch (ctrl->id) {
|
|
|
|
|
case V4L2_CID_BRIGHTNESS:
|
2010-12-12 11:45:43 +00:00
|
|
|
tvp5150_write(sd, TVP5150_BRIGHT_CTL, ctrl->val);
|
2005-11-09 05:37:07 +00:00
|
|
|
return 0;
|
|
|
|
|
case V4L2_CID_CONTRAST:
|
2010-12-12 11:45:43 +00:00
|
|
|
tvp5150_write(sd, TVP5150_CONTRAST_CTL, ctrl->val);
|
2005-11-09 05:37:07 +00:00
|
|
|
return 0;
|
|
|
|
|
case V4L2_CID_SATURATION:
|
2010-12-12 11:45:43 +00:00
|
|
|
tvp5150_write(sd, TVP5150_SATURATION_CTL, ctrl->val);
|
2005-11-09 05:37:07 +00:00
|
|
|
return 0;
|
|
|
|
|
case V4L2_CID_HUE:
|
2010-12-12 11:45:43 +00:00
|
|
|
tvp5150_write(sd, TVP5150_HUE_CTL, ctrl->val);
|
2016-12-08 22:22:43 +00:00
|
|
|
break;
|
2016-02-12 17:42:02 +00:00
|
|
|
case V4L2_CID_TEST_PATTERN:
|
|
|
|
|
decoder->enable = ctrl->val ? false : true;
|
|
|
|
|
tvp5150_selmux(sd);
|
2005-11-09 05:37:07 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
2006-01-09 17:25:14 +00:00
|
|
|
return -EINVAL;
|
2005-11-09 05:37:07 +00:00
|
|
|
}
|
|
|
|
|
|
2012-01-05 13:57:39 +00:00
|
|
|
static v4l2_std_id tvp5150_read_std(struct v4l2_subdev *sd)
|
|
|
|
|
{
|
|
|
|
|
int val = tvp5150_read(sd, TVP5150_STATUS_REG_5);
|
|
|
|
|
|
|
|
|
|
switch (val & 0x0F) {
|
|
|
|
|
case 0x01:
|
|
|
|
|
return V4L2_STD_NTSC;
|
|
|
|
|
case 0x03:
|
|
|
|
|
return V4L2_STD_PAL;
|
|
|
|
|
case 0x05:
|
|
|
|
|
return V4L2_STD_PAL_M;
|
|
|
|
|
case 0x07:
|
|
|
|
|
return V4L2_STD_PAL_N | V4L2_STD_PAL_Nc;
|
|
|
|
|
case 0x09:
|
|
|
|
|
return V4L2_STD_NTSC_443;
|
|
|
|
|
case 0xb:
|
|
|
|
|
return V4L2_STD_SECAM;
|
|
|
|
|
default:
|
|
|
|
|
return V4L2_STD_UNKNOWN;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2015-04-09 07:02:34 +00:00
|
|
|
static int tvp5150_fill_fmt(struct v4l2_subdev *sd,
|
|
|
|
|
struct v4l2_subdev_pad_config *cfg,
|
|
|
|
|
struct v4l2_subdev_format *format)
|
2012-01-05 13:57:39 +00:00
|
|
|
{
|
2015-04-09 07:02:34 +00:00
|
|
|
struct v4l2_mbus_framefmt *f;
|
2012-01-05 13:57:39 +00:00
|
|
|
struct tvp5150 *decoder = to_tvp5150(sd);
|
|
|
|
|
|
2017-03-31 13:33:25 +00:00
|
|
|
if (!format || (format->pad != DEMOD_PAD_VID_OUT))
|
2012-01-05 13:57:39 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
2015-04-09 07:02:34 +00:00
|
|
|
f = &format->format;
|
|
|
|
|
|
2012-01-31 08:23:46 +00:00
|
|
|
f->width = decoder->rect.width;
|
2017-03-31 13:33:26 +00:00
|
|
|
f->height = decoder->rect.height;
|
2012-01-05 13:57:39 +00:00
|
|
|
|
2014-11-10 17:28:29 +00:00
|
|
|
f->code = MEDIA_BUS_FMT_UYVY8_2X8;
|
2016-01-26 12:46:23 +00:00
|
|
|
f->field = V4L2_FIELD_ALTERNATE;
|
2012-01-05 13:57:39 +00:00
|
|
|
f->colorspace = V4L2_COLORSPACE_SMPTE170M;
|
|
|
|
|
|
2016-11-16 10:58:05 +00:00
|
|
|
dev_dbg_lvl(sd->dev, 1, debug, "width = %d, height = %d\n", f->width,
|
2012-01-05 13:57:39 +00:00
|
|
|
f->height);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2015-12-14 10:25:32 +00:00
|
|
|
static int tvp5150_set_selection(struct v4l2_subdev *sd,
|
|
|
|
|
struct v4l2_subdev_pad_config *cfg,
|
|
|
|
|
struct v4l2_subdev_selection *sel)
|
2012-01-31 08:23:46 +00:00
|
|
|
{
|
|
|
|
|
struct tvp5150 *decoder = to_tvp5150(sd);
|
2015-12-14 10:25:32 +00:00
|
|
|
struct v4l2_rect rect = sel->r;
|
2012-01-31 08:23:46 +00:00
|
|
|
v4l2_std_id std;
|
2015-12-14 10:25:32 +00:00
|
|
|
int hmax;
|
|
|
|
|
|
|
|
|
|
if (sel->which != V4L2_SUBDEV_FORMAT_ACTIVE ||
|
|
|
|
|
sel->target != V4L2_SEL_TGT_CROP)
|
|
|
|
|
return -EINVAL;
|
2012-01-31 08:23:46 +00:00
|
|
|
|
2016-11-16 10:58:05 +00:00
|
|
|
dev_dbg_lvl(sd->dev, 1, debug, "%s left=%d, top=%d, width=%d, height=%d\n",
|
2012-01-31 08:23:46 +00:00
|
|
|
__func__, rect.left, rect.top, rect.width, rect.height);
|
|
|
|
|
|
|
|
|
|
/* tvp5150 has some special limits */
|
|
|
|
|
rect.left = clamp(rect.left, 0, TVP5150_MAX_CROP_LEFT);
|
2013-11-26 08:31:42 +00:00
|
|
|
rect.width = clamp_t(unsigned int, rect.width,
|
|
|
|
|
TVP5150_H_MAX - TVP5150_MAX_CROP_LEFT - rect.left,
|
|
|
|
|
TVP5150_H_MAX - rect.left);
|
2012-01-31 08:23:46 +00:00
|
|
|
rect.top = clamp(rect.top, 0, TVP5150_MAX_CROP_TOP);
|
|
|
|
|
|
|
|
|
|
/* Calculate height based on current standard */
|
|
|
|
|
if (decoder->norm == V4L2_STD_ALL)
|
|
|
|
|
std = tvp5150_read_std(sd);
|
|
|
|
|
else
|
|
|
|
|
std = decoder->norm;
|
|
|
|
|
|
|
|
|
|
if (std & V4L2_STD_525_60)
|
|
|
|
|
hmax = TVP5150_V_MAX_525_60;
|
|
|
|
|
else
|
|
|
|
|
hmax = TVP5150_V_MAX_OTHERS;
|
|
|
|
|
|
2013-11-26 08:31:42 +00:00
|
|
|
rect.height = clamp_t(unsigned int, rect.height,
|
|
|
|
|
hmax - TVP5150_MAX_CROP_TOP - rect.top,
|
|
|
|
|
hmax - rect.top);
|
2012-01-31 08:23:46 +00:00
|
|
|
|
|
|
|
|
tvp5150_write(sd, TVP5150_VERT_BLANKING_START, rect.top);
|
|
|
|
|
tvp5150_write(sd, TVP5150_VERT_BLANKING_STOP,
|
|
|
|
|
rect.top + rect.height - hmax);
|
|
|
|
|
tvp5150_write(sd, TVP5150_ACT_VD_CROP_ST_MSB,
|
|
|
|
|
rect.left >> TVP5150_CROP_SHIFT);
|
|
|
|
|
tvp5150_write(sd, TVP5150_ACT_VD_CROP_ST_LSB,
|
|
|
|
|
rect.left | (1 << TVP5150_CROP_SHIFT));
|
|
|
|
|
tvp5150_write(sd, TVP5150_ACT_VD_CROP_STP_MSB,
|
|
|
|
|
(rect.left + rect.width - TVP5150_MAX_CROP_LEFT) >>
|
|
|
|
|
TVP5150_CROP_SHIFT);
|
|
|
|
|
tvp5150_write(sd, TVP5150_ACT_VD_CROP_STP_LSB,
|
|
|
|
|
rect.left + rect.width - TVP5150_MAX_CROP_LEFT);
|
|
|
|
|
|
|
|
|
|
decoder->rect = rect;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2015-12-14 10:25:32 +00:00
|
|
|
static int tvp5150_get_selection(struct v4l2_subdev *sd,
|
|
|
|
|
struct v4l2_subdev_pad_config *cfg,
|
|
|
|
|
struct v4l2_subdev_selection *sel)
|
2012-01-31 08:23:46 +00:00
|
|
|
{
|
2015-12-14 10:25:32 +00:00
|
|
|
struct tvp5150 *decoder = container_of(sd, struct tvp5150, sd);
|
2012-01-31 08:23:46 +00:00
|
|
|
v4l2_std_id std;
|
|
|
|
|
|
2015-12-14 10:25:32 +00:00
|
|
|
if (sel->which != V4L2_SUBDEV_FORMAT_ACTIVE)
|
2012-01-31 08:23:46 +00:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
2015-12-14 10:25:32 +00:00
|
|
|
switch (sel->target) {
|
|
|
|
|
case V4L2_SEL_TGT_CROP_BOUNDS:
|
|
|
|
|
case V4L2_SEL_TGT_CROP_DEFAULT:
|
|
|
|
|
sel->r.left = 0;
|
|
|
|
|
sel->r.top = 0;
|
|
|
|
|
sel->r.width = TVP5150_H_MAX;
|
|
|
|
|
|
|
|
|
|
/* Calculate height based on current standard */
|
|
|
|
|
if (decoder->norm == V4L2_STD_ALL)
|
|
|
|
|
std = tvp5150_read_std(sd);
|
|
|
|
|
else
|
|
|
|
|
std = decoder->norm;
|
|
|
|
|
if (std & V4L2_STD_525_60)
|
|
|
|
|
sel->r.height = TVP5150_V_MAX_525_60;
|
|
|
|
|
else
|
|
|
|
|
sel->r.height = TVP5150_V_MAX_OTHERS;
|
|
|
|
|
return 0;
|
|
|
|
|
case V4L2_SEL_TGT_CROP:
|
|
|
|
|
sel->r = decoder->rect;
|
|
|
|
|
return 0;
|
|
|
|
|
default:
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
2012-01-31 08:23:46 +00:00
|
|
|
}
|
|
|
|
|
|
2016-01-07 12:46:46 +00:00
|
|
|
static int tvp5150_g_mbus_config(struct v4l2_subdev *sd,
|
|
|
|
|
struct v4l2_mbus_config *cfg)
|
|
|
|
|
{
|
2016-01-07 12:46:50 +00:00
|
|
|
struct tvp5150 *decoder = to_tvp5150(sd);
|
|
|
|
|
|
|
|
|
|
cfg->type = decoder->mbus_type;
|
2016-01-07 12:46:46 +00:00
|
|
|
cfg->flags = V4L2_MBUS_MASTER | V4L2_MBUS_PCLK_SAMPLE_RISING
|
|
|
|
|
| V4L2_MBUS_FIELD_EVEN_LOW | V4L2_MBUS_DATA_ACTIVE_HIGH;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2016-01-26 12:46:24 +00:00
|
|
|
/****************************************************************************
|
|
|
|
|
V4L2 subdev pad ops
|
|
|
|
|
****************************************************************************/
|
|
|
|
|
static int tvp5150_enum_mbus_code(struct v4l2_subdev *sd,
|
|
|
|
|
struct v4l2_subdev_pad_config *cfg,
|
|
|
|
|
struct v4l2_subdev_mbus_code_enum *code)
|
|
|
|
|
{
|
|
|
|
|
if (code->pad || code->index)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
code->code = MEDIA_BUS_FMT_UYVY8_2X8;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int tvp5150_enum_frame_size(struct v4l2_subdev *sd,
|
|
|
|
|
struct v4l2_subdev_pad_config *cfg,
|
|
|
|
|
struct v4l2_subdev_frame_size_enum *fse)
|
|
|
|
|
{
|
|
|
|
|
struct tvp5150 *decoder = to_tvp5150(sd);
|
|
|
|
|
|
|
|
|
|
if (fse->index >= 8 || fse->code != MEDIA_BUS_FMT_UYVY8_2X8)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
|
|
fse->code = MEDIA_BUS_FMT_UYVY8_2X8;
|
|
|
|
|
fse->min_width = decoder->rect.width;
|
|
|
|
|
fse->max_width = decoder->rect.width;
|
|
|
|
|
fse->min_height = decoder->rect.height / 2;
|
|
|
|
|
fse->max_height = decoder->rect.height / 2;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2016-02-05 19:09:58 +00:00
|
|
|
/****************************************************************************
|
|
|
|
|
Media entity ops
|
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
2016-12-08 22:22:41 +00:00
|
|
|
#ifdef CONFIG_MEDIA_CONTROLLER
|
2016-02-05 19:09:58 +00:00
|
|
|
static int tvp5150_link_setup(struct media_entity *entity,
|
|
|
|
|
const struct media_pad *local,
|
|
|
|
|
const struct media_pad *remote, u32 flags)
|
|
|
|
|
{
|
|
|
|
|
struct v4l2_subdev *sd = media_entity_to_v4l2_subdev(entity);
|
|
|
|
|
struct tvp5150 *decoder = to_tvp5150(sd);
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < TVP5150_INPUT_NUM; i++) {
|
|
|
|
|
if (remote->entity == &decoder->input_ent[i])
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Do nothing for entities that are not input connectors */
|
|
|
|
|
if (i == TVP5150_INPUT_NUM)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
decoder->input = i;
|
|
|
|
|
|
|
|
|
|
tvp5150_selmux(sd);
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static const struct media_entity_operations tvp5150_sd_media_ops = {
|
|
|
|
|
.link_setup = tvp5150_link_setup,
|
|
|
|
|
};
|
2016-12-08 22:22:41 +00:00
|
|
|
#endif
|
2016-02-05 19:09:58 +00:00
|
|
|
|
2005-11-09 05:36:41 +00:00
|
|
|
/****************************************************************************
|
|
|
|
|
I2C Command
|
|
|
|
|
****************************************************************************/
|
2006-04-02 16:35:00 +00:00
|
|
|
|
2016-01-07 12:46:45 +00:00
|
|
|
static int tvp5150_s_stream(struct v4l2_subdev *sd, int enable)
|
|
|
|
|
{
|
2016-01-07 12:46:50 +00:00
|
|
|
struct tvp5150 *decoder = to_tvp5150(sd);
|
2016-12-09 11:47:19 +00:00
|
|
|
int val;
|
2016-01-07 12:46:50 +00:00
|
|
|
|
2016-12-09 11:47:19 +00:00
|
|
|
/* Enable or disable the video output signals. */
|
|
|
|
|
val = tvp5150_read(sd, TVP5150_MISC_CTL);
|
|
|
|
|
if (val < 0)
|
|
|
|
|
return val;
|
|
|
|
|
|
|
|
|
|
val &= ~(TVP5150_MISC_CTL_YCBCR_OE | TVP5150_MISC_CTL_SYNC_OE |
|
|
|
|
|
TVP5150_MISC_CTL_CLOCK_OE);
|
|
|
|
|
|
|
|
|
|
if (enable) {
|
|
|
|
|
/*
|
|
|
|
|
* Enable the YCbCr and clock outputs. In discrete sync mode
|
|
|
|
|
* (non-BT.656) additionally enable the the sync outputs.
|
|
|
|
|
*/
|
|
|
|
|
val |= TVP5150_MISC_CTL_YCBCR_OE | TVP5150_MISC_CTL_CLOCK_OE;
|
|
|
|
|
if (decoder->mbus_type == V4L2_MBUS_PARALLEL)
|
|
|
|
|
val |= TVP5150_MISC_CTL_SYNC_OE;
|
|
|
|
|
}
|
2016-01-07 12:46:45 +00:00
|
|
|
|
2016-12-09 11:47:19 +00:00
|
|
|
tvp5150_write(sd, TVP5150_MISC_CTL, val);
|
2016-01-07 12:46:45 +00:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2009-04-02 14:26:22 +00:00
|
|
|
static int tvp5150_s_routing(struct v4l2_subdev *sd,
|
|
|
|
|
u32 input, u32 output, u32 config)
|
2008-12-18 14:17:25 +00:00
|
|
|
{
|
|
|
|
|
struct tvp5150 *decoder = to_tvp5150(sd);
|
2005-11-09 05:36:41 +00:00
|
|
|
|
2009-04-02 14:26:22 +00:00
|
|
|
decoder->input = input;
|
|
|
|
|
decoder->output = output;
|
2016-02-12 17:42:02 +00:00
|
|
|
|
|
|
|
|
if (output == TVP5150_BLACK_SCREEN)
|
|
|
|
|
decoder->enable = false;
|
|
|
|
|
else
|
|
|
|
|
decoder->enable = true;
|
|
|
|
|
|
2008-12-18 14:17:25 +00:00
|
|
|
tvp5150_selmux(sd);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2006-01-23 19:11:05 +00:00
|
|
|
|
2010-03-14 13:59:16 +00:00
|
|
|
static int tvp5150_s_raw_fmt(struct v4l2_subdev *sd, struct v4l2_vbi_format *fmt)
|
|
|
|
|
{
|
|
|
|
|
/* this is for capturing 36 raw vbi lines
|
|
|
|
|
if there's a way to cut off the beginning 2 vbi lines
|
|
|
|
|
with the tvp5150 then the vbi line count could be lowered
|
|
|
|
|
to 17 lines/field again, although I couldn't find a register
|
|
|
|
|
which could do that cropping */
|
|
|
|
|
if (fmt->sample_format == V4L2_PIX_FMT_GREY)
|
|
|
|
|
tvp5150_write(sd, TVP5150_LUMA_PROC_CTL_1, 0x70);
|
|
|
|
|
if (fmt->count[0] == 18 && fmt->count[1] == 18) {
|
|
|
|
|
tvp5150_write(sd, TVP5150_VERT_BLANKING_START, 0x00);
|
|
|
|
|
tvp5150_write(sd, TVP5150_VERT_BLANKING_STOP, 0x01);
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int tvp5150_s_sliced_fmt(struct v4l2_subdev *sd, struct v4l2_sliced_vbi_format *svbi)
|
2008-12-18 14:17:25 +00:00
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
if (svbi->service_set != 0) {
|
|
|
|
|
for (i = 0; i <= 23; i++) {
|
|
|
|
|
svbi->service_lines[1][i] = 0;
|
|
|
|
|
svbi->service_lines[0][i] =
|
2018-02-19 18:23:39 +00:00
|
|
|
tvp5150_set_vbi(sd, svbi->service_lines[0][i],
|
|
|
|
|
0xf0, i, 3);
|
2008-10-24 15:19:14 +00:00
|
|
|
}
|
2008-12-18 14:17:25 +00:00
|
|
|
/* Enables FIFO */
|
|
|
|
|
tvp5150_write(sd, TVP5150_FIFO_OUT_CTRL, 1);
|
|
|
|
|
} else {
|
|
|
|
|
/* Disables FIFO*/
|
|
|
|
|
tvp5150_write(sd, TVP5150_FIFO_OUT_CTRL, 0);
|
2006-01-23 19:11:08 +00:00
|
|
|
|
2008-12-18 14:17:25 +00:00
|
|
|
/* Disable Full Field */
|
|
|
|
|
tvp5150_write(sd, TVP5150_FULL_FIELD_ENA, 0);
|
2006-01-23 19:11:08 +00:00
|
|
|
|
2008-12-18 14:17:25 +00:00
|
|
|
/* Disable Line modes */
|
|
|
|
|
for (i = TVP5150_LINE_MODE_INI; i <= TVP5150_LINE_MODE_END; i++)
|
|
|
|
|
tvp5150_write(sd, i, 0xff);
|
2006-01-23 19:11:08 +00:00
|
|
|
}
|
2008-12-18 14:17:25 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
2006-01-23 19:11:08 +00:00
|
|
|
|
2010-03-14 13:59:16 +00:00
|
|
|
static int tvp5150_g_sliced_fmt(struct v4l2_subdev *sd, struct v4l2_sliced_vbi_format *svbi)
|
|
|
|
|
{
|
|
|
|
|
int i, mask = 0;
|
|
|
|
|
|
2012-09-05 13:38:10 +00:00
|
|
|
memset(svbi->service_lines, 0, sizeof(svbi->service_lines));
|
2006-01-23 19:11:08 +00:00
|
|
|
|
2008-12-18 14:17:25 +00:00
|
|
|
for (i = 0; i <= 23; i++) {
|
|
|
|
|
svbi->service_lines[0][i] =
|
2018-02-19 18:23:39 +00:00
|
|
|
tvp5150_get_vbi(sd, i);
|
2008-12-18 14:17:25 +00:00
|
|
|
mask |= svbi->service_lines[0][i];
|
2006-01-23 19:11:06 +00:00
|
|
|
}
|
2008-12-18 14:17:25 +00:00
|
|
|
svbi->service_set = mask;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2006-01-09 17:25:37 +00:00
|
|
|
#ifdef CONFIG_VIDEO_ADV_DEBUG
|
2008-12-30 10:14:19 +00:00
|
|
|
static int tvp5150_g_register(struct v4l2_subdev *sd, struct v4l2_dbg_register *reg)
|
2008-12-18 14:17:25 +00:00
|
|
|
{
|
2012-06-13 10:49:30 +00:00
|
|
|
int res;
|
|
|
|
|
|
|
|
|
|
res = tvp5150_read(sd, reg->reg & 0xff);
|
|
|
|
|
if (res < 0) {
|
2016-11-16 10:58:05 +00:00
|
|
|
dev_err(sd->dev, "%s: failed with error = %d\n", __func__, res);
|
2012-06-13 10:49:30 +00:00
|
|
|
return res;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
reg->val = res;
|
2008-12-30 10:14:19 +00:00
|
|
|
reg->size = 1;
|
2008-12-18 14:17:25 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
2005-11-09 05:36:41 +00:00
|
|
|
|
2013-03-24 11:28:46 +00:00
|
|
|
static int tvp5150_s_register(struct v4l2_subdev *sd, const struct v4l2_dbg_register *reg)
|
2008-12-18 14:17:25 +00:00
|
|
|
{
|
2016-04-15 01:00:08 +00:00
|
|
|
return tvp5150_write(sd, reg->reg & 0xff, reg->val & 0xff);
|
2008-12-18 14:17:25 +00:00
|
|
|
}
|
|
|
|
|
#endif
|
2005-11-09 05:37:07 +00:00
|
|
|
|
2008-12-18 14:17:25 +00:00
|
|
|
static int tvp5150_g_tuner(struct v4l2_subdev *sd, struct v4l2_tuner *vt)
|
|
|
|
|
{
|
|
|
|
|
int status = tvp5150_read(sd, 0x88);
|
2005-11-09 05:37:07 +00:00
|
|
|
|
2008-12-18 14:17:25 +00:00
|
|
|
vt->signal = ((status & 0x04) && (status & 0x02)) ? 0xffff : 0x0;
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
2005-11-09 05:37:07 +00:00
|
|
|
|
2016-08-11 16:28:15 +00:00
|
|
|
static int tvp5150_registered(struct v4l2_subdev *sd)
|
2016-02-05 19:09:58 +00:00
|
|
|
{
|
|
|
|
|
#ifdef CONFIG_MEDIA_CONTROLLER
|
|
|
|
|
struct tvp5150 *decoder = to_tvp5150(sd);
|
|
|
|
|
int ret = 0;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < TVP5150_INPUT_NUM; i++) {
|
|
|
|
|
struct media_entity *input = &decoder->input_ent[i];
|
|
|
|
|
struct media_pad *pad = &decoder->input_pad[i];
|
|
|
|
|
|
|
|
|
|
if (!input->name)
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
decoder->input_pad[i].flags = MEDIA_PAD_FL_SOURCE;
|
|
|
|
|
|
|
|
|
|
ret = media_entity_pads_init(input, 1, pad);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
|
|
ret = media_device_register_entity(sd->v4l2_dev->mdev, input);
|
|
|
|
|
if (ret < 0)
|
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
|
|
ret = media_create_pad_link(input, 0, &sd->entity,
|
|
|
|
|
DEMOD_PAD_IF_INPUT, 0);
|
|
|
|
|
if (ret < 0) {
|
|
|
|
|
media_device_unregister_entity(input);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2008-12-18 14:17:25 +00:00
|
|
|
/* ----------------------------------------------------------------------- */
|
|
|
|
|
|
2010-12-12 11:45:43 +00:00
|
|
|
static const struct v4l2_ctrl_ops tvp5150_ctrl_ops = {
|
|
|
|
|
.s_ctrl = tvp5150_s_ctrl,
|
|
|
|
|
};
|
|
|
|
|
|
2008-12-18 14:17:25 +00:00
|
|
|
static const struct v4l2_subdev_core_ops tvp5150_core_ops = {
|
|
|
|
|
.log_status = tvp5150_log_status,
|
|
|
|
|
.reset = tvp5150_reset,
|
|
|
|
|
#ifdef CONFIG_VIDEO_ADV_DEBUG
|
|
|
|
|
.g_register = tvp5150_g_register,
|
|
|
|
|
.s_register = tvp5150_s_register,
|
|
|
|
|
#endif
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static const struct v4l2_subdev_tuner_ops tvp5150_tuner_ops = {
|
|
|
|
|
.g_tuner = tvp5150_g_tuner,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static const struct v4l2_subdev_video_ops tvp5150_video_ops = {
|
2014-04-28 19:53:01 +00:00
|
|
|
.s_std = tvp5150_s_std,
|
2016-01-07 12:46:45 +00:00
|
|
|
.s_stream = tvp5150_s_stream,
|
2008-12-18 14:17:25 +00:00
|
|
|
.s_routing = tvp5150_s_routing,
|
2016-01-07 12:46:46 +00:00
|
|
|
.g_mbus_config = tvp5150_g_mbus_config,
|
2010-03-14 12:57:30 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static const struct v4l2_subdev_vbi_ops tvp5150_vbi_ops = {
|
2008-12-18 14:17:25 +00:00
|
|
|
.g_sliced_vbi_cap = tvp5150_g_sliced_vbi_cap,
|
2010-03-14 13:59:16 +00:00
|
|
|
.g_sliced_fmt = tvp5150_g_sliced_fmt,
|
|
|
|
|
.s_sliced_fmt = tvp5150_s_sliced_fmt,
|
|
|
|
|
.s_raw_fmt = tvp5150_s_raw_fmt,
|
2008-12-18 14:17:25 +00:00
|
|
|
};
|
|
|
|
|
|
2015-04-09 07:01:33 +00:00
|
|
|
static const struct v4l2_subdev_pad_ops tvp5150_pad_ops = {
|
|
|
|
|
.enum_mbus_code = tvp5150_enum_mbus_code,
|
2016-01-26 12:46:24 +00:00
|
|
|
.enum_frame_size = tvp5150_enum_frame_size,
|
2015-04-09 07:02:34 +00:00
|
|
|
.set_fmt = tvp5150_fill_fmt,
|
|
|
|
|
.get_fmt = tvp5150_fill_fmt,
|
2015-12-14 10:25:32 +00:00
|
|
|
.get_selection = tvp5150_get_selection,
|
|
|
|
|
.set_selection = tvp5150_set_selection,
|
2015-04-09 07:01:33 +00:00
|
|
|
};
|
|
|
|
|
|
2008-12-18 14:17:25 +00:00
|
|
|
static const struct v4l2_subdev_ops tvp5150_ops = {
|
|
|
|
|
.core = &tvp5150_core_ops,
|
|
|
|
|
.tuner = &tvp5150_tuner_ops,
|
|
|
|
|
.video = &tvp5150_video_ops,
|
2010-03-14 12:57:30 +00:00
|
|
|
.vbi = &tvp5150_vbi_ops,
|
2015-04-09 07:01:33 +00:00
|
|
|
.pad = &tvp5150_pad_ops,
|
2008-12-18 14:17:25 +00:00
|
|
|
};
|
|
|
|
|
|
2016-08-11 16:28:15 +00:00
|
|
|
static const struct v4l2_subdev_internal_ops tvp5150_internal_ops = {
|
|
|
|
|
.registered = tvp5150_registered,
|
|
|
|
|
};
|
|
|
|
|
|
2008-12-18 14:17:25 +00:00
|
|
|
|
2005-11-09 05:36:40 +00:00
|
|
|
/****************************************************************************
|
|
|
|
|
I2C Client & Driver
|
|
|
|
|
****************************************************************************/
|
|
|
|
|
|
2016-01-07 12:46:41 +00:00
|
|
|
static int tvp5150_detect_version(struct tvp5150 *core)
|
|
|
|
|
{
|
|
|
|
|
struct v4l2_subdev *sd = &core->sd;
|
|
|
|
|
struct i2c_client *c = v4l2_get_subdevdata(sd);
|
|
|
|
|
unsigned int i;
|
|
|
|
|
u8 regs[4];
|
|
|
|
|
int res;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Read consequent registers - TVP5150_MSB_DEV_ID, TVP5150_LSB_DEV_ID,
|
|
|
|
|
* TVP5150_ROM_MAJOR_VER, TVP5150_ROM_MINOR_VER
|
|
|
|
|
*/
|
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
|
res = tvp5150_read(sd, TVP5150_MSB_DEV_ID + i);
|
|
|
|
|
if (res < 0)
|
|
|
|
|
return res;
|
|
|
|
|
regs[i] = res;
|
|
|
|
|
}
|
|
|
|
|
|
2016-02-05 19:09:54 +00:00
|
|
|
core->dev_id = (regs[0] << 8) | regs[1];
|
|
|
|
|
core->rom_ver = (regs[2] << 8) | regs[3];
|
2016-01-07 12:46:41 +00:00
|
|
|
|
2016-11-16 10:58:05 +00:00
|
|
|
dev_info(sd->dev, "tvp%04x (%u.%u) chip found @ 0x%02x (%s)\n",
|
2016-02-05 19:09:54 +00:00
|
|
|
core->dev_id, regs[2], regs[3], c->addr << 1,
|
|
|
|
|
c->adapter->name);
|
2016-01-07 12:46:41 +00:00
|
|
|
|
2016-02-05 19:09:54 +00:00
|
|
|
if (core->dev_id == 0x5150 && core->rom_ver == 0x0321) {
|
2016-11-16 10:58:05 +00:00
|
|
|
dev_info(sd->dev, "tvp5150a detected.\n");
|
2016-02-05 19:09:54 +00:00
|
|
|
} else if (core->dev_id == 0x5150 && core->rom_ver == 0x0400) {
|
2016-11-16 10:58:05 +00:00
|
|
|
dev_info(sd->dev, "tvp5150am1 detected.\n");
|
2016-01-07 12:46:41 +00:00
|
|
|
|
|
|
|
|
/* ITU-T BT.656.4 timing */
|
|
|
|
|
tvp5150_write(sd, TVP5150_REV_SELECT, 0);
|
2016-02-05 19:09:54 +00:00
|
|
|
} else if (core->dev_id == 0x5151 && core->rom_ver == 0x0100) {
|
2016-11-16 10:58:05 +00:00
|
|
|
dev_info(sd->dev, "tvp5151 detected.\n");
|
2016-01-07 12:46:41 +00:00
|
|
|
} else {
|
2016-11-16 10:58:05 +00:00
|
|
|
dev_info(sd->dev, "*** unknown tvp%04x chip detected.\n",
|
2016-02-05 19:09:54 +00:00
|
|
|
core->dev_id);
|
2016-01-07 12:46:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2016-01-07 12:46:49 +00:00
|
|
|
static int tvp5150_init(struct i2c_client *c)
|
|
|
|
|
{
|
|
|
|
|
struct gpio_desc *pdn_gpio;
|
|
|
|
|
struct gpio_desc *reset_gpio;
|
|
|
|
|
|
|
|
|
|
pdn_gpio = devm_gpiod_get_optional(&c->dev, "pdn", GPIOD_OUT_HIGH);
|
|
|
|
|
if (IS_ERR(pdn_gpio))
|
|
|
|
|
return PTR_ERR(pdn_gpio);
|
|
|
|
|
|
|
|
|
|
if (pdn_gpio) {
|
|
|
|
|
gpiod_set_value_cansleep(pdn_gpio, 0);
|
|
|
|
|
/* Delay time between power supplies active and reset */
|
|
|
|
|
msleep(20);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
reset_gpio = devm_gpiod_get_optional(&c->dev, "reset", GPIOD_OUT_HIGH);
|
|
|
|
|
if (IS_ERR(reset_gpio))
|
|
|
|
|
return PTR_ERR(reset_gpio);
|
|
|
|
|
|
|
|
|
|
if (reset_gpio) {
|
|
|
|
|
/* RESETB pulse duration */
|
|
|
|
|
ndelay(500);
|
|
|
|
|
gpiod_set_value_cansleep(reset_gpio, 0);
|
|
|
|
|
/* Delay time between end of reset to I2C active */
|
|
|
|
|
usleep_range(200, 250);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2016-01-07 12:46:50 +00:00
|
|
|
static int tvp5150_parse_dt(struct tvp5150 *decoder, struct device_node *np)
|
|
|
|
|
{
|
2016-08-26 23:17:25 +00:00
|
|
|
struct v4l2_fwnode_endpoint bus_cfg;
|
2016-01-07 12:46:50 +00:00
|
|
|
struct device_node *ep;
|
2016-02-05 19:09:58 +00:00
|
|
|
#ifdef CONFIG_MEDIA_CONTROLLER
|
|
|
|
|
struct device_node *connectors, *child;
|
|
|
|
|
struct media_entity *input;
|
|
|
|
|
const char *name;
|
|
|
|
|
u32 input_type;
|
|
|
|
|
#endif
|
2016-01-07 12:46:50 +00:00
|
|
|
unsigned int flags;
|
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
|
|
ep = of_graph_get_next_endpoint(np, NULL);
|
|
|
|
|
if (!ep)
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
2016-08-26 23:17:25 +00:00
|
|
|
ret = v4l2_fwnode_endpoint_parse(of_fwnode_handle(ep), &bus_cfg);
|
2016-01-07 12:46:50 +00:00
|
|
|
if (ret)
|
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
|
|
flags = bus_cfg.bus.parallel.flags;
|
|
|
|
|
|
|
|
|
|
if (bus_cfg.bus_type == V4L2_MBUS_PARALLEL &&
|
|
|
|
|
!(flags & V4L2_MBUS_HSYNC_ACTIVE_HIGH &&
|
|
|
|
|
flags & V4L2_MBUS_VSYNC_ACTIVE_HIGH &&
|
2016-02-05 19:09:53 +00:00
|
|
|
flags & V4L2_MBUS_FIELD_EVEN_LOW)) {
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
|
goto err;
|
|
|
|
|
}
|
2016-01-07 12:46:50 +00:00
|
|
|
|
|
|
|
|
decoder->mbus_type = bus_cfg.bus_type;
|
|
|
|
|
|
2016-02-05 19:09:58 +00:00
|
|
|
#ifdef CONFIG_MEDIA_CONTROLLER
|
|
|
|
|
connectors = of_get_child_by_name(np, "connectors");
|
|
|
|
|
|
|
|
|
|
if (!connectors)
|
|
|
|
|
goto err;
|
|
|
|
|
|
|
|
|
|
for_each_available_child_of_node(connectors, child) {
|
|
|
|
|
ret = of_property_read_u32(child, "input", &input_type);
|
|
|
|
|
if (ret) {
|
2016-11-16 10:58:05 +00:00
|
|
|
dev_err(decoder->sd.dev,
|
2016-02-05 19:09:58 +00:00
|
|
|
"missing type property in node %s\n",
|
|
|
|
|
child->name);
|
|
|
|
|
goto err_connector;
|
|
|
|
|
}
|
|
|
|
|
|
2016-02-19 17:02:30 +00:00
|
|
|
if (input_type >= TVP5150_INPUT_NUM) {
|
2016-02-05 19:09:58 +00:00
|
|
|
ret = -EINVAL;
|
|
|
|
|
goto err_connector;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
input = &decoder->input_ent[input_type];
|
|
|
|
|
|
|
|
|
|
/* Each input connector can only be defined once */
|
|
|
|
|
if (input->name) {
|
2016-11-16 10:58:05 +00:00
|
|
|
dev_err(decoder->sd.dev,
|
2016-02-05 19:09:58 +00:00
|
|
|
"input %s with same type already exists\n",
|
|
|
|
|
input->name);
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
|
goto err_connector;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
switch (input_type) {
|
|
|
|
|
case TVP5150_COMPOSITE0:
|
|
|
|
|
case TVP5150_COMPOSITE1:
|
|
|
|
|
input->function = MEDIA_ENT_F_CONN_COMPOSITE;
|
|
|
|
|
break;
|
|
|
|
|
case TVP5150_SVIDEO:
|
|
|
|
|
input->function = MEDIA_ENT_F_CONN_SVIDEO;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
input->flags = MEDIA_ENT_FL_CONNECTOR;
|
|
|
|
|
|
|
|
|
|
ret = of_property_read_string(child, "label", &name);
|
|
|
|
|
if (ret < 0) {
|
2016-11-16 10:58:05 +00:00
|
|
|
dev_err(decoder->sd.dev,
|
2016-02-05 19:09:58 +00:00
|
|
|
"missing label property in node %s\n",
|
|
|
|
|
child->name);
|
|
|
|
|
goto err_connector;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
input->name = name;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
err_connector:
|
|
|
|
|
of_node_put(connectors);
|
|
|
|
|
#endif
|
2016-01-07 12:46:50 +00:00
|
|
|
err:
|
|
|
|
|
of_node_put(ep);
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2016-02-12 17:42:02 +00:00
|
|
|
static const char * const tvp5150_test_patterns[2] = {
|
|
|
|
|
"Disabled",
|
|
|
|
|
"Black screen"
|
|
|
|
|
};
|
|
|
|
|
|
2008-12-18 14:17:25 +00:00
|
|
|
static int tvp5150_probe(struct i2c_client *c,
|
|
|
|
|
const struct i2c_device_id *id)
|
2005-11-09 05:36:40 +00:00
|
|
|
{
|
|
|
|
|
struct tvp5150 *core;
|
2008-12-18 14:17:25 +00:00
|
|
|
struct v4l2_subdev *sd;
|
2016-01-07 12:46:50 +00:00
|
|
|
struct device_node *np = c->dev.of_node;
|
2016-01-07 12:46:41 +00:00
|
|
|
int res;
|
2005-11-09 05:36:40 +00:00
|
|
|
|
|
|
|
|
/* Check if the adapter supports the needed features */
|
2008-12-18 14:17:25 +00:00
|
|
|
if (!i2c_check_functionality(c->adapter,
|
2005-11-09 05:36:40 +00:00
|
|
|
I2C_FUNC_SMBUS_READ_BYTE | I2C_FUNC_SMBUS_WRITE_BYTE_DATA))
|
2008-12-18 14:17:25 +00:00
|
|
|
return -EIO;
|
2005-11-09 05:36:40 +00:00
|
|
|
|
2016-01-07 12:46:49 +00:00
|
|
|
res = tvp5150_init(c);
|
|
|
|
|
if (res)
|
|
|
|
|
return res;
|
|
|
|
|
|
2013-05-02 11:29:43 +00:00
|
|
|
core = devm_kzalloc(&c->dev, sizeof(*core), GFP_KERNEL);
|
|
|
|
|
if (!core)
|
2005-11-09 05:36:40 +00:00
|
|
|
return -ENOMEM;
|
2016-01-07 12:46:50 +00:00
|
|
|
|
2008-12-18 14:17:25 +00:00
|
|
|
sd = &core->sd;
|
2016-01-07 12:46:50 +00:00
|
|
|
|
|
|
|
|
if (IS_ENABLED(CONFIG_OF) && np) {
|
|
|
|
|
res = tvp5150_parse_dt(core, np);
|
|
|
|
|
if (res) {
|
2016-11-16 10:58:05 +00:00
|
|
|
dev_err(sd->dev, "DT parsing error: %d\n", res);
|
2016-01-07 12:46:50 +00:00
|
|
|
return res;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
/* Default to BT.656 embedded sync */
|
|
|
|
|
core->mbus_type = V4L2_MBUS_BT656;
|
|
|
|
|
}
|
|
|
|
|
|
2008-12-18 14:17:25 +00:00
|
|
|
v4l2_i2c_subdev_init(sd, c, &tvp5150_ops);
|
2016-08-11 16:28:15 +00:00
|
|
|
sd->internal_ops = &tvp5150_internal_ops;
|
2016-01-26 12:46:24 +00:00
|
|
|
sd->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
|
|
|
|
|
|
|
|
|
|
#if defined(CONFIG_MEDIA_CONTROLLER)
|
2016-01-27 14:08:13 +00:00
|
|
|
core->pads[DEMOD_PAD_IF_INPUT].flags = MEDIA_PAD_FL_SINK;
|
|
|
|
|
core->pads[DEMOD_PAD_VID_OUT].flags = MEDIA_PAD_FL_SOURCE;
|
|
|
|
|
core->pads[DEMOD_PAD_VBI_OUT].flags = MEDIA_PAD_FL_SOURCE;
|
2016-01-27 17:09:15 +00:00
|
|
|
|
|
|
|
|
sd->entity.function = MEDIA_ENT_F_ATV_DECODER;
|
|
|
|
|
|
2016-01-27 14:08:13 +00:00
|
|
|
res = media_entity_pads_init(&sd->entity, DEMOD_NUM_PADS, core->pads);
|
2016-01-26 12:46:24 +00:00
|
|
|
if (res < 0)
|
|
|
|
|
return res;
|
2016-02-05 19:09:58 +00:00
|
|
|
|
|
|
|
|
sd->entity.ops = &tvp5150_sd_media_ops;
|
2016-01-26 12:46:24 +00:00
|
|
|
#endif
|
2012-06-13 10:49:30 +00:00
|
|
|
|
2016-01-07 12:46:41 +00:00
|
|
|
res = tvp5150_detect_version(core);
|
|
|
|
|
if (res < 0)
|
|
|
|
|
return res;
|
2011-02-22 03:10:22 +00:00
|
|
|
|
2006-01-23 19:11:05 +00:00
|
|
|
core->norm = V4L2_STD_ALL; /* Default is autodetect */
|
2009-04-02 14:26:22 +00:00
|
|
|
core->input = TVP5150_COMPOSITE1;
|
2016-02-12 17:42:02 +00:00
|
|
|
core->enable = true;
|
2010-12-12 11:45:43 +00:00
|
|
|
|
2016-01-07 12:46:44 +00:00
|
|
|
v4l2_ctrl_handler_init(&core->hdl, 5);
|
2010-12-12 11:45:43 +00:00
|
|
|
v4l2_ctrl_new_std(&core->hdl, &tvp5150_ctrl_ops,
|
|
|
|
|
V4L2_CID_BRIGHTNESS, 0, 255, 1, 128);
|
|
|
|
|
v4l2_ctrl_new_std(&core->hdl, &tvp5150_ctrl_ops,
|
|
|
|
|
V4L2_CID_CONTRAST, 0, 255, 1, 128);
|
|
|
|
|
v4l2_ctrl_new_std(&core->hdl, &tvp5150_ctrl_ops,
|
|
|
|
|
V4L2_CID_SATURATION, 0, 255, 1, 128);
|
|
|
|
|
v4l2_ctrl_new_std(&core->hdl, &tvp5150_ctrl_ops,
|
|
|
|
|
V4L2_CID_HUE, -128, 127, 1, 0);
|
2016-01-07 12:46:44 +00:00
|
|
|
v4l2_ctrl_new_std(&core->hdl, &tvp5150_ctrl_ops,
|
|
|
|
|
V4L2_CID_PIXEL_RATE, 27000000,
|
|
|
|
|
27000000, 1, 27000000);
|
2016-02-12 17:42:02 +00:00
|
|
|
v4l2_ctrl_new_std_menu_items(&core->hdl, &tvp5150_ctrl_ops,
|
|
|
|
|
V4L2_CID_TEST_PATTERN,
|
|
|
|
|
ARRAY_SIZE(tvp5150_test_patterns),
|
|
|
|
|
0, 0, tvp5150_test_patterns);
|
2010-12-12 11:45:43 +00:00
|
|
|
sd->ctrl_handler = &core->hdl;
|
|
|
|
|
if (core->hdl.error) {
|
2012-06-13 10:49:30 +00:00
|
|
|
res = core->hdl.error;
|
2015-09-21 11:23:09 +00:00
|
|
|
goto err;
|
2010-12-12 11:45:43 +00:00
|
|
|
}
|
2005-11-09 05:36:43 +00:00
|
|
|
|
2012-01-31 08:23:46 +00:00
|
|
|
/* Default is no cropping */
|
|
|
|
|
core->rect.top = 0;
|
|
|
|
|
if (tvp5150_read_std(sd) & V4L2_STD_525_60)
|
|
|
|
|
core->rect.height = TVP5150_V_MAX_525_60;
|
|
|
|
|
else
|
|
|
|
|
core->rect.height = TVP5150_V_MAX_OTHERS;
|
|
|
|
|
core->rect.left = 0;
|
|
|
|
|
core->rect.width = TVP5150_H_MAX;
|
|
|
|
|
|
2016-12-09 11:47:17 +00:00
|
|
|
tvp5150_reset(sd, 0); /* Calls v4l2_ctrl_handler_setup() */
|
|
|
|
|
|
2015-09-21 11:23:09 +00:00
|
|
|
res = v4l2_async_register_subdev(sd);
|
|
|
|
|
if (res < 0)
|
|
|
|
|
goto err;
|
|
|
|
|
|
2006-02-07 03:01:19 +00:00
|
|
|
if (debug > 1)
|
2008-12-18 14:17:25 +00:00
|
|
|
tvp5150_log_status(sd);
|
2005-11-09 05:36:40 +00:00
|
|
|
return 0;
|
2015-09-21 11:23:09 +00:00
|
|
|
|
|
|
|
|
err:
|
|
|
|
|
v4l2_ctrl_handler_free(&core->hdl);
|
|
|
|
|
return res;
|
2005-11-09 05:36:40 +00:00
|
|
|
}
|
|
|
|
|
|
2008-12-18 14:17:25 +00:00
|
|
|
static int tvp5150_remove(struct i2c_client *c)
|
2005-11-09 05:36:40 +00:00
|
|
|
{
|
2008-12-18 14:17:25 +00:00
|
|
|
struct v4l2_subdev *sd = i2c_get_clientdata(c);
|
2010-12-12 11:45:43 +00:00
|
|
|
struct tvp5150 *decoder = to_tvp5150(sd);
|
2005-11-09 05:36:40 +00:00
|
|
|
|
2016-11-16 10:58:05 +00:00
|
|
|
dev_dbg_lvl(sd->dev, 1, debug,
|
2006-01-09 17:25:36 +00:00
|
|
|
"tvp5150.c: removing tvp5150 adapter on address 0x%x\n",
|
|
|
|
|
c->addr << 1);
|
|
|
|
|
|
2015-09-21 11:23:09 +00:00
|
|
|
v4l2_async_unregister_subdev(sd);
|
2010-12-12 11:45:43 +00:00
|
|
|
v4l2_ctrl_handler_free(&decoder->hdl);
|
2005-11-09 05:36:40 +00:00
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* ----------------------------------------------------------------------- */
|
|
|
|
|
|
2008-12-18 14:17:25 +00:00
|
|
|
static const struct i2c_device_id tvp5150_id[] = {
|
|
|
|
|
{ "tvp5150", 0 },
|
|
|
|
|
{ }
|
|
|
|
|
};
|
|
|
|
|
MODULE_DEVICE_TABLE(i2c, tvp5150_id);
|
2005-11-09 05:36:41 +00:00
|
|
|
|
2016-01-07 12:46:48 +00:00
|
|
|
#if IS_ENABLED(CONFIG_OF)
|
|
|
|
|
static const struct of_device_id tvp5150_of_match[] = {
|
|
|
|
|
{ .compatible = "ti,tvp5150", },
|
|
|
|
|
{ /* sentinel */ },
|
|
|
|
|
};
|
|
|
|
|
MODULE_DEVICE_TABLE(of, tvp5150_of_match);
|
|
|
|
|
#endif
|
|
|
|
|
|
2010-09-15 18:45:20 +00:00
|
|
|
static struct i2c_driver tvp5150_driver = {
|
|
|
|
|
.driver = {
|
2016-01-07 12:46:48 +00:00
|
|
|
.of_match_table = of_match_ptr(tvp5150_of_match),
|
2010-09-15 18:45:20 +00:00
|
|
|
.name = "tvp5150",
|
|
|
|
|
},
|
|
|
|
|
.probe = tvp5150_probe,
|
|
|
|
|
.remove = tvp5150_remove,
|
|
|
|
|
.id_table = tvp5150_id,
|
2005-11-09 05:36:40 +00:00
|
|
|
};
|
2010-09-15 18:45:20 +00:00
|
|
|
|
2012-02-12 09:56:32 +00:00
|
|
|
module_i2c_driver(tvp5150_driver);
|
