static int exynos_parse_gpio(struct device *dev) { int gpio = -1; struct device_node *np = dev->of_node; enum of_gpio_flags flags; u32 value; int ret = -1; if (!of_find_property(np, "lcd_bl_gpio", &value)) { dev_err(dev, "no bl gpio property found\n"); return -1; } gpio = of_get_named_gpio_flags(np, "lcd_bl_gpio", 0, &flags); if (gpio_is_valid(gpio)) { ret = gpio_request_one(gpio, GPIOF_OUT_INIT_HIGH, "exynos4-fb"); if (ret < 0) { return ret; } } gpio_set_value(gpio, 1); if (!of_find_property(np, "lcd_en_gpio", &value)) { dev_err(dev, "no bl gpio property found\n"); return -1; } gpio = of_get_named_gpio_flags(np, "lcd_en_gpio", 0, &flags); if (gpio_is_valid(gpio)) { ret = gpio_request_one(gpio, GPIOF_OUT_INIT_HIGH, "exynos4-fb"); if (ret < 0) { return ret; } } gpio_set_value(gpio, 1); return 0; }
static int serial_omap_probe_rs485(struct uart_omap_port *up, struct device_node *np) { struct serial_rs485 *rs485conf = &up->port.rs485; u32 rs485_delay[2]; enum of_gpio_flags flags; int ret; rs485conf->flags = 0; up->rts_gpio = -EINVAL; if (!np) return 0; if (of_property_read_bool(np, "rs485-rts-active-high")) rs485conf->flags |= SER_RS485_RTS_ON_SEND; else rs485conf->flags |= SER_RS485_RTS_AFTER_SEND; /* check for tx enable gpio */ up->rts_gpio = of_get_named_gpio_flags(np, "rts-gpio", 0, &flags); if (gpio_is_valid(up->rts_gpio)) { ret = devm_gpio_request(up->dev, up->rts_gpio, "omap-serial"); if (ret < 0) return ret; ret = gpio_direction_output(up->rts_gpio, flags & SER_RS485_RTS_AFTER_SEND); if (ret < 0) return ret; } else if (up->rts_gpio == -EPROBE_DEFER) { return -EPROBE_DEFER; } else { up->rts_gpio = -EINVAL; } if (of_property_read_u32_array(np, "rs485-rts-delay", rs485_delay, 2) == 0) { rs485conf->delay_rts_before_send = rs485_delay[0]; rs485conf->delay_rts_after_send = rs485_delay[1]; } if (of_property_read_bool(np, "rs485-rx-during-tx")) rs485conf->flags |= SER_RS485_RX_DURING_TX; if (of_property_read_bool(np, "linux,rs485-enabled-at-boot-time")) rs485conf->flags |= SER_RS485_ENABLED; return 0; }
static int pn547_parse_dt(struct device *dev, struct pn547_i2c_platform_data *pdata) { struct device_node *np = dev->of_node; pdata->irq_gpio = of_get_named_gpio_flags(np, "pn547,irq-gpio", 0, &pdata->irq_gpio_flags); pdata->ven_gpio = of_get_named_gpio_flags(np, "pn547,ven-gpio", 0, &pdata->ven_gpio_flags); pdata->firm_gpio = of_get_named_gpio_flags(np, "pn547,firm-gpio", 0, &pdata->firm_gpio_flags); #ifdef CONFIG_NFC_PN547_8916_USE_BBCLK2 pdata->nfc_clock = clk_get(dev, "nfc_clock"); if (IS_ERR(pdata->nfc_clock)) { pr_err("[NFC] %s: Couldn't get D1)\n", __func__); } else { clk_put(pdata->nfc_clock); #ifndef CONFIG_NFC_PN547_8916_CLK_CTL if (clk_prepare_enable(pdata->nfc_clock)) pr_err("[NFC] %s: Couldn't prepare D1\n", __func__); #endif } #endif if (pdata->firm_gpio < 0) of_property_read_u32(np, "pn547,firm-expander-gpio", &pdata->firm_gpio); pr_info("%s: irq : %u, ven : %u, firm : %u\n", __func__, pdata->irq_gpio, pdata->ven_gpio, pdata->firm_gpio); return 0; }
static int backlight_parse_dt(struct device *dev, struct backlight_platform_data *pdata) { struct device_node *np = dev->of_node; pdata->gpio_scl = of_get_named_gpio_flags(np, "backlight,scl-gpio", 0, &pdata->scl_gpio_flags); pdata->gpio_sda = of_get_named_gpio_flags(np, "backlight,sda-gpio", 0, &pdata->sda_gpio_flags); pdata->gpio_backlight_en = of_get_named_gpio_flags(np, "backlight-en-gpio", 0, &pdata->en_gpio_flags); pdata->gpio_backlight_pwm= of_get_named_gpio_flags(np, "backlight-pwm-gpio", 0, &pdata->en_gpio_flags); bl_ic_name = of_get_property(np, "backlight-ic-name", NULL); if (!bl_ic_name) { pr_info("%s:%d, backlight IC name not specified\n",__func__, __LINE__); } else { pr_info("%s: Backlight IC Name = %s\n", __func__,bl_ic_name); } pr_err("%s gpio_scl : %d , gpio_sda : %d en : %d pwm:%d\n", __func__, pdata->gpio_scl, pdata->gpio_sda, pdata->gpio_backlight_en, pdata->gpio_backlight_en); return 0; }
static void i2c_fsl_init_recovery(struct fsl_i2c_struct *i2c_fsl, struct device_d *dev) { if (!dev->device_node) return; i2c_fsl->rinfo.sda_gpio = of_get_named_gpio_flags(dev->device_node, "sda-gpios", 0, NULL); i2c_fsl->rinfo.scl_gpio = of_get_named_gpio_flags(dev->device_node, "scl-gpios", 0, NULL); if (!gpio_is_valid(i2c_fsl->rinfo.sda_gpio) || !gpio_is_valid(i2c_fsl->rinfo.scl_gpio)) return; i2c_fsl->rinfo.get_scl = i2c_get_scl_gpio_value; i2c_fsl->rinfo.get_sda = i2c_get_sda_gpio_value; i2c_fsl->rinfo.set_scl = i2c_set_scl_gpio_value; i2c_fsl->rinfo.prepare_recovery = i2c_fsl_prepare_recovery; i2c_fsl->rinfo.unprepare_recovery = i2c_fsl_unprepare_recovery; i2c_fsl->rinfo.recover_bus = i2c_generic_gpio_recovery; i2c_fsl->adapter.bus_recovery_info = &i2c_fsl->rinfo; dev_dbg(dev, "initialized recovery info\n"); }
static int of_max77804k_dt(struct device *dev, struct max77804k_platform_data *pdata) { struct device_node *np = dev->of_node; // int retval = 0; #ifdef CONFIG_VIBETONZ struct max77804k_haptic_platform_data *haptic_data; #endif if(!np) return -EINVAL; #ifdef CONFIG_VIBETONZ haptic_data = kzalloc(sizeof(struct max77804k_haptic_platform_data), GFP_KERNEL); if (haptic_data == NULL) return -ENOMEM; #endif pdata->irq_gpio = of_get_named_gpio_flags(np, "max77804k,irq-gpio", 0, &pdata->irq_gpio_flags); pdata->wakeup = of_property_read_bool(np, "max77804k,wakeup"); #if 0 pdata->irq_base = irq_alloc_descs(-1, 0, MAX77804K_IRQ_NR, -1); if (pdata->irq_base < 0) { pr_info("%s irq_alloc_descs is failed! irq_base:%d\n", __func__, pdata->irq_base); /* getting a predefined irq_base on dt file */ of_property_read_u32(np, "max77804k,irq-base", &pdata->irq_base); } retval = of_get_named_gpio(np, "max77804k,wc-irq-gpio", 0); if (retval < 0) pdata->wc_irq_gpio = 0; else pdata->wc_irq_gpio = retval; #endif pr_info("%s: irq-gpio: %u \n", __func__, pdata->irq_gpio); #ifdef CONFIG_VIBETONZ of_property_read_u32(np, "haptic,max_timeout", &haptic_data->max_timeout); of_property_read_u32(np, "haptic,duty", &haptic_data->duty); of_property_read_u32(np, "haptic,period", &haptic_data->period); of_property_read_u32(np, "haptic,pwm_id", &haptic_data->pwm_id); pr_info("%s: timeout: %u \n", __func__, haptic_data->max_timeout); pr_info("%s: duty: %u \n", __func__, haptic_data->duty); pr_info("%s: period: %u \n", __func__, haptic_data->period); pr_info("%s: pwm_id: %u \n", __func__, haptic_data->pwm_id); pdata->haptic_data = haptic_data; kfree(haptic_data); #endif return 0; }
static int hall_sensor_parse_dt(struct device *dev, struct hall_sensor_data *hsdata) { struct device_node *np = dev->of_node; u32 gpio_flag; hsdata->irq_gpio = of_get_named_gpio_flags(np, "Seiko,irq-gpio", 0, &gpio_flag); if (gpio_is_valid(hsdata->irq_gpio)) hsdata->irq_gpio_flags = gpio_flag; else return -EINVAL; hsdata->irq = gpio_to_irq(hsdata->irq_gpio); return 0; }
static int yas_parse_dt(struct device *dev, struct yas_acc_platform_data *pdata) { struct property *prop = NULL; struct device_node *dt = dev->of_node; u32 buf = 0; uint32_t irq_gpio_flags = 0; struct device_node *offset = NULL; int cali_size; unsigned char *cali_data; int i; prop = of_find_property(dt, "g_sensor_kxtj2,placement", NULL); if (prop) { of_property_read_u32(dt, "g_sensor_kxtj2,placement", &buf); pdata->placement = buf; I("%s: placement = %d\n", __func__, pdata->placement); } else E("%s: g_sensor_kxtj2,placement not found\n", __func__); #ifdef CONFIG_CIR_ALWAYS_READY pdata->intr = of_get_named_gpio_flags(dt, "g_sensor_kxtj2,intr", 0, &irq_gpio_flags); if (pdata->intr < 0) { E("%s: of_get_named_gpio_flags fails: pdata->intr\n", __func__); return -EINVAL; } #endif pdata->gs_kvalue = 0; offset = of_find_node_by_path(CALIBRATION_DATA_PATH); if (offset) { cali_data = (unsigned char *)of_get_property(offset, G_SENSOR_FLASH_DATA, &cali_size); if (cali_data) { for (i = 0; (i < cali_size) && (i < 4); i++) { I("cali_data[%d] = 0x%02x\n", i, cali_data[i]); pdata->gs_kvalue |= (cali_data[i] << (i * 8)); } } } else I("%s: Calibration data offset not found\n", __func__); return 0; }
static int apds_parse_dt(struct device *dev, struct apds9900_platform_data *pdata) { //int rc; struct device_node *np = dev->of_node; pdata->int_pin = of_get_named_gpio_flags(np, "apds,irq-gpio", 0, &pdata->int_flags); if (pdata->int_pin < 0) { dev_err(dev, "Unable to read irq-gpio\n"); return pdata->int_pin; } pdata->use_fir = of_property_read_bool(np, "apds,use-fir"); return 0; }
static int fan53555_of_init(struct device_node *node, struct fan53555_device_info *di) { int ret, gpio; enum of_gpio_flags flags; if (of_property_read_bool(node, "fairchild,restore-reg")) { ret = fan53555_restore_working_reg(node, di); if (ret) return ret; } if (of_find_property(node, "fairchild,vsel-gpio", NULL)) { gpio = of_get_named_gpio_flags(node, "fairchild,vsel-gpio", 0, &flags); if (!gpio_is_valid(gpio)) { if (gpio != -EPROBE_DEFER) dev_err(di->dev, "Could not get vsel, ret = %d\n", gpio); return gpio; } ret = devm_gpio_request(di->dev, gpio, "fan53555_vsel"); if (ret) { dev_err(di->dev, "Failed to obtain gpio %d ret = %d\n", gpio, ret); return ret; } ret = gpio_direction_output(gpio, flags & OF_GPIO_ACTIVE_LOW ? 0 : 1); if (ret) { dev_err(di->dev, "Failed to set GPIO %d to: %s, ret = %d", gpio, flags & OF_GPIO_ACTIVE_LOW ? "GPIO_LOW" : "GPIO_HIGH", ret); return ret; } } di->disable_suspend = of_property_read_bool(node, "fairchild,disable-suspend"); return 0; }
static int siw_touch_of_gpio(struct device *dev, void *np, void *string, enum of_gpio_flags *flags) { int gpio = 0; gpio = of_get_named_gpio_flags(np, string, 0, flags); if (gpio_is_valid(gpio)) { if (flags) t_dev_info(dev, "of gpio : %s(0x%X), %d\n", (char *)string, (*flags), gpio); else t_dev_info(dev, "of gpio : %s, %d\n", (char *)string, gpio); } return gpio; }
static int bma255_parse_dt(struct bma255_p *data, struct device *dev) { struct device_node *dNode = dev->of_node; enum of_gpio_flags flags; if (dNode == NULL) return -ENODEV; /*scl,sda and irq */ data->i2c_pull_up = of_property_read_bool(dNode, "bma255-i2c,i2c-pull-up"); data->str_l6 = of_get_property(dNode,"bma255-i2c,reg_vdd", NULL); data->str_lvs1 = of_get_property(dNode,"bma255-i2c,reg_vio", NULL); data->used_chip = of_property_read_u32(dNode,"bma255-i2c,used_chip", &data->used_chip_flags); printk(KERN_INFO "%s pull-up:%d \n", __func__, data->i2c_pull_up); data->acc_int1 = of_get_named_gpio(dNode, "bma255-i2c,acc_int1-gpio", 0); if (data->acc_int1 < 0) { pr_err("[SENSOR]: %s - get acc_int1 error\n", __func__); return -ENODEV; } data->acc_int2 = of_get_named_gpio_flags(dNode, "bma255-i2c,acc_int2-gpio", 0, &flags); if (data->acc_int2 < 0) { pr_err("[SENSOR]: %s - acc_int2 error\n", __func__); //return -ENODEV; } if (of_property_read_u32(dNode, "bma255-i2c,chip_pos", &data->chip_pos) < 0) data->chip_pos = BMA255_TOP_LOWER_RIGHT; #if defined(CONFIG_MACH_MS01_LTE_KOR) data->chip_pos = BMA255_BOTTOM_UPPER_LEFT; #elif defined(CONFIG_MACH_BAFFIN2_CHN_CMCC) data->chip_pos = BMA255_BOTTOM_UPPER_LEFT; #endif return 0; }
static int p3_parse_dt(struct device *dev, struct p3_dev *data) { struct device_node *np = dev->of_node; enum of_gpio_flags flags; int errorno = 0; //int gpio; #if 0//def ENABLE_SENSORS_FPRINT_SECURE if (of_property_read_u32(np, "p3-mosipin", &data->mosipin)) data->mosipin = 0; if (of_property_read_u32(np, "p3-misopin", &data->misopin)) data->misopin = 0; if (of_property_read_u32(np, "p3-cspin", &data->cspin)) data->cspin = 0; if (of_property_read_u32(np, "p3-clkpin", &data->clkpin)) data->clkpin = 0; //data->tz_mode = true; #endif data->cs_gpio = of_get_named_gpio_flags(np, "p3-cs-gpio", 0, &flags); if (data->cs_gpio < 0) { P3_ERR_MSG("%s - get cs_gpio error\n", __func__); //return -ENODEV; } else { errorno = gpio_request(data->cs_gpio, "ese_cs"); if (errorno) { P3_ERR_MSG("%s - failed to request ese_cs\n", __func__); //sreturn errorno; } #if 1 /* Keep CS up*/ gpio_direction_output(data->cs_gpio, 1); #else /*CS down for later power up */ gpio_direction_output(data->cs_gpio, 0); #endif } P3_DBG_MSG("%s: mosipin=%d, %d, %d, %d cs_gpio:%d\n", __func__, data->mosipin, data->misopin, data->cspin, data->clkpin, data->cs_gpio); //dt_exit: return errorno; }
static int of_hall_data_parsing_dt(struct hall_drvdata *ddata) { struct device_node *np_haptic; int gpio; enum of_gpio_flags flags; #ifdef CONFIG_SENSORS_HALL_IRQ_CTRL u32 temp; int ret; #endif np_haptic = of_find_node_by_path("/hall"); if (np_haptic == NULL) { printk("%s : error to get dt node\n", __func__); return -EINVAL; } gpio = of_get_named_gpio_flags(np_haptic, "hall,gpio_flip_cover", 0, &flags); if (gpio < 0) { pr_info("%s: fail to get flip_cover \n", __func__ ); return -EINVAL; } ddata->gpio_flip_cover = gpio; gpio = gpio_to_irq(gpio); if (gpio < 0) { pr_info("%s: fail to return irq corresponding gpio \n", __func__ ); return -EINVAL; } ddata->irq_flip_cover = gpio; #ifdef CONFIG_SENSORS_HALL_IRQ_CTRL ret = of_property_read_u32(np_haptic, "hall,gsm_wa", &temp); if (ret) { pr_info("%s: No property about WA\n", __func__); ddata->wa_enable = false; } else { pr_info("%s: get the wa property\n", __func__); ddata->wa_enable = temp; } #endif return 0; }
int snfc_intu_probe(struct device_node *np) { int rc; /* register the device file */ rc = misc_register(&snfc_intu_device); if (rc < 0) { SNFC_DEBUG_MSG("[snfc_intu_poll] FAIL!! can not register snfc_intu_poll_init \n"); return rc; } snfc_gpios.gpio_intu = of_get_named_gpio_flags(np, "sony,intu-gpio", 0, NULL); rc = gpio_request(snfc_gpios.gpio_intu, "snfc_intu"); if (rc) { SNFC_DEBUG_MSG("[snfc_intu_poll] gpio_request snfc_intu fail (rc = %d)\n",rc); } rc = request_irq(gpio_to_irq(snfc_gpios.gpio_intu), snfc_int_low_isr,IRQF_TRIGGER_FALLING | IRQF_DISABLED , "snfc_intu", NULL); if (rc) { SNFC_DEBUG_MSG("[snfc_intu_poll] request_irq fail (rc = %d )\n",rc); return rc; } disable_irq_nosync(gpio_to_irq(snfc_gpios.gpio_intu)); init_waitqueue_head(&intuwq); SNFC_DEBUG_MSG_LOW("[snfc_intu_poll] GPIO_SNFC_INTU =%d\n",snfc_gpios.gpio_intu); rc = gpio_direction_input((unsigned)snfc_gpios.gpio_intu); if(rc) { SNFC_DEBUG_MSG("[snfc] ERROR - gpio_direction_input \n"); return rc; } SNFC_DEBUG_MSG_LOW("[snfc] set gpio %d input \n",snfc_gpios.gpio_intu); return rc; }
static int of_hall_data_parsing_dt(struct hall_drvdata *ddata) { struct device_node *np_haptic; int gpio; enum of_gpio_flags flags; np_haptic = of_find_node_by_path("/hall"); if (np_haptic == NULL) { printk("%s : error to get dt node\n", __func__); return -EINVAL; } gpio = of_get_named_gpio_flags(np_haptic, "hall,gpio_flip_cover", 0, &flags); ddata->gpio_flip_cover = gpio; gpio = gpio_to_irq(gpio); ddata->irq_flip_cover = gpio; return 0; }
static int of_max77804k_dt(struct device *dev, struct max77804k_platform_data *pdata) { struct device_node *np = dev->of_node; struct max77804k_haptic_platform_data *haptic_data; int retval = 0; haptic_data = kzalloc(sizeof(struct max77804k_haptic_platform_data), GFP_KERNEL); if (haptic_data == NULL) return -ENOMEM; if(!np) { kfree(haptic_data); return -EINVAL; } pdata->irq_gpio = of_get_named_gpio_flags(np, "max77804k,irq-gpio", 0, &pdata->irq_gpio_flags); of_property_read_u32(np, "max77804k,irq-base", &pdata->irq_base); pdata->wakeup = of_property_read_bool(np, "max77804k,wakeup"); retval = of_get_named_gpio(np, "max77804k,wc-irq-gpio", 0); if (retval < 0) pdata->wc_irq_gpio = 0; else pdata->wc_irq_gpio = retval; pr_info("%s: irq-gpio: %u \n", __func__, pdata->irq_gpio); pr_info("%s: irq-base: %u \n", __func__, pdata->irq_base); pr_info("%s: wc-irq-gpio: %u \n", __func__, pdata->wc_irq_gpio); #ifdef CONFIG_VIBETONZ of_property_read_u32(np, "haptic,max_timeout", &haptic_data->max_timeout); of_property_read_u32(np, "haptic,duty", &haptic_data->duty); of_property_read_u32(np, "haptic,period", &haptic_data->period); of_property_read_u32(np, "haptic,pwm_id", &haptic_data->pwm_id); pr_info("%s: timeout: %u \n", __func__, haptic_data->max_timeout); pr_info("%s: duty: %u \n", __func__, haptic_data->duty); pr_info("%s: period: %u \n", __func__, haptic_data->period); pr_info("%s: pwm_id: %u \n", __func__, haptic_data->pwm_id); pdata->haptic_data = haptic_data; #endif kfree(haptic_data); return 0; }
static int of_max77828_dt(struct device *dev, struct max77828_platform_data *pdata) { struct device_node *np = dev->of_node; int retval = 0; struct max77828_haptic_platform_data *haptic_data; haptic_data = kzalloc(sizeof(struct max77828_haptic_platform_data), GFP_KERNEL); if (haptic_data == NULL) return -ENOMEM; if(!np) return -EINVAL; pdata->irq_gpio = of_get_named_gpio_flags(np, "max77828,irq-gpio", 0, &pdata->irq_gpio_flags); of_property_read_u32(np, "max77828,irq-base", &pdata->irq_base); pdata->wakeup = of_property_read_bool(np, "max77828,wakeup"); retval = of_get_named_gpio(np, "max77828,wc-irq-gpio", 0); if (retval < 0) pdata->wc_irq_gpio = 0; else pdata->wc_irq_gpio = retval; pr_info("%s: irq-gpio: %u \n", __func__, pdata->irq_gpio); pr_info("%s: irq-base: %u \n", __func__, pdata->irq_base); pr_info("%s: wc-irq-gpio: %u \n", __func__, pdata->wc_irq_gpio); #ifdef CONFIG_SS_VIBRATOR if (!of_property_read_u32(np, "haptic,mode", &haptic_data->mode)) haptic_data->mode = 0; if (!of_property_read_u32(np, "haptic,divisor", &haptic_data->divisor)) haptic_data->divisor = 128; pr_info("%s: mode: %u \n", __func__, haptic_data->mode); pr_info("%s: divisor: %u \n", __func__, haptic_data->divisor); pdata->haptic_data = haptic_data; #endif return 0; }
int snfc_rfs_probe(struct device_node *np) { int rc = 0; /* register the device file */ rc = misc_register(&snfc_rfs_device); if (rc < 0) { SNFC_DEBUG_MSG("[snfc_rfs] FAIL!! can not register snfc_rfs \n"); return rc; } snfc_gpios.gpio_rfs = of_get_named_gpio_flags(np, "sony,rfs-gpio", 0, NULL); rc = gpio_request_one(snfc_gpios.gpio_rfs, GPIOF_IN, "snfc_rfs"); if (rc) { SNFC_DEBUG_MSG("[snfc_rfs] gpio_request snfc_rfs fail\n"); } return rc; }
static int ak09911c_parse_dt(struct ak09911c_p *data, struct device *dev) { struct device_node *dNode = dev->of_node; enum of_gpio_flags flags; if (dNode == NULL) return -ENODEV; data->m_rst_n = of_get_named_gpio_flags(dNode, "ak09911c-i2c,m_rst_n-gpio", 0, &flags); if (data->m_rst_n < 0) { pr_err("[SENSOR]: %s - m_rst_n error\n", __func__); return -ENODEV; } if (of_property_read_u32(dNode, "ak09911c-i2c,chip_pos", &data->chip_pos) < 0) data->chip_pos = AK09911C_TOP_LOWER_RIGHT; return 0; }
static int tpa2028d_parse_dt(struct device *dev, struct audio_amp_platform_data *pdata) { int ret =0; u32 value; struct device_node *np = dev->of_node; ret = of_property_read_u32(np, "tpa2028d,agc_compression_rate", &value); pdata->agc_compression_rate = (char)value; ret = of_property_read_u32(np, "tpa2028d,agc_output_limiter_disable", &value); pdata->agc_output_limiter_disable = (char)value; ret = of_property_read_u32(np, "tpa2028d,agc_fixed_gain", &value); pdata->agc_fixed_gain = (char)value; pdata->enable_gpio = of_get_named_gpio_flags(np, "tpa2028d,enable_gpio", 0, NULL); pdata->enable = amp_enable; return ret; }
static struct clk *of_clk_gpio_delayed_register_get( struct of_phandle_args *clkspec, void *_data) { struct clk_gpio_delayed_register_data *data = _data; struct clk *clk; int gpio; enum of_gpio_flags of_flags; mutex_lock(&data->lock); if (data->clk) { mutex_unlock(&data->lock); return data->clk; } gpio = of_get_named_gpio_flags(data->node, data->gpio_name, 0, &of_flags); if (gpio < 0) { mutex_unlock(&data->lock); if (gpio == -EPROBE_DEFER) pr_debug("%s: %s: GPIOs not yet available, retry later\n", data->node->name, __func__); else pr_err("%s: %s: Can't get '%s' DT property\n", data->node->name, __func__, data->gpio_name); return ERR_PTR(gpio); } clk = data->clk_register_get(data->node->name, data->parent_names, data->num_parents, gpio, of_flags & OF_GPIO_ACTIVE_LOW); if (IS_ERR(clk)) goto out; data->clk = clk; out: mutex_unlock(&data->lock); return clk; }
static int bq51221_chg_parse_dt(struct device *dev, bq51221_charger_platform_data_t *pdata) { int ret = 0; struct device_node *np = dev->of_node; if (!np) { pr_info("%s: np NULL\n", __func__); return 1; } np = of_find_node_by_name(NULL, "battery"); if (!np) { pr_err("%s np NULL\n", __func__); } else { ret = of_property_read_u32(np, "battery,wireless_cc_cv", &pdata->wireless_cc_cv); ret = of_property_read_string(np, "battery,wirelss_charger_name", (char const **)&pdata->wireless_charger_name); if (ret) pr_info("%s: Vendor is Empty\n", __func__); } return ret; #if 0 /* this part is for bq51221s */ ret = pdata->irq_gpio = of_get_named_gpio_flags(np, "bq51221-charger,irq-gpio", 0, &irq_gpio_flags); if (ret < 0) { dev_err(dev, "%s : can't get irq-gpio\r\n", __FUNCTION__); return ret; } pr_info("%s irq_gpio = %d \n",__func__, pdata->irq_gpio); pdata->irq_base = gpio_to_irq(pdata->irq_gpio); return 0; #endif }
static int fbtft_request_one_gpio(struct fbtft_par *par, const char *name, int index, int *gpiop) { struct device *dev = par->info->device; struct device_node *node = dev->of_node; int gpio, flags, ret = 0; enum of_gpio_flags of_flags; if (of_find_property(node, name, NULL)) { gpio = of_get_named_gpio_flags(node, name, index, &of_flags); if (gpio == -ENOENT) return 0; if (gpio == -EPROBE_DEFER) return gpio; if (gpio < 0) { dev_err(dev, "failed to get '%s' from DT\n", name); return gpio; } /* active low translates to initially low */ flags = (of_flags & OF_GPIO_ACTIVE_LOW) ? GPIOF_OUT_INIT_LOW : GPIOF_OUT_INIT_HIGH; ret = devm_gpio_request_one(dev, gpio, flags, dev->driver->name); if (ret) { dev_err(dev, "gpio_request_one('%s'=%d) failed with %d\n", name, gpio, ret); return ret; } if (gpiop) *gpiop = gpio; fbtft_par_dbg(DEBUG_REQUEST_GPIOS, par, "%s: '%s' = GPIO%d\n", __func__, name, gpio); } return ret; }
static int ist30xx_parse_dt(struct device *dev, struct ist30xx_tsi_platform_data *pdata) { struct device_node *np = dev->of_node; //struct property *prop; u32 temp_val;//, num_buttons; // u32 button_map[MAX_NUM_OF_BUTTON]; int rc; char propname[128]; strcpy(propname, "imagis,i2c-pull-up"); pdata->i2c_pull_up = of_property_read_bool(np, propname); tsp_debug("%s : %d \n", propname, pdata->i2c_pull_up); // x,y cordination strcpy(propname, "imagis,panel-x"); rc = of_property_read_u32(np, propname, &temp_val); if (rc && (rc != -EINVAL)) { return rc; } else { pdata->x_max = temp_val; } tsp_debug("%s :rc=%d val=%d \n", propname, rc, pdata->x_max); strcpy(propname, "imagis,panel-y"); rc = of_property_read_u32(np, propname, &temp_val); if (rc && (rc != -EINVAL)) { return rc; } else { pdata->y_max = temp_val; } tsp_debug("%s :rc=%d val=%d \n", propname, rc, pdata->y_max); strcpy(propname, "imagis,i2c_int_gpio"); pdata->i2c_int_gpio = of_get_named_gpio_flags(np, propname, 0, &pdata->irq_flag); //irq_flag active low or high tsp_debug("%s : i2c_int_gpio=%d flag=%d \n", propname, pdata->i2c_int_gpio, pdata->irq_flag); return 0; }
static int cm32131_parse_dt(struct device *dev, struct cm32131_platform_data *pdata) { int i, ret; u32 value; u32 array[16]; enum of_gpio_flags flags; struct device_node *np = dev->of_node; /* parse irq and request gpio */ value = of_get_named_gpio_flags(np, "capella,intr", 0, &flags); pdata->intr = value; dev_info(dev, "%s: irq gpio num is %d\n", __func__, pdata->intr); if (pdata->intr < 0) { return -EINVAL; } gpio_request(pdata->intr, "gpio_cm32131_intr"); gpio_direction_input(pdata->intr); /* general_reg */ ret = cm32131_get_configs(dev, "capella,configs", array); if (ret) { dev_err(dev, "Looking up %s property in node %s failed", "capella,configs", np->full_name); return -ENODEV; } for (i = 0; i < 10; i++) { pdata->levels[i] = array[i]; } pdata->ALS_slave_address = array[10]; pdata->check_interrupt_add = array[11]; pdata->is_cmd = array[12]; #if 0 ret = of_property_read_string(np, "atmel,vcc_i2c_supply", &pdata->ts_vcc_i2c); ret = of_property_read_string(np, "atmel,vdd_ana_supply", &pdata->ts_vdd_ana); printk("pwr_en=%d, sleep_pwr_en=%d, vcc_i2c=%s, vdd_ana=%s\n", pdata->pwr_en, pdata->sleep_pwr_en, pdata->ts_vcc_i2c, pdata->ts_vdd_ana); #endif return 0; }
static int of_max77693_dt(struct device *dev, struct max77693_platform_data *pdata) { // int retval = 0; struct device_node *np = dev->of_node; if(!np) return -EINVAL; pdata->irq_gpio = of_get_named_gpio_flags(np, "max77693,irq-gpio", 0, &pdata->irq_gpio_flags); printk(KERN_CRIT "[@@MAX77693@@]%s called, gpio_base = %d",__func__,gpio_to_irq(pdata->irq_gpio)); of_property_read_u32(np, "max77693,irq-base", &pdata->irq_base); pdata->wakeup = of_property_read_bool(np, "max77693,wakeup"); // retval = of_get_named_gpio(np, "max77693,wc-irq-gpio", 0); // if (retval < 0) // pdata->wc_irq_gpio = 0; // else // pdata->wc_irq_gpio = retval; pr_info("%s: irq-gpio: %u \n", __func__, pdata->irq_gpio); pr_info("%s: irq-base: %u \n", __func__, pdata->irq_base); // pr_info("%s: wc-irq-gpio: %u \n", __func__, pdata->wc_irq_gpio); return 0; }
static int __devinit chromeos_arm_probe(struct platform_device *pdev) { int gpio, err, active_low; enum of_gpio_flags flags; struct device_node *np = pdev->dev.of_node; if (!np) { err = -ENODEV; goto err; } gpio = of_get_named_gpio_flags(np, "write-protect-gpio", 0, &flags); if (!gpio_is_valid(gpio)) { dev_err(&pdev->dev, "invalid write-protect gpio descriptor\n"); err = -EINVAL; goto err; } active_low = !!(flags & OF_GPIO_ACTIVE_LOW); err = gpio_request_one(gpio, GPIOF_DIR_IN, "firmware-write-protect"); if (err) goto err; err = gpio_sysfs_set_active_low(gpio, active_low); if (err) goto err; gpio_export(gpio, 0); gpio_export_link(&pdev->dev, "write-protect", gpio); dev_info(&pdev->dev, "chromeos system detected\n"); err = 0; err: of_node_put(np); return err; }
static int ncp6335d_parse_gpio(struct device_node *node, struct ncp6335d_info *dd) { int ret = 0, gpio; enum of_gpio_flags flags; if (!of_find_property(node, "onnn,vsel-gpio", NULL)) return ret; /* Get GPIO connected to vsel and set its output */ gpio = of_get_named_gpio_flags(node, "onnn,vsel-gpio", 0, &flags); if (!gpio_is_valid(gpio)) { if (gpio != -EPROBE_DEFER) dev_err(dd->dev, "Could not get vsel, ret = %d\n", gpio); return gpio; } ret = devm_gpio_request(dd->dev, gpio, "ncp6335d_vsel"); if (ret) { dev_err(dd->dev, "Failed to obtain gpio %d ret = %d\n", gpio, ret); return ret; } ret = gpio_direction_output(gpio, flags & OF_GPIO_ACTIVE_LOW ? 0 : 1); if (ret) { dev_err(dd->dev, "Failed to set GPIO %d to: %s, ret = %d", gpio, flags & OF_GPIO_ACTIVE_LOW ? "GPIO_LOW" : "GPIO_HIGH", ret); return ret; } return ret; }
/* Fail if any of the required gpios is absent. */ static int mdm_dt_parse_gpios(struct mdm_ctrl *mdm) { int i, val, rc = 0; struct device_node *node = mdm->dev->of_node; // enum of_gpio_flags flags = OF_GPIO_ACTIVE_LOW; for (i = 0; i < NUM_GPIOS; i++) mdm->gpios[i] = INVALID_GPIO; for (i = 0; i < ARRAY_SIZE(gpio_map); i++) { val = of_get_named_gpio(node, gpio_map[i].name, 0); if (val >= 0) { MDM_GPIO(mdm, gpio_map[i].index) = val; pr_info("[MIF] %s, gpio : %s\n", __func__, gpio_map[i].name); } } #if 0 /* These two are special because they can be inverted. */ val = of_get_named_gpio_flags(node, "qcom,ap2mdm-soft-reset-gpio", 0, &flags); if (val >= 0) { MDM_GPIO(mdm, AP2MDM_SOFT_RESET) = val; if (flags & OF_GPIO_ACTIVE_LOW) mdm->soft_reset_inverted = 1; } #endif /* Verify that the required gpios have valid values */ for (i = 0; i < ARRAY_SIZE(required_gpios); i++) { if (MDM_GPIO(mdm, required_gpios[i]) == INVALID_GPIO) { rc = -ENXIO; break; } } mdm_debug_gpio_show(mdm); return rc; }