Skip to content

L
linux
Commit f5dde49b authored by Lars-Peter Clausen's avatar Lars-Peter Clausen Committed by Mauro Carvalho Chehab
Browse files
Options

[media] adv7180: Prepare for multi-chip support 

The adv7180 is part of a larger family of device, which have all a very
similar register map layout. This patch prepares the adv7180 driver for
support for multiple different devices. For now the only difference we care
about is the number of input channel configurations. Also the way the input
format is configured slightly differs between some devices.
Signed-off-by: default avatarLars-Peter Clausen <lars@metafoo.de>
Acked-by: default avatarFederico Vaga <federico.vaga@gmail.com>
Acked-by: default avatarHans Verkuil <hans.verkuil@cisco.com>
Signed-off-by: default avatarHans Verkuil <hans.verkuil@cisco.com>
Signed-off-by: default avatarMauro Carvalho Chehab <mchehab@osg.samsung.com>
parent 3e35e33c
Hide whitespace changes
Inline Side-by-side
Showing with 130 additions and 57 deletions
drivers/media/i2c/adv7180.c
View file @ f5dde49b
......@@ -32,23 +32,24 @@
#include <linux/mutex.h>
#include <linux/delay.h>
#define ADV7180_STD_AD_PAL_BG_NTSC_J_SECAM 0x0
#define ADV7180_STD_AD_PAL_BG_NTSC_J_SECAM_PED 0x1
#define ADV7180_STD_AD_PAL_N_NTSC_J_SECAM 0x2
#define ADV7180_STD_AD_PAL_N_NTSC_M_SECAM 0x3
#define ADV7180_STD_NTSC_J 0x4
#define ADV7180_STD_NTSC_M 0x5
#define ADV7180_STD_PAL60 0x6
#define ADV7180_STD_NTSC_443 0x7
#define ADV7180_STD_PAL_BG 0x8
#define ADV7180_STD_PAL_N 0x9
#define ADV7180_STD_PAL_M 0xa
#define ADV7180_STD_PAL_M_PED 0xb
#define ADV7180_STD_PAL_COMB_N 0xc
#define ADV7180_STD_PAL_COMB_N_PED 0xd
#define ADV7180_STD_PAL_SECAM 0xe
#define ADV7180_STD_PAL_SECAM_PED 0xf
#define ADV7180_REG_INPUT_CONTROL 0x0000
#define ADV7180_INPUT_CONTROL_AD_PAL_BG_NTSC_J_SECAM 0x00
#define ADV7180_INPUT_CONTROL_AD_PAL_BG_NTSC_J_SECAM_PED 0x10
#define ADV7180_INPUT_CONTROL_AD_PAL_N_NTSC_J_SECAM 0x20
#define ADV7180_INPUT_CONTROL_AD_PAL_N_NTSC_M_SECAM 0x30
#define ADV7180_INPUT_CONTROL_NTSC_J 0x40
#define ADV7180_INPUT_CONTROL_NTSC_M 0x50
#define ADV7180_INPUT_CONTROL_PAL60 0x60
#define ADV7180_INPUT_CONTROL_NTSC_443 0x70
#define ADV7180_INPUT_CONTROL_PAL_BG 0x80
#define ADV7180_INPUT_CONTROL_PAL_N 0x90
#define ADV7180_INPUT_CONTROL_PAL_M 0xa0
#define ADV7180_INPUT_CONTROL_PAL_M_PED 0xb0
#define ADV7180_INPUT_CONTROL_PAL_COMB_N 0xc0
#define ADV7180_INPUT_CONTROL_PAL_COMB_N_PED 0xd0
#define ADV7180_INPUT_CONTROL_PAL_SECAM 0xe0
#define ADV7180_INPUT_CONTROL_PAL_SECAM_PED 0xf0
#define ADV7180_INPUT_CONTROL_INSEL_MASK 0x0f
#define ADV7180_REG_EXTENDED_OUTPUT_CONTROL 0x0004
......@@ -121,6 +122,30 @@
#define ADV7180_REG_NTSC_V_BIT_END 0x00E6
#define ADV7180_NTSC_V_BIT_END_MANUAL_NVEND 0x4F
#define ADV7180_INPUT_CVBS_AIN1 0x00
#define ADV7180_INPUT_CVBS_AIN2 0x01
#define ADV7180_INPUT_CVBS_AIN3 0x02
#define ADV7180_INPUT_CVBS_AIN4 0x03
#define ADV7180_INPUT_CVBS_AIN5 0x04
#define ADV7180_INPUT_CVBS_AIN6 0x05
#define ADV7180_INPUT_SVIDEO_AIN1_AIN2 0x06
#define ADV7180_INPUT_SVIDEO_AIN3_AIN4 0x07
#define ADV7180_INPUT_SVIDEO_AIN5_AIN6 0x08
#define ADV7180_INPUT_YPRPB_AIN1_AIN2_AIN3 0x09
#define ADV7180_INPUT_YPRPB_AIN4_AIN5_AIN6 0x0a
struct adv7180_state;
#define ADV7180_FLAG_RESET_POWERED BIT(0)
struct adv7180_chip_info {
unsigned int flags;
unsigned int valid_input_mask;
int (*set_std)(struct adv7180_state *st, unsigned int std);
int (*select_input)(struct adv7180_state *st, unsigned int input);
int (*init)(struct adv7180_state *state);
};
struct adv7180_state {
struct v4l2_ctrl_handler ctrl_hdl;
struct v4l2_subdev sd;
......@@ -134,6 +159,7 @@ struct adv7180_state {
struct i2c_client *client;
unsigned int register_page;
const struct adv7180_chip_info *chip_info;
};
#define to_adv7180_sd(_ctrl) (&container_of(_ctrl->handler, \
struct adv7180_state, \
......@@ -165,6 +191,11 @@ static int adv7180_read(struct adv7180_state *state, unsigned int reg)
return i2c_smbus_read_byte_data(state->client, reg & 0xff);
}
static int adv7180_set_video_standard(struct adv7180_state *state,
unsigned int std)
{
return state->chip_info->set_std(state, std);
}
static v4l2_std_id adv7180_std_to_v4l2(u8 status1)
{
......@@ -197,22 +228,22 @@ static v4l2_std_id adv7180_std_to_v4l2(u8 status1)
static int v4l2_std_to_adv7180(v4l2_std_id std)
{
if (std == V4L2_STD_PAL_60)
return ADV7180_INPUT_CONTROL_PAL60;
return ADV7180_STD_PAL60;
if (std == V4L2_STD_NTSC_443)
return ADV7180_INPUT_CONTROL_NTSC_443;
return ADV7180_STD_NTSC_443;
if (std == V4L2_STD_PAL_N)
return ADV7180_INPUT_CONTROL_PAL_N;
return ADV7180_STD_PAL_N;
if (std == V4L2_STD_PAL_M)
return ADV7180_INPUT_CONTROL_PAL_M;
return ADV7180_STD_PAL_M;
if (std == V4L2_STD_PAL_Nc)
return ADV7180_INPUT_CONTROL_PAL_COMB_N;
return ADV7180_STD_PAL_COMB_N;
if (std & V4L2_STD_PAL)
return ADV7180_INPUT_CONTROL_PAL_BG;
return ADV7180_STD_PAL_BG;
if (std & V4L2_STD_NTSC)
return ADV7180_INPUT_CONTROL_NTSC_M;
return ADV7180_STD_NTSC_M;
if (std & V4L2_STD_SECAM)
return ADV7180_INPUT_CONTROL_PAL_SECAM;
return ADV7180_STD_PAL_SECAM;
return -EINVAL;
}
......@@ -272,19 +303,15 @@ static int adv7180_s_routing(struct v4l2_subdev *sd, u32 input,
if (ret)
return ret;
/* We cannot discriminate between LQFP and 40-pin LFCSP, so accept
* all inputs and let the card driver take care of validation
*/
if ((input & ADV7180_INPUT_CONTROL_INSEL_MASK) != input)
if (input > 31 || !(BIT(input) & state->chip_info->valid_input_mask)) {
ret = -EINVAL;
goto out;
}
ret = adv7180_read(state, ADV7180_REG_INPUT_CONTROL);
if (ret < 0)
goto out;
ret = state->chip_info->select_input(state, input);
ret &= ~ADV7180_INPUT_CONTROL_INSEL_MASK;
ret = adv7180_write(state, ADV7180_REG_INPUT_CONTROL, ret | input);
state->input = input;
if (ret == 0)
state->input = input;
out:
mutex_unlock(&state->mutex);
return ret;
......@@ -307,9 +334,8 @@ static int adv7180_program_std(struct adv7180_state *state)
int ret;
if (state->autodetect) {
ret = adv7180_write(state, ADV7180_REG_INPUT_CONTROL,
ADV7180_INPUT_CONTROL_AD_PAL_BG_NTSC_J_SECAM
| state->input);
ret = adv7180_set_video_standard(state,
ADV7180_STD_AD_PAL_BG_NTSC_J_SECAM);
if (ret < 0)
return ret;
......@@ -319,8 +345,7 @@ static int adv7180_program_std(struct adv7180_state *state)
if (ret < 0)
return ret;
ret = adv7180_write(state, ADV7180_REG_INPUT_CONTROL,
ret | state->input);
ret = adv7180_set_video_standard(state, ret);
if (ret < 0)
return ret;
}
......@@ -521,6 +546,7 @@ static const struct v4l2_subdev_video_ops adv7180_video_ops = {
.g_mbus_config = adv7180_g_mbus_config,
};
static const struct v4l2_subdev_core_ops adv7180_core_ops = {
.s_power = adv7180_s_power,
};
......@@ -554,33 +580,77 @@ static irqreturn_t adv7180_irq(int irq, void *devid)
return IRQ_HANDLED;
}
static int init_device(struct adv7180_state *state)
static int adv7180_init(struct adv7180_state *state)
{
int ret;
mutex_lock(&state->mutex);
adv7180_write(state, ADV7180_REG_PWR_MAN, ADV7180_PWR_MAN_RES);
usleep_range(2000, 10000);
ret = adv7180_program_std(state);
if (ret)
goto out_unlock;
/* ITU-R BT.656-4 compatible */
ret = adv7180_write(state, ADV7180_REG_EXTENDED_OUTPUT_CONTROL,
ADV7180_EXTENDED_OUTPUT_CONTROL_NTSCDIS);
if (ret < 0)
goto out_unlock;
return ret;
/* Manually set V bit end position in NTSC mode */
ret = adv7180_write(state, ADV7180_REG_NTSC_V_BIT_END,
return adv7180_write(state, ADV7180_REG_NTSC_V_BIT_END,
ADV7180_NTSC_V_BIT_END_MANUAL_NVEND);
}
static int adv7180_set_std(struct adv7180_state *state, unsigned int std)
{
return adv7180_write(state, ADV7180_REG_INPUT_CONTROL,
(std << 4) | state->input);
}
static int adv7180_select_input(struct adv7180_state *state, unsigned int input)
{
int ret;
ret = adv7180_read(state, ADV7180_REG_INPUT_CONTROL);
if (ret < 0)
return ret;
ret &= ~ADV7180_INPUT_CONTROL_INSEL_MASK;
ret |= input;
return adv7180_write(state, ADV7180_REG_INPUT_CONTROL, ret);
}
static const struct adv7180_chip_info adv7180_info = {
.flags = ADV7180_FLAG_RESET_POWERED,
/* We cannot discriminate between LQFP and 40-pin LFCSP, so accept
* all inputs and let the card driver take care of validation
*/
.valid_input_mask = BIT(ADV7180_INPUT_CVBS_AIN1) |
BIT(ADV7180_INPUT_CVBS_AIN2) |
BIT(ADV7180_INPUT_CVBS_AIN3) |
BIT(ADV7180_INPUT_CVBS_AIN4) |
BIT(ADV7180_INPUT_CVBS_AIN5) |
BIT(ADV7180_INPUT_CVBS_AIN6) |
BIT(ADV7180_INPUT_SVIDEO_AIN1_AIN2) |
BIT(ADV7180_INPUT_SVIDEO_AIN3_AIN4) |
BIT(ADV7180_INPUT_SVIDEO_AIN5_AIN6) |
BIT(ADV7180_INPUT_YPRPB_AIN1_AIN2_AIN3) |
BIT(ADV7180_INPUT_YPRPB_AIN4_AIN5_AIN6),
.init = adv7180_init,
.set_std = adv7180_set_std,
.select_input = adv7180_select_input,
};
static int init_device(struct adv7180_state *state)
{
int ret;
mutex_lock(&state->mutex);
adv7180_write(state, ADV7180_REG_PWR_MAN, ADV7180_PWR_MAN_RES);
usleep_range(2000, 10000);
ret = state->chip_info->init(state);
if (ret)
goto out_unlock;
/* read current norm */
__adv7180_status(state, NULL, &state->curr_norm);
ret = adv7180_program_std(state);
if (ret)
goto out_unlock;
/* register for interrupts */
if (state->irq > 0) {
......@@ -635,11 +705,15 @@ static int adv7180_probe(struct i2c_client *client,
return -ENOMEM;
state->client = client;
state->chip_info = (struct adv7180_chip_info *)id->driver_data;
state->irq = client->irq;
mutex_init(&state->mutex);
state->autodetect = true;
state->powered = true;
if (state->chip_info->flags & ADV7180_FLAG_RESET_POWERED)
state->powered = true;
else
state->powered = false;
state->input = 0;
sd = &state->sd;
v4l2_i2c_subdev_init(sd, client, &adv7180_ops);
......@@ -702,9 +776,10 @@ static int adv7180_remove(struct i2c_client *client)
}
static const struct i2c_device_id adv7180_id[] = {
{KBUILD_MODNAME, 0},
{ "adv7180", (kernel_ulong_t)&adv7180_info },
{},
};
MODULE_DEVICE_TABLE(i2c, adv7180_id);
#ifdef CONFIG_PM_SLEEP
static int adv7180_suspend(struct device *dev)
......@@ -741,8 +816,6 @@ static SIMPLE_DEV_PM_OPS(adv7180_pm_ops, adv7180_suspend, adv7180_resume);
#define ADV7180_PM_OPS NULL
#endif
MODULE_DEVICE_TABLE(i2c, adv7180_id);
static struct i2c_driver adv7180_driver = {
.driver = {
.owner = THIS_MODULE,
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7