自学教程：C++ tegra_gpio_disable函数代码示例

static int cpcap_audio_probe(struct platform_device *pdev){    int rc;    pr_debug("%s/n", __func__);    cpcap = platform_get_drvdata(pdev);    BUG_ON(!cpcap);    pdata = pdev->dev.platform_data;    BUG_ON(!pdata);    if (pdata->speaker_gpio >= 0) {        tegra_gpio_enable(pdata->speaker_gpio);        rc = gpio_request(pdata->speaker_gpio, "speaker");        if (rc) {            pr_err("%s: could not get speaker GPIO %d: %d/n",                   __func__, pdata->speaker_gpio, rc);            goto fail1;        }    }    if (pdata->headset_gpio >= 0) {        tegra_gpio_enable(pdata->headset_gpio);        rc = gpio_request(pdata->headset_gpio, "headset");        if (rc) {            pr_err("%s: could not get headset GPIO %d: %d/n",                   __func__, pdata->headset_gpio, rc);            goto fail2;        }    }    pdata->state->cpcap = cpcap;    if (cpcap_audio_init(pdata->state, pdata->regulator))        goto fail3;    cpcap->h2w_new_state = &cpcap_audio_callback;    rc = misc_register(&cpcap_audio_ctl);    if (rc < 0) {        pr_err("%s: failed to register misc device: %d/n", __func__,               rc);        goto fail3;    }    return rc;fail3:    if (pdata->headset_gpio >= 0)        gpio_free(pdata->headset_gpio);fail2:    if (pdata->headset_gpio >= 0)        tegra_gpio_disable(pdata->headset_gpio);    if (pdata->speaker_gpio >= 0)        gpio_free(pdata->speaker_gpio);fail1:    if (pdata->speaker_gpio >= 0)        tegra_gpio_disable(pdata->speaker_gpio);    return rc;}

static int cardhu_dsi_panel_disable(void){	int err;	err = 0;	if (is_panel_219) {		gpio_free(cardhu_dsi_219_pnl_reset);		gpio_free(cardhu_bl_enb);		gpio_free(cardhu_bl_pwm);		gpio_free(cardhu_lvds_shutdown);	} else if (is_panel_218) {		gpio_free(cardhu_dsi_pnl_reset);	} else if (is_panel_1506) {		tegra_gpio_disable(e1506_bl_enb);		gpio_free(e1506_bl_enb);		tegra_gpio_disable(cardhu_dsi_pnl_reset);		gpio_free(cardhu_dsi_pnl_reset);		tegra_gpio_disable(e1506_panel_enb);		gpio_free(e1506_panel_enb);		tegra_gpio_disable(e1506_dsi_vddio);		gpio_free(e1506_dsi_vddio);	}	return err;}

static void tegra_sdhci_pltfm_exit(struct sdhci_host *host){	struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);	struct platform_device *pdev = to_platform_device(mmc_dev(host->mmc));	struct tegra_sdhci_platform_data *plat;	plat = pdev->dev.platform_data;	if (gpio_is_valid(plat->wp_gpio)) {		tegra_gpio_disable(plat->wp_gpio);		gpio_free(plat->wp_gpio);	}	if (gpio_is_valid(plat->cd_gpio)) {		free_irq(gpio_to_irq(plat->cd_gpio), host);		tegra_gpio_disable(plat->cd_gpio);		gpio_free(plat->cd_gpio);	}	if (gpio_is_valid(plat->power_gpio)) {		tegra_gpio_disable(plat->power_gpio);		gpio_free(plat->power_gpio);	}	clk_disable(pltfm_host->clk);	clk_put(pltfm_host->clk);}

static int cardhu_dsi_panel_disable(void){	int err;	err = 0;	printk(KERN_INFO "DSI panel disable/n");#if DSI_PANEL_219	tegra_gpio_disable(TEGRA_GPIO_PU2);	gpio_free(TEGRA_GPIO_PU2);	tegra_gpio_disable(TEGRA_GPIO_PH2);	gpio_free(TEGRA_GPIO_PH2);	tegra_gpio_disable(TEGRA_GPIO_PH0);	gpio_free(TEGRA_GPIO_PH0);	tegra_gpio_disable(TEGRA_GPIO_PL2);	gpio_free(TEGRA_GPIO_PL2);#endif#if DSI_PANEL_218	tegra_gpio_disable(TEGRA_GPIO_PD2);	gpio_free(TEGRA_GPIO_PD2);#endif	return err;}

static int __devexit sdhci_tegra_remove(struct platform_device *pdev){	struct sdhci_host *host = platform_get_drvdata(pdev);	struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);	struct sdhci_tegra *tegra_host = pltfm_host->priv;	const struct tegra_sdhci_platform_data *plat = tegra_host->plat;	int dead = (readl(host->ioaddr + SDHCI_INT_STATUS) == 0xffffffff);	sdhci_remove_host(host, dead);	if (gpio_is_valid(plat->wp_gpio)) {		tegra_gpio_disable(plat->wp_gpio);		gpio_free(plat->wp_gpio);	}	if (gpio_is_valid(plat->cd_gpio)) {		free_irq(gpio_to_irq(plat->cd_gpio), host);		tegra_gpio_disable(plat->cd_gpio);		gpio_free(plat->cd_gpio);	}	if (gpio_is_valid(plat->power_gpio)) {		tegra_gpio_disable(plat->power_gpio);		gpio_free(plat->power_gpio);	}	clk_disable(pltfm_host->clk);	clk_put(pltfm_host->clk);	sdhci_pltfm_free(pdev);	return 0;}

void blue_pincfg_uartc_resume(void) {    tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_UART3_CTS_N, TEGRA_PUPD_NORMAL);    tegra_gpio_disable(TEGRA_GPIO_PA1);    tegra_gpio_disable(TEGRA_GPIO_PC0);    tegra_gpio_disable(TEGRA_GPIO_PW6);    tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_UART3_RXD, TEGRA_PUPD_NORMAL);    tegra_gpio_disable(TEGRA_GPIO_PW7);}

static int endeavor_s5k6a1gx03_power_on(void){    int ret;    gpio_direction_output(FRONT_CAM_RST, 0);    gpio_direction_output(CAM_SEL, 0);    tegra_gpio_disable(CAM_I2C_SCL);    tegra_gpio_disable(CAM_I2C_SDA);    tegra_gpio_disable(CAM_MCLK);    /* analog */        ret = regulator_enable(cam_a2v85_en);	if (ret < 0) {		pr_err("[CAM] couldn't enable regulator cam_a2v85_en/n");		regulator_put(cam_a2v85_en);		cam_a2v85_en = NULL;		return ret;	}    ENR_usleep(200);    /* vcm */	ret = regulator_enable(cam_vcm_2v85_en);	if (ret < 0) {		pr_err("[CAM] couldn't enable regulator cam_vcm_2v85_en/n");		regulator_put(cam_vcm_2v85_en);		cam_vcm_2v85_en = NULL;		return ret;	}    ENR_usleep(200);    /* IO */	ret = regulator_enable(cam_vddio_1v8_en);	if (ret < 0) {		pr_err("[CAM] couldn't enable regulator cam_vddio_1v8_en/n");		regulator_put(cam_vddio_1v8_en);		cam_vddio_1v8_en = NULL;		return ret;	}    ENR_usleep(200);    /* RSTN */    gpio_direction_output(FRONT_CAM_RST, 1);    /* digital */	ret = regulator_enable(cam2_d1v2_en);	if (ret < 0) {		pr_err("[CAM] couldn't enable regulator cam_d1v2_en/n");		regulator_put(cam_d1v2_en);		cam_d1v2_en = NULL;		return ret;	}    /* CAM SEL */    gpio_direction_output(CAM_SEL, 1);    ENR_msleep(1);	/* SPI send command to configure RAWCHIP here! */	rawchip_spi_clock_control(1);	yushan_spi_write(0x0008, 0x7f);    return 0;}

static int endeavor_s5k6a1gx03_power_on(void){    int ret;    gpio_direction_output(FRONT_CAM_RST_GPIO, 0);    gpio_direction_output(CAM_SEL_GPIO, 0);    tegra_gpio_disable(CAM_I2C_SCL_GPIO);    tegra_gpio_disable(CAM_I2C_SDA_GPIO);    tegra_gpio_disable(CAM_MCLK_GPIO);    /* analog */    ret = regulator_enable(cam_a2v85_en);    if (ret < 0) {        pr_err("[CAM] couldn't enable regulator cam_a2v85_en/n");        regulator_put(cam_a2v85_en);        cam_a2v85_en = NULL;        return ret;    }    ENR_usleep(200);    /* vcm */    ret = regulator_enable(cam_vcm_2v85_en);    if (ret < 0) {        pr_err("[CAM] couldn't enable regulator cam_vcm_2v85_en/n");        regulator_put(cam_vcm_2v85_en);        cam_vcm_2v85_en = NULL;        return ret;    }    ENR_usleep(200);    /* IO */    ret = regulator_enable(cam_vddio_1v8_en);    if (ret < 0) {        pr_err("[CAM] couldn't enable regulator cam_vddio_1v8_en/n");        regulator_put(cam_vddio_1v8_en);        cam_vddio_1v8_en = NULL;        return ret;    }    ENR_usleep(200);    /* RSTN */    gpio_direction_output(FRONT_CAM_RST_GPIO, 1);    /* digital */    ret = regulator_enable(cam2_d1v2_en);    if (ret < 0) {        pr_err("[CAM] couldn't enable regulator cam_d1v2_en/n");        regulator_put(cam_d1v2_en);        cam_d1v2_en = NULL;        return ret;    }    /* CAM SEL */    gpio_direction_output(CAM_SEL_GPIO, 1);    ENR_msleep(1);    return 0;}

static int enterprise_dsi_panel_disable(void){	tegra_gpio_disable(enterprise_dsi_panel_bl);	gpio_free(enterprise_dsi_panel_bl);#if DSI_PANEL_RESET	tegra_gpio_disable(enterprise_dsi_panel_reset);	gpio_free(enterprise_dsi_panel_reset);#endif	return 0;}

/*disable one-wire GPIO setting*/static void disable_1wire(){	int ret;	tegra_gpio_disable(hi->pdata.rx_1wire_gpio);	tegra_gpio_disable(hi->pdata.tx_1wire_gpio);	ret = gpio_direction_output(hi->pdata.level_1wire_gpio,1);	if (ret < 0) {		printk(KERN_WARNING "[HS_UART_GPIO] %s: gpio_direction_input failed %d/n", __func__, ret);		gpio_free(hi->pdata.level_1wire_gpio);		return;	}	return;}

static int flounder_camera_init(void){	pr_debug("%s: ++/n", __func__);	tegra_io_dpd_enable(&csia_io);	tegra_io_dpd_enable(&csib_io);	tegra_io_dpd_enable(&csie_io);	tegra_gpio_disable(TEGRA_GPIO_PBB0);	tegra_gpio_disable(TEGRA_GPIO_PCC0);#if IS_ENABLED(CONFIG_SOC_CAMERA_PLATFORM)	platform_device_register(&flounder_soc_camera_device);#endif	return 0;}

static int acer_backlight_init(struct device *dev){	/* TBR: disable gpio to  change function pin */	tegra_gpio_disable(BL_PWM);	INIT_DELAYED_WORK(&bl_en_gpio,acer_backlight_work_queue);	return 0;}

static int grouper_backlight_init(struct device *dev){	int ret = 0;	bl_output = grouper_bl_output_measured;	if (WARN_ON(ARRAY_SIZE(grouper_bl_output_measured) != 256))		pr_err("bl_output array does not have 256 elements/n");	tegra_gpio_disable(grouper_bl_pwm);      /*	ret = gpio_request(grouper_bl_enb, "backlight_enb");	if (ret < 0)		return ret;	ret = gpio_direction_output(grouper_bl_enb, 1);	if (ret < 0)		gpio_free(grouper_bl_enb);	else		tegra_gpio_enable(grouper_bl_enb);	*/	return ret;};

int __init star_vibrator_init(void){	tegra_gpio_enable(TEGRA_GPIO_PU4);	tegra_gpio_disable(TEGRA_GPIO_PU3);	platform_device_register(&star_vib_device);	return	0;}

int enrc2u_wifi_sdclk (int enable){    printk("set sdio clk:%d/n",enable);    if(enable) {        tegra_gpio_disable(WIFI_SDIO_CLK);    }else{        tegra_gpio_enable(WIFI_SDIO_CLK);        gpio_direction_output(WIFI_SDIO_CLK, 0);    }}

static void __exit simdet_switch_exit(void){	printk(KERN_INFO "simdet_switch driver unregister/n");	platform_driver_unregister(&simdet_switch_driver);#if defined(CONFIG_ARCH_ACER_T30)	// disable 3G_DISABLE PIN (TEGRA_GPIO_PI7)	tegra_gpio_disable(TEGRA_GPIO_PI7);#endif}

static int enable_wifi_sdio_func(void){	int i = 0;	for (i = 0; i < ARRAY_SIZE(wifi_sdio_gpio); i++) {		tegra_gpio_disable(wifi_sdio_gpio[i]);		gpio_free(wifi_sdio_gpio[i]);	}	return 0;}

static void ast_panel_early_suspend(struct early_suspend *h){	/* power down LCD, add use a black screen for HDMI */	if (num_registered_fb > 0)		fb_blank(registered_fb[0], FB_BLANK_POWERDOWN);	if (num_registered_fb > 1)		fb_blank(registered_fb[1], FB_BLANK_NORMAL);	tegra_gpio_disable(AST_HDMI_HPD);}

static void tegra_gpio_config(struct tegra_gpio_table* tab, int size){    int i;    for (i = 0; i < size; i++) {        if (tab[i].enable) {            tegra_gpio_enable(tab[i].gpio);        } else {            tegra_gpio_disable(tab[i].gpio);        }    }}

static int enterprise_dsi_panel_disable(void){#if DSI_PANEL_RESET	if (kernel_1st_panel_init != true) {		tegra_gpio_disable(enterprise_dsi_panel_reset);		gpio_free(enterprise_dsi_panel_reset);	} else		kernel_1st_panel_init = false;#endif	return 0;}

static void kai_backlight_exit(struct device *dev){	/* int ret; */	/*ret = gpio_request(kai_vdd_bl_enb, "backlight_enb");*/	gpio_set_value(kai_vdd_bl_enb, 0);#if 0 //Kai, 20120607, JimmySu remove unsed setting	gpio_free(kai_vdd_bl_enb);	tegra_gpio_disable(kai_vdd_bl_enb);#endif	return;}

static int wm8994_i2c_remove(struct i2c_client *i2c){	struct wm8994 *wm8994 = i2c_get_clientdata(i2c);#if defined(CONFIG_ARCH_TEGRA)	tegra_gpio_disable(GPIO_WM8994_LDO_EN);	gpio_free(GPIO_WM8994_LDO_EN);#endif /* defined(CONFIG_ARCH_TEGRA) */	wm8994_device_exit(wm8994);	return 0;}

static int vibrator_resume(struct platform_device *pdev){	struct vibrator *vib = platform_get_drvdata(pdev);	D("vibrator_resume +++/n");	if(vib->pdata->pwm_gpio >= 0) {		tegra_gpio_disable(vib->pdata->pwm_gpio);		vib->pwm_duty = PLAYBACK_DUTY_US;	}	D("vibrator_resume ---/n");	return 0;}

int get_pin_value(unsigned int gpio, char *name){	int pin_value = 0;	tegra_gpio_enable(gpio);	gpio_request(gpio, name);	gpio_direction_input(gpio);	pin_value = gpio_get_value(gpio);	gpio_free(gpio);	tegra_gpio_disable(gpio);	return pin_value;}

static void endeavortd_config_bt_on(void){	printk(KERN_INFO "[BT]== R ON ==/n");	tegra_gpio_disable(ENDEAVORTD_GPIO_BT_UART3_CTS);	tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_UART3_CTS_N, TEGRA_PUPD_NORMAL);	tegra_gpio_disable(ENDEAVORTD_GPIO_BT_UART3_RTS);	tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_UART3_RTS_N, TEGRA_PUPD_NORMAL);	tegra_gpio_disable(ENDEAVORTD_GPIO_BT_UART3_TX);	tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_UART3_TXD, TEGRA_PUPD_NORMAL);	tegra_gpio_disable(ENDEAVORTD_GPIO_BT_UART3_RX);	tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_UART3_RXD, TEGRA_PUPD_NORMAL);	/* BT_RTS */	/* BT_CTS */	/* BT_TX */	/* BT_RX */	/* BT_HOST_WAKE */	tegra_pinmux_set_pullupdown(TEGRA_PINGROUP_ULPI_DATA4, TEGRA_PUPD_PULL_UP);	/* BT_CHIP_WAKE */	gpio_set_value(ENDEAVORTD_GPIO_BT_WAKE, 1);	/* BT_SHUTDOWN_N */	gpio_set_value(ENDEAVORTD_GPIO_BT_SHUTDOWN_N, 0);	mdelay(5);	/* BT_SHUTDOWN_N */	gpio_set_value(ENDEAVORTD_GPIO_BT_SHUTDOWN_N, 1);	mdelay(1);}