static int __init mapphone_touch_gpio_init(struct i2c_board_info *i2c_info) { int err = 0; int pin = 0; pin = get_gpio_by_name("touch_panel_rst"); if (pin >= 0) { err = gpio_request(pin, "touch_reset"); if (err >= 0) { err = gpio_direction_output(pin, 0); if (err < 0) { printk(KERN_ERR "%s: Unable to config reset.\n", __func__); goto touch_gpio_init_fail; } } else { printk(KERN_ERR "%s: Reset GPIO request failed.\n", __func__); goto touch_gpio_init_fail; } } else { printk(KERN_ERR "%s: Cannot acquire reset pin.\n", __func__); err = pin; goto touch_gpio_init_fail; } pin = get_gpio_by_name("touch_panel_int"); if (pin >= 0) { err = gpio_request(pin, "touch_irq"); if (err >= 0) { err = gpio_direction_input(pin); if (err < 0) { printk(KERN_ERR "%s: Unable to config irq.\n", __func__); goto touch_gpio_init_fail; } } else { printk(KERN_ERR "%s: IRQ GPIO request failed.\n", __func__); goto touch_gpio_init_fail; } } else { printk(KERN_ERR "%s: Cannot acquire irq pin.\n", __func__); err = pin; goto touch_gpio_init_fail; } i2c_info->irq = gpio_to_irq(pin); touch_gpio_init_fail: return err; }
void *ektf3k_platform_data(void *info) { static struct elan_ktf3k_i2c_platform_data elan_pdata; elan_pdata.abs_x_max = ELAN_X_MAX - 1; elan_pdata.abs_y_max = ELAN_Y_MAX - 1; elan_pdata.abs_x_min = 0; elan_pdata.abs_y_min = 0; elan_pdata.rst_gpio = get_gpio_by_name("Touch_RST_N"); elan_pdata.intr_gpio = get_gpio_by_name("TP_INT_N"); elan_pdata.pwr_en_gpio = get_gpio_by_name("TP_PWR_EN"); return &elan_pdata; }
void __init *xmm2230_platform_data(void *info) { static struct ifx_modem_platform_data xmm2230_pdata; struct spi_board_info *spi_info = (struct spi_board_info *)info; if(spi_info != NULL) spi_bus_num = spi_info->bus_num; xmm2230_pdata.srdy = get_gpio_by_name("xmm2230_srdy"); xmm2230_pdata.mrdy = get_gpio_by_name("xmm2230_mrdy"); xmm2230_pdata.max_hz = XMM2330_SPI_SPEED_HZ; xmm2230_pdata.use_dma = true; return &xmm2230_pdata; }
void *gt927_platform_data(void *info) { static struct goodix_gt927_i2c_platform_data goodix_pdata; //goodix_pdata.abs_x_max = ELAN_X_MAX - 1; //goodix_pdata.abs_y_max = ELAN_Y_MAX - 1; //goodix_pdata.abs_x_min = 0; //goodix_pdata.abs_y_min = 0; goodix_pdata.rst_gpio = get_gpio_by_name("Touch_RST_N"); goodix_pdata.intr_gpio = get_gpio_by_name("TP_INT_N"); goodix_pdata.pwr_en_gpio = get_gpio_by_name("TP_PWR_EN"); printk("intr_gpio=%d, rst_gpio=%d\n",goodix_pdata.intr_gpio,goodix_pdata.rst_gpio); return &goodix_pdata; }
static void omap4_mapphone_wifi_init(void) { int ret; mapphone_wifi_pmena_gpio = get_gpio_by_name("wlan_pmena"); mapphone_wifi_irq_gpio = get_gpio_by_name("wlan_irqena"); ret = gpio_request(mapphone_wifi_pmena_gpio, "wifi_pmena"); if (ret < 0) goto out; gpio_direction_output(mapphone_wifi_pmena_gpio, 0); omap4_mapphone_wlan_data.irq = OMAP_GPIO_IRQ(mapphone_wifi_irq_gpio); if (wl12xx_set_platform_data(&omap4_mapphone_wlan_data)) pr_err("Error setting wl12xx data\n"); out: return; }
void __init *emc1403_platform_data(void *info) { static short intr2nd_pdata; struct i2c_board_info *i2c_info = info; int intr = get_gpio_by_name("thermal_int"); int intr2nd = get_gpio_by_name("thermal_alert"); if (intr == -1 || intr2nd == -1) return NULL; i2c_info->irq = intr + INTEL_MID_IRQ_OFFSET; intr2nd_pdata = intr2nd + INTEL_MID_IRQ_OFFSET; return &intr2nd_pdata; }
static void __init *lis331dl_platform_data(void *info) { static short intr2nd_pdata; struct i2c_board_info *i2c_info = info; int intr = get_gpio_by_name("accel_int"); int intr2nd = get_gpio_by_name("accel_2"); if (intr == -1 || intr2nd == -1) return NULL; i2c_info->irq = intr + INTEL_MID_IRQ_OFFSET; intr2nd_pdata = intr2nd + INTEL_MID_IRQ_OFFSET; return &intr2nd_pdata; }
/** * Retrieves GPIO configuration. * * @return -1 if at least one GPIO value is missing * @return 0 if successful */ int mcd_register_finalize(struct mcd_base_info const *info) { int ret = 0; if (!info) { pr_err("%s - oops: info is NULL\n", __func__); ret = 0; goto out; } switch (info->cpu_ver) { case CPU_PWELL: case CPU_CLVIEW: case CPU_TANGIER: case CPU_ANNIEDALE: { struct mdm_ctrl_cpu_data *cpu_data = info->cpu_data; cpu_data->gpio_rst_out = get_gpio_by_name(cpu_data->gpio_rst_out_name); cpu_data->gpio_pwr_on = get_gpio_by_name(cpu_data->gpio_pwr_on_name); cpu_data->gpio_rst_bbn = get_gpio_by_name(cpu_data->gpio_rst_bbn_name); cpu_data->gpio_cdump = get_gpio_by_name(cpu_data->gpio_cdump_name); if ((cpu_data->gpio_rst_out == -1) || (cpu_data->gpio_pwr_on == -1) || (cpu_data->gpio_rst_bbn == -1) || (cpu_data->gpio_cdump == -1)) ret = -1; /* gpio on_key is only used by Modem 2230 */ if (!cpu_data->gpio_on_key_name) { cpu_data->gpio_on_key = -1; break; } cpu_data->gpio_on_key = get_gpio_by_name(cpu_data->gpio_on_key_name); break; } } out: return ret; }
void *px3212c_platform_data(void *info) { static struct px3212c_platform_data platform_data; platform_data.gpio=get_gpio_by_name("PROXM_INT#"); return &platform_data; }
const struct camera_af_platform_data *camera_get_af_platform_data(void) { static const int GP_CORE = 96; static const int GPIO_DEFAULT = GP_CORE + 76; static const char gpio_name[] = "CAM_0_AF_EN"; static const struct camera_af_platform_data platform_data = { .power_ctrl = camera_af_power_ctrl }; #if 0 int gpio, r; if (!INTEL_MID_BOARD(1, TABLET, BYT) && camera_af_power_gpio == -1) { gpio = get_gpio_by_name(gpio_name); if (gpio < 0) { pr_err("%s: can't find gpio `%s',default\n", __func__, gpio_name); gpio = GPIO_DEFAULT; } pr_info("camera pdata: af gpio: %d\n", gpio); r = gpio_request(gpio, gpio_name); if (r) return NULL; r = gpio_direction_output(gpio, 0); if (r) return NULL; camera_af_power_gpio = gpio; } return &platform_data; #else return &platform_data; #endif }
static int mdfld_dsi_sharp25x16_panel_reset(struct mdfld_dsi_config *dsi_config) { int ret = 0; PSB_DEBUG_ENTRY("\n"); msleep(10); if (mipi_reset_gpio == 0) { ret = get_gpio_by_name("disp0_rst"); if (ret < 0) { DRM_ERROR("Faild to get panel reset gpio, " \ "use default reset pin\n"); return 0; } mipi_reset_gpio = ret; ret = gpio_request(mipi_reset_gpio, "mipi_display"); if (ret) { DRM_ERROR("Faild to request panel reset gpio\n"); return 0; } } gpio_direction_output(mipi_reset_gpio, 0); usleep_range(1000, 1500); gpio_set_value_cansleep(mipi_reset_gpio, 1); return 0; }
const struct camera_af_platform_data *camera_get_af_platform_data(void) { static const int GP_CORE = 96; static const int GPIO_DEFAULT = GP_CORE + 76; static const char gpio_name[] = "CAM_0_AF_EN"; static const struct camera_af_platform_data platform_data = { .power_ctrl = camera_af_power_ctrl }; int gpio, r; if (camera_af_power_gpio == -1) { gpio = get_gpio_by_name(gpio_name); if (gpio < 0) { pr_err("%s: can not find gpio `%s', using default\n", __func__, gpio_name); gpio = GPIO_DEFAULT; } r = gpio_request(gpio, gpio_name); if (r) return NULL; r = gpio_direction_output(gpio, 0); if (r) return NULL; pr_info("%s: using gpio %i\n", __func__, gpio); camera_af_power_gpio = gpio; } return &platform_data; }
void *apds990x_platform_data(void *info) { static struct apds990x_platform_data platform_data = { .cf = { .cf1 = 7782, .irf1 = 2456, .cf2 = 1228, .irf2 = 1638, .df = 52, .ga = 15728, }, .pdrive = 0, .ppcount = 1, }; if (spid.product_line_id == INTEL_MFLDP_LEX_ENG) { platform_data.cf.cf1 = 8602; platform_data.cf.irf1 = 6552; platform_data.cf.cf2 = 1064; platform_data.cf.irf2 = 860; if (spid.hardware_id < MFLDP_LEX_PR21) platform_data.cf.ga = 1474; else platform_data.cf.ga = 11796; } platform_data.gpio_number = get_gpio_by_name("AL-intr"); return &platform_data; }
void *apds990x_platform_data(void *info) { static struct apds990x_platform_data platform_data = { .cf = { .cf1 = 4096, .irf1 = 9134, .cf2 = 2867, .irf2 = 5816, .df = 52, .ga = 1966 * 9 / 2, }, .pdrive = 0, .ppcount = 1, }; if (spid.product_line_id == INTEL_MFLDP_LEX_ENG) { if (spid.hardware_id < MFLDP_LEX_PR21) platform_data.cf.ga = 1966 / 2; else platform_data.cf.ga = 1966 * 4; } platform_data.gpio_number = get_gpio_by_name("AL-intr"); return &platform_data; }
static int __init bq27541_platform_init(void) { int soc_int_gpio, soc_int_irq; int res; soc_int_gpio = get_gpio_by_name("max_fg_alert"); printk("<AXS> %s: fuegauge interrupt gpio = %d\n", __func__, soc_int_gpio); if(soc_int_gpio != -ENODEV) { printk("<AXS> %s:gpio is OK fuegauge interrupt gpio = %d\n", __func__, soc_int_gpio); if (!INTEL_MID_BOARD(1, TABLET, BYT)) soc_int_gpio = soc_int_gpio + INTEL_MID_IRQ_OFFSET; res = irq_set_irq_wake(soc_int_irq, 1); if (res) { pr_err("%s: Failed to set irq wake for soc_int: %d\n", __func__, res); return 0; } } bq27541_platform_data.soc_int_irq = soc_int_irq; //bq27541_platform_data.translate_temp = bq27541_translate_temp; res = i2c_register_board_info(BQ27541_I2C_MASTER, &bq27541_i2c_boardinfo, ARRAY_SIZE(bq27541_i2c_boardinfo)); if(res < 0){ pr_err("%s: fail register bq27541 i2c device\n"); } return 0; }
void *px3003b_platform_data(void *info) { static struct px3003b_i2c_platform_data platform_data; platform_data.int_gpio=get_gpio_by_name("ALS_INT#"); return &platform_data; }
void mapphone_init_modem_interface(void) { struct device_node *node; const void *prop; int rwkup_gpio = get_gpio_by_name("bp2ap_usb_rwkup"); if (rwkup_gpio < 0) dummy_usb_config.usb_remote_wake_gpio = MAPPHONE_BP_READY2_AP_GPIO; else dummy_usb_config.usb_remote_wake_gpio = rwkup_gpio; node = of_find_node_by_path(DT_PATH_CHOSEN); if (node == NULL) { pr_err("Unable to read node %s from device tree!\n", DT_PATH_CHOSEN); return; } prop = of_get_property(node, DT_PROP_CHOSEN_MODEM_IFACE_NUM, NULL); if (prop) { pr_err("Setting the Modem Interface num to %d\n", *(u8 *)prop); set_cdma_modem_interface(*(u8 *)prop); } else set_cdma_modem_interface(0); of_node_put(node); return; }
static void adp5588_reset(void) { int reset_gpio; reset_gpio = get_gpio_by_name("adp5588_reset_b"); /* If RESET GPIO is not configured in device_tree, assume default */ if (reset_gpio < 0) { printk(KERN_INFO "%s: ADP5588: RESET_GPIO not in device_tree\n", __func__); reset_gpio = ADP5588_RESET_GPIO; } printk(KERN_INFO "%s: ADP5588: RESET asserted\n", __func__); /* Assert ADP5588 RESET */ gpio_set_value(reset_gpio, 0); /* This will keep RESET asserted for ~15 msec. */ msleep_interruptible(1); /* Deassert ADP5588 RESET */ gpio_set_value(reset_gpio, 1); /* Allow ADP5588 to come out of reset */ msleep_interruptible(1); printk(KERN_INFO "%s: ADP5588: RESET deasserted\n", __func__); }
/* * One-time gpio initialization. * @name: gpio name: coded in SFI table * @gpio: gpio pin number (bypass @name) * @dir: GPIOF_DIR_IN or GPIOF_DIR_OUT * @value: if dir = GPIOF_DIR_OUT, this is the init value for output pin * if dir = GPIOF_DIR_IN, this argument is ignored * return: a positive pin number if succeeds, otherwise a negative value */ int camera_sensor_gpio(int gpio, char *name, int dir, int value) { int ret, pin; if (gpio == -1) { pin = get_gpio_by_name(name); if (pin == -1) { pr_err("%s: failed to get gpio(name: %s)\n", __func__, name); return -EINVAL; } pr_info("camera pdata: gpio: %s: %d\n", name, pin); } else { pin = gpio; } ret = gpio_request(pin, name); if (ret) { pr_err("%s: failed to request gpio(pin %d)\n", __func__, pin); return -EINVAL; } if (dir == GPIOF_DIR_OUT) ret = gpio_direction_output(pin, value); else ret = gpio_direction_input(pin); if (ret) { pr_err("%s: failed to set gpio(pin %d) direction\n", __func__, pin); gpio_free(pin); } return ret ? ret : pin; }
/* Init HSIC AUX2 GPIO as side band remote wakeup source */ static int hsic_wakeup_gpio_init(void) { int retval = 0; dev_dbg(&pci_dev->dev, "%s---->\n", __func__); hsic.wakeup_gpio = get_gpio_by_name(HSIC_WAKEUP_GPIO_NAME); if (gpio_is_valid(hsic.wakeup_gpio)) { retval = gpio_request(hsic.wakeup_gpio, "hsic_wakeup"); if (retval < 0) { dev_err(&pci_dev->dev, "Request GPIO %d with error %d\n", hsic.wakeup_gpio, retval); retval = -ENODEV; goto err; } } else { retval = -ENODEV; goto err; } gpio_direction_input(hsic.wakeup_gpio); dev_dbg(&pci_dev->dev, "%s<----\n", __func__); return retval; err: gpio_free(hsic.wakeup_gpio); return retval; }
void *ap3212c_platform_data(void *info) { static struct ap3212c_platform_data platform_data; platform_data.gpio=get_gpio_by_name("ALS_INT#"); return &platform_data; }
static int mdfld_dsi_h8c7_cmd_panel_reset(struct mdfld_dsi_config *dsi_config) { static int mipi_reset_gpio; int ret = 0; PSB_DEBUG_ENTRY("\n"); if (mipi_reset_gpio == 0) { ret = get_gpio_by_name("mipi-reset"); if (ret < 0) { DRM_ERROR("Faild to get panel reset gpio, " \ "use default reset pin\n"); ret = 128; } mipi_reset_gpio = ret; ret = gpio_request(mipi_reset_gpio, "mipi_display"); if (ret) { DRM_ERROR("Faild to request panel reset gpio\n"); return -EINVAL; } gpio_direction_output(mipi_reset_gpio, 0); } gpio_set_value_cansleep(mipi_reset_gpio, 0); mdelay(11); gpio_set_value_cansleep(mipi_reset_gpio, 1); mdelay(5); return 0; }
static int mapphone_bpwake_probe(struct platform_device *pdev) { int rc; int apwake_trigger_gpio; apwake_trigger_gpio = get_gpio_by_name("ipc_apwake_trigger"); if (apwake_trigger_gpio < 0) apwake_trigger_gpio = MAPPHONE_APWAKE_TRIGGER_GPIO; gpio_request(apwake_trigger_gpio, "BP -> AP IPC trigger"); gpio_direction_input(apwake_trigger_gpio); wake_lock_init(&baseband_wakeup_wakelock, WAKE_LOCK_SUSPEND, "bpwake"); rc = request_irq(gpio_to_irq(apwake_trigger_gpio), mapphone_bpwake_irqhandler, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, "Remote Wakeup", NULL); if (rc) { wake_lock_destroy(&baseband_wakeup_wakelock); printk(KERN_ERR "Failed requesting APWAKE_TRIGGER irq (%d)\n", rc); return rc; } enable_irq_wake(gpio_to_irq(apwake_trigger_gpio)); return 0; }
/* Initialization function for thermal probe; success or failure does not impact the rest of the system (except right channel audio if tp_en_gpio is invalid).So return type is void */ void mfld_therm_probe_init(struct mfld_mc_private *ctx, int adc_ch_id) { int ret_val; struct mfld_therm_probe_data *tp_data_ptr; tp_data_ptr = &ctx->tp_data; tp_data_ptr->tp_status = false; tp_data_ptr->tp_adc_ch_id = adc_ch_id; /* Init therm probe enable GPIO */ tp_data_ptr->tp_en_gpio = get_gpio_by_name("thermal_probe_en"); if (tp_data_ptr->tp_en_gpio >= 0) { pr_info("GPIO for therm probe %d\n", tp_data_ptr->tp_en_gpio); } else { /* Workaround if the GPIO not defined in SFI table */ tp_data_ptr->tp_en_gpio = 114; } ret_val = gpio_request(tp_data_ptr->tp_en_gpio, "thermal_probe_en"); if (ret_val) { pr_err("Therm probe Enable GPIO alloc fail:%d\n", ret_val); /* Set gpio to -1 to indicate that gpio request had failed*/ tp_data_ptr->tp_en_gpio = -1; return; } /* Default Ground HSL and HSR of MSIC. Grounding HSL is needed for getting PlugDet interrupt in case thermal probe is connected. This does not impact HS insertion interrupt*/ snd_soc_update_bits(ctx->mfld_jack.codec, SN95031_BTNCTRL2, BIT(1), BIT(1)); gpio_direction_output(tp_data_ptr->tp_en_gpio, 0); }
void __init wifi_platform_data_init_sfi(void) { int err; int wifi_irq_gpio = -1; pr_err("wifi_platform_data_init_sfi\n"); /*Get GPIO numbers from the SFI table*/ wifi_irq_gpio = get_gpio_by_name(WIFI_SFI_GPIO_IRQ_NAME); if (wifi_irq_gpio < 0) { pr_err("%s: Unable to find" WIFI_SFI_GPIO_IRQ_NAME "WLAN-interrupt GPIO in the SFI table\n", __func__); return; } wifi_res[0].start = wifi_res[0].end = wifi_irq_gpio; /* For SFI compliant platforms, we need to manually register a platform device */ err = platform_device_register(&wifi_device); if (err < 0) pr_err("platform_device_register failed for wifi_device\n"); }
void *compass_platform_data(void *info) { static struct akm8963_platform_data akm8963_pdata; akm8963_pdata.gpio_DRDY = get_gpio_by_name("COMP_DRDY"); // akm8963_pdata.gpio_RSTN = get_gpio_by_name("RSTN"); return &akm8963_pdata; }
void __init *msic_gpio_platform_data(void *info) { struct platform_device *pdev = NULL; struct sfi_device_table_entry *entry = info; static struct intel_msic_gpio_pdata msic_gpio_pdata; int ret; int gpio; struct resource res; pdev = platform_device_alloc(MSIC_GPIO_DEVICE_NAME, -1); if (!pdev) { pr_err("out of memory for SFI platform dev %s\n", MSIC_GPIO_DEVICE_NAME); return NULL; } gpio = get_gpio_by_name("msic_gpio_base"); if (gpio < 0) return NULL; /* Basincove PMIC GPIO has total 8 GPIO pins, * GPIO[5:2,0] support 1.8V, GPIO[7:6,1] support 1.8V and 3.3V, * We group GPIO[5:2] to low voltage and GPIO[7:6] to * high voltage. Because the CTL registers are contiguous, * this grouping method doesn't affect the driver usage but * easy for the driver sharing among multiple platforms. */ msic_gpio_pdata.ngpio_lv = 6; msic_gpio_pdata.ngpio_hv = 2; msic_gpio_pdata.gpio0_lv_ctlo = 0x7E; msic_gpio_pdata.gpio0_lv_ctli = 0x8E; msic_gpio_pdata.gpio0_hv_ctlo = 0x84; msic_gpio_pdata.gpio0_hv_ctli = 0x94; msic_gpio_pdata.can_sleep = 1; msic_gpio_pdata.gpio_base = gpio; pdev->dev.platform_data = &msic_gpio_pdata; ret = platform_device_add(pdev); if (ret) { pr_err("failed to add msic gpio platform device\n"); platform_device_put(pdev); return NULL; } res.name = "IRQ", res.flags = IORESOURCE_IRQ, res.start = entry->irq; platform_device_add_resources(pdev, &res, 1); register_rpmsg_service("rpmsg_msic_gpio", RPROC_SCU, RP_MSIC_GPIO); return &msic_gpio_pdata; }
void *lsm303dlhc_accel_platform_data(void *info) { static struct lis3dh_acc_platform_data accel; accel.poll_interval = 200; accel.g_range = 2; accel.negate_x = 1; accel.negate_y = 0; accel.negate_z = 0; accel.axis_map_x = 0; accel.axis_map_y = 1; accel.axis_map_z = 2; accel.gpio_int1 = get_gpio_by_name("accel_int"); accel.gpio_int2 = get_gpio_by_name("accel_2"); accel.model = MODEL_LSM303DLHC; return &accel; }
static void __init *max7315_platform_data(void *info) { static struct pca953x_platform_data max7315_pdata[MAX7315_NUM]; static int nr; struct pca953x_platform_data *max7315 = &max7315_pdata[nr]; struct i2c_board_info *i2c_info = info; int gpio_base, intr; char base_pin_name[SFI_NAME_LEN + 1]; char intr_pin_name[SFI_NAME_LEN + 1]; if (nr == MAX7315_NUM) { pr_err("too many max7315s, we only support %d\n", MAX7315_NUM); return NULL; } /* we have several max7315 on the board, we only need load several * instances of the same pca953x driver to cover them */ strcpy(i2c_info->type, "max7315"); if (nr++) { sprintf(base_pin_name, "max7315_%d_base", nr); sprintf(intr_pin_name, "max7315_%d_int", nr); } else { strcpy(base_pin_name, "max7315_base"); strcpy(intr_pin_name, "max7315_int"); } gpio_base = get_gpio_by_name(base_pin_name); intr = get_gpio_by_name(intr_pin_name); if (gpio_base == -1) return NULL; max7315->gpio_base = gpio_base; if (intr != -1) { i2c_info->irq = intr + INTEL_MID_IRQ_OFFSET; max7315->irq_base = gpio_base + INTEL_MID_IRQ_OFFSET; } else { i2c_info->irq = -1; max7315->irq_base = -1; } return max7315; }
static int mapphone_bpwake_remove(struct platform_device *pdev) { int apwake_trigger_gpio ; wake_lock_destroy(&baseband_wakeup_wakelock); apwake_trigger_gpio = get_gpio_by_name("ipc_apwake_trigger"); if (apwake_trigger_gpio < 0) apwake_trigger_gpio = MAPPHONE_APWAKE_TRIGGER_GPIO; free_irq(gpio_to_irq(apwake_trigger_gpio), NULL); return 0; }