C++ (Cpp) msm_camio_clk_disable 예제들

예제 #1

파일: msm_io_vfe31.c 프로젝트: ARMP/samsung_kernel_cooper

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;
}

예제 #2

파일: rawchip.c 프로젝트: bilalliberty/android_kernel_htc_K2UL

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;
	}

#ifdef CONFIG_RAWCHIP_MCLK
	rc = msm_camio_clk_enable(CAMIO_CAM_RAWCHIP_MCLK_CLK);
#else
	rc = msm_camio_clk_enable(CAMIO_CAM_MCLK_CLK);
#endif

	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:
#ifdef CONFIG_RAWCHIP_MCLK
	rc = msm_camio_clk_disable(CAMIO_CAM_RAWCHIP_MCLK_CLK);
#else
	rc = msm_camio_clk_disable(CAMIO_CAM_MCLK_CLK);
#endif

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;
}

예제 #3

파일: msm_io7x.c 프로젝트: 325116067/semc-qsd8x50

void msm_camio_disable(struct platform_device *pdev)
{
	struct msm_camera_sensor_info *sinfo = pdev->dev.platform_data;
	struct msm_camera_device_platform_data *camdev = sinfo->pdata;

	iounmap(appbase);
	release_mem_region(camio_ext.appphy, camio_ext.appsz);
	msm_camio_clk_disable(CAMIO_VFE_CLK);
	msm_camio_clk_disable(CAMIO_MDC_CLK);
}

예제 #4

파일: msm_io8x.c 프로젝트: FPChaim/android_kernel_lge_msm7x27-3.0.x

int msm_camio_sensor_clk_off(struct platform_device *pdev)
{
	struct msm_camera_sensor_info *sinfo = pdev->dev.platform_data;
	struct msm_camera_device_platform_data *camdev = sinfo->pdata;
	camdev->camera_gpio_off();
	iounmap(mdcbase);
	release_mem_region(camio_ext.mdcphy, camio_ext.mdcsz);
	msm_camio_clk_disable(CAMIO_VFE_CLK);
	return msm_camio_clk_disable(CAMIO_VFE_MDC_CLK);

}

예제 #5

int msm_camio_jpeg_clk_disable(void)
{
    int rc = 0;
    if (fs_ijpeg) {
        regulator_disable(fs_ijpeg);
        regulator_put(fs_ijpeg);
    }
    rc = msm_camio_clk_disable(CAMIO_JPEG_CLK);
    if (rc < 0)
        return rc;
    rc = msm_camio_clk_disable(CAMIO_JPEG_PCLK);
    return rc;
}

예제 #6

void msm_camio_disable(struct platform_device *pdev)
{
	iounmap(appbase);
	release_mem_region(camio_ext.appphy, camio_ext.appsz);

#if 1 //kk0704.park
	gpio_set_value(0, 0);//RESET    
	msleep(1);
	msm_camio_clk_sel(MSM_CAMIO_CLK_SRC_INTERNAL);
#endif
	msm_camio_clk_disable(CAMIO_VFE_CLK);
	msm_camio_clk_disable(CAMIO_MDC_CLK);
}

예제 #7

파일: msm_io_8x60.c 프로젝트: CSRedRat/CM-LG-L5_Kernel

int msm_camio_vpe_clk_disable(void)
{
	int rc = 0;
	if (fs_vpe) {
		regulator_disable(fs_vpe);
		regulator_put(fs_vpe);
	}

	rc = msm_camio_clk_disable(CAMIO_VPE_CLK);
	if (rc < 0)
		return rc;
	rc = msm_camio_clk_disable(CAMIO_VPE_PCLK);
	return rc;
}

예제 #8

파일: msm_io_vfe31.c 프로젝트: Soaa-/lightspeed-vision-2

void msm_camio_disable(struct platform_device *pdev)
{
	struct msm_camera_sensor_info *sinfo = pdev->dev.platform_data;
	struct msm_camera_device_platform_data *camdev = sinfo->pdata;

	if (!sinfo->csi_if) {
		msm_camio_clk_disable(CAMIO_VFE_CAMIF_CLK);
		iounmap(camifpadbase);
		release_mem_region(camio_ext.camifpadphy, camio_ext.camifpadsz);
	} else {
		free_irq(camio_ext.csiirq, 0);
		msm_camio_clk_disable(CAMIO_CSI_PCLK);
		msm_camio_clk_disable(CAMIO_CSI_VFE_CLK);
		msm_camio_clk_disable(CAMIO_CSI_CLK);
		iounmap(csibase);
		release_mem_region(camio_ext.csiphy, camio_ext.csisz);
	}
	CDBG("disable clocks\n");

	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();
}

예제 #9

파일: msm_io_7x30.c 프로젝트: Flemmard/htc7x30-3.0

int msm_camio_probe_off(struct platform_device *pdev)
{
	struct msm_camera_sensor_info *sinfo = pdev->dev.platform_data;
	struct msm_camera_device_platform_data *camdev = sinfo->pdata;
#ifdef CONFIG_MACH_GOLFC
	int rc = 0;
	rc = msm_camio_clk_disable(CAMIO_CAM_MCLK_CLK);
	camdev->camera_gpio_off();
	return rc;
#else
	camdev->camera_gpio_off();
	return msm_camio_clk_disable(CAMIO_CAM_MCLK_CLK);
#endif
}

예제 #10

파일: ov2722_v4l2.c 프로젝트: boa19861105/android_442_KitKat_kernel_htc_dlxpul

int32_t ov2722_power_down(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_off == NULL) {
		pr_err("sensor platform_data didnt register\n");
		return -EIO;
	}

	if (!sdata->use_rawchip && (sdata->htc_image != HTC_CAMERA_IMAGE_YUSHANII_BOARD)) {
		msm_camio_clk_disable(sdata,CAMIO_CAM_MCLK_CLK);
	}
	rc = sdata->camera_power_off();
	if (rc < 0) {
		pr_err("%s failed to disable power\n", __func__);
		return rc;
	}
	return 0;  
}

예제 #11

파일: board-victor-camera.c 프로젝트: Bengineered/kernel-lge-msm7x30

int vga_camera_power_off (void)
{
    struct vreg *vreg_cam_iovdd_1_8v;
    struct vreg *vreg_cam_dvdd_1_8v;
    struct vreg *vreg_cam_avdd_2_8v;

    gpio_set_value(CAM_VGA_GPIO_RESET_N, 0);
    mdelay(1);

    gpio_set_value(CAM_VGA_GPIO_PWDN, 0);
    mdelay(5);

    msm_camio_clk_disable(CAMIO_CAM_MCLK_CLK);
    mdelay(5);


    vreg_cam_dvdd_1_8v = vreg_get(NULL, "gp13");
    vreg_disable(vreg_cam_dvdd_1_8v);

    vreg_cam_avdd_2_8v = vreg_get(NULL, "gp9");
    vreg_disable(vreg_cam_avdd_2_8v);

    vreg_cam_iovdd_1_8v = vreg_get(NULL, "lvsw0");
    vreg_disable(vreg_cam_iovdd_1_8v);

    mdelay(10);
	
    printk(KERN_ERR "vga_camera_power_off\n");
    
    return 0;        
}

예제 #12

파일: board-victor-camera.c 프로젝트: Bengineered/kernel-lge-msm7x30

int main_camera_power_off (void)
{
    printk(KERN_ERR "%s: main_camera_power_off \n",__func__);

    gpio_set_value(CAM_MAIN_GPIO_RESET_N, 0);
    mdelay(1);
    
    msm_camio_clk_disable(CAMIO_CAM_MCLK_CLK);
    mdelay(1);
    
    {
        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_af_2_8v = vreg_get(NULL, "gp2");
        vreg_disable(vreg_cam_af_2_8v);

        vreg_cam_avdd_2_8v = vreg_get(NULL, "gp9");
        vreg_disable(vreg_cam_avdd_2_8v);

        vreg_cam_dvdd_1_8v = vreg_get(NULL, "gp13");
        vreg_disable(vreg_cam_dvdd_1_8v);
        
        vreg_cam_iovdd_1_8v = vreg_get(NULL, "lvsw0");
        vreg_disable(vreg_cam_iovdd_1_8v);
    }

    return 0;
}

예제 #13

int32_t s5k6a1gx_power_down(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_off == NULL) {
		pr_err("sensor platform_data didnt register\n");
		return -EIO;
	}

		msm_camio_clk_disable(sdata,CAMIO_CAM_MCLK_CLK);

	rc = sdata->camera_power_off();
	if (rc < 0) {
		pr_err("%s failed to disable power\n", __func__);
		return rc;
	}
	return 0;  
}

예제 #14

파일: msm_io7x.c 프로젝트: OpenSwift/android_kernel_swift

void msm_camio_disable(struct platform_device *pdev)
{
	struct msm_camera_sensor_info *sinfo = pdev->dev.platform_data;
	struct msm_camera_device_platform_data *camdev = sinfo->pdata;

	iounmap(mdcbase);
	release_mem_region(camio_ext.mdcphy, camio_ext.mdcsz);
	iounmap(appbase);
	release_mem_region(camio_ext.appphy, camio_ext.appsz);

	camdev->camera_gpio_off();
	msm_camio_clk_sel(MSM_CAMIO_CLK_SRC_INTERNAL);
	msm_camio_clk_disable(CAMIO_VFE_CLK);
	msm_camio_clk_disable(CAMIO_MDC_CLK);
	msm_camio_clk_disable(CAMIO_VFE_MDC_CLK);
}

예제 #15

파일: msm_io_7x30.c 프로젝트: Ll0ir/htc_kernel_msm7x30

int msm_camio_probe_off(struct platform_device *pdev)
{
	struct msm_camera_sensor_info *sinfo = pdev->dev.platform_data;
	struct msm_camera_device_platform_data *camdev = sinfo->pdata;
	camdev->camera_gpio_off();
	return msm_camio_clk_disable(CAMIO_CAM_MCLK_CLK);
}

예제 #16

파일: rawchip.c 프로젝트: talnoah/Lemur_cm-11.0

int rawchip_power_down(const struct msm_camera_rawchip_info *pdata)
{
	int rc = 0;
	CDBG("%s\n", __func__);

	rc = gpio_request(pdata->rawchip_reset, "rawchip");
	if (rc < 0)
		pr_err("GPIO(%d) request failed\n", pdata->rawchip_reset);
	gpio_direction_output(pdata->rawchip_reset, 0);
	gpio_free(pdata->rawchip_reset);

	mdelay(1);

	rc = msm_camio_clk_disable(CAMIO_CAM_MCLK_CLK);
	if (rc < 0)
		pr_err("disable MCLK failed\n");

	if (pdata->camera_rawchip_power_off == NULL) {
		pr_err("rawchip power off platform_data didn't register\n");
		return -EIO;
	}

	rc = pdata->camera_rawchip_power_off();
	if (rc < 0)
		pr_err("rawchip power off failed\n");

	return rc;
}

예제 #17

파일: ov2722_v4l2.c 프로젝트: Snuzzo/funky_dna_old

int32_t ov2722_power_down(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_off == NULL) {
		pr_err("sensor platform_data didnt register\n");
		return -EIO;
	}

	if (!sdata->use_rawchip) {
		msm_camio_clk_disable(CAMIO_CAM_MCLK_CLK);
	}
	rc = sdata->camera_power_off();
	if (rc < 0) {
		pr_err("%s failed to disable power\n", __func__);
		return rc;
	}
	return 0;  /*msm_sensor_power_down(sdata);*/
}

예제 #18

파일: msm_io_vfe31.c 프로젝트: Shabbypenguin/Cayman-Island-Kernel

int msm_camio_sensor_clk_off(struct platform_device *pdev)
{
	uint32_t rc = 0;
	struct msm_camera_sensor_info *sinfo = pdev->dev.platform_data;
	struct msm_camera_device_platform_data *camdev = sinfo->pdata;
	camdev->camera_gpio_off();
	msm_camera_vreg_disable();
	rc = msm_camio_clk_disable(CAMIO_CAM_MCLK_CLK);
	rc = msm_camio_clk_disable(CAMIO_CAMIF_PAD_PBDG_CLK);
	if (!sinfo->csi_if) {
		iounmap(camifpadbase);
		release_mem_region(camio_ext.camifpadphy, camio_ext.camifpadsz);
		rc = msm_camio_clk_disable(CAMIO_VFE_CLK);
	}
	return rc;
}

예제 #19

파일: ov5693_v4l2.c 프로젝트: curbthepain/NuK3rn3l_m7_sense_lollipop

int32_t ov5693_power_down(struct msm_sensor_ctrl_t *s_ctrl)
{
	int rc = 0;
	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_off == NULL) {
		pr_err(" %s: sensor platform_data didn't register\n", __func__);
		return -EIO;
	}

	rc = sdata->camera_power_off();
	if (rc < 0) {
		pr_err(" %s failed to disable power\n", __func__);
	}
	rc = msm_sensor_set_power_down(s_ctrl);
	if (rc < 0)
		pr_err("%s msm_sensor_power_down failed\n", __func__);

	if (!sdata->use_rawchip) {
		msm_camio_clk_disable(sdata,CAMIO_CAM_MCLK_CLK);
		if (rc < 0)
			pr_err(" %s: msm_camio_clk_disable failed:%d\n",
				 __func__, rc);
	}

	return rc;
}

예제 #20

파일: msm_io7x.c 프로젝트: thornbirdblue/8064_kernel

void msm_camio_disable(struct platform_device *pdev)
{
	struct msm_camera_device_platform_data *camdev =
		pdev->dev.platform_data;

	iounmap(mdcbase);
	release_mem_region(camio_ext.mdcphy, camio_ext.mdcsz);
	iounmap(appbase);
	release_mem_region(camio_ext.appphy, camio_ext.appsz);

	camdev->camera_gpio_off();

	msm_camio_clk_disable(CAMIO_VFE_CLK);
	msm_camio_clk_disable(CAMIO_MDC_CLK);
	msm_camio_clk_disable(CAMIO_VFE_MDC_CLK);
}

예제 #21

파일: msm_io_7x27a_v4l2.c 프로젝트: ColonelSaumon/android_kernel_nokia_msm8x25

static int __devinit clkctl_probe(struct platform_device *pdev)
{
	int rc = 0;

	apps_reset = *(int *)pdev->dev.platform_data;
	clk_ctrl_mem = platform_get_resource_byname(pdev,
					IORESOURCE_MEM, "clk_ctl");
	if (!clk_ctrl_mem) {
		pr_err("%s: no mem resource:3?\n", __func__);
		return -ENODEV;
	}

	appbase = ioremap(clk_ctrl_mem->start,
		resource_size(clk_ctrl_mem));
	if (!appbase) {
		pr_err("clkctl_probe: appbase:err\n");
		rc = -ENOMEM;
		goto ioremap_fail;
	}
	return 0;

ioremap_fail:
	msm_camio_clk_disable(CAMIO_CAM_MCLK_CLK);
	return rc;
}

예제 #22

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;
	cam_bus_scale_table = camdev->cam_bus_scale_table;

	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 = csi_request_irq();
	if (rc < 0)
		goto csi_irq_fail;

	return 0;

csi_irq_fail:
	iounmap(csibase);
	csibase = NULL;
csi_busy:
	release_mem_region(camio_ext.csiphy, camio_ext.csisz);
	csibase = NULL;
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_vreg_disable();
	camdev->camera_gpio_off();
	return rc;
}

예제 #23

int msm_camio_probe_off(struct platform_device *pdev)
{
	struct msm_camera_device_platform_data *camdev =
		pdev->dev.platform_data;

	camdev->camera_gpio_off();
	return msm_camio_clk_disable(CAMIO_VFE_CLK);
}

예제 #24

void msm_camio_disable(struct platform_device *pdev)
{
	uint32_t val;

	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);
	msleep(10);

	free_irq(camio_ext.csiirq, 0);
	iounmap(csibase);
	release_mem_region(camio_ext.csiphy, camio_ext.csisz);
	CDBG("disable clocks\n");

	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);
}

예제 #25

파일: msm_io_8960.c 프로젝트: desalesouche/kernel_huawei

int msm_camio_probe_off(struct platform_device *pdev)
{
	int rc = 0;
	msm_camera_vreg_disable();
	rc = config_gpio_table(0);
	if (rc < 0)
		return rc;
	return msm_camio_clk_disable(CAMIO_CAM_MCLK_CLK);
}

예제 #26

파일: msm_io_8x60.c 프로젝트: CSRedRat/CM-LG-L5_Kernel

int msm_camio_jpeg_clk_disable(void)
{
	int rc = 0;
	if (fs_ijpeg) {
		rc = regulator_disable(fs_ijpeg);
		if (rc < 0) {
			CDBG("%s: Regulator disable failed %d\n", __func__, rc);
			return rc;
		}
		regulator_put(fs_ijpeg);
	}
	rc = msm_camio_clk_disable(CAMIO_JPEG_PCLK);
	if (rc < 0)
		return rc;
	rc = msm_camio_clk_disable(CAMIO_JPEG_CLK);
	CDBG("%s: exit %d\n", __func__, rc);
	return rc;
}

예제 #27

파일: msm_io_vfe31.c 프로젝트: Aarush/shardul-xperia-4.1.B.0.431

int msm_camio_sensor_clk_off(struct platform_device *pdev)
{
	uint32_t rc = 0;
	struct msm_camera_sensor_info *sinfo = pdev->dev.platform_data;
	struct msm_camera_device_platform_data *camdev = sinfo->pdata;
	camdev->camera_gpio_off();
#if !defined(CONFIG_SEMC_CAMERA_MODULE) && \
	!defined(CONFIG_SEMC_SUB_CAMERA_MODULE)
	rc = msm_camio_clk_disable(CAMIO_CAM_MCLK_CLK);
#endif
	rc = msm_camio_clk_disable(CAMIO_CAMIF_PAD_PBDG_CLK);
	if (!sinfo->csi_if) {
		iounmap(camifpadbase);
		release_mem_region(camio_ext.camifpadphy, camio_ext.camifpadsz);
		rc = msm_camio_clk_disable(CAMIO_VFE_CLK);
	}
	return rc;
}

예제 #28

파일: msm_io_8x60.c 프로젝트: marduk191/android_kernel_pantech_msm8660-common

int msm_camio_sensor_clk_off(struct platform_device *pdev)
{
	struct msm_camera_sensor_info *sinfo = pdev->dev.platform_data;
	struct msm_camera_device_platform_data *camdev = sinfo->pdata;
	unsigned int mclk_cfg;
#if !defined (CONFIG_SENSOR_ISX012)
	int rc = 0;
#endif

	pr_info("%s\n", __func__);

#if !defined (CONFIG_SENSOR_ISX012)
	//reset low
	if (sinfo->sensor_platform_info->sensor_reset) {
		gpio_set_value_cansleep(sinfo->sensor_platform_info->sensor_reset, 0);
	}
	msleep(3);

	// 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);	

	// ldo off
	if (sinfo->sensor_platform_info->sensor_power_control(0)){
		pr_info("power off ldo fail\n");
		// false routine
	}
	
	msm_camera_vreg_disable();
	camdev->camera_gpio_off();
	rc = msm_camio_clk_disable(CAMIO_CAM_MCLK_CLK);
	pr_info("%s : X\n", __func__);
	return rc;

#else
	// 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_disable();
	camdev->camera_gpio_off();
	return msm_camio_clk_disable(CAMIO_CAM_MCLK_CLK);
#endif

}

예제 #29

void msm_camio_disable(struct platform_device *pdev)
{
	uint32_t val;
	val = (0x0 << MIPI_CALIBRATION_CONTROL_SWCAL_CAL_EN_SHFT) |
		(0x0 <<
		MIPI_CALIBRATION_CONTROL_SWCAL_STRENGTH_OVERRIDE_EN_SHFT) |
		(0x0 << MIPI_CALIBRATION_CONTROL_CAL_SW_HW_MODE_SHFT) |
		(0x0 << MIPI_CALIBRATION_CONTROL_MANUAL_OVERRIDE_EN_SHFT);
	CDBG("%s MIPI_CALIBRATION_CONTROL val=0x%x\n", __func__, val);
	msm_io_w(val, csibase + MIPI_CALIBRATION_CONTROL);

	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);
	msleep(10);

	val = msm_io_r(csibase + MIPI_PHY_D1_CONTROL);
	val &= ~((0x1 << MIPI_PHY_D1_CONTROL_MIPI_CLK_PHY_SHUTDOWNB_SHFT) |
	(0x1 << MIPI_PHY_D1_CONTROL_MIPI_DATA_PHY_SHUTDOWNB_SHFT));
	CDBG("%s MIPI_PHY_D1_CONTROL val=0x%x\n", __func__, val);
	msm_io_w(val, csibase + MIPI_PHY_D1_CONTROL);
	usleep_range(5000, 6000);
	free_irq(camio_ext.csiirq, 0);
	iounmap(csibase);
	release_mem_region(camio_ext.csiphy, camio_ext.csisz);
	CDBG("disable clocks\n");

	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_camio_clk_disable(CAMIO_CSI_SRC_CLK);
	msm_camio_clk_disable(CAMIO_VFE_CLK);
}

예제 #30

파일: msm_io_8x60.c 프로젝트: CSRedRat/CM-LG-L5_Kernel

void msm_camio_disable(struct platform_device *pdev)
{
	CDBG("disable mipi\n");
	msm_camio_csi_disable();
	CDBG("disable clocks\n");
	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_camio_clk_disable(CAMIO_CSI_SRC_CLK);
	msm_camio_clk_disable(CAMIO_VFE_CLK);
}