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

void sku3_lcdc_lcd_camera_power_init(void){	int rc = 0;	u32 socinfo = socinfo_get_platform_type();	  /* LDO_EXT2V8 */	if (gpio_request(SKU3_LCDC_LCD_CAMERA_LDO_2V8, "lcd_camera_ldo_2v8")) {		pr_err("failed to request gpio lcd_camera_ldo_2v8/n");		return;	}	rc = gpio_tlmm_config(GPIO_CFG(SKU3_LCDC_LCD_CAMERA_LDO_2V8, 0,		GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA),		GPIO_CFG_ENABLE);	if (rc < 0) {		pr_err("%s:unable to enable lcd_camera_ldo_2v8!/n", __func__);		goto fail_gpio2;	}	/* LDO_EVT1V8 */	if (socinfo == 0x0B) {		if (gpio_request(SKU3_LCDC_LCD_CAMERA_LDO_1V8,				"lcd_camera_ldo_1v8")) {			pr_err("failed to request gpio lcd_camera_ldo_1v8/n");			goto fail_gpio1;		}		rc = gpio_tlmm_config(GPIO_CFG(SKU3_LCDC_LCD_CAMERA_LDO_1V8, 0,			GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA),			GPIO_CFG_ENABLE);		if (rc < 0) {			pr_err("%s: unable to enable lcdc_camera_ldo_1v8!/n",				__func__);			goto fail_gpio1;		}	} else if (socinfo == 0x0F || machine_is_msm8625_qrd7()) {		if (gpio_request(SKU3_1_LCDC_LCD_CAMERA_LDO_1V8,				"lcd_camera_ldo_1v8")) {			pr_err("failed to request gpio lcd_camera_ldo_1v8/n");			goto fail_gpio1;		}		rc = gpio_tlmm_config(GPIO_CFG(SKU3_1_LCDC_LCD_CAMERA_LDO_1V8,			0, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA),			GPIO_CFG_ENABLE);		if (rc < 0) {			pr_err("%s: unable to enable lcdc_camera_ldo_1v8!/n",				__func__);			goto fail_gpio1;		}	}	rc = regulator_bulk_get(NULL, ARRAY_SIZE(regs_truly_lcdc),			regs_truly_lcdc);	if (rc)		pr_err("%s: could not get regulators: %d/n", __func__, rc);	rc = regulator_bulk_set_voltage(ARRAY_SIZE(regs_truly_lcdc),			regs_truly_lcdc);	if (rc)		pr_err("%s: could not set voltages: %d/n", __func__, rc);	return;fail_gpio1:	if (socinfo == 0x0B)		gpio_free(SKU3_LCDC_LCD_CAMERA_LDO_1V8);	else if (socinfo == 0x0F || machine_is_msm8625_qrd7())		gpio_free(SKU3_1_LCDC_LCD_CAMERA_LDO_1V8);fail_gpio2:	gpio_free(SKU3_LCDC_LCD_CAMERA_LDO_2V8);	return;}

static int init_gpios(void){    int ret;    struct gpio_switch_data *p = head;    while(p){	    ret = gpio_tlmm_config(GPIO_CFG(p->gpio, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_UP, GPIO_CFG_2MA),GPIO_CFG_ENABLE);	    if (ret){	    	pr_err("Could not configure gpio %d/n", p->gpio);            return -EINVAL;        }        gpio_request(p->gpio , p->name);        if(p->event_mode == PAN_INPUTEVENT){            p->input_dev = input_allocate_device();            if(p->input_dev == NULL){                pr_err("switch_gpio failed to allocate input device/n");                return -ENOMEM;            }            p->input_dev->name = p->name;	        set_bit(EV_SW, p->input_dev->evbit);	        set_bit(SW_LID, p->input_dev->swbit);            ret = input_register_device(p->input_dev);            if(ret){                pr_err("switch_gpio unable to register %s input device/n", p->input_dev->name);                return -EINVAL;            }        }        else if(p->event_mode == PAN_UEVENT){            p->sdev.print_state = gpio_switch_print_state;            p->sdev.name = p->name;            ret = switch_dev_register(&p->sdev);            if(ret < 0){                pr_err("%s Switch dev register is failed/n" , p->sdev.name);                return -EINVAL;            }        }        else{            pr_err("event_mode : %d does not exist/n" , p->event_mode);             return -EINVAL;        }        p->current_state = gpio_get_value(p->gpio) ^ p->flag;        if(p->event_mode == PAN_INPUTEVENT){            dbg("INPUTEVENT %s sent event : %d/n" , p->name , p->current_state);            input_report_switch(p->input_dev , SW_LID , p->current_state);            input_sync(p->input_dev);        }        else if(p->event_mode == PAN_UEVENT){            dbg("UEVENT %s sent event : %d/n" , p->name , p->current_state);            switch_set_state(&p->sdev , p->current_state);        }        p->last_state = p->current_state;        ret = request_threaded_irq(p->irq , NULL , gpio_switch_irq_handler , IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING , p->name , p);        if(ret){            pr_err("%s request_irq is failed reason : %d/n" , p->name , ret);            return -EINVAL;        }                hrtimer_init(&p->timer , CLOCK_MONOTONIC , HRTIMER_MODE_REL);        p->timer.function = gpio_switch_timer_func;        p->debounce = DEBOUNCE_UNKNOWN | DEBOUNCE_WAIT_IRQ;        p->debounce_count = 0;        p->notify = NULL;        p->emergency_notify = NULL;        INIT_WORK(&p->work , gpio_switch_work);        wake_lock_init(&p->wakelock, WAKE_LOCK_SUSPEND, p->name);        enable_irq_wake(p->irq);        p->disabled = false;                p = p->next;    }    return 0;}

static int max77803_i2c_probe(struct i2c_client *i2c,			      const struct i2c_device_id *id){	struct max77803_dev *max77803;	struct max77803_platform_data *pdata;	u8 reg_data;	int ret = 0;	dev_info(&i2c->dev, "%s/n", __func__);	max77803 = kzalloc(sizeof(struct max77803_dev), GFP_KERNEL);	if (max77803 == NULL)		return -ENOMEM;	if (i2c->dev.of_node) {		pdata = devm_kzalloc(&i2c->dev,				sizeof(struct max77803_platform_data),				GFP_KERNEL);		if (!pdata) {			dev_err(&i2c->dev, "Failed to allocate memory /n");			ret = -ENOMEM;			goto err;		}		ret = of_max77803_dt(&i2c->dev, pdata);		if (ret < 0){			dev_err(&i2c->dev, "Failed to get device of_node /n");			return ret;		}		/*Filling the platform data*/		pdata->num_regulators = MAX77803_REG_MAX;		pdata->muic_data = &max77803_muic;		pdata->charger_data = &sec_battery_pdata;		pdata->regulators = max77803_regulators,#ifdef CONFIG_VIBETONZ		pdata->haptic_data = &max77803_haptic_pdata;#endif		pdata->led_data = &max77803_led_pdata;		/* set irq_base at sec_battery_pdata */		sec_battery_pdata.bat_irq = pdata->irq_base + MAX77803_CHG_IRQ_BATP_I;		/*pdata update to other modules*/		i2c->dev.platform_data = pdata;	} else		pdata = i2c->dev.platform_data;	i2c_set_clientdata(i2c, max77803);	max77803->dev = &i2c->dev;	max77803->i2c = i2c;	max77803->irq = i2c->irq;//	max77803->type = id->driver_data;	if (pdata) {		max77803->irq_base = pdata->irq_base;		max77803->irq_gpio = pdata->irq_gpio;		max77803->wakeup = pdata->wakeup;		gpio_tlmm_config(GPIO_CFG(max77803->irq_gpio,  0, GPIO_CFG_INPUT,                GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_DISABLE);	} else {		ret = -EINVAL;		goto err;	}	mutex_init(&max77803->iolock);	if (max77803_read_reg(i2c, MAX77803_PMIC_REG_PMIC_ID2, &reg_data) < 0) {		dev_err(max77803->dev,			"device not found on this channel (this is not an error)/n");		ret = -ENODEV;		goto err;	} else {		/* print rev */		max77803->pmic_rev = (reg_data & 0x7);		max77803->pmic_ver = ((reg_data & 0xF8) >> 0x3);		pr_info("%s: device found: rev.0x%x, ver.0x%x/n", __func__,				max77803->pmic_rev, max77803->pmic_ver);	}#if 0#if defined(CONFIG_MACH_JF_VZW) || defined(CONFIG_MACH_JF_LGT)	if (kernel_sec_get_debug_level() == KERNEL_SEC_DEBUG_LEVEL_LOW) {		pm8xxx_hard_reset_config(PM8XXX_DISABLE_HARD_RESET);		max77803_write_reg(i2c, MAX77803_PMIC_REG_MAINCTRL1, 0x04);	} else {		pm8xxx_hard_reset_config(PM8XXX_DISABLE_HARD_RESET);		max77803_write_reg(i2c, MAX77803_PMIC_REG_MAINCTRL1, 0x0c);	}#else	if (kernel_sec_get_debug_level() == KERNEL_SEC_DEBUG_LEVEL_LOW) {		max77803_write_reg(i2c, MAX77803_PMIC_REG_MAINCTRL1, 0x04);	} else {		pm8xxx_hard_reset_config(PM8XXX_DISABLE_HARD_RESET);		max77803_write_reg(i2c, MAX77803_PMIC_REG_MAINCTRL1, 0x0c);	}#endif#endif	max77803_update_reg(i2c, MAX77803_CHG_REG_SAFEOUT_CTRL, 0x00, 0x30);	max77803->muic = i2c_new_dummy(i2c->adapter, I2C_ADDR_MUIC);	i2c_set_clientdata(max77803->muic, max77803);	max77803->haptic = i2c_new_dummy(i2c->adapter, I2C_ADDR_HAPTIC);	i2c_set_clientdata(max77803->haptic, max77803);//.........这里部分代码省略.........

};static char lcdc_splash_is_enabled(){	return mdp_pdata.cont_splash_enabled;}#define GPIO_LCDC_BRDG_PD	128#define GPIO_LCDC_BRDG_RESET_N	129#define GPIO_LCD_DSI_SEL	125#define LCDC_RESET_PHYS		0x90008014static  void __iomem *lcdc_reset_ptr;static unsigned mipi_dsi_gpio[] = {		GPIO_CFG(GPIO_LCDC_BRDG_RESET_N, 0, GPIO_CFG_OUTPUT,		GPIO_CFG_NO_PULL, GPIO_CFG_2MA), /* LCDC_BRDG_RESET_N */		GPIO_CFG(GPIO_LCDC_BRDG_PD, 0, GPIO_CFG_OUTPUT,		GPIO_CFG_NO_PULL, GPIO_CFG_2MA), /* LCDC_BRDG_PD */};static unsigned lcd_dsi_sel_gpio[] = {	GPIO_CFG(GPIO_LCD_DSI_SEL, 0, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP,			GPIO_CFG_2MA),};enum {	DSI_SINGLE_LANE = 1,	DSI_TWO_LANES,};static int msm_fb_get_lane_config(void)

//.........这里部分代码省略.........								false;				pr_debug("%s: dynamic FPS disabled/n",								__func__);		}		pinfo->new_fps = pinfo->mipi.frame_rate;	}	pinfo->panel_max_fps = mdss_panel_get_framerate(pinfo);	pinfo->panel_max_vtotal = mdss_panel_get_vtotal(pinfo);	ctrl_pdata->disp_en_gpio = of_get_named_gpio(ctrl_pdev->dev.of_node,		"qcom,platform-enable-gpio", 0);	if (!gpio_is_valid(ctrl_pdata->disp_en_gpio))		pr_err("%s:%d, Disp_en gpio not specified/n",						__func__, __LINE__);	if (pinfo->type == MIPI_CMD_PANEL) {		ctrl_pdata->disp_te_gpio = of_get_named_gpio(ctrl_pdev->dev.of_node,						"qcom,platform-te-gpio", 0);		if (!gpio_is_valid(ctrl_pdata->disp_te_gpio)) {			pr_err("%s:%d, Disp_te gpio not specified/n",						__func__, __LINE__);		}	}	if (gpio_is_valid(ctrl_pdata->disp_te_gpio) &&					pinfo->type == MIPI_CMD_PANEL) {		rc = gpio_request(ctrl_pdata->disp_te_gpio, "disp_te");		if (rc) {			pr_err("request TE gpio failed, rc=%d/n",			       rc);			return -ENODEV;		}		rc = gpio_tlmm_config(GPIO_CFG(				ctrl_pdata->disp_te_gpio, 1,				GPIO_CFG_INPUT,				GPIO_CFG_PULL_DOWN,				GPIO_CFG_2MA),				GPIO_CFG_ENABLE);		if (rc) {			pr_err("%s: unable to config tlmm = %d/n",				__func__, ctrl_pdata->disp_te_gpio);			gpio_free(ctrl_pdata->disp_te_gpio);			return -ENODEV;		}		rc = gpio_direction_input(ctrl_pdata->disp_te_gpio);		if (rc) {			pr_err("set_direction for disp_en gpio failed, rc=%d/n",			       rc);			gpio_free(ctrl_pdata->disp_te_gpio);			return -ENODEV;		}		pr_debug("%s: te_gpio=%d/n", __func__,					ctrl_pdata->disp_te_gpio);	}	ctrl_pdata->rst_gpio = of_get_named_gpio(ctrl_pdev->dev.of_node,			 "qcom,platform-reset-gpio", 0);	if (!gpio_is_valid(ctrl_pdata->rst_gpio))		pr_err("%s:%d, reset gpio not specified/n",						__func__, __LINE__);	if (pinfo->mode_gpio_state != MODE_GPIO_NOT_VALID) {

//#include <linux/module.h>int msm_proc_comm(unsigned cmd, unsigned *data1, unsigned *data2);extern int msm_add_sdcc(unsigned int controller, struct mmc_platform_data *plat);/* ---- SDCARD ---- *//* ---- WIFI ---- */static uint32_t wifi_on_gpio_table[] = {	//GPIO_CFG(116, 1, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_4MA), /* DAT3 */	//GPIO_CFG(117, 1, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_4MA), /* DAT2 */	//GPIO_CFG(118, 1, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_4MA), /* DAT1 */	//GPIO_CFG(119, 1, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_4MA), /* DAT0 */	//GPIO_CFG(111, 1, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_UP, GPIO_CFG_8MA), /* CMD */	//GPIO_CFG(110, 1, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_8MA), /* CLK */	GPIO_CFG(RIDER_GPIO_WIFI_IRQ, 0, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), /* WLAN IRQ */};static uint32_t wifi_off_gpio_table[] = {	//GPIO_CFG(116, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_UP, GPIO_CFG_4MA), /* DAT3 */	//GPIO_CFG(117, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_UP, GPIO_CFG_4MA), /* DAT2 */	//GPIO_CFG(118, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_UP, GPIO_CFG_4MA), /* DAT1 */	//GPIO_CFG(119, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_UP, GPIO_CFG_4MA), /* DAT0 */	//GPIO_CFG(111, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_UP, GPIO_CFG_4MA), /* CMD */	//GPIO_CFG(110, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_4MA), /* CLK */	GPIO_CFG(RIDER_GPIO_WIFI_IRQ, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), /* WLAN IRQ */};static void config_gpio_table(uint32_t *table, int len){		int n, rc;

static int lge_hsd_probe(struct platform_device *pdev){    int ret;    struct gpio_switch_platform_data *pdata = pdev->dev.platform_data;    HSD_DBG("%s/n", pdata->name);    if (!pdata) {        HSD_ERR("The platform data is null/n");        return -EBUSY;    }    hi = kzalloc(sizeof(struct hsd_info), GFP_KERNEL);    if (!hi) {        HSD_ERR("Failed to allloate headset per device info/n");        return -ENOMEM;    }    hi->gpio = pdata->gpio;    mutex_init(&hi->mutex_lock);    hi->sdev.name = pdata->name;    hi->sdev.print_state = lge_hsd_print_state;    hi->sdev.print_name = lge_hsd_print_name;    ret = switch_dev_register(&hi->sdev);    if (ret < 0) {        HSD_ERR("Failed to register switch device/n");        goto err_switch_dev_register;    }    hs_detect_work_queue = create_workqueue("hs_detect");    if (hs_detect_work_queue == NULL) {        HSD_ERR("Failed to create workqueue/n");        goto err_create_work_queue;    }    ret = gpio_request(hi->gpio, pdev->name);    if (ret < 0) {        HSD_ERR("Failed to request gpio%d/n", hi->gpio);        goto err_request_detect_gpio;    }    ret = gpio_direction_input(hi->gpio);    if (ret < 0) {        HSD_ERR("Failed to set gpio%d as input/n", hi->gpio);        goto err_set_detect_gpio;    }    if (hi->gpio == LGE_HEADSET_DETECT_GPIO) {        ret = gpio_tlmm_config(GPIO_CFG(hi->gpio, 0, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL,                                        GPIO_CFG_2MA), GPIO_CFG_ENABLE);        if (ret < 0) {            HSD_ERR("Failed to configure gpio%d tlmm/n", hi->gpio);            goto err_set_detect_gpio;        }    }    hi->irq = gpio_to_irq(pdata->gpio);    if (hi->irq < 0) {        HSD_ERR("Failed to get interrupt number/n");        ret = hi->irq;        goto err_get_irq_num_failed;    }    ret = request_irq(hi->irq, gpio_irq_handler,                      IRQF_TRIGGER_RISING|IRQF_TRIGGER_FALLING, pdev->name, NULL);    if (ret < 0) {        HSD_ERR("Failed to request interrupt handler/n");        goto err_request_detect_irq;    }    ret = irq_set_irq_wake(hi->irq, 1);    if (ret < 0) {        HSD_ERR("Failed to set interrupt wake/n");        goto err_request_input_dev;    }    hi->input = input_allocate_device();    if (!hi->input) {        HSD_ERR("Failed to allocate input device/n");        ret = -ENOMEM;        goto err_request_input_dev;    }    if (pdev->dev.platform_data)        hi->input->name = "7k_headset";    else        hi->input->name = "hsd_headset";    hi->input->id.vendor	= 0x0001;    hi->input->id.product	= 1;    hi->input->id.version	= 1;    input_set_capability(hi->input, EV_SW, SW_HEADPHONE_INSERT);    ret = input_register_device(hi->input);    if (ret) {        HSD_ERR("Failed to register input device/n");        goto err_register_input_dev;//.........这里部分代码省略.........

static void hallic_init_gpio(void) {	gpio_request(s5712ACDL1_pdata.irq_pin,"hallic_irq");	gpio_tlmm_config(GPIO_CFG(s5712ACDL1_pdata.irq_pin,		0, GPIO_CFG_INPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE);}

void mdp_config_vsync(struct platform_device *pdev,	struct msm_fb_data_type *mfd){	/* vsync on primary lcd only for now */	if ((mfd->dest != DISPLAY_LCD) || (mfd->panel_info.pdest != DISPLAY_1)	    || (!vsync_mode)) {		goto err_handle;	}	vsync_clk_status = 0;	if (mfd->panel_info.lcd.vsync_enable) {		mfd->total_porch_lines = mfd->panel_info.lcd.v_back_porch +		    mfd->panel_info.lcd.v_front_porch +		    mfd->panel_info.lcd.v_pulse_width;		mfd->total_lcd_lines =		    mfd->panel_info.yres + mfd->total_porch_lines;		mfd->lcd_ref_usec_time =		    100000000 / mfd->panel_info.lcd.refx100;		mfd->vsync_handler_pending = FALSE;		mfd->last_vsync_timetick.tv64 = 0;#ifdef MDP_HW_VSYNC		if (mdp_vsync_clk == NULL)			mdp_vsync_clk = clk_get(&pdev->dev, "vsync_clk");		if (IS_ERR(mdp_vsync_clk)) {			printk(KERN_ERR "error: can't get mdp_vsync_clk!/n");			mfd->use_mdp_vsync = 0;		} else			mfd->use_mdp_vsync = 1;		if (mfd->use_mdp_vsync) {			uint32 vsync_cnt_cfg_dem;			uint32 mdp_vsync_clk_speed_hz;			mdp_vsync_clk_speed_hz = clk_get_rate(mdp_vsync_clk);			if (mdp_vsync_clk_speed_hz == 0) {				mfd->use_mdp_vsync = 0;			} else {				/*				 * Do this calculation in 2 steps for				 * rounding uint32 properly.				 */				vsync_cnt_cfg_dem =				    (mfd->panel_info.lcd.refx100 *				     mfd->total_lcd_lines) / 100;				vsync_cnt_cfg =				    (mdp_vsync_clk_speed_hz) /				    vsync_cnt_cfg_dem;				mdp_vsync_cfg_regs(mfd, TRUE);			}		}#else		mfd->use_mdp_vsync = 0;		hrtimer_init(&mfd->dma_hrtimer, CLOCK_MONOTONIC,			     HRTIMER_MODE_REL);		mfd->dma_hrtimer.function = mdp_dma2_vsync_hrtimer_handler;		mfd->vsync_width_boundary = vmalloc(mfd->panel_info.xres * 4);#endif#ifdef CONFIG_FB_MSM_MDDI		mfd->channel_irq = 0;		if (mfd->panel_info.lcd.hw_vsync_mode) {			u32 vsync_gpio = mfd->vsync_gpio;			u32 ret;			if (vsync_gpio == -1) {				MSM_FB_INFO("vsync_gpio not defined!/n");				goto err_handle;			}			ret = gpio_tlmm_config(GPIO_CFG					(vsync_gpio,					(mfd->use_mdp_vsync) ? 1 : 0,					GPIO_CFG_INPUT,					GPIO_CFG_PULL_DOWN,					GPIO_CFG_2MA),					GPIO_CFG_ENABLE);			if (ret)				goto err_handle;			/*			 * if use_mdp_vsync, then no interrupt need since			 * mdp_vsync is feed directly to mdp to reset the			 * write pointer counter. therefore no irq_handler			 * need to reset write pointer counter.			 */			if (!mfd->use_mdp_vsync) {				mfd->channel_irq = MSM_GPIO_TO_INT(vsync_gpio);				if (request_irq				    (mfd->channel_irq,				     &mdp_hw_vsync_handler_proxy,				     IRQF_TRIGGER_FALLING, "VSYNC_GPIO",				     (void *)mfd)) {					MSM_FB_INFO					("irq=%d failed! vsync_gpio=%d/n",						mfd->channel_irq,						vsync_gpio);//.........这里部分代码省略.........

static int icp_hd_power(int on){	int rc = 0;	//int status=0;		//CAM_INFO("%s %s:%d power = %d/n", __FILE__, __func__, __LINE__,on);	if(on) {		//standby control		rc = gpio_tlmm_config(GPIO_CFG(SENSOR_STANDBY_8M, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA),GPIO_CFG_ENABLE);		if (!rc) {			//CAM_INFO("%s %s:%d/n", __FILE__, __func__, __LINE__);			gpio_set_value(SENSOR_STANDBY_8M,0);							}				rc = regulator_enable(s2b_1p2v_8m);		if (rc) {			//CAM_ERR("%s: Enable regulator s2b_1p2v failed/n", __func__);			goto fail;		}		msleep(1);				rc = regulator_enable(mvs0b_1p8v_8m);		if (rc) {			//CAM_ERR("%s: Enable regulator mvs0b_1p8v failed/n", __func__);			goto fail;		}		msleep(1);				rc = regulator_enable(lvs3b_1p8v);		if (rc) {			//CAM_ERR("%s: Enable regulator lvs3b_1p8v failed/n", __func__);			goto fail;		}				msleep(1);				rc = regulator_enable(l2b_2p8v_8m);		if (rc) {			//CAM_ERR("%s: Enable regulator l2b_2p8v failed/n", __func__);			goto fail;		}		msleep(1);				rc = regulator_enable(l3b_2p8v_8m);		if (rc) {			//CAM_ERR("%s: Enable regulator l3b_2p8v failed/n", __func__);			goto fail;		}		//CAM_INFO("%s %s ON Success:%d/n", __FILE__, __func__, __LINE__);	}	else {		//CAM_INFO("%s %s:%d power /n", __FILE__, __func__, __LINE__);		//CAM_INFO("%s %s:%d power /n", __FILE__, __func__, __LINE__);		if(1)//mvs0b_1p8v) 		{			rc = regulator_disable(mvs0b_1p8v_8m);			if (rc){				//CAM_ERR("%s: Disable regulator mvs0b_1p8v failed/n", __func__);				goto fail;			}		}		//CAM_INFO("%s %s:%d power /n", __FILE__, __func__, __LINE__);		if(1)//l2b_2p8v) 		{			rc = regulator_disable(l2b_2p8v_8m);			if (rc){				//CAM_ERR("%s: Disable regulator l2b_2p8v failed/n", __func__);				goto fail;			}			regulator_put(l2b_2p8v_8m);		}		//CAM_INFO("%s %s:%d power /n", __FILE__, __func__, __LINE__);		if(1)//l3b_2p8v) 		{		rc = regulator_disable(l3b_2p8v_8m);			if (rc){				//CAM_ERR("%s: Disable regulator l3b_2p8v failed/n", __func__);				goto fail;			}			regulator_put(l3b_2p8v_8m);				}		//CAM_INFO("%s %s OFF Success:%d/n", __FILE__, __func__, __LINE__);	}		return rc;fail:	CAM_ERR("%s %s Failed!:%d/n", __FILE__, __func__, __LINE__);	if(l2b_2p8v_8m){		regulator_put(l2b_2p8v_8m);	}	if(s2b_1p2v_8m){		regulator_put(s2b_1p2v_8m);	}	if(l3b_2p8v_8m){		regulator_put(l3b_2p8v_8m);	}	return rc;			}

static unsigned int msm_AR600X_setup_power(bool on){	int rc = 0;	static bool init_done;	if (wlan_powered_up) {		pr_info("WLAN already powered up/n");		return 0;	}	if (unlikely(!init_done)) {		gpio_wlan_config();		rc = qrf6285_init_regs();		if (rc) {			pr_err("%s: qrf6285 init failed = %d/n", __func__, rc);			return rc;		} else {			init_done = true;		}	}	rc = wlan_switch_regulators(on);	if (rc) {		pr_err("%s: wlan_switch_regulators error = %d/n", __func__, rc);		goto out;	}	/* GPIO_WLAN_3V3_EN is only required for the QRD7627a */	if (machine_is_msm7627a_qrd1()) {		rc = gpio_tlmm_config(GPIO_CFG(GPIO_WLAN_3V3_EN, 0,					GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL,					GPIO_CFG_2MA), GPIO_CFG_ENABLE);		if (rc) {			pr_err("%s gpio_tlmm_config 119 failed,error = %d/n",				__func__, rc);			goto reg_disable;		}		gpio_set_value(GPIO_WLAN_3V3_EN, 1);	}	/*	 * gpio_wlan_sys_rest_en is not from the GPIO expander for QRD7627a,	 * EVB1.0 and QRD8625,so the below step is required for those devices.	 */	if (machine_is_msm7627a_qrd1() || machine_is_msm7627a_evb()					|| machine_is_msm8625_evb()					|| machine_is_msm8625_evt()					|| machine_is_msm7627a_qrd3()					|| machine_is_msm8625_qrd7()) {		rc = gpio_tlmm_config(GPIO_CFG(gpio_wlan_sys_rest_en, 0,					GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL,					GPIO_CFG_2MA), GPIO_CFG_ENABLE);		if (rc) {			pr_err("%s gpio_tlmm_config 119 failed,error = %d/n",				__func__, rc);			goto qrd_gpio_fail;		}		gpio_set_value(gpio_wlan_sys_rest_en, 1);	} else {		rc = gpio_request(gpio_wlan_sys_rest_en, "WLAN_DEEP_SLEEP_N");		if (rc) {			pr_err("%s: WLAN sys_rest_en GPIO %d request failed %d/n",				__func__,				gpio_wlan_sys_rest_en, rc);			goto qrd_gpio_fail;		}		rc = setup_wlan_gpio(on);		if (rc) {			pr_err("%s: wlan_set_gpio = %d/n", __func__, rc);			goto gpio_fail;		}	}	/* Enable the A0 clock */	rc = setup_wlan_clock(on);	if (rc) {		pr_err("%s: setup_wlan_clock = %d/n", __func__, rc);		goto set_gpio_fail;	}	/* Configure A0 clock to be slave to WLAN_CLK_PWR_REQ */	rc = pmapp_clock_vote(id, PMAPP_CLOCK_ID_A0,				 PMAPP_CLOCK_VOTE_PIN_CTRL);	if (rc) {		pr_err("%s: Configuring A0 to Pin controllable failed %d/n",				__func__, rc);		goto set_clock_fail;	}	pr_info("WLAN power-up success/n");	wlan_powered_up = true;	return 0;set_clock_fail:	setup_wlan_clock(0);set_gpio_fail:	setup_wlan_gpio(0);gpio_fail:	if (!(machine_is_msm7627a_qrd1() || machine_is_msm7627a_evb() ||	    machine_is_msm8625_evb() || machine_is_msm8625_evt() ||	    machine_is_msm7627a_qrd3() || machine_is_msm8625_qrd7()))//.........这里部分代码省略.........

	{		.gpio = PWR_KEY_MSMz,		.code = KEY_POWER,	},	{		.gpio = VOL_DOWNz_XA_XB,		.code = KEY_VOLUMEDOWN,	},	{		.gpio = VOL_UPz_XA_XB,		.code = KEY_VOLUMEUP,	},};static uint32_t matirx_inputs_gpio_table_xc[] = {	GPIO_CFG(PWR_KEY_MSMz, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_UP,		 GPIO_CFG_2MA),	GPIO_CFG(VOL_DOWNz_XC, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_UP,		 GPIO_CFG_2MA),	GPIO_CFG(VOL_UPz_XC, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_UP,		 GPIO_CFG_2MA),};static uint32_t matirx_inputs_gpio_table[] = {	GPIO_CFG(PWR_KEY_MSMz, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_UP,		 GPIO_CFG_2MA),	GPIO_CFG(VOL_DOWNz_XA_XB, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_UP,		 GPIO_CFG_2MA),	GPIO_CFG(VOL_UPz_XA_XB, 0, GPIO_CFG_INPUT, GPIO_CFG_PULL_UP,		 GPIO_CFG_2MA),};

static unsigned int msm_AR600X_shutdown_power(bool on){	int rc = 0;	if (!wlan_powered_up) {		pr_info("WLAN is not powered up, returning success/n");		return 0;	}	/* Disable the A0 clock */	rc = setup_wlan_clock(on);	if (rc) {		pr_err("%s: setup_wlan_clock = %d/n", __func__, rc);		goto set_clock_fail;	}	/*	 * gpio_wlan_sys_rest_en is not from the GPIO expander for QRD7627a,	 * EVB1.0 and QRD8625,so the below step is required for those devices.	 */	if (machine_is_msm7627a_qrd1() || machine_is_msm7627a_evb()					|| machine_is_msm8625_evb()					|| machine_is_msm8625_evt()					|| machine_is_msm7627a_qrd3()					|| machine_is_msm8625_qrd7()) {		rc = gpio_tlmm_config(GPIO_CFG(gpio_wlan_sys_rest_en, 0,					GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL,					GPIO_CFG_2MA), GPIO_CFG_ENABLE);		if (rc) {			pr_err("%s gpio_tlmm_config 119 failed,error = %d/n",				__func__, rc);			goto gpio_fail;		}		gpio_set_value(gpio_wlan_sys_rest_en, 0);	} else {		rc = setup_wlan_gpio(on);		if (rc) {			pr_err("%s: setup_wlan_gpio = %d/n", __func__, rc);			goto set_gpio_fail;		}		gpio_free(gpio_wlan_sys_rest_en);	}	/* GPIO_WLAN_3V3_EN is only required for the QRD7627a */	if (machine_is_msm7627a_qrd1()) {		rc = gpio_tlmm_config(GPIO_CFG(GPIO_WLAN_3V3_EN, 0,					GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL,					GPIO_CFG_2MA), GPIO_CFG_ENABLE);		if (rc) {			pr_err("%s gpio_tlmm_config 119 failed,error = %d/n",				__func__, rc);			goto qrd_gpio_fail;		}		gpio_set_value(GPIO_WLAN_3V3_EN, 0);	}	rc = wlan_switch_regulators(on);	if (rc) {		pr_err("%s: wlan_switch_regulators error = %d/n",			__func__, rc);		goto reg_disable;	}	wlan_powered_up = false;	pr_info("WLAN power-down success/n");	return 0;set_clock_fail:	setup_wlan_clock(0);set_gpio_fail:	setup_wlan_gpio(0);gpio_fail:	if (!(machine_is_msm7627a_qrd1() || machine_is_msm7627a_evb() ||	    machine_is_msm8625_evb() || machine_is_msm8625_evt() ||	    machine_is_msm7627a_qrd3() || machine_is_msm8625_qrd7()))	gpio_free(gpio_wlan_sys_rest_en);qrd_gpio_fail:	/* GPIO_WLAN_3V3_EN is only required for the QRD7627a */	if (machine_is_msm7627a_qrd1())		gpio_free(GPIO_WLAN_3V3_EN);reg_disable:	wlan_switch_regulators(0);	pr_info("WLAN power-down failed/n");	return rc;}

static int mipi_dsi_panel_power(int on){	static struct regulator *reg_lvs5, *reg_l2;	static int gpio36, gpio37;	int rc;	pr_debug("%s: on=%d/n", __func__, on);	if (!dsi_power_on) {		reg_lvs5 = regulator_get(&msm_mipi_dsi1_device.dev,				"dsi1_vddio");		if (IS_ERR_OR_NULL(reg_lvs5)) {			pr_err("could not get 8921_lvs5, rc = %ld/n",				PTR_ERR(reg_lvs5));			return -ENODEV;		}		reg_l2 = regulator_get(&msm_mipi_dsi1_device.dev,				"dsi1_pll_vdda");		if (IS_ERR_OR_NULL(reg_l2)) {			pr_err("could not get 8921_l2, rc = %ld/n",				PTR_ERR(reg_l2));			return -ENODEV;		}		rc = regulator_set_voltage(reg_l2, 1200000, 1200000);		if (rc) {			pr_err("set_voltage l2 failed, rc=%d/n", rc);			return -EINVAL;		}		gpio36 = PM8921_GPIO_PM_TO_SYS(V_LCM_N5V_EN); 		rc = gpio_request(gpio36, "lcd_5v-");		if (rc) {			pr_err("request lcd_5v- failed, rc=%d/n", rc);			return -ENODEV;		}		gpio37 = PM8921_GPIO_PM_TO_SYS(V_LCM_P5V_EN); 		rc = gpio_request(gpio37, "lcd_5v+");		if (rc) {			pr_err("request lcd_5v+ failed, rc=%d/n", rc);			return -ENODEV;		}		gpio_tlmm_config(GPIO_CFG(LCD_RST, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE);		dsi_power_on = true;	}	if (on) {		if (!first_init) {			rc = regulator_enable(reg_lvs5);			if (rc) {				pr_err("enable lvs5 failed, rc=%d/n", rc);				return -ENODEV;			}			msleep(200);			gpio_set_value_cansleep(gpio37, 1);			msleep(10);			gpio_set_value_cansleep(gpio36, 1);			rc = regulator_set_optimum_mode(reg_l2, 100000);			if (rc < 0) {				pr_err("set_optimum_mode l2 failed, rc=%d/n", rc);				return -EINVAL;			}			rc = regulator_enable(reg_l2);			if (rc) {				pr_err("enable l2 failed, rc=%d/n", rc);				return -ENODEV;			}						msm_xo_mode_vote(wa_xo, MSM_XO_MODE_ON);			gpio_set_value(LCD_RST, 0);			msleep(10);			gpio_set_value(LCD_RST, 1);						msm_xo_mode_vote(wa_xo, MSM_XO_MODE_OFF);		} else {						rc = regulator_enable(reg_lvs5);			if (rc) {				pr_err("enable lvs5 failed, rc=%d/n", rc);				return -ENODEV;			}			rc = regulator_set_optimum_mode(reg_l2, 100000);			if (rc < 0) {				pr_err("set_optimum_mode l2 failed, rc=%d/n", rc);				return -EINVAL;			}			rc = regulator_enable(reg_l2);			if (rc) {				pr_err("enable l2 failed, rc=%d/n", rc);				return -ENODEV;			}						msm_xo_mode_vote(wa_xo, MSM_XO_MODE_ON);			msleep(10);			msm_xo_mode_vote(wa_xo, MSM_XO_MODE_OFF);//.........这里部分代码省略.........

static int mipi_dsi_panel_power(int on){	int rc = 0;/* LGE_CHANGE_S [email
C++ GPIO_ClearValue函数代码示例
C++ GPIO_BIT函数代码示例