};
&vin_sysctl {
- /* when use dvp open this pinctrl*/
status = "okay";
ports {
#address-cells = <1>;
#size-cells = <0>;
- port@2 {
- reg = <2>;
+ port@0 {
+ reg = <0>;
#address-cells = <1>;
#size-cells = <0>;
};
};
- port@3 {
- reg = <3>;
+ port@1 {
+ reg = <1>;
#address-cells = <1>;
#size-cells = <0>;
reg = <0x0 0x19800000 0x0 0x10000>,
<0x0 0x19810000 0x0 0x10000>,
<0x0 0x19820000 0x0 0x10000>,
- <0x0 0x19830000 0x0 0x10000>,
<0x0 0x19840000 0x0 0x10000>,
<0x0 0x19870000 0x0 0x30000>,
<0x0 0x11840000 0x0 0x10000>,
<0x0 0x17030000 0x0 0x10000>,
<0x0 0x13020000 0x0 0x10000>;
- reg-names = "mipi0", "vclk", "vrst", "mipi1", "sctrl",
+ reg-names = "csi2rx", "vclk", "vrst", "sctrl",
"isp", "trst", "pmu", "syscrg";
clocks = <&clkisp JH7110_DOM4_APB_FUNC>,
<&clkisp JH7110_U0_VIN_PCLK>,
return -EINVAL;
}
-int stf_csi_subdev_init(struct stfcamss *stfcamss, int id)
+int stf_csi_subdev_init(struct stfcamss *stfcamss)
{
- struct stf_csi_dev *csi_dev = &stfcamss->csi_dev[id];
+ struct stf_csi_dev *csi_dev = stfcamss->csi_dev;
- csi_dev->id = id;
- csi_dev->csiphy_id = id;
csi_dev->s_type = SENSOR_VIN;
csi_dev->hw_ops = &csi_ops;
csi_dev->stfcamss = stfcamss;
static int csi_set_stream(struct v4l2_subdev *sd, int enable)
{
struct stf_csi_dev *csi_dev = v4l2_get_subdevdata(sd);
- struct stf_csi_dev *csi0_dev = &csi_dev->stfcamss->csi_dev[0];
struct v4l2_mbus_framefmt *format;
int ret = 0, is_raw10 = 0;
u32 code;
- if (csi_dev->id == 1)
- csi_set_stream(&csi0_dev->subdev, enable);
-
format = __csi_get_format(csi_dev, NULL, STF_CSI_PAD_SRC,
V4L2_SUBDEV_FORMAT_ACTIVE);
if (format == NULL)
mutex_lock(&csi_dev->stream_lock);
if (enable) {
if (csi_dev->stream_count == 0) {
- //csi_dev->hw_ops->csi_config_set(csi_dev);
csi_dev->hw_ops->csi_clk_enable(csi_dev);
csi_dev->hw_ops->csi_set_format(csi_dev,
format->height,
csi_dev->s_type = SENSOR_VIN;
if (line->sdev_type == ISP_DEV_TYPE)
csi_dev->s_type = SENSOR_ISP;
- st_info(ST_CSI, "CSI%d device sensor type: %d\n",
- csi_dev->id, csi_dev->s_type);
+ st_info(ST_CSI, "CSI device sensor type: %d\n", csi_dev->s_type);
}
if ((local->flags & MEDIA_PAD_FL_SINK) &&
sd = media_entity_to_v4l2_subdev(remote->entity);
csiphy_dev = v4l2_get_subdevdata(sd);
- csi_dev->csiphy_id = csiphy_dev->id;
- st_info(ST_CSI, "CSI%d link to csiphy%d\n",
- csi_dev->id, csi_dev->csiphy_id);
+ st_info(ST_CSI, "CSI0 link to csiphy0\n");
}
return 0;
sd->internal_ops = &csi_v4l2_internal_ops;
sd->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
snprintf(sd->name, ARRAY_SIZE(sd->name), "%s%d",
- STF_CSI_NAME, csi_dev->id);
+ STF_CSI_NAME, 0);
v4l2_set_subdevdata(sd, csi_dev);
ret = csi_init_formats(sd, NULL);
int (*csi_power_on)(struct stf_csi_dev *csi_dev, u8 on);
int (*csi_clk_enable)(struct stf_csi_dev *csi_dev);
int (*csi_clk_disable)(struct stf_csi_dev *csi_dev);
- int (*csi_config_set)(struct stf_csi_dev *csi_dev);
int (*csi_set_format)(struct stf_csi_dev *csi_dev,
u32 vsize, u8 bpp, int is_raw10);
int (*csi_stream_set)(struct stf_csi_dev *csi_dev, int on);
struct stf_csi_dev {
struct stfcamss *stfcamss;
- u8 id;
- u8 csiphy_id;
enum sensor_type s_type;
struct v4l2_subdev subdev;
struct media_pad pads[STF_CSI_PADS_NUM];
struct regulator *mipirx_0p9;
};
-extern int stf_csi_subdev_init(struct stfcamss *stfcamss, int id);
+extern int stf_csi_subdev_init(struct stfcamss *stfcamss);
extern int stf_csi_register(struct stf_csi_dev *csi_dev,
struct v4l2_device *v4l2_dev);
extern int stf_csi_unregister(struct stf_csi_dev *csi_dev);
-extern int raw_csi2rx_dphy_config(struct stf_vin_dev *vin,
- const csi2rx_dphy_cfg_t *cfg);
-extern int raw_csi2rx_config(struct stf_vin_dev *vin,
- int id,
- const csi2rx_cfg_t *cfg);
extern struct csi_hw_ops csi_ops;
-extern void dump_csi_reg(void *__iomem csibase, int id);
+extern void dump_csi_reg(void *__iomem csibase);
#endif /* STF_CSI_H */
return 0;
}
-static int stf_csi_config_set(struct stf_csi_dev *csi_dev)
-{
- struct stf_vin_dev *vin = csi_dev->stfcamss->vin;
- u32 mipi_channel_sel, mipi_vc = 0;
-
- st_info(ST_CSI, "%s, csi_id = %d\n", __func__, csi_dev->id);
-
- switch (csi_dev->s_type) {
- case SENSOR_VIN:
- st_err(ST_CSI, "%s, %d: need todo\n", __func__, __LINE__);
- break;
- case SENSOR_ISP:
- reg_set_bit(vin->clkgen_base,
- CLK_ISP_MIPI_CTRL,
- BIT(24), csi_dev->id << 24);
-
- reg_set_bit(vin->clkgen_base,
- CLK_C_ISP_CTRL,
- BIT(25) | BIT(24),
- csi_dev->id << 24);
-
- mipi_channel_sel = csi_dev->id * 4 + mipi_vc;
- reg_set_bit(vin->sysctrl_base,
- SYSCTRL_VIN_SRC_CHAN_SEL,
- 0xF, mipi_channel_sel);
- break;
- default:
- break;
- }
-
- return 0;
-}
-
static int stf_csi_set_format(struct stf_csi_dev *csi_dev,
u32 vsize, u8 bpp, int is_raw10)
{
struct stf_vin_dev *vin = csi_dev->stfcamss->vin;
- void *reg_base = NULL;
-
- if (csi_dev->id == 0)
- reg_base = vin->mipi0_base;
- else if (csi_dev->id == 1)
- reg_base = vin->mipi1_base;
- else
- return 0;
switch (csi_dev->s_type) {
case SENSOR_VIN:
{
struct stfcamss *stfcamss = csi_dev->stfcamss;
struct csi2phy_cfg *csiphy =
- stfcamss->csiphy_dev[csi_dev->csiphy_id].csiphy;
+ stfcamss->csiphy_dev->csiphy;
unsigned int i;
unsigned long lanes_used = 0;
u32 reg;
if (!csiphy) {
- st_err(ST_CSI, "csiphy%d config not exist\n", csi_dev->csiphy_id);
+ st_err(ST_CSI, "csiphy0 config not exist\n");
return -EINVAL;
}
{
struct stfcamss *stfcamss = csi_dev->stfcamss;
struct stf_vin_dev *vin = csi_dev->stfcamss->vin;
- void *reg_base = NULL;
-
- if (csi_dev->id == 0)
- reg_base = vin->mipi0_base;
- else if (csi_dev->id == 1)
- reg_base = vin->mipi1_base;
- else
- return 0;
+ void __iomem *reg_base = vin->csi2rx_base;
switch (csi_dev->s_type) {
case SENSOR_VIN:
return 0;
}
-void dump_csi_reg(void *__iomem csibase, int id)
+void dump_csi_reg(void *__iomem csibase)
{
- st_info(ST_CSI, "DUMP CSI%d register:\n", id);
+ st_info(ST_CSI, "DUMP CSI register:\n");
print_reg(ST_CSI, csibase, 0x00);
print_reg(ST_CSI, csibase, 0x04);
print_reg(ST_CSI, csibase, 0x08);
.csi_power_on = stf_csi_power_on,
.csi_clk_enable = stf_csi_clk_enable,
.csi_clk_disable = stf_csi_clk_disable,
- .csi_config_set = stf_csi_config_set,
.csi_set_format = stf_csi_set_format,
.csi_stream_set = stf_csi_stream_set,
};
{ MEDIA_BUS_FMT_SBGGR10_1X10, 10},
};
-int stf_csiphy_subdev_init(struct stfcamss *stfcamss, int id)
+int stf_csiphy_subdev_init(struct stfcamss *stfcamss)
{
- struct stf_csiphy_dev *csiphy_dev = &stfcamss->csiphy_dev[id];
+ struct stf_csiphy_dev *csiphy_dev = stfcamss->csiphy_dev;
- csiphy_dev->id = id;
- csiphy_dev->csi_id = id;
csiphy_dev->hw_ops = &csiphy_ops;
csiphy_dev->stfcamss = stfcamss;
csiphy_dev->formats = csiphy_formats_st7110;
static int csiphy_set_power(struct v4l2_subdev *sd, int on)
{
-#ifdef CONFIG_VIDEO_CADENCE_CSI2RX
- struct stf_csiphy_dev *csiphy_dev = v4l2_get_subdevdata(sd);
-
- if (on)
- csiphy_dev->hw_ops->cdns_csi_power(csiphy_dev, on);
-#endif
return 0;
}
exit:
mutex_unlock(&csiphy_dev->stream_lock);
-#ifdef CONFIG_VIDEO_CADENCE_CSI2RX
- if (!enable)
- csiphy_dev->hw_ops->cdns_csi_power(csiphy_dev, enable);
-#endif
return 0;
}
sd = media_entity_to_v4l2_subdev(remote->entity);
csi_dev = v4l2_get_subdevdata(sd);
- csiphy_dev->csi_id = csi_dev->id;
- st_info(ST_CSIPHY, "CSIPHY%d link to CSI%d\n",
- csiphy_dev->id, csiphy_dev->csi_id);
+ st_info(ST_CSIPHY, "CSIPHY0 link to CSI0\n");
}
return 0;
sd->internal_ops = &csiphy_v4l2_internal_ops;
sd->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
snprintf(sd->name, ARRAY_SIZE(sd->name), "%s%d",
- STF_CSIPHY_NAME, csiphy_dev->id);
+ STF_CSIPHY_NAME, 0);
v4l2_set_subdevdata(sd, csiphy_dev);
ret = csiphy_init_formats(sd, NULL);
return ret;
}
-#ifndef CONFIG_VIDEO_CADENCE_CSI2RX
ret = v4l2_device_register_subdev(v4l2_dev, sd);
if (ret < 0) {
dev_err(dev, "Failed to register subdev: %d\n", ret);
goto err_sreg;
}
-#else
- sd->dev = dev;
- ret = v4l2_async_register_subdev(sd);
- if (ret < 0) {
- dev_err(dev, "Failed to async register subdev: %d\n", ret);
- goto err_sreg;
- }
-#endif
return 0;
int (*csiphy_clk_disable)(struct stf_csiphy_dev *csiphy_dev);
int (*csiphy_config_set)(struct stf_csiphy_dev *csiphy_dev);
int (*csiphy_stream_set)(struct stf_csiphy_dev *csiphy_dev, int on);
-#ifdef CONFIG_VIDEO_CADENCE_CSI2RX
- int (*cdns_csi_power)(struct stf_csiphy_dev *csiphy_dev, int on);
-#endif
};
struct stf_csiphy_dev {
struct stfcamss *stfcamss;
struct csi2phy_cfg *csiphy;
- u8 id;
- u8 csi_id;
struct v4l2_subdev subdev;
struct media_pad pads[STF_CSIPHY_PADS_NUM];
struct v4l2_mbus_framefmt fmt[STF_CSIPHY_PADS_NUM];
int stream_count;
};
-extern int stf_csiphy_subdev_init(struct stfcamss *stfcamss, int id);
+extern int stf_csiphy_subdev_init(struct stfcamss *stfcamss);
extern int stf_csiphy_register(struct stf_csiphy_dev *csiphy_dev,
struct v4l2_device *v4l2_dev);
extern int stf_csiphy_unregister(struct stf_csiphy_dev *csiphy_dev);
{
struct csi2phy_cfg2 cfg2 = {0};
struct csi2phy_cfg2 *cfg = &cfg2;
- struct stf_csiphy_dev *csiphy0_dev =
- &csiphy_dev->stfcamss->csiphy_dev[0];
- struct stf_csiphy_dev *csiphy1_dev =
- &csiphy_dev->stfcamss->csiphy_dev[1];
- struct csi2phy_cfg *phy0cfg = csiphy0_dev->csiphy;
- struct csi2phy_cfg *phy1cfg = csiphy1_dev->csiphy;
- int id = csiphy_dev->id;
+ struct csi2phy_cfg *phycfg = csiphy_dev->csiphy;
- st_debug(ST_CSIPHY, "%s, csiphy id = %d\n",
- __func__, id);
-
- if (!phy0cfg && !phy1cfg)
+ if (!phycfg)
return -EINVAL;
-#ifdef USE_CSIDPHY_ONE_CLK_MODE
- if (id == 0) {
- phy0cfg = csiphy0_dev->csiphy;
- phy1cfg = NULL;
- } else {
- phy0cfg = NULL;
- phy1cfg = csiphy1_dev->csiphy;
- }
-#endif
-
- if (try_cfg(cfg, phy0cfg, phy1cfg))
+ if (try_cfg(cfg, phycfg, NULL))
return -EINVAL;
reg_write(vin->rstgen_base, M31DPHY_APBCFGSAIF__SYSCFG_4, 0x0);
{
struct stf_vin_dev *vin = csiphy_dev->stfcamss->vin;
- st_debug(ST_CSIPHY, "%s, csiphy id = %d\n",
- __func__, csiphy_dev->id);
-
csi2rx_dphy_config(vin, csiphy_dev);
return 0;
}
return 0;
}
-#ifdef CONFIG_VIDEO_CADENCE_CSI2RX
-static int stf_csi_clk_enable(struct stf_csiphy_dev *csiphy_dev)
-{
- struct stf_vin_dev *vin = csiphy_dev->stfcamss->vin;
-
- reg_set_highest_bit(vin->clkgen_base, CLK_CSI2RX0_APB_CTRL);
-
- if (csiphy_dev->id == 0) {
- reg_set_bit(vin->clkgen_base,
- CLK_MIPI_RX0_PXL_CTRL,
- 0x1F, 0x3);
- reg_set_highest_bit(vin->clkgen_base, CLK_MIPI_RX0_PXL_0_CTRL);
- reg_set_highest_bit(vin->clkgen_base, CLK_MIPI_RX0_PXL_1_CTRL);
- reg_set_highest_bit(vin->clkgen_base, CLK_MIPI_RX0_PXL_2_CTRL);
- reg_set_highest_bit(vin->clkgen_base, CLK_MIPI_RX0_PXL_3_CTRL);
- reg_set_highest_bit(vin->clkgen_base, CLK_MIPI_RX0_SYS0_CTRL);
- } else {
- reg_set_bit(vin->clkgen_base,
- CLK_MIPI_RX1_PXL_CTRL,
- 0x1F, 0x3);
- reg_set_highest_bit(vin->clkgen_base, CLK_MIPI_RX1_PXL_0_CTRL);
- reg_set_highest_bit(vin->clkgen_base, CLK_MIPI_RX1_PXL_1_CTRL);
- reg_set_highest_bit(vin->clkgen_base, CLK_MIPI_RX1_PXL_2_CTRL);
- reg_set_highest_bit(vin->clkgen_base, CLK_MIPI_RX1_PXL_3_CTRL);
- reg_set_highest_bit(vin->clkgen_base, CLK_MIPI_RX1_SYS1_CTRL);
- }
-
- return 0;
-}
-
-static int stf_csi_clk_disable(struct stf_csiphy_dev *csiphy_dev)
-{
- struct stf_vin_dev *vin = csiphy_dev->stfcamss->vin;
-
- reg_clr_highest_bit(vin->clkgen_base, CLK_CSI2RX0_APB_CTRL);
-
- if (csiphy_dev->id == 0) {
- reg_clr_highest_bit(vin->clkgen_base, CLK_MIPI_RX0_PXL_0_CTRL);
- reg_clr_highest_bit(vin->clkgen_base, CLK_MIPI_RX0_PXL_1_CTRL);
- reg_clr_highest_bit(vin->clkgen_base, CLK_MIPI_RX0_PXL_2_CTRL);
- reg_clr_highest_bit(vin->clkgen_base, CLK_MIPI_RX0_PXL_3_CTRL);
- reg_clr_highest_bit(vin->clkgen_base, CLK_MIPI_RX0_SYS0_CTRL);
- } else {
- reg_clr_highest_bit(vin->clkgen_base, CLK_MIPI_RX1_PXL_0_CTRL);
- reg_clr_highest_bit(vin->clkgen_base, CLK_MIPI_RX1_PXL_1_CTRL);
- reg_clr_highest_bit(vin->clkgen_base, CLK_MIPI_RX1_PXL_2_CTRL);
- reg_clr_highest_bit(vin->clkgen_base, CLK_MIPI_RX1_PXL_3_CTRL);
- reg_clr_highest_bit(vin->clkgen_base, CLK_MIPI_RX1_SYS1_CTRL);
- }
-
- return 0;
-}
-
-static int stf_csi_config_set(struct stf_csiphy_dev *csiphy_dev, int is_raw10)
-{
- struct stf_vin_dev *vin = csiphy_dev->stfcamss->vin;
- u32 mipi_channel_sel, mipi_vc = 0;
- enum sensor_type s_type = SENSOR_ISP;
-
- switch (s_type) {
- case SENSOR_VIN:
- break;
- case SENSOR_ISP:
- reg_set_bit(vin->clkgen_base,
- CLK_ISP_MIPI_CTRL,
- BIT(24), csiphy_dev->id << 24);
-
- reg_set_bit(vin->clkgen_base,
- CLK_C_ISP_CTRL,
- BIT(25) | BIT(24),
- csiphy_dev->id << 24);
-
- mipi_channel_sel = csiphy_dev->id * 4 + mipi_vc;
- reg_set_bit(vin->sysctrl_base,
- SYSCTRL_VIN_SRC_CHAN_SEL,
- 0xF, mipi_channel_sel);
-
- if (is_raw10)
- reg_set_bit(vin->sysctrl_base,
- SYSCTRL_VIN_SRC_DW_SEL,
- BIT(4), 1 << 4);
- break;
- case SENSOR_ISP1:
- reg_set_bit(vin->clkgen_base,
- CLK_ISP1_MIPI_CTRL,
- BIT(24), csiphy_dev->id << 24);
- reg_set_bit(vin->clkgen_base,
- CLK_C_ISP1_CTRL,
- BIT(25) | BIT(24),
- csiphy_dev->id << 24);
-
- mipi_channel_sel = csiphy_dev->id * 4 + mipi_vc;
- reg_set_bit(vin->sysctrl_base,
- SYSCTRL_VIN_SRC_CHAN_SEL,
- 0xF << 4, mipi_channel_sel << 4);
-
- if (is_raw10)
- reg_set_bit(vin->sysctrl_base,
- SYSCTRL_VIN_SRC_DW_SEL,
- BIT(5), 1 << 5);
- default:
- break;
- }
-
- return 0;
-}
-
-static int stf_cdns_csi_power(struct stf_csiphy_dev *csiphy_dev, int on)
-{
- if (on) {
- stf_csi_config_set(csiphy_dev, 1);
- stf_csi_clk_enable(csiphy_dev);
- } else
- stf_csi_clk_disable(csiphy_dev);
-
- return 0;
-}
-#endif
-
struct csiphy_hw_ops csiphy_ops = {
.csiphy_clk_enable = stf_csiphy_clk_enable,
.csiphy_clk_disable = stf_csiphy_clk_disable,
.csiphy_config_set = stf_csiphy_config_set,
.csiphy_stream_set = stf_csiphy_stream_set,
-#ifdef CONFIG_VIDEO_CADENCE_CSI2RX
- .cdns_csi_power = stf_cdns_csi_power,
-#endif
};
sd->internal_ops = &dvp_v4l2_internal_ops;
sd->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
snprintf(sd->name, ARRAY_SIZE(sd->name), "%s%d",
- STF_DVP_NAME, dvp_dev->id);
+ STF_DVP_NAME, 0);
v4l2_set_subdevdata(sd, dvp_dev);
ret = dvp_init_formats(sd, NULL);
struct stf_dvp_dev {
struct stfcamss *stfcamss;
struct dvp_cfg *dvp;
- u8 id;
enum sensor_type s_type;
struct v4l2_subdev subdev;
struct media_pad pads[STF_DVP_PADS_NUM];
sd->internal_ops = &vin_v4l2_internal_ops;
sd->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
snprintf(sd->name, ARRAY_SIZE(sd->name), "%s%d_%s",
- STF_VIN_NAME, vin_dev->id, sub_name);
+ STF_VIN_NAME, 0, sub_name);
v4l2_set_subdevdata(sd, &vin_dev->line[i]);
ret = vin_init_formats(sd, NULL);
struct stf_vin2_dev {
struct stfcamss *stfcamss;
- u8 id;
struct vin_line line[VIN_LINE_MAX];
struct dummy_buffer dummy_buffer[STF_DUMMY_MODULE_NUMS];
struct vin_hw_ops *hw_ops;
EXPORT_SYMBOL_GPL(stdbg_mask);
static const struct reg_name mem_reg_name[] = {
-#ifndef CONFIG_VIDEO_CADENCE_CSI2RX
- {"mipi0"},
-#endif
+ {"csi2rx"},
{"vclk"},
{"vrst"},
- {"mipi1"},
{"sctrl"},
{"isp"},
{"trst"},
if (!res)
return -EINVAL;
- if (!strcmp(name, "mipi0")) {
- vin->mipi0_base = devm_ioremap_resource(dev, res);
- if (IS_ERR(vin->mipi0_base))
- return PTR_ERR(vin->mipi0_base);
+ if (!strcmp(name, "csi2rx")) {
+ vin->csi2rx_base = devm_ioremap_resource(dev, res);
+ if (IS_ERR(vin->csi2rx_base))
+ return PTR_ERR(vin->csi2rx_base);
} else if (!strcmp(name, "vclk")) {
vin->clkgen_base = ioremap(res->start, resource_size(res));
if (!vin->clkgen_base)
vin->rstgen_base = devm_ioremap_resource(dev, res);
if (IS_ERR(vin->rstgen_base))
return PTR_ERR(vin->rstgen_base);
- } else if (!strcmp(name, "mipi1")) {
- vin->mipi1_base = devm_ioremap_resource(dev, res);
- if (IS_ERR(vin->mipi1_base))
- return PTR_ERR(vin->mipi1_base);
} else if (!strcmp(name, "sctrl")) {
vin->sysctrl_base = devm_ioremap_resource(dev, res);
if (IS_ERR(vin->sysctrl_base))
if (!vin->sys_crg)
return -ENOMEM;
} else {
-
st_err(ST_CAMSS, "Could not match resource name\n");
}
}
csd->port = vep.base.port;
switch (csd->port) {
- case CSI2RX0_PORT_NUMBER:
- case CSI2RX1_PORT_NUMBER:
- break;
case DVP_SENSOR_PORT_NUMBER:
st_debug(ST_CAMSS, "%s, flags = 0x%x\n", __func__,
parallel_bus->flags);
dvp->bus_width = parallel_bus->bus_width;
dvp->data_shift = parallel_bus->data_shift;
break;
- case CSI2RX0_SENSOR_PORT_NUMBER:
- case CSI2RX1_SENSOR_PORT_NUMBER:
+ case CSI2RX_SENSOR_PORT_NUMBER:
st_debug(ST_CAMSS, "%s, CSI2 flags = 0x%x\n",
__func__, parallel_bus->flags);
csiphy->flags = csi2_bus->flags;
static int stfcamss_init_subdevices(struct stfcamss *stfcamss)
{
- int ret, i;
+ int ret;
ret = stf_dvp_subdev_init(stfcamss);
if (ret < 0) {
return ret;
}
- for (i = 0; i < stfcamss->csiphy_num; i++) {
- ret = stf_csiphy_subdev_init(stfcamss, i);
- if (ret < 0) {
- st_err(ST_CAMSS,
- "Failed to init stf_csiphy sub-device: %d\n",
- ret);
- return ret;
- }
+ ret = stf_csiphy_subdev_init(stfcamss);
+ if (ret < 0) {
+ st_err(ST_CAMSS,
+ "Failed to init stf_csiphy sub-device: %d\n",
+ ret);
+ return ret;
}
-#ifndef CONFIG_VIDEO_CADENCE_CSI2RX
- for (i = 0; i < stfcamss->csi_num; i++) {
- ret = stf_csi_subdev_init(stfcamss, i);
- if (ret < 0) {
- st_err(ST_CAMSS,
- "Failed to init stf_csi sub-device: %d\n",
- ret);
- return ret;
- }
+ ret = stf_csi_subdev_init(stfcamss);
+ if (ret < 0) {
+ st_err(ST_CAMSS,
+ "Failed to init stf_csi sub-device: %d\n",
+ ret);
+ return ret;
}
-#endif
ret = stf_isp_subdev_init(stfcamss);
if (ret < 0) {
static int stfcamss_register_subdevices(struct stfcamss *stfcamss)
{
- int ret, i, j;
+ int ret;
struct stf_vin2_dev *vin_dev = stfcamss->vin_dev;
struct stf_dvp_dev *dvp_dev = stfcamss->dvp_dev;
struct stf_csiphy_dev *csiphy_dev = stfcamss->csiphy_dev;
ret = stf_dvp_register(dvp_dev, &stfcamss->v4l2_dev);
if (ret < 0) {
st_err(ST_CAMSS,
- "Failed to register stf dvp entity: %d\n",
- ret);
+ "Failed to register stf dvp%d entity: %d\n",
+ 0, ret);
goto err_reg_dvp;
}
- for (i = 0; i < stfcamss->csiphy_num; i++) {
- ret = stf_csiphy_register(&csiphy_dev[i],
- &stfcamss->v4l2_dev);
- if (ret < 0) {
- st_err(ST_CAMSS,
- "Failed to register stf csiphy%d entity: %d\n",
- i, ret);
- goto err_reg_csiphy;
- }
+ ret = stf_csiphy_register(csiphy_dev, &stfcamss->v4l2_dev);
+ if (ret < 0) {
+ st_err(ST_CAMSS,
+ "Failed to register stf csiphy%d entity: %d\n",
+ 0, ret);
+ goto err_reg_csiphy;
}
-#ifndef CONFIG_VIDEO_CADENCE_CSI2RX
- for (i = 0; i < stfcamss->csi_num; i++) {
- ret = stf_csi_register(&csi_dev[i],
- &stfcamss->v4l2_dev);
- if (ret < 0) {
- st_err(ST_CAMSS,
- "Failed to register stf csi%d entity: %d\n",
- i, ret);
- goto err_reg_csi;
- }
+ ret = stf_csi_register(csi_dev, &stfcamss->v4l2_dev);
+ if (ret < 0) {
+ st_err(ST_CAMSS,
+ "Failed to register stf csi%d entity: %d\n",
+ 0, ret);
+ goto err_reg_csi;
}
-#endif
- ret = stf_isp_register(isp_dev,
- &stfcamss->v4l2_dev);
+ ret = stf_isp_register(isp_dev, &stfcamss->v4l2_dev);
if (ret < 0) {
st_err(ST_CAMSS,
"Failed to register stf isp%d entity: %d\n",
- i, ret);
+ 0, ret);
goto err_reg_isp;
}
goto err_link;
}
-#ifndef CONFIG_VIDEO_CADENCE_CSI2RX
- for (i = 0; i < stfcamss->csi_num; i++) {
- ret = media_create_pad_link(
- &csi_dev[i].subdev.entity,
- STF_CSI_PAD_SRC,
- &vin_dev->line[VIN_LINE_WR].subdev.entity,
- STF_VIN_PAD_SINK,
- 0);
- if (ret < 0) {
- st_err(ST_CAMSS,
- "Failed to link %s->vin entities: %d\n",
- csi_dev[i].subdev.entity.name,
- ret);
- goto err_link;
- }
+ ret = media_create_pad_link(
+ &csi_dev->subdev.entity,
+ STF_CSI_PAD_SRC,
+ &vin_dev->line[VIN_LINE_WR].subdev.entity,
+ STF_VIN_PAD_SINK,
+ 0);
+ if (ret < 0) {
+ st_err(ST_CAMSS,
+ "Failed to link %s->vin entities: %d\n",
+ csi_dev->subdev.entity.name,
+ ret);
+ goto err_link;
}
- for (j = 0; j < stfcamss->csi_num; j++) {
- ret = media_create_pad_link(
- &csiphy_dev[j].subdev.entity,
- STF_CSIPHY_PAD_SRC,
- &csi_dev[j].subdev.entity,
- STF_CSI_PAD_SINK,
- MEDIA_LNK_FL_IMMUTABLE | MEDIA_LNK_FL_ENABLED);
- if (ret < 0) {
- st_err(ST_CAMSS,
- "Failed to link %s->%s entities: %d\n",
- csiphy_dev[j].subdev.entity.name,
- csi_dev[j].subdev.entity.name,
- ret);
- goto err_link;
- }
+ ret = media_create_pad_link(
+ &csiphy_dev->subdev.entity,
+ STF_CSIPHY_PAD_SRC,
+ &csi_dev->subdev.entity,
+ STF_CSI_PAD_SINK,
+ MEDIA_LNK_FL_IMMUTABLE | MEDIA_LNK_FL_ENABLED);
+ if (ret < 0) {
+ st_err(ST_CAMSS,
+ "Failed to link %s->%s entities: %d\n",
+ csiphy_dev->subdev.entity.name,
+ csi_dev->subdev.entity.name,
+ ret);
+ goto err_link;
}
-#endif
ret = media_create_pad_link(
&isp_dev->subdev.entity,
st_err(ST_CAMSS,
"Failed to link %s->%s entities: %d\n",
isp_dev->subdev.entity.name,
- vin_dev->line[i + VIN_LINE_ISP_SS0]
+ vin_dev->line[VIN_LINE_ISP_SS0]
.subdev.entity.name,
ret);
goto err_link;
goto err_link;
}
-#ifndef CONFIG_VIDEO_CADENCE_CSI2RX
- for (j = 0; j < stfcamss->csi_num; j++) {
- ret = media_create_pad_link(
- &csi_dev[j].subdev.entity,
- STF_CSI_PAD_SRC,
- &isp_dev->subdev.entity,
- STF_ISP_PAD_SINK,
- 0);
- if (ret < 0) {
- st_err(ST_CAMSS,
- "Failed to link %s->%s entities: %d\n",
- csi_dev[j].subdev.entity.name,
- isp_dev->subdev.entity.name,
- ret);
- goto err_link;
- }
+ ret = media_create_pad_link(
+ &csi_dev->subdev.entity,
+ STF_CSI_PAD_SRC,
+ &isp_dev->subdev.entity,
+ STF_ISP_PAD_SINK,
+ 0);
+ if (ret < 0) {
+ st_err(ST_CAMSS,
+ "Failed to link %s->%s entities: %d\n",
+ csi_dev->subdev.entity.name,
+ isp_dev->subdev.entity.name,
+ ret);
+ goto err_link;
}
-#endif
return ret;
err_reg_vin:
stf_isp_unregister(stfcamss->isp_dev);
err_reg_isp:
-#ifndef CONFIG_VIDEO_CADENCE_CSI2RX
- i = stfcamss->csi_num;
+ stf_csi_unregister(stfcamss->csi_dev);
err_reg_csi:
- for (i--; i >= 0; i--)
- stf_csi_unregister(&stfcamss->csi_dev[i]);
-#endif
-
- i = stfcamss->csiphy_num;
+ stf_csiphy_unregister(stfcamss->csiphy_dev);
err_reg_csiphy:
- for (i--; i >= 0; i--)
- stf_csiphy_unregister(&stfcamss->csiphy_dev[i]);
-
stf_dvp_unregister(stfcamss->dvp_dev);
err_reg_dvp:
return ret;
static void stfcamss_unregister_subdevices(struct stfcamss *stfcamss)
{
- int i;
-
stf_dvp_unregister(stfcamss->dvp_dev);
-
- i = stfcamss->csiphy_num;
- for (i--; i >= 0; i--)
- stf_csiphy_unregister(&stfcamss->csiphy_dev[i]);
-
-#ifndef CONFIG_VIDEO_CADENCE_CSI2RX
- i = stfcamss->csi_num;
- for (i--; i >= 0; i--)
- stf_csi_unregister(&stfcamss->csi_dev[i]);
-#endif
-
+ stf_csiphy_unregister(stfcamss->csiphy_dev);
+ stf_csi_unregister(stfcamss->csi_dev);
stf_isp_unregister(stfcamss->isp_dev);
-
stf_vin_unregister(stfcamss->vin_dev);
}
enum port_num port = csd->port;
struct stf_dvp_dev *dvp_dev = stfcamss->dvp_dev;
struct stf_csiphy_dev *csiphy_dev = stfcamss->csiphy_dev;
- struct stf_isp_dev *isp_dev = stfcamss->isp_dev;
- u32 id;
switch (port) {
- case CSI2RX0_PORT_NUMBER:
- case CSI2RX1_PORT_NUMBER:
- id = port - CSI2RX0_PORT_NUMBER;
- subdev->host_priv = &isp_dev->subdev.entity;
- break;
case DVP_SENSOR_PORT_NUMBER:
dvp_dev->dvp = &csd->interface.dvp;
subdev->host_priv = &dvp_dev->subdev.entity;
break;
- case CSI2RX0_SENSOR_PORT_NUMBER:
- case CSI2RX1_SENSOR_PORT_NUMBER:
- id = port - CSI2RX0_SENSOR_PORT_NUMBER;
- csiphy_dev = &csiphy_dev[id];
+ case CSI2RX_SENSOR_PORT_NUMBER:
csiphy_dev->csiphy = &csd->interface.csiphy;
subdev->host_priv = &csiphy_dev->subdev.entity;
break;
enum module_id {
VIN_MODULE = 0,
ISP_MODULE,
- CSI0_MODULE,
- CSI1_MODULE,
+ CSI_MODULE,
CSIPHY_MODULE,
DVP_MODULE,
CLK_MODULE,
struct stf_vin_dev *vin = stfcamss->vin;
struct stf_vin2_dev *vin_dev = stfcamss->vin_dev;
struct stf_isp_dev *isp_dev = stfcamss->isp_dev;
- struct stf_csi_dev *csi0_dev = &stfcamss->csi_dev[0];
- struct stf_csi_dev *csi1_dev = &stfcamss->csi_dev[1];
+ struct stf_csi_dev *csi0_dev = stfcamss->csi_dev;
switch (id_num) {
case VIN_MODULE:
}
mutex_unlock(&isp_dev->stream_lock);
break;
- case CSI0_MODULE:
+ case CSI_MODULE:
mutex_lock(&csi0_dev->stream_lock);
if (csi0_dev->stream_count > 0) {
- reg_base = vin->mipi0_base;
- dump_csi_reg(reg_base, 0);
+ reg_base = vin->csi2rx_base;
+ dump_csi_reg(reg_base);
}
mutex_unlock(&csi0_dev->stream_lock);
break;
- case CSI1_MODULE:
- mutex_lock(&csi1_dev->stream_lock);
- if (csi1_dev->stream_count > 0) {
- reg_base = vin->mipi1_base;
- dump_csi_reg(reg_base, 1);
- }
- mutex_unlock(&csi1_dev->stream_lock);
- break;
case CLK_MODULE:
mutex_lock(&vin_dev->power_lock);
if (vin_dev->power_count > 0) {
struct stf_vin_dev *vin = stfcamss->vin;
struct stf_vin2_dev *vin_dev = stfcamss->vin_dev;
struct stf_isp_dev *isp_dev = stfcamss->isp_dev;
- struct stf_csi_dev *csi0_dev = &stfcamss->csi_dev[0];
- struct stf_csi_dev *csi1_dev = &stfcamss->csi_dev[1];
+ struct stf_csi_dev *csi_dev = stfcamss->csi_dev;
void __iomem *reg_base;
switch (id) {
}
mutex_unlock(&isp_dev->stream_lock);
break;
- case CSI0_MODULE:
- mutex_lock(&csi0_dev->stream_lock);
- if (csi0_dev->stream_count > 0) {
- reg_base = vin->mipi0_base;
+ case CSI_MODULE:
+ mutex_lock(&csi_dev->stream_lock);
+ if (csi_dev->stream_count > 0) {
+ reg_base = vin->csi2rx_base;
print_reg(ST_CSI, reg_base, offset);
reg_write(reg_base, offset, val);
print_reg(ST_CSI, reg_base, offset);
}
- mutex_unlock(&csi0_dev->stream_lock);
- break;
- case CSI1_MODULE:
- mutex_lock(&csi1_dev->stream_lock);
- if (csi1_dev->stream_count > 0) {
- reg_base = vin->mipi1_base;
- print_reg(ST_CSI, reg_base, offset);
- reg_write(reg_base, offset, val);
- print_reg(ST_CSI, reg_base, offset);
- }
- mutex_unlock(&csi1_dev->stream_lock);
+ mutex_unlock(&csi_dev->stream_lock);
break;
case CLK_MODULE:
mutex_lock(&vin_dev->power_lock);
if (!stfcamss)
return -ENOMEM;
- stfcamss->csi_num = 2;
-#ifndef CONFIG_VIDEO_CADENCE_CSI2RX
- stfcamss->csiphy_num = 2;
-#else
- stfcamss->csiphy_num = 1;
-#endif
-
stfcamss->dvp_dev = devm_kzalloc(dev,
sizeof(*stfcamss->dvp_dev), GFP_KERNEL);
if (!stfcamss->dvp_dev) {
}
stfcamss->csiphy_dev = devm_kzalloc(dev,
- stfcamss->csiphy_num * sizeof(*stfcamss->csiphy_dev),
+ sizeof(*stfcamss->csiphy_dev),
GFP_KERNEL);
if (!stfcamss->csiphy_dev) {
ret = -ENOMEM;
}
stfcamss->csi_dev = devm_kzalloc(dev,
- stfcamss->csi_num * sizeof(*stfcamss->csi_dev),
+ sizeof(*stfcamss->csi_dev),
GFP_KERNEL);
if (!stfcamss->csi_dev) {
ret = -ENOMEM;
#define STF_PADS_NUM 2
enum port_num {
- CSI2RX0_PORT_NUMBER = 0,
- CSI2RX1_PORT_NUMBER,
- DVP_SENSOR_PORT_NUMBER,
- CSI2RX0_SENSOR_PORT_NUMBER,
- CSI2RX1_SENSOR_PORT_NUMBER
+ DVP_SENSOR_PORT_NUMBER = 0,
+ CSI2RX_SENSOR_PORT_NUMBER
};
enum stf_clk_num {
struct device *dev;
struct stf_vin2_dev *vin_dev; // subdev
struct stf_dvp_dev *dvp_dev; // subdev
- int csi_num;
struct stf_csi_dev *csi_dev; // subdev
- int csiphy_num;
struct stf_csiphy_dev *csiphy_dev; // subdev
struct stf_isp_dev *isp_dev; // subdev
struct v4l2_async_notifier notifier;
struct device *dev;
struct cdev vin_cdev;
void __iomem *base;
- void __iomem *mipi0_base;
+ void __iomem *csi2rx_base;
void __iomem *clkgen_base;
void __iomem *rstgen_base;
- void __iomem *mipi1_base;
void __iomem *sysctrl_base;
void __iomem *isp_base;
void __iomem *vin_top_clkgen_base;
void __iomem *vin_top_rstgen_base;
void __iomem *vin_top_iopad_base;
void __iomem *pmu_test;
- void __iomem * sys_crg;
+ void __iomem *sys_crg;
struct vin_framesize frame;
struct vin_format format;
bool isp;
projects / platform / kernel / linux-starfive.git / commitdiff