本文整理汇总了C++中GPIO_CFG函数的典型用法代码示例。如果您正苦于以下问题：C++ GPIO_CFG函数的具体用法？C++ GPIO_CFG怎么用？C++ GPIO_CFG使用的例子？那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了GPIO_CFG函数的15个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: sku3_lcdc_lcd_camera_power_init
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;
}示例2: init_gpios
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;
}示例3: max77803_i2c_probe
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, ®_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);
//.........这里部分代码省略.........
示例4: lcdc_splash_is_enabled
};
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 0x90008014
static 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)示例5: dsi_panel_device_register
//.........这里部分代码省略.........
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) {
示例6: msm_proc_comm
//#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;示例7: lge_hsd_probe
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;
//.........这里部分代码省略.........
示例8: hallic_init_gpio
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);
}示例9: mdp_config_vsync
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);
//.........这里部分代码省略.........
示例10: icp_hd_power
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;
}示例11: msm_AR600X_setup_power
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()))
//.........这里部分代码省略.........
示例12: GPIO_CFG
{
.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),
};
示例13: msm_AR600X_shutdown_power
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;
}示例14: mipi_dsi_panel_power
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);
//.........这里部分代码省略.........
示例15: mipi_dsi_panel_power
static int mipi_dsi_panel_power(int on)
{
int rc = 0;
/* LGE_CHANGE_S [email protected] 2013-01-15 booting animation sometimes no display*/
if(on == 0){
if(firstbootend == 0){
firstbootend = 1;
return 0;
}
}
/* LGE_CHANGE_E [email protected] 2013-01-15 booting animation sometimes no display*/
if (unlikely(!dsi_gpio_initialized))
{
/* Resetting LCD Panel*/
rc = gpio_request(GPIO_LCD_RESET, "lcd_reset");
if (rc) {
pr_err("%s: gpio_request GPIO_LCD_RESET failed\n", __func__);
}
rc = gpio_tlmm_config(GPIO_CFG(GPIO_LCD_RESET, 0, GPIO_CFG_OUTPUT,
GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
if (rc) {
printk(KERN_ERR "%s: Failed to configure GPIO %d\n",
__func__, rc);
}
dsi_gpio_initialized = 1;
}
if (on) {
rc = regulator_enable(regulator_mipi_dsi[0]);
if (rc) {
pr_err("%s: vreg_enable failed for mipi_dsi_v18\n", __func__);
goto vreg_put_dsi_v18;
}
msleep(3); //LGE_CHANGE_S [changbum.lee] 20120130 : add delay
rc = regulator_enable(regulator_mipi_dsi[1]);
if (rc) {
pr_err("%s: vreg_enable failed for mipi_dsi_v28\n", __func__);
goto vreg_put_dsi_v28;
}
rc = gpio_direction_output(GPIO_LCD_RESET, 1);
if (rc) {
pr_err("%s: gpio_direction_output failed for lcd_reset\n", __func__);
goto vreg_put_dsi_v28;
}
if (firstbootend)
{
gpio_set_value(GPIO_LCD_RESET, 0); //sohyun.nam, 12-11-23, arrange nReset pin
msleep(8); //sohyun.nam, 12-11-23, arrange nReset pin
rc = regulator_disable(regulator_mipi_dsi[1]);//2.8v
msleep(15); //sohyun.nam, 12-11-23, arrange nReset pin
if (rc) {
pr_err("%s: vreg_disable failed for mipi_dsi_v28\n", __func__);
goto vreg_put_dsi_v28;
}
rc = regulator_enable(regulator_mipi_dsi[1]);//2.8v
msleep(15); //sohyun.nam, 12-11-23, arrange nReset pin
gpio_set_value(GPIO_LCD_RESET, 1); //sohyun.nam
msleep(8);
if (rc) {
pr_err("%s: vreg_enable failed for mipi_dsi_v28\n", __func__);
goto vreg_put_dsi_v28;
}
}
else {
firstbootend=1;
}
}
else//off
{
rc = regulator_disable(regulator_mipi_dsi[0]);
if (rc) {
pr_err("%s: vreg_disable failed for mipi_dsi_v18\n", __func__);
goto vreg_put_dsi_v18;
}
rc = regulator_disable(regulator_mipi_dsi[1]);
if (rc) {
pr_err("%s: vreg_disable failed for mipi_dsi_v28\n", __func__);
goto vreg_put_dsi_v28;
}
}
return 0;
vreg_put_dsi_v28:
regulator_put(regulator_mipi_dsi[1]);
vreg_put_dsi_v18:
regulator_put(regulator_mipi_dsi[0]);
return rc;
//.........这里部分代码省略.........