int msm_camio_vpe_clk_enable(uint32_t clk_rate)
{
int rc = 0;
fs_vpe = regulator_get(NULL, "fs_vpe");
if (IS_ERR(fs_vpe)) {
CDBG("%s: Regulator FS_VPE get failed %ld\n", __func__,
PTR_ERR(fs_vpe));
fs_vpe = NULL;
} else if (regulator_enable(fs_vpe)) {
CDBG("%s: Regulator FS_VPE enable failed\n", __func__);
regulator_put(fs_vpe);
}
vpe_clk_rate = clk_rate;
rc = msm_camio_clk_enable(CAMIO_VPE_CLK);
if (rc < 0)
return rc;
rc = msm_camio_clk_enable(CAMIO_VPE_PCLK);
return rc;
}
int msm_camio_jpeg_clk_enable(void)
{
int rc = 0;
rc = msm_camio_clk_enable(CAMIO_JPEG_CLK);
if (rc < 0)
return rc;
rc = msm_camio_clk_enable(CAMIO_JPEG_PCLK);
if (rc < 0)
return rc;
fs_ijpeg = regulator_get(NULL, "fs_ijpeg");
if (IS_ERR(fs_ijpeg)) {
CDBG("[CAM] %s: Regulator FS_IJPEG get failed %ld\n", __func__,
PTR_ERR(fs_ijpeg));
fs_ijpeg = NULL;
} else if (regulator_enable(fs_ijpeg)) {
CDBG("[CAM] %s: Regulator FS_IJPEG enable failed\n", __func__);
regulator_put(fs_ijpeg);
}
CDBG("[CAM] %s: exit %d\n", __func__, rc);
return rc;
}
int msm_camio_sensor_clk_on(struct platform_device *pdev)
{
int rc = 0;
struct msm_camera_sensor_info *sinfo = pdev->dev.platform_data;
struct msm_camera_device_platform_data *camdev = sinfo->pdata;
msm_camera_vreg_enable();
msleep(10);
rc = camdev->camera_gpio_on();
if (rc < 0)
return rc;
return msm_camio_clk_enable(CAMIO_CAM_MCLK_CLK);
}
int msm_camio_sensor_clk_on(struct platform_device *pdev)
{
int rc = 0;
struct msm_camera_sensor_info *sinfo = pdev->dev.platform_data;
struct msm_camera_device_platform_data *camdev = sinfo->pdata;
camio_clk = camdev->ioclk;
camio_ext = camdev->ioext;
camdev->camera_gpio_on();
#if !defined(CONFIG_SEMC_CAMERA_MODULE) && \
!defined(CONFIG_SEMC_SUB_CAMERA_MODULE)
msm_camio_clk_enable(CAMIO_CAM_MCLK_CLK);
#endif
msm_camio_clk_enable(CAMIO_CAMIF_PAD_PBDG_CLK);
if (!sinfo->csi_if) {
camifpadio = request_mem_region(camio_ext.camifpadphy,
camio_ext.camifpadsz, pdev->name);
msm_camio_clk_enable(CAMIO_VFE_CLK);
if (!camifpadio) {
rc = -EBUSY;
goto common_fail;
}
camifpadbase = ioremap(camio_ext.camifpadphy,
camio_ext.camifpadsz);
if (!camifpadbase) {
CDBG("msm_camio_sensor_clk_on fail\n");
rc = -ENOMEM;
goto parallel_busy;
}
}
return rc;
parallel_busy:
release_mem_region(camio_ext.camifpadphy, camio_ext.camifpadsz);
goto common_fail;
common_fail:
msm_camio_clk_disable(CAMIO_CAM_MCLK_CLK);
msm_camio_clk_disable(CAMIO_VFE_CLK);
msm_camio_clk_disable(CAMIO_CAMIF_PAD_PBDG_CLK);
camdev->camera_gpio_off();
return rc;
}
int msm_camio_enable(struct platform_device *pdev)
{
int rc = 0;
uint32_t val;
struct msm_camera_sensor_info *sinfo = pdev->dev.platform_data;
msm_camio_clk_enable(CAMIO_VFE_PBDG_CLK);
if (!sinfo->csi_if)
msm_camio_clk_enable(CAMIO_VFE_CAMIF_CLK);
else {
msm_camio_clk_enable(CAMIO_VFE_CLK);
csiio = request_mem_region(camio_ext.csiphy,
camio_ext.csisz, pdev->name);
if (!csiio) {
rc = -EBUSY;
goto common_fail;
}
csibase = ioremap(camio_ext.csiphy,
camio_ext.csisz);
if (!csibase) {
rc = -ENOMEM;
goto csi_busy;
}
rc = request_irq(camio_ext.csiirq, msm_io_csi_irq,
IRQF_TRIGGER_RISING, "csi", 0);
if (rc < 0)
goto csi_irq_fail;
/* enable required clocks for CSI */
msm_camio_clk_enable(CAMIO_CSI0_PCLK);
msm_camio_clk_enable(CAMIO_CSI0_VFE_CLK);
msm_camio_clk_enable(CAMIO_CSI0_CLK);
msleep(10);
val = (20 <<
MIPI_PHY_D0_CONTROL2_SETTLE_COUNT_SHFT) |
(0x0F << MIPI_PHY_D0_CONTROL2_HS_TERM_IMP_SHFT) |
(0x0 << MIPI_PHY_D0_CONTROL2_LP_REC_EN_SHFT) |
(0x1 << MIPI_PHY_D0_CONTROL2_ERR_SOT_HS_EN_SHFT);
CDBG("%s MIPI_PHY_D0_CONTROL2 val=0x%x\n", __func__, val);
msm_io_w(val, csibase + MIPI_PHY_D0_CONTROL2);
msm_io_w(val, csibase + MIPI_PHY_D1_CONTROL2);
msm_io_w(val, csibase + MIPI_PHY_D2_CONTROL2);
msm_io_w(val, csibase + MIPI_PHY_D3_CONTROL2);
val = (0x0F << MIPI_PHY_CL_CONTROL_HS_TERM_IMP_SHFT) |
(0x0 << MIPI_PHY_CL_CONTROL_LP_REC_EN_SHFT);
CDBG("%s MIPI_PHY_CL_CONTROL val=0x%x\n", __func__, val);
msm_io_w(val, csibase + MIPI_PHY_CL_CONTROL);
}
return 0;
csi_irq_fail:
iounmap(csibase);
csi_busy:
release_mem_region(camio_ext.csiphy, camio_ext.csisz);
common_fail:
msm_camio_clk_disable(CAMIO_VFE_PBDG_CLK);
msm_camio_clk_disable(CAMIO_VFE_CLK);
return rc;
}
int msm_camio_probe_on(struct platform_device *pdev)
{
int rc = 0;
struct msm_camera_sensor_info *sinfo = pdev->dev.platform_data;
struct msm_camera_device_platform_data *camdev = sinfo->pdata;
camio_dev = pdev;
camio_clk = camdev->ioclk;
rc = config_gpio_table(1);
if (rc < 0)
return rc;
msm_camera_vreg_enable(pdev);
return msm_camio_clk_enable(CAMIO_CAM_MCLK_CLK);
}
int msm_camio_vpe_clk_enable(void)
{
fs_vpe = regulator_get(NULL, "fs_vpe");
if (IS_ERR(fs_vpe)) {
pr_err("%s: Regulator FS_VPE get failed %ld\n", __func__,
PTR_ERR(fs_vpe));
fs_vpe = NULL;
} else if (regulator_enable(fs_vpe)) {
pr_err("%s: Regulator FS_VPE enable failed\n", __func__);
regulator_put(fs_vpe);
}
msm_camio_clk_enable(CAMIO_VPE_CLK);
return 0;
}
int msm_sensor_probe_on(struct device *dev)
{
int rc = 0;
struct msm_camera_sensor_info *sinfo = dev->platform_data;
struct msm_camera_device_platform_data *camdev = sinfo->pdata;
camio_clk = camdev->ioclk;
rc = camdev->camera_gpio_on();
if (rc < 0)
return rc;
rc = msm_camio_clk_enable(CAMIO_CAM_MCLK_CLK);
if (rc < 0)
camdev->camera_gpio_off();
return rc;
}
int rawchip_power_up(const struct msm_camera_rawchip_info *pdata)
{
int rc = 0;
CDBG("[CAM] %s\n", __func__);
if (pdata->camera_rawchip_power_on == NULL) {
pr_err("rawchip power on platform_data didn't register\n");
return -EIO;
}
rc = pdata->camera_rawchip_power_on();
if (rc < 0) {
pr_err("rawchip power on failed\n");
goto enable_power_on_failed;
}
rc = msm_camio_clk_enable(CAMIO_CAM_MCLK_CLK);
if (rc < 0) {
pr_err("enable MCLK failed\n");
goto enable_mclk_failed;
}
mdelay(1);
rc = gpio_request(pdata->rawchip_reset, "rawchip");
if (rc < 0) {
pr_err("GPIO(%d) request failed\n", pdata->rawchip_reset);
goto enable_reset_failed;
}
gpio_direction_output(pdata->rawchip_reset, 1);
gpio_free(pdata->rawchip_reset);
mdelay(1);
yushan_spi_write(0x0008, 0x7f);
mdelay(1);
return rc;
enable_reset_failed:
msm_camio_clk_disable(CAMIO_CAM_MCLK_CLK);
enable_mclk_failed:
if (pdata->camera_rawchip_power_off == NULL)
pr_err("rawchip power off platform_data didn't register\n");
else
pdata->camera_rawchip_power_off();
enable_power_on_failed:
return rc;
}
int vga_camera_power_on (void)
{
int rc;
struct vreg *vreg_cam_iovdd_1_8v;
struct vreg *vreg_cam_dvdd_1_8v;
struct vreg *vreg_cam_avdd_2_8v;
printk(KERN_ERR "vga_camera_power_on\n");
gpio_set_value(CAM_VGA_GPIO_RESET_N, 1);
mdelay(1);
gpio_set_value(CAM_VGA_GPIO_PWDN, 1);
mdelay(1);
vreg_cam_iovdd_1_8v = vreg_get(NULL, "lvsw0");
vreg_enable(vreg_cam_iovdd_1_8v);
mdelay(1);
vreg_cam_avdd_2_8v = vreg_get(NULL, "gp9");
rc = vreg_set_level(vreg_cam_avdd_2_8v, 2800);
vreg_enable(vreg_cam_avdd_2_8v);
mdelay(1);
vreg_cam_dvdd_1_8v = vreg_get(NULL, "gp13");
rc = vreg_set_level(vreg_cam_dvdd_1_8v, 1800);
vreg_enable(vreg_cam_dvdd_1_8v);
mdelay(10);
/* Input MCLK = 24MHz */
msm_camio_clk_enable(CAMIO_CAM_MCLK_CLK);
mdelay(10);
gpio_set_value(CAM_VGA_GPIO_PWDN, 0);
mdelay(5);
gpio_set_value(CAM_VGA_GPIO_RESET_N, 0);
mdelay(10);
gpio_set_value(CAM_VGA_GPIO_RESET_N, 1);
mdelay(10);
return 0;
}
int32_t ov2722_power_up(struct msm_sensor_ctrl_t *s_ctrl)
{
int rc;
struct msm_camera_sensor_info *sdata = NULL;
pr_info("%s\n", __func__);
if (s_ctrl && s_ctrl->sensordata)
sdata = s_ctrl->sensordata;
else {
pr_err("%s: s_ctrl sensordata NULL\n", __func__);
return (-1);
}
if (sdata->camera_power_on == NULL) {
pr_err("sensor platform_data didnt register\n");
return -EIO;
}
rc = sdata->camera_power_on();
if (rc < 0) {
pr_err("%s failed to enable power\n", __func__);
return rc;
}
if (!sdata->use_rawchip && (sdata->htc_image != HTC_CAMERA_IMAGE_YUSHANII_BOARD)) {
rc = msm_camio_clk_enable(CAMIO_CAM_MCLK_CLK);
if (rc < 0) {
return rc;
}
}
#ifdef CONFIG_RAWCHIPII
Ilp0100_enableIlp0100SensorClock(SENSOR_1);
mdelay(3);
#endif
ov2722_sensor_open_init(sdata);
pr_info("%s end\n", __func__);
return 0;
}
int msm_camio_sensor_clk_on(struct platform_device *pdev)
{
int rc = 0;
struct msm_camera_sensor_info *sinfo = pdev->dev.platform_data;
struct msm_camera_device_platform_data *camdev = sinfo->pdata;
camio_dev = pdev;
camio_clk = camdev->ioclk;
msm_camera_vreg_enable(pdev);
if (sinfo->sensor_platform_info->privacy_light) {
struct msm8960_privacy_light_cfg *privacy_light_config =
sinfo->sensor_platform_info->privacy_light_info;
pm8xxx_mpp_config(privacy_light_config->mpp,
&privacy_light_on_config);
}
msleep(20);
rc = config_gpio_table(1);
if (rc < 0)
return rc;
return msm_camio_clk_enable(CAMIO_CAM_MCLK_CLK);
}
int msm_camio_sensor_clk_on(struct platform_device *pdev)
{
int rc = 0;
struct msm_camera_sensor_info *sinfo = pdev->dev.platform_data;
struct msm_camera_device_platform_data *camdev = sinfo->pdata;
unsigned int mclk_cfg;
camio_dev = pdev;
camio_ext = camdev->ioext;
camio_clk = camdev->ioclk;
// Disable MCLK
mclk_cfg = GPIO_CFG(32, 0, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_2MA);
gpio_tlmm_config(mclk_cfg, GPIO_CFG_ENABLE);
msm_camera_vreg_enable();
msleep(10);
rc = camdev->camera_gpio_on();
if (rc < 0)
return rc;
return msm_camio_clk_enable(CAMIO_CAM_MCLK_CLK);
}
int main_camera_power_on (void)
{
printk(KERN_ERR "%s: main_camera_power_on \n",__func__);
gpio_set_value(CAM_MAIN_GPIO_RESET_N, 0);
{
int rc;
struct vreg *vreg_cam_iovdd_1_8v;
struct vreg *vreg_cam_dvdd_1_8v;
struct vreg *vreg_cam_avdd_2_8v;
struct vreg *vreg_cam_af_2_8v;
vreg_cam_iovdd_1_8v = vreg_get(NULL, "lvsw0");
vreg_enable(vreg_cam_iovdd_1_8v);
vreg_cam_dvdd_1_8v = vreg_get(NULL, "gp13");
rc = vreg_set_level(vreg_cam_dvdd_1_8v, 1800);
vreg_enable(vreg_cam_dvdd_1_8v);
vreg_cam_af_2_8v = vreg_get(NULL, "gp2");
rc = vreg_set_level(vreg_cam_af_2_8v, 2800);
vreg_enable(vreg_cam_af_2_8v);
vreg_cam_avdd_2_8v = vreg_get(NULL, "gp9");
rc = vreg_set_level(vreg_cam_avdd_2_8v, 2800);
vreg_enable(vreg_cam_avdd_2_8v);
}
mdelay(1);
msm_camio_clk_enable(CAMIO_CAM_MCLK_CLK);
mdelay(1);
gpio_set_value(CAM_MAIN_GPIO_RESET_N, 1);
mdelay(10);
return 0;
}
int msm_camio_sensor_clk_on(struct platform_device *pdev)
{
struct msm_camera_sensor_info *sinfo = pdev->dev.platform_data;
struct msm_camera_device_platform_data *camdev = sinfo->pdata;
int32_t rc = 0;
camio_ext = camdev->ioext;
mdcio = request_mem_region(camio_ext.mdcphy,
camio_ext.mdcsz, pdev->name);
if (!mdcio)
rc = -EBUSY;
mdcbase = ioremap(camio_ext.mdcphy,
camio_ext.mdcsz);
if (!mdcbase) {
rc = -EINVAL;
goto mdc_no_mem;
}
camdev->camera_gpio_on();
return msm_camio_clk_enable(CAMIO_VFE_MDC_CLK);
mdc_no_mem:
release_mem_region(camio_ext.mdcphy, camio_ext.mdcsz);
return rc;
}
int32_t ov2722_power_up(struct msm_sensor_ctrl_t *s_ctrl)
{
int rc;
struct msm_camera_sensor_info *sdata = NULL;
pr_info("%s\n", __func__);
if (s_ctrl && s_ctrl->sensordata)
sdata = s_ctrl->sensordata;
else {
pr_err("%s: s_ctrl sensordata NULL\n", __func__);
return (-1);
}
if (sdata->camera_power_on == NULL) {
pr_err("sensor platform_data didnt register\n");
return -EIO;
}
rc = sdata->camera_power_on();
if (rc < 0) {
pr_err("%s failed to enable power\n", __func__);
return rc;
}
if (!sdata->use_rawchip) {
rc = msm_camio_clk_enable(CAMIO_CAM_MCLK_CLK);
if (rc < 0) {
return rc;
}
}
ov2722_sensor_open_init(sdata);
pr_info("%s end\n", __func__);
return 0; /*msm_sensor_power_up(sdata)*/
}
int msm_camio_enable(struct platform_device *pdev)
{
int rc = 0;
struct msm_camera_sensor_info *sinfo = pdev->dev.platform_data;
msm_camio_clk_enable(CAMIO_VFE_PBDG_CLK);
if (!sinfo->csi_if)
msm_camio_clk_enable(CAMIO_VFE_CAMIF_CLK);
else {
msm_camio_clk_enable(CAMIO_VFE_CLK);
csiio = request_mem_region(camio_ext.csiphy,
camio_ext.csisz, pdev->name);
if (!csiio) {
rc = -EBUSY;
goto common_fail;
}
csibase = ioremap(camio_ext.csiphy,
camio_ext.csisz);
if (!csibase) {
rc = -ENOMEM;
goto csi_busy;
}
rc = request_irq(camio_ext.csiirq, msm_io_csi_irq,
IRQF_TRIGGER_RISING, "csi", 0);
if (rc < 0)
goto csi_irq_fail;
/* enable required clocks for CSI */
msm_camio_clk_enable(CAMIO_CSI0_PCLK);
msm_camio_clk_enable(CAMIO_CSI0_VFE_CLK);
msm_camio_clk_enable(CAMIO_CSI0_CLK);
}
return 0;
csi_irq_fail:
iounmap(csibase);
csi_busy:
release_mem_region(camio_ext.csiphy, camio_ext.csisz);
common_fail:
msm_camio_clk_disable(CAMIO_VFE_PBDG_CLK);
msm_camio_clk_disable(CAMIO_VFE_CLK);
return rc;
}
int msm_camio_enable(struct platform_device *pdev)
{
int rc = 0;
struct msm_camera_sensor_info *sinfo = pdev->dev.platform_data;
struct msm_camera_device_platform_data *camdev = sinfo->pdata;
uint32_t val;
camio_dev = pdev;
camio_ext = camdev->ioext;
camio_clk = camdev->ioclk;
msm_camio_clk_enable(CAMIO_VFE_CLK);
msm_camio_clk_enable(CAMIO_CSI0_VFE_CLK);
msm_camio_clk_enable(CAMIO_CSI1_VFE_CLK);
msm_camio_clk_enable(CAMIO_CSI_SRC_CLK);
msm_camio_clk_enable(CAMIO_CSI0_CLK);
msm_camio_clk_enable(CAMIO_CSI1_CLK);
msm_camio_clk_enable(CAMIO_VFE_PCLK);
msm_camio_clk_enable(CAMIO_CSI0_PCLK);
msm_camio_clk_enable(CAMIO_CSI1_PCLK);
csiio = request_mem_region(camio_ext.csiphy,
camio_ext.csisz, pdev->name);
if (!csiio) {
rc = -EBUSY;
goto common_fail;
}
csibase = ioremap(camio_ext.csiphy,
camio_ext.csisz);
if (!csibase) {
rc = -ENOMEM;
goto csi_busy;
}
#ifndef CONFIG_MACH_VERDI_LTE
rc = request_irq(camio_ext.csiirq, msm_io_csi_irq,
IRQF_TRIGGER_HIGH, "csi", 0);
if (rc < 0)
goto csi_irq_fail;
#endif
msleep(10);
val = (settle_cnt<<
MIPI_PHY_D0_CONTROL2_SETTLE_COUNT_SHFT) |
(0x0F << MIPI_PHY_D0_CONTROL2_HS_TERM_IMP_SHFT) |
(0x0 << MIPI_PHY_D0_CONTROL2_LP_REC_EN_SHFT) |
(0x1 << MIPI_PHY_D0_CONTROL2_ERR_SOT_HS_EN_SHFT);
CDBG("[CAM] %s MIPI_PHY_D0_CONTROL2 val=0x%x\n", __func__, val);
msm_io_w(val, csibase + MIPI_PHY_D0_CONTROL2);
msm_io_w(val, csibase + MIPI_PHY_D1_CONTROL2);
msm_io_w(val, csibase + MIPI_PHY_D2_CONTROL2);
msm_io_w(val, csibase + MIPI_PHY_D3_CONTROL2);
val = (0x0F << MIPI_PHY_CL_CONTROL_HS_TERM_IMP_SHFT) |
(0x0 << MIPI_PHY_CL_CONTROL_LP_REC_EN_SHFT);
CDBG("[CAM] %s MIPI_PHY_CL_CONTROL val=0x%x\n", __func__, val);
msm_io_w(val, csibase + MIPI_PHY_CL_CONTROL);
return 0;
#ifndef CONFIG_MACH_VERDI_LTE
csi_irq_fail:
iounmap(csibase);
#endif
csi_busy:
release_mem_region(camio_ext.csiphy, camio_ext.csisz);
common_fail:
msm_camio_clk_disable(CAMIO_CAM_MCLK_CLK);
msm_camio_clk_disable(CAMIO_CSI0_VFE_CLK);
msm_camio_clk_disable(CAMIO_CSI0_CLK);
msm_camio_clk_disable(CAMIO_CSI1_VFE_CLK);
msm_camio_clk_disable(CAMIO_CSI1_CLK);
msm_camio_clk_disable(CAMIO_VFE_PCLK);
msm_camio_clk_disable(CAMIO_CSI0_PCLK);
msm_camio_clk_disable(CAMIO_CSI1_PCLK);
msm_camera_fs_disable();
return rc;
}
int msm_camio_enable(struct platform_device *pdev)
{
int rc = 0;
struct msm_camera_sensor_info *sinfo = pdev->dev.platform_data;
struct msm_camera_device_platform_data *camdev = sinfo->pdata;
camio_ext = camdev->ioext;
/*suggest per-sensor driver to config*/
/* camdev->camera_gpio_on(); */
msm_camio_clk_enable(CAMIO_VFE_PBDG_CLK);
msm_camio_clk_enable(CAMIO_CAMIF_PAD_PBDG_CLK);
if (!sinfo->use_rawchip) {
msm_camio_clk_enable(CAMIO_CAM_MCLK_CLK);
}
if (!sinfo->csi_if) {
msm_camio_clk_enable(CAMIO_VFE_CLK);
camifpadio = request_mem_region(camio_ext.camifpadphy,
camio_ext.camifpadsz, pdev->name);
if (!camifpadio) {
rc = -EBUSY;
goto common_fail;
}
camifpadbase = ioremap(camio_ext.camifpadphy,
camio_ext.camifpadsz);
if (!camifpadbase) {
rc = -ENOMEM;
goto parallel_busy;
}
msm_camio_clk_enable(CAMIO_VFE_CAMIF_CLK);
} else {
uint32_t val;
msm_camio_clk_enable(CAMIO_VFE_CLK_FOR_MIPI_2_LANE);
csiio = request_mem_region(camio_ext.csiphy,
camio_ext.csisz, pdev->name);
if (!csiio) {
rc = -EBUSY;
goto common_fail;
}
csibase = ioremap(camio_ext.csiphy,
camio_ext.csisz);
if (!csibase) {
rc = -ENOMEM;
goto csi_busy;
}
rc = request_irq(camio_ext.csiirq, msm_io_csi_irq,
IRQF_TRIGGER_HIGH, "csi", 0);
if (rc < 0)
goto csi_irq_fail;
/* enable required clocks for CSI */
msm_camio_clk_enable(CAMIO_CSI0_PCLK);
msm_camio_clk_enable(CAMIO_CSI0_VFE_CLK);
msm_camio_clk_enable(CAMIO_CSI0_CLK);
val = (20 << MIPI_PHY_D0_CONTROL2_SETTLE_COUNT_SHFT) |
(0x0F << MIPI_PHY_D0_CONTROL2_HS_TERM_IMP_SHFT) |
(0x0 << MIPI_PHY_D0_CONTROL2_LP_REC_EN_SHFT) |
(0x1 << MIPI_PHY_D0_CONTROL2_ERR_SOT_HS_EN_SHFT);
CDBG("[CAM] %s MIPI_PHY_D0_CONTROL2 val=0x%x\n", __func__, val);
msm_io_w(val, csibase + MIPI_PHY_D0_CONTROL2);
msm_io_w(val, csibase + MIPI_PHY_D1_CONTROL2);
msm_io_w(val, csibase + MIPI_PHY_D2_CONTROL2);
msm_io_w(val, csibase + MIPI_PHY_D3_CONTROL2);
val = (0x0F << MIPI_PHY_CL_CONTROL_HS_TERM_IMP_SHFT) |
(0x0 << MIPI_PHY_CL_CONTROL_LP_REC_EN_SHFT);
CDBG("[CAM] %s MIPI_PHY_CL_CONTROL val=0x%x\n", __func__, val);
msm_io_w(val, csibase + MIPI_PHY_CL_CONTROL);
}
return 0;
parallel_busy:
release_mem_region(camio_ext.camifpadphy, camio_ext.camifpadsz);
goto common_fail;
csi_irq_fail:
iounmap(csibase);
csi_busy:
release_mem_region(camio_ext.csiphy, camio_ext.csisz);
common_fail:
msm_camio_clk_disable(CAMIO_VFE_CLK);
msm_camio_clk_disable(CAMIO_CAM_MCLK_CLK);
msm_camio_clk_disable(CAMIO_CAMIF_PAD_PBDG_CLK);
msm_camio_clk_disable(CAMIO_VFE_PBDG_CLK);
camdev->camera_gpio_off();
return rc;
}
int32_t s5k6a2ya_power_up(struct msm_sensor_ctrl_t *s_ctrl)//(const struct msm_camera_sensor_info *sdata)
{
int rc;
struct msm_camera_sensor_info *sdata = NULL;
pr_info("%s\n", __func__);
if (s_ctrl && s_ctrl->sensordata)
sdata = s_ctrl->sensordata;
else {
pr_err("%s: s_ctrl sensordata NULL\n", __func__);
return (-1);
}
if (sdata->camera_power_on == NULL) {
pr_err("sensor platform_data didnt register\n");
return -EIO;
}
rc = sdata->camera_power_on();
if (rc < 0) {
pr_err("%s failed to enable power\n", __func__);
goto enable_power_on_failed;
}
#ifndef CONFIG_DISABLE_MCLK_RAWCHIP_TO_MAINCAM
if (!sdata->use_rawchip && (sdata->htc_image != HTC_CAMERA_IMAGE_YUSHANII_BOARD)) {
rc = msm_camio_clk_enable(sdata,CAMIO_CAM_MCLK_CLK);
if (rc < 0) {
pr_err("%s: msm_camio_clk_enable failed:%d\n",
__func__, rc);
goto enable_mclk_failed;
}
}
rc = msm_sensor_set_power_up(s_ctrl);//(sdata);
if (rc < 0) {
pr_err("%s msm_sensor_power_up failed\n", __func__);
goto set_sensor_power_up_failed;
}
#else
rc = msm_camio_clk_enable(sdata,CAMIO_CAM_MCLK_CLK);
if (rc < 0) {
pr_err("%s msm_camio_clk_enable failed\n", __func__);
goto enable_mclk_failed;
}
#endif
#ifdef CONFIG_RAWCHIPII
Ilp0100_enableIlp0100SensorClock(SENSOR_1);
mdelay(35); //temp timing setting
#endif
s5k6a2ya_sensor_open_init(sdata);
pr_info("%s end\n", __func__);
return rc;
#ifndef CONFIG_DISABLE_MCLK_RAWCHIP_TO_MAINCAM
set_sensor_power_up_failed:
msm_camio_clk_disable(sdata,CAMIO_CAM_MCLK_CLK);
#endif
enable_mclk_failed:
if (sdata->camera_power_off == NULL)
pr_err("sensor platform_data didnt register\n");
else
sdata->camera_power_off();
enable_power_on_failed:
return rc;
}
int32_t ov5693_power_up(struct msm_sensor_ctrl_t *s_ctrl)
{
int rc;
struct sensor_cfg_data cdata;
struct msm_camera_sensor_info *sdata = NULL;
pr_info(" %s\n", __func__);
if (s_ctrl && s_ctrl->sensordata)
sdata = s_ctrl->sensordata;
else {
pr_err(" %s: s_ctrl sensordata NULL\n", __func__);
return (-1);
}
if (sdata->camera_power_on == NULL) {
pr_err("sensor platform_data didnt register\n");
return -EIO;
}
if (!sdata->use_rawchip) {
rc = msm_camio_clk_enable(sdata,CAMIO_CAM_MCLK_CLK);
if (rc < 0) {
pr_err(" %s: msm_camio_sensor_clk_on failed:%d\n",
__func__, rc);
goto enable_mclk_failed;
}
}
rc = sdata->camera_power_on();
if (rc < 0) {
pr_err(" %s failed to enable power\n", __func__);
goto enable_power_on_failed;
}
rc = msm_sensor_set_power_up(s_ctrl);
if (rc < 0) {
pr_err(" %s msm_sensor_power_up failed\n", __func__);
goto enable_sensor_power_up_failed;
}
ov5693_sensor_open_init(sdata);
if (s_ctrl->func_tbl->sensor_i2c_read_fuseid == NULL) {
rc = -EFAULT;
return rc;
}
rc = s_ctrl->func_tbl->sensor_i2c_read_fuseid(&cdata, s_ctrl);
if (rc < 0) {
return rc;
}
pr_info(" %s end\n", __func__);
return rc;
enable_sensor_power_up_failed:
if (sdata->camera_power_off == NULL)
pr_err("sensor platform_data didnt register\n");
else
sdata->camera_power_off();
enable_power_on_failed:
msm_camio_clk_disable(sdata,CAMIO_CAM_MCLK_CLK);
enable_mclk_failed:
return rc;
}
int msm_camio_vpe_clk_enable(uint32_t clk_rate)
{
vpe_clk_rate = clk_rate;
msm_camio_clk_enable(CAMIO_VPE_CLK);
return 0;
}
int msm_camio_jpeg_clk_enable(void)
{
msm_camio_clk_enable(CAMIO_JPEG_CLK);
msm_camio_clk_enable(CAMIO_JPEG_PCLK);
return 0;
}
//Div2-SW6-MM-MC-BringUpHM0357ForSF5PCR-00*{
static int tcm9001md_sensor_probe(const struct msm_camera_sensor_info *info,
struct msm_sensor_ctrl *s)
{
unsigned char v;
int rc = i2c_add_driver(&tcm9001md_i2c_driver);
printk(KERN_INFO "tcm9001md_sensor_probe: Called.....\n");
if (rc < 0 || tcm9001md_client == NULL) {
rc = -ENOTSUPP;
goto probe_done;
}
tcm9001mdinfo= info;
v = 0;
/* Init VGA pins state */
#if 0
gpio_tlmm_config(GPIO_CFG(tcm9001mdinfo->vga_rst_pin, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
printk(KERN_INFO "%s: Re-set config for gpio %d .\n", __func__, tcm9001mdinfo->vga_rst_pin);
gpio_tlmm_config(GPIO_CFG(tcm9001mdinfo->vga_pwdn_pin, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
printk(KERN_INFO "%s: Re-set config for gpio %d .\n", __func__, tcm9001mdinfo->vga_pwdn_pin);
gpio_tlmm_config(GPIO_CFG(tcm9001mdinfo->vga_power_en_pin, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
printk(KERN_INFO "%s: Re-set config for gpio %d .\n", __func__, tcm9001mdinfo->vga_power_en_pin);
#endif
rc = fih_cam_output_gpio_control(tcm9001mdinfo->vga_rst_pin, "tcm9001md", 0);
if (rc)
return rc;
rc = fih_cam_output_gpio_control(tcm9001mdinfo->vga_pwdn_pin, "tcm9001md", 0);
if (rc)
return rc;
rc = fih_cam_output_gpio_control(tcm9001mdinfo->vga_power_en_pin, "tcm9001md", 0);
if (rc)
return rc;
/* Here to check sensor is existence */
msm_camio_clk_enable(CAMIO_CAM_MCLK_CLK);
msleep(30);
/* Setting MCLK = 24MHz */
msm_camio_clk_rate_set(24000000);
//msm_camio_camif_pad_reg_reset();
printk(KERN_INFO "%s: Setting MCLK = 24MHz \n", __func__);
/* Pull hight power enable = GPIO98 */
rc = fih_cam_output_gpio_control(tcm9001mdinfo->vga_power_en_pin, "tcm9001md", 1);
if (rc)
return rc;
mdelay(1); //t1+t2+t3 = 1ms
/* Pull hight PWRDWN = CAM_VGA_STANDBY */
rc = fih_cam_output_gpio_control(tcm9001mdinfo->vga_pwdn_pin, "tcm9001md", 1);
if (rc)
return rc;
mdelay(2); //t4 = 1ms
/* Enable MCLK = 24MHz */
gpio_tlmm_config(GPIO_CFG(tcm9001mdinfo->MCLK_PIN, 1, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
printk(KERN_INFO "%s: Output MCLK end. \n", __func__);
mdelay(2);
/* Pull Low PWRDWN = CAM_VGA_STANDBY */
rc = fih_cam_output_gpio_control(tcm9001mdinfo->vga_pwdn_pin, "tcm9001md", 0);
if (rc)
return rc;
mdelay(2); //t5 = 2ms
/* Pull High REDET = CAM_VGA_RST_N */
rc = fih_cam_output_gpio_control(tcm9001mdinfo->vga_rst_pin, "tcm9001md", 1);
if (rc)
return rc;
mdelay(2); //t6 > 2ms
// Here to check chip version identification.
rc = tcm9001md_i2c_read(tcm9001md_client, REG_TCM9001MD_MODEL_ID_1, &v);
if (rc < 0 || v != TCM9001MD_MODEL_ID_1)
{
printk("tcm9001md_sensor_probe: ERR: Red MODEL_ID_1 = 0x%x failed !\n", v);
goto probe_done;
}
printk("tcm9001md_sensor_probe: MODEL_ID_1 = 0x%x .\n", v);
rc = tcm9001md_i2c_read(tcm9001md_client, REG_TCM9001MD_MODEL_ID_2, &v);
if (rc < 0 || v != TCM9001MD_MODEL_ID_2)
{
printk("tcm9001md_sensor_probe: ERR: Red MODEL_ID_2 = 0x%x failed !\n", v);
goto probe_done;
}
printk("tcm9001md_sensor_probe: MODEL_ID_2 = 0x%x .\n", v);
s->s_init = tcm9001md_sensor_init;
s->s_release = tcm9001md_sensor_release;
s->s_config = tcm9001md_sensor_config;
s->s_camera_type = FRONT_CAMERA_2D;
s->s_mount_angle = 0;
probe_done:
tcm9001md_power_off();
msm_camio_clk_disable(CAMIO_CAM_MCLK_CLK);
CDBG("%s %s:%d\n", __FILE__, __func__, __LINE__);
return rc;
}
int msm_camio_vpe_clk_enable(void)
{
msm_camio_clk_enable(CAMIO_VPE_CLK);
return 0;
}
int main_camera_power_on (struct platform_device *pdev)
{
int count1, count2, rc;
struct device *dev = &pdev->dev;
printk(KERN_ERR "%s: main_camera_power_on \n",__func__);
gpio_set_value(CAM_MAIN_GPIO_RESET_N, 0);
// Turn On Main Camera Power Part1
count1 = ARRAY_SIZE(regs_main1);
rc = regulator_bulk_get(dev, count1, regs_main1);
if (rc) {
dev_err(dev, "%s: regs_main1 could not get regulators: %d\n", __func__, rc);
return 0;
}
rc = regulator_bulk_set_voltage(count1, regs_main1);
if (rc) {
dev_err(dev, "%s: regs_main1 could not set voltages: %d\n", __func__, rc);
goto reg_free1;
}
rc = regulator_bulk_enable(count1, regs_main1);
if (rc) {
dev_err(dev, "%s: regs_main1 could not enable regulators: %d\n", __func__, rc);
goto reg_free1;
}
reg_count_main1 = count1;
mdelay(20);
// Supply Clock and Make high on reset
msm_camio_clk_enable(CAMIO_CAM_MCLK_CLK);
mdelay(10);
gpio_set_value(CAM_MAIN_GPIO_RESET_N, 1);
mdelay(10);
// Turn On Main Camera Power Part2
count2 = ARRAY_SIZE(regs_main2);
rc = regulator_bulk_get(dev, count2, regs_main2);
if (rc) {
dev_err(dev, "%s: regs_main2 could not get regulators: %d\n", __func__, rc);
goto reg_free1;;
}
rc = regulator_bulk_set_voltage(count2, regs_main2);
if (rc) {
dev_err(dev, "%s: regs_main2 could not set voltages: %d\n", __func__, rc);
goto reg_free2;
}
rc = regulator_bulk_enable(count2, regs_main2);
if (rc) {
dev_err(dev, "%s: regs_main2 could not enable regulators: %d\n", __func__, rc);
goto reg_free2;
}
reg_count_main2 = count2;
mdelay(3);
return 0;
reg_free2:
regulator_bulk_free(count2, regs_main2);
reg_count_main2 = 0;
regulator_bulk_disable(reg_count_main1, regs_main1);
reg_free1:
regulator_bulk_free(count1, regs_main1);
reg_count_main1 = 0;
return 0;
}
int vga_camera_power_on (struct platform_device *pdev)
{
int count1, count2, rc;
struct device *dev = &pdev->dev;
printk(KERN_ERR "vga_camera_power_on\n");
gpio_set_value(CAM_VGA_GPIO_RESET_N, 0);
mdelay(1);
gpio_set_value(CAM_VGA_GPIO_PWDN, 0);
mdelay(1);
// Turn On Main Camera Power Part1
count1 = ARRAY_SIZE(regs_vga1);
rc = regulator_bulk_get(dev, count1, regs_vga1);
if (rc) {
dev_err(dev, "%s: regs_vga1 could not get regulators: %d\n", __func__, rc);
return 0;
}
rc = regulator_bulk_set_voltage(count1, regs_vga1);
if (rc) {
dev_err(dev, "%s: regs_vga1 could not set voltages: %d\n", __func__, rc);
goto reg_free1;
}
rc = regulator_bulk_enable(count1, regs_vga1);
if (rc) {
dev_err(dev, "%s: regs_vga1 could not enable regulators: %d\n", __func__, rc);
goto reg_free1;
}
reg_count_vga1 = count1;
// Turn On Main Camera Power Part2
count2 = ARRAY_SIZE(regs_vga2);
rc = regulator_bulk_get(dev, count2, regs_vga2);
if (rc) {
dev_err(dev, "%s: regs_vga2 could not get regulators: %d\n", __func__, rc);
goto reg_free1;;
}
rc = regulator_bulk_set_voltage(count2, regs_vga2);
if (rc) {
dev_err(dev, "%s: regs_vga2 could not set voltages: %d\n", __func__, rc);
goto reg_free2;
}
rc = regulator_bulk_enable(count2, regs_vga2);
if (rc) {
dev_err(dev, "%s: regs_vga2 could not enable regulators: %d\n", __func__, rc);
goto reg_free2;
}
reg_count_vga2 = count2;
gpio_set_value(CAM_VGA_GPIO_PWDN, 1);
mdelay(1);
msm_camio_clk_enable(CAMIO_CAM_MCLK_CLK);
mdelay(1);
gpio_set_value(CAM_VGA_GPIO_PWDN, 0);
mdelay(1);
gpio_set_value(CAM_VGA_GPIO_RESET_N, 1);
mdelay(10);
return 0;
reg_free2:
regulator_bulk_free(count2, regs_vga2);
reg_count_vga2 = 0;
regulator_bulk_disable(reg_count_vga1, regs_vga1);
reg_free1:
regulator_bulk_free(count1, regs_vga1);
reg_count_vga1 = 0;
return 0;
}
int rawchip_power_up(const struct msm_camera_rawchip_info *pdata)
{
int rc = 0;
CDBG("[CAM]%s\n", __func__);
if (pdata->camera_rawchip_power_on == NULL) {
pr_err("[CAM]rawchip power on platform_data didn't register\n");
return -EIO;
}
rc = pdata->camera_rawchip_power_on();
if (rc < 0) {
pr_err("[CAM] rawchip power on failed\n");
goto enable_power_on_failed;
}
rc = msm_camio_clk_enable(CAMIO_CAM_MCLK_CLK);
if (rc < 0) {
pr_err("[CAM] enable MCLK failed\n");
goto enable_mclk_failed;
}
mdelay(1);
#if ((defined CONFIG_I2C_CPLD) && ((defined CONFIG_MACH_DUMMY) || (defined CONFIG_MACH_DUMMY) || (defined CONFIG_MACH_DUMMY)))
pr_info("[CAM]%s rawchip reset High", __func__);
rc = cpld_gpio_write(pdata->rawchip_reset, 1);
if(rc < 0) {
pr_err("[CAM]%s: rawchip_reset fail\n", __func__);
goto enable_reset_failed;
}
mdelay(1);
#else
rc = gpio_request(pdata->rawchip_reset, "rawchip");
if (rc < 0) {
pr_err("GPIO(%d) request failed\n", pdata->rawchip_reset);
goto enable_reset_failed;
}
pr_info("[CAM]%s rawchip reset High", __func__);
gpio_direction_output(pdata->rawchip_reset, 1);
gpio_free(pdata->rawchip_reset);
mdelay(1);
#endif
yushan_spi_write(0x0008, 0x7f);
mdelay(1);
{
uint16_t uwSpiData = 0x1E00;
SPI_Write(0x1018, 2, (unsigned char*)&uwSpiData);
}
return rc;
enable_reset_failed:
msm_camio_clk_disable(CAMIO_CAM_MCLK_CLK);
enable_mclk_failed:
if (pdata->camera_rawchip_power_off == NULL)
pr_err("rawchip power off platform_data didn't register\n");
else
pdata->camera_rawchip_power_off();
enable_power_on_failed:
return rc;
}
int msm_camio_enable(struct platform_device *pdev)
{
int rc = 0;
void __iomem *clkbase;
struct msm_camera_sensor_info *sinfo = pdev->dev.platform_data;
struct msm_camera_device_platform_data *camdev = sinfo->pdata;
camio_dev = pdev;
camio_ext = camdev->ioext;
camio_clk = camdev->ioclk;
clkbase = ioremap(0x4000000, 0x334);
msm_io_w(0x0, clkbase + 0x204);
msm_io_w(0x0, clkbase + 0x208);
msm_io_w(0x0, clkbase + 0x20C);
msm_io_w(0x0, clkbase + 0x210);
/* TODO */
msm_camio_clk_enable(CAMIO_VFE_CLK);
msm_camio_clk_enable(CAMIO_CSI0_VFE_CLK);
msm_camio_clk_enable(CAMIO_CSI_SRC_CLK);
msm_camio_clk_enable(CAMIO_CSI1_SRC_CLK);
msm_camio_clk_enable(CAMIO_CSI0_CLK);
msm_camio_clk_enable(CAMIO_CSI1_CLK);
msm_camio_clk_enable(CAMIO_CSI_PIX_CLK);
msm_camio_clk_enable(CAMIO_CSI_RDI_CLK);
msm_camio_clk_enable(CAMIO_CSIPHY0_TIMER_CLK);
msm_camio_clk_enable(CAMIO_CSIPHY1_TIMER_CLK);
msm_camio_clk_enable(CAMIO_CSI0_PCLK);
csidio = request_mem_region(camio_ext.csiphy,
camio_ext.csisz, pdev->name);
if (!csidio) {
rc = -EBUSY;
goto common_fail;
}
csidbase = ioremap(camio_ext.csiphy,
camio_ext.csisz);
if (!csidbase) {
rc = -ENOMEM;
goto csi_busy;
}
rc = request_irq(camio_ext.csiirq, msm_io_csi_irq,
IRQF_TRIGGER_RISING, "csid", 0);
if (rc < 0)
goto csi_irq_fail;
csiphyio = request_mem_region(camio_ext.csiphyphy,
camio_ext.csiphysz, pdev->name);
if (!csidio) {
rc = -EBUSY;
goto csi_irq_fail;
}
csiphybase = ioremap(camio_ext.csiphyphy,
camio_ext.csiphysz);
if (!csiphybase) {
rc = -ENOMEM;
goto csiphy_busy;
}
rc = request_irq(camio_ext.csiphyirq , msm_io_csiphy_irq,
IRQF_TRIGGER_RISING, "csiphy", 0);
if (rc < 0)
goto csiphy_irq_fail;
rc = msm_ispif_init(pdev);
if (rc < 0)
goto csiphy_irq_fail;
CDBG("camio enable done\n");
return 0;
csiphy_irq_fail:
iounmap(csiphybase);
csiphy_busy:
release_mem_region(camio_ext.csiphyphy, camio_ext.csiphysz);
csi_irq_fail:
iounmap(csidbase);
csi_busy:
release_mem_region(camio_ext.csiphy, camio_ext.csisz);
common_fail:
msm_camio_clk_disable(CAMIO_CSI0_PCLK);
msm_camio_clk_disable(CAMIO_CSIPHY1_TIMER_CLK);
msm_camio_clk_disable(CAMIO_CSIPHY0_TIMER_CLK);
msm_camio_clk_disable(CAMIO_CSI_RDI_CLK);
msm_camio_clk_disable(CAMIO_CSI_PIX_CLK);
msm_camio_clk_disable(CAMIO_CSI1_CLK);
msm_camio_clk_disable(CAMIO_CSI0_CLK);
msm_camio_clk_disable(CAMIO_CSI1_SRC_CLK);
msm_camio_clk_disable(CAMIO_CSI_SRC_CLK);
msm_camio_clk_disable(CAMIO_CSI0_VFE_CLK);
msm_camio_clk_disable(CAMIO_VFE_CLK);
msm_camera_vreg_disable();
camdev->camera_gpio_off();
return rc;
}
int msm_camio_enable(struct platform_device *pdev)
{
int rc = 0;
struct msm_camera_sensor_info *sinfo = pdev->dev.platform_data;
struct msm_camera_device_platform_data *camdev = sinfo->pdata;
camio_dev = pdev;
camio_ext = camdev->ioext;
camio_clk = camdev->ioclk;
camdev->camera_gpio_on();
msm_camera_vreg_enable();
msm_camio_clk_enable(CAMIO_CAM_MCLK_CLK);
msm_camio_clk_enable(CAMIO_VFE_CLK);
msm_camio_clk_enable(CAMIO_CSI0_VFE_CLK);
msm_camio_clk_enable(CAMIO_CSI1_VFE_CLK);
msm_camio_clk_enable(CAMIO_CSI_SRC_CLK);
msm_camio_clk_enable(CAMIO_CSI0_CLK);
msm_camio_clk_enable(CAMIO_CSI1_CLK);
msm_camio_clk_enable(CAMIO_VFE_PCLK);
msm_camio_clk_enable(CAMIO_CSI0_PCLK);
msm_camio_clk_enable(CAMIO_CSI1_PCLK);
csiio = request_mem_region(camio_ext.csiphy,
camio_ext.csisz, pdev->name);
if (!csiio) {
rc = -EBUSY;
goto common_fail;
}
csibase = ioremap(camio_ext.csiphy,
camio_ext.csisz);
if (!csibase) {
rc = -ENOMEM;
goto csi_busy;
}
rc = request_irq(camio_ext.csiirq, msm_io_csi_irq,
IRQF_TRIGGER_RISING, "csi", 0);
if (rc < 0)
goto csi_irq_fail;
return 0;
csi_irq_fail:
iounmap(csibase);
csi_busy:
release_mem_region(camio_ext.csiphy, camio_ext.csisz);
common_fail:
msm_camio_clk_disable(CAMIO_CAM_MCLK_CLK);
msm_camio_clk_disable(CAMIO_CSI0_VFE_CLK);
msm_camio_clk_disable(CAMIO_CSI0_CLK);
msm_camio_clk_disable(CAMIO_CSI1_VFE_CLK);
msm_camio_clk_disable(CAMIO_CSI1_CLK);
msm_camio_clk_disable(CAMIO_VFE_PCLK);
msm_camio_clk_disable(CAMIO_CSI0_PCLK);
msm_camio_clk_disable(CAMIO_CSI1_PCLK);
/* Disable CAMIO_CSI1_VFE_CLK, CAMIO_CSI1_CLK,
CAMIO_CSI1_PCLK for the secondary sensor */
msm_camera_vreg_disable();
camdev->camera_gpio_off();
return rc;
}
