static int lp8788_gpio_request_ldo_en(struct platform_device *pdev, struct lp8788_ldo *ldo, enum lp8788_ext_ldo_en_id id) { struct device *dev = &pdev->dev; struct lp8788_ldo_enable_pin *pin = ldo->en_pin; int ret, gpio, pinstate; char *name[] = { [EN_ALDO1] = "LP8788_EN_ALDO1", [EN_ALDO234] = "LP8788_EN_ALDO234", [EN_ALDO5] = "LP8788_EN_ALDO5", [EN_ALDO7] = "LP8788_EN_ALDO7", [EN_DLDO7] = "LP8788_EN_DLDO7", [EN_DLDO911] = "LP8788_EN_DLDO911", }; gpio = pin->gpio; if (!gpio_is_valid(gpio)) { dev_err(dev, "invalid gpio: %d\n", gpio); return -EINVAL; } pinstate = pin->init_state; ret = devm_gpio_request_one(dev, gpio, pinstate, name[id]); if (ret == -EBUSY) { dev_warn(dev, "gpio%d already used\n", gpio); return 0; } return ret; }
static int lp872x_init_dvs(struct lp872x *lp) { int ret, gpio; struct lp872x_dvs *dvs = lp->pdata ? lp->pdata->dvs : NULL; enum lp872x_dvs_state pinstate; u8 mask[] = { LP8720_EXT_DVS_M, LP8725_DVS1_M | LP8725_DVS2_M }; u8 default_dvs_mode[] = { LP8720_DEFAULT_DVS, LP8725_DEFAULT_DVS }; if (!dvs) goto set_default_dvs_mode; gpio = dvs->gpio; if (!gpio_is_valid(gpio)) { dev_warn(lp->dev, "invalid gpio: %d\n", gpio); goto set_default_dvs_mode; } pinstate = dvs->init_state; ret = devm_gpio_request_one(lp->dev, gpio, pinstate, "LP872X DVS"); if (ret) { dev_err(lp->dev, "gpio request err: %d\n", ret); return ret; } lp->dvs_pin = pinstate; lp->dvs_gpio = gpio; return 0; set_default_dvs_mode: return lp872x_update_bits(lp, LP872X_GENERAL_CFG, mask[lp->chipid], default_dvs_mode[lp->chipid]); }
static int ak4104_spi_probe(struct spi_device *spi) { struct device_node *np = spi->dev.of_node; struct ak4104_private *ak4104; unsigned int val; int ret; spi->bits_per_word = 8; spi->mode = SPI_MODE_0; ret = spi_setup(spi); if (ret < 0) return ret; ak4104 = devm_kzalloc(&spi->dev, sizeof(struct ak4104_private), GFP_KERNEL); if (ak4104 == NULL) return -ENOMEM; ak4104->regulator = devm_regulator_get(&spi->dev, "vdd"); if (IS_ERR(ak4104->regulator)) { ret = PTR_ERR(ak4104->regulator); dev_err(&spi->dev, "Unable to get Vdd regulator: %d\n", ret); return ret; } ak4104->regmap = devm_regmap_init_spi(spi, &ak4104_regmap); if (IS_ERR(ak4104->regmap)) { ret = PTR_ERR(ak4104->regmap); return ret; } if (np) { enum of_gpio_flags flags; int gpio = of_get_named_gpio_flags(np, "reset-gpio", 0, &flags); if (gpio_is_valid(gpio)) { ret = devm_gpio_request_one(&spi->dev, gpio, flags & OF_GPIO_ACTIVE_LOW ? GPIOF_OUT_INIT_LOW : GPIOF_OUT_INIT_HIGH, "ak4104 reset"); if (ret < 0) return ret; } } /* read the 'reserved' register - according to the datasheet, it * should contain 0x5b. Not a good way to verify the presence of * the device, but there is no hardware ID register. */ ret = regmap_read(ak4104->regmap, AK4104_REG_RESERVED, &val); if (ret != 0) return ret; if (val != AK4104_RESERVED_VAL) return -ENODEV; spi_set_drvdata(spi, ak4104); ret = snd_soc_register_codec(&spi->dev, &soc_codec_device_ak4104, &ak4104_dai, 1); return ret; }
static int aic31xx_device_init(struct aic31xx_priv *aic31xx) { int ret, i; dev_set_drvdata(aic31xx->dev, aic31xx); if (dev_get_platdata(aic31xx->dev)) memcpy(&aic31xx->pdata, dev_get_platdata(aic31xx->dev), sizeof(aic31xx->pdata)); else if (aic31xx->dev->of_node) aic31xx_pdata_from_of(aic31xx); if (aic31xx->pdata.gpio_reset) { ret = devm_gpio_request_one(aic31xx->dev, aic31xx->pdata.gpio_reset, GPIOF_OUT_INIT_HIGH, "aic31xx-reset-pin"); if (ret < 0) { dev_err(aic31xx->dev, "not able to acquire gpio\n"); return ret; } } for (i = 0; i < ARRAY_SIZE(aic31xx->supplies); i++) aic31xx->supplies[i].supply = aic31xx_supply_names[i]; ret = devm_regulator_bulk_get(aic31xx->dev, ARRAY_SIZE(aic31xx->supplies), aic31xx->supplies); if (ret != 0) dev_err(aic31xx->dev, "Failed to request supplies: %d\n", ret); return ret; }
static int lp872x_hw_enable(struct lp872x *lp) { int ret, gpio; if (!lp->pdata) return -EINVAL; gpio = lp->pdata->enable_gpio; if (!gpio_is_valid(gpio)) return 0; /* Always set enable GPIO high. */ ret = devm_gpio_request_one(lp->dev, gpio, GPIOF_OUT_INIT_HIGH, "LP872X EN"); if (ret) { dev_err(lp->dev, "gpio request err: %d\n", ret); return ret; } /* Each chip has a different enable delay. */ if (lp->chipid == LP8720) usleep_range(LP8720_ENABLE_DELAY, 1.5 * LP8720_ENABLE_DELAY); else usleep_range(LP8725_ENABLE_DELAY, 1.5 * LP8725_ENABLE_DELAY); return 0; }
static int tpm_stm_i2c_request_resources(struct i2c_client *client, struct tpm_chip *chip) { struct st33zp24_platform_data *pdata; struct tpm_stm_dev *tpm_dev = (struct tpm_stm_dev *)TPM_VPRIV(chip); int ret; pdata = client->dev.platform_data; if (!pdata) { dev_err(chip->pdev, "No platform data\n"); return -ENODEV; } /* store for late use */ tpm_dev->io_lpcpd = pdata->io_lpcpd; if (gpio_is_valid(pdata->io_lpcpd)) { ret = devm_gpio_request_one(&client->dev, pdata->io_lpcpd, GPIOF_OUT_INIT_HIGH, "TPM IO_LPCPD"); if (ret) { dev_err(chip->pdev, "%s : reset gpio_request failed\n", __FILE__); return ret; } } return 0; }
static int st_nci_i2c_of_request_resources(struct i2c_client *client) { struct st_nci_i2c_phy *phy = i2c_get_clientdata(client); struct device_node *pp; int gpio; int r; pp = client->dev.of_node; if (!pp) return -ENODEV; /* Get GPIO from device tree */ gpio = of_get_named_gpio(pp, "reset-gpios", 0); if (gpio < 0) { nfc_err(&client->dev, "Failed to retrieve reset-gpios from device tree\n"); return gpio; } /* GPIO request and configuration */ r = devm_gpio_request_one(&client->dev, gpio, GPIOF_OUT_INIT_HIGH, "clf_reset"); if (r) { nfc_err(&client->dev, "Failed to request reset pin\n"); return r; } phy->gpio_reset = gpio; phy->irq_polarity = irq_get_trigger_type(client->irq); return 0; }
static int st_nci_i2c_request_resources(struct i2c_client *client) { struct st_nci_nfc_platform_data *pdata; struct st_nci_i2c_phy *phy = i2c_get_clientdata(client); int r; pdata = client->dev.platform_data; if (pdata == NULL) { nfc_err(&client->dev, "No platform data\n"); return -EINVAL; } /* store for later use */ phy->gpio_reset = pdata->gpio_reset; phy->irq_polarity = pdata->irq_polarity; r = devm_gpio_request_one(&client->dev, phy->gpio_reset, GPIOF_OUT_INIT_HIGH, ST_NCI_GPIO_NAME_RESET); if (r) { pr_err("%s : reset gpio_request failed\n", __FILE__); return r; } phy->se_status.is_ese_present = pdata->is_ese_present; phy->se_status.is_uicc_present = pdata->is_uicc_present; return 0; }
static int lp872x_init_dvs(struct lp872x *lp) { int ret, gpio; struct lp872x_dvs *dvs = lp->pdata->dvs; enum lp872x_dvs_state pinstate; ret = lp872x_check_dvs_validity(lp); if (ret) { dev_warn(lp->dev, "invalid dvs data: %d\n", ret); return ret; } gpio = dvs->gpio; if (!gpio_is_valid(gpio)) { dev_err(lp->dev, "invalid gpio: %d\n", gpio); return -EINVAL; } pinstate = dvs->init_state; ret = devm_gpio_request_one(lp->dev, gpio, pinstate, "LP872X DVS"); if (ret) { dev_err(lp->dev, "gpio request err: %d\n", ret); return ret; } lp->dvs_pin = pinstate; lp->dvs_gpio = gpio; return 0; }
static int sdhci_acpi_add_own_cd(struct device *dev, int gpio, struct mmc_host *mmc) { unsigned long flags; int err, irq; if (gpio < 0) { err = gpio; goto out; } err = devm_gpio_request_one(dev, gpio, GPIOF_DIR_IN, "sd_cd"); if (err) goto out; irq = gpio_to_irq(gpio); if (irq < 0) { err = irq; goto out_free; } flags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING; err = devm_request_irq(dev, irq, sdhci_acpi_sd_cd, flags, "sd_cd", mmc); if (err) goto out_free; return 0; out_free: devm_gpio_free(dev, gpio); out: dev_warn(dev, "failed to setup card detect wake up\n"); return err; }
static int ak5386_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct ak5386_priv *priv; priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); if (!priv) return -ENOMEM; priv->reset_gpio = -EINVAL; dev_set_drvdata(dev, priv); if (of_match_device(of_match_ptr(ak5386_dt_ids), dev)) priv->reset_gpio = of_get_named_gpio(dev->of_node, "reset-gpio", 0); if (gpio_is_valid(priv->reset_gpio)) if (devm_gpio_request_one(dev, priv->reset_gpio, GPIOF_OUT_INIT_LOW, "AK5386 Reset")) priv->reset_gpio = -EINVAL; return snd_soc_register_codec(dev, &soc_codec_ak5386, &ak5386_dai, 1); }
static int sharp_ls_panel_probe(struct omap_dss_device *dssdev) { struct panel_sharp_ls037v7dw01_data *pd = get_panel_data(dssdev); int r; if (!pd) return -EINVAL; dssdev->panel.timings = sharp_ls_timings; if (gpio_is_valid(pd->mo_gpio)) { r = devm_gpio_request_one(&dssdev->dev, pd->mo_gpio, GPIOF_OUT_INIT_LOW, "lcd MO"); if (r) return r; } if (gpio_is_valid(pd->lr_gpio)) { r = devm_gpio_request_one(&dssdev->dev, pd->lr_gpio, GPIOF_OUT_INIT_HIGH, "lcd LR"); if (r) return r; } if (gpio_is_valid(pd->ud_gpio)) { r = devm_gpio_request_one(&dssdev->dev, pd->ud_gpio, GPIOF_OUT_INIT_HIGH, "lcd UD"); if (r) return r; } if (gpio_is_valid(pd->resb_gpio)) { r = devm_gpio_request_one(&dssdev->dev, pd->resb_gpio, GPIOF_OUT_INIT_LOW, "lcd RESB"); if (r) return r; } if (gpio_is_valid(pd->ini_gpio)) { r = devm_gpio_request_one(&dssdev->dev, pd->ini_gpio, GPIOF_OUT_INIT_LOW, "lcd INI"); if (r) return r; } return 0; }
static void exynos_pcie_assert_reset(struct pcie_port *pp) { struct exynos_pcie *exynos_pcie = to_exynos_pcie(pp); if (exynos_pcie->reset_gpio >= 0) devm_gpio_request_one(pp->dev, exynos_pcie->reset_gpio, GPIOF_OUT_INIT_HIGH, "RESET"); }
int lp55xx_init_device(struct lp55xx_chip *chip) { struct lp55xx_platform_data *pdata; struct lp55xx_device_config *cfg; struct device *dev = &chip->cl->dev; int ret = 0; WARN_ON(!chip); pdata = chip->pdata; cfg = chip->cfg; if (!pdata || !cfg) return -EINVAL; if (gpio_is_valid(pdata->enable_gpio)) { ret = devm_gpio_request_one(dev, pdata->enable_gpio, GPIOF_DIR_OUT, "lp5523_enable"); if (ret < 0) { dev_err(dev, "could not acquire enable gpio (err=%d)\n", ret); goto err; } gpio_set_value(pdata->enable_gpio, 0); usleep_range(1000, 2000); /* Keep enable down at least 1ms */ gpio_set_value(pdata->enable_gpio, 1); usleep_range(1000, 2000); /* 500us abs min. */ } lp55xx_reset_device(chip); /* * Exact value is not available. 10 - 20ms * appears to be enough for reset. */ usleep_range(10000, 20000); ret = lp55xx_detect_device(chip); if (ret) { dev_err(dev, "device detection err: %d\n", ret); goto err; } /* chip specific initialization */ ret = lp55xx_post_init_device(chip); if (ret) { dev_err(dev, "post init device err: %d\n", ret); goto err_post_init; } return 0; err_post_init: lp55xx_deinit_device(chip); err: return ret; }
static int de1soc_audio_probe(struct platform_device *pdev) { struct device_node *np = pdev->dev.of_node; struct device_node *codec_np, *cpu_np; struct snd_soc_card *card = &snd_soc_de1soc; int ret; if (!np) { return -ENODEV; } card->dev = &pdev->dev; /* I2C bus is muxed between HPS and FPGA. Set mux to HPS */ i2c_mux_gpio = of_get_named_gpio(np, "i2c-mux-gpio", 0); if (gpio_is_valid(i2c_mux_gpio)) { ret = devm_gpio_request_one(&pdev->dev, i2c_mux_gpio, GPIOF_OUT_INIT_LOW, "I2C_MUX"); if (ret) { dev_err(&pdev->dev, "Failed to request GPIO_%d for i2c_mux: %d\n", i2c_mux_gpio, ret); return ret; } gpio_set_value(i2c_mux_gpio, 1); } /* Parse codec info */ de1soc_dai.codec_name = NULL; codec_np = of_parse_phandle(np, "audio-codec", 0); if (!codec_np) { dev_err(&pdev->dev, "codec info missing\n"); return -EINVAL; } de1soc_dai.codec_of_node = codec_np; /* Parse dai and platform info */ de1soc_dai.cpu_dai_name = NULL; de1soc_dai.platform_name = NULL; cpu_np = of_parse_phandle(np, "i2s-controller", 0); if (!cpu_np) { dev_err(&pdev->dev, "dai and pcm info missing\n"); return -EINVAL; } de1soc_dai.cpu_of_node = cpu_np; de1soc_dai.platform_of_node = cpu_np; of_node_put(codec_np); of_node_put(cpu_np); ret = snd_soc_register_card(card); if (ret) { dev_err(&pdev->dev, "snd_soc_register_card() failed\n"); } return ret; }
static void exynos_pcie_assert_reset(struct exynos_pcie *exynos_pcie) { struct pcie_port *pp = &exynos_pcie->pp; struct device *dev = pp->dev; if (exynos_pcie->reset_gpio >= 0) devm_gpio_request_one(dev, exynos_pcie->reset_gpio, GPIOF_OUT_INIT_HIGH, "RESET"); }
static void exynos_pcie_assert_reset(struct exynos_pcie *ep) { struct dw_pcie *pci = ep->pci; struct device *dev = pci->dev; if (ep->reset_gpio >= 0) devm_gpio_request_one(dev, ep->reset_gpio, GPIOF_OUT_INIT_HIGH, "RESET"); }
static int st21nfcb_nci_i2c_request_resources(struct i2c_client *client) { struct st21nfcb_nfc_platform_data *pdata; struct st21nfcb_i2c_phy *phy = i2c_get_clientdata(client); int r; int irq; pdata = client->dev.platform_data; if (pdata == NULL) { nfc_err(&client->dev, "No platform data\n"); return -EINVAL; } /* store for later use */ phy->gpio_irq = pdata->gpio_irq; phy->gpio_reset = pdata->gpio_reset; phy->irq_polarity = pdata->irq_polarity; r = devm_gpio_request_one(&client->dev, phy->gpio_irq, GPIOF_IN, "clf_irq"); if (r) { pr_err("%s : gpio_request failed\n", __FILE__); return -ENODEV; } r = devm_gpio_request_one(&client->dev, phy->gpio_reset, GPIOF_OUT_INIT_HIGH, "clf_reset"); if (r) { pr_err("%s : reset gpio_request failed\n", __FILE__); return -ENODEV; } /* IRQ */ irq = gpio_to_irq(phy->gpio_irq); if (irq < 0) { nfc_err(&client->dev, "Unable to get irq number for GPIO %d error %d\n", phy->gpio_irq, r); return -ENODEV; } client->irq = irq; return 0; }
static int s3fwrn5_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct s3fwrn5_i2c_phy *phy; int ret; phy = devm_kzalloc(&client->dev, sizeof(*phy), GFP_KERNEL); if (!phy) return -ENOMEM; mutex_init(&phy->mutex); phy->mode = S3FWRN5_MODE_COLD; phy->irq_skip = true; phy->i2c_dev = client; i2c_set_clientdata(client, phy); ret = s3fwrn5_i2c_parse_dt(client); if (ret < 0) return ret; ret = devm_gpio_request_one(&phy->i2c_dev->dev, phy->gpio_en, GPIOF_OUT_INIT_HIGH, "s3fwrn5_en"); if (ret < 0) return ret; ret = devm_gpio_request_one(&phy->i2c_dev->dev, phy->gpio_fw_wake, GPIOF_OUT_INIT_LOW, "s3fwrn5_fw_wake"); if (ret < 0) return ret; ret = s3fwrn5_probe(&phy->ndev, phy, &phy->i2c_dev->dev, &i2c_phy_ops, S3FWRN5_I2C_MAX_PAYLOAD); if (ret < 0) return ret; ret = request_threaded_irq(phy->i2c_dev->irq, NULL, s3fwrn5_i2c_irq_thread_fn, IRQF_TRIGGER_HIGH | IRQF_ONESHOT, S3FWRN5_I2C_DRIVER_NAME, phy); if (ret) s3fwrn5_remove(phy->ndev); return ret; }
/** * mmc_gpio_request_cd - request a gpio for card-detection * @host: mmc host * @gpio: gpio number requested * * As devm_* managed functions are used in mmc_gpio_request_cd(), client * drivers do not need to explicitly call mmc_gpio_free_cd() for freeing up, * if the requesting and freeing are only needed at probing and unbinding time * for once. However, if client drivers do something special like runtime * switching for card-detection, they are responsible for calling * mmc_gpio_request_cd() and mmc_gpio_free_cd() as a pair on their own. * * Returns zero on success, else an error. */ int mmc_gpio_request_cd(struct mmc_host *host, unsigned int gpio) { struct mmc_gpio *ctx; int irq = gpio_to_irq(gpio); int ret; ret = mmc_gpio_alloc(host); if (ret < 0) return ret; ctx = host->slot.handler_priv; ret = devm_gpio_request_one(&host->class_dev, gpio, GPIOF_DIR_IN, ctx->cd_label); if (ret < 0) /* * don't bother freeing memory. It might still get used by other * slot functions, in any case it will be freed, when the device * is destroyed. */ return ret; /* * Even if gpio_to_irq() returns a valid IRQ number, the platform might * still prefer to poll, e.g., because that IRQ number is already used * by another unit and cannot be shared. */ if (irq >= 0 && host->caps & MMC_CAP_NEEDS_POLL) irq = -EINVAL; ctx->cd_gpio = gpio; host->slot.cd_irq = irq; ret = mmc_gpio_get_status(host); if (ret < 0) return ret; ctx->status = ret; if (irq >= 0) { ret = devm_request_threaded_irq(&host->class_dev, irq, NULL, mmc_gpio_cd_irqt, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, ctx->cd_label, host); if (ret < 0) irq = ret; #ifndef VENDOR_EDIT //[email protected], 2014-07-10 Add for retry 5 times when new sdcard init error enable_irq_wake(irq); #endif /* VENDOR_EDIT */ } if (irq < 0) host->caps |= MMC_CAP_NEEDS_POLL; return 0; }
static int soc_pcmcia_hw_init(struct soc_pcmcia_socket *skt) { int ret = 0, i; clk_prepare_enable(skt->clk); if (skt->ops->hw_init) { ret = skt->ops->hw_init(skt); if (ret) return ret; } for (i = 0; i < ARRAY_SIZE(skt->stat); i++) { if (gpio_is_valid(skt->stat[i].gpio)) { unsigned long flags = GPIOF_IN; /* CD is active low by default */ if (i == SOC_STAT_CD) flags |= GPIOF_ACTIVE_LOW; ret = devm_gpio_request_one(skt->socket.dev.parent, skt->stat[i].gpio, flags, skt->stat[i].name); if (ret) { __soc_pcmcia_hw_shutdown(skt, i); return ret; } skt->stat[i].desc = gpio_to_desc(skt->stat[i].gpio); } if (i < SOC_STAT_VS1 && skt->stat[i].desc) { int irq = gpiod_to_irq(skt->stat[i].desc); if (irq > 0) { if (i == SOC_STAT_RDY) skt->socket.pci_irq = irq; else skt->stat[i].irq = irq; } } if (skt->stat[i].irq) { ret = request_irq(skt->stat[i].irq, soc_common_pcmcia_interrupt, IRQF_TRIGGER_NONE, skt->stat[i].name, skt); if (ret) { __soc_pcmcia_hw_shutdown(skt, i); return ret; } } } return ret; }
static int mcuio_dio_probe(struct mcuio_device *mdev) { struct mcuio_shld_i2c_info *i; int cnt; int ret; struct mcuio_shld_data *data; dev_dbg(&mdev->dev, "%s entered\n", __func__); data = devm_kzalloc(&mdev->dev, sizeof(*data), GFP_KERNEL); if (!data) return -ENOMEM; dev_set_drvdata(&mdev->dev, data); /* Apply module_param values to platform_data when needed */ pca9555_plat.gpio_base = pca9555_base; data->i2c_adap = mcuio_get_i2c_adapter(mdev); if (!data->i2c_adap) { dev_err(&mdev->dev, "error setting up i2c adapter\n"); return -ENODEV; } data->i2c_info = i2c_lst; data->i2c_cnt = ARRAY_SIZE(i2c_lst); /* Register all devices in Digital IO shield */ for (cnt = 0; cnt < data->i2c_cnt; cnt++) { i = &data->i2c_info[cnt]; i->info.addr = *i->paddr; /* HACK this is needed to enable pullup */ ret = devm_gpio_request_one(&mdev->dev, i->gpio_irq, GPIOF_DIR_IN, "digitalio-shield"); if (ret < 0) return ret; gpio_direction_output(i->gpio_irq, 1); gpio_direction_input(i->gpio_irq); devm_gpio_free(&mdev->dev, i->gpio_irq); i->info.irq = (i->gpio_irq >= 0) ? gpio_to_irq(i->gpio_irq) : 0; i->i2c_client = i2c_new_device(data->i2c_adap, &i->info); if (!i->i2c_client) dev_err(&mdev->dev, "i2c_new_device %s failed\n", i->info.type); } dev_dbg(&mdev->dev, "%s returns ok\n", __func__); return 0; }
static int tfp410_probe(struct platform_device *pdev) { struct panel_drv_data *ddata; struct omap_dss_device *dssdev; int r; ddata = devm_kzalloc(&pdev->dev, sizeof(*ddata), GFP_KERNEL); if (!ddata) return -ENOMEM; platform_set_drvdata(pdev, ddata); if (dev_get_platdata(&pdev->dev)) { r = tfp410_probe_pdata(pdev); if (r) return r; } else if (pdev->dev.of_node) { r = tfp410_probe_of(pdev); if (r) return r; } else { return -ENODEV; } if (gpio_is_valid(ddata->pd_gpio)) { r = devm_gpio_request_one(&pdev->dev, ddata->pd_gpio, GPIOF_OUT_INIT_LOW, "tfp410 PD"); if (r) { dev_err(&pdev->dev, "Failed to request PD GPIO %d\n", ddata->pd_gpio); goto err_gpio; } } dssdev = &ddata->dssdev; dssdev->ops.dvi = &tfp410_dvi_ops; dssdev->dev = &pdev->dev; dssdev->type = OMAP_DISPLAY_TYPE_DPI; dssdev->output_type = OMAP_DISPLAY_TYPE_DVI; dssdev->owner = THIS_MODULE; dssdev->phy.dpi.data_lines = ddata->data_lines; dssdev->port_num = 1; r = omapdss_register_output(dssdev); if (r) { dev_err(&pdev->dev, "Failed to register output\n"); goto err_reg; } return 0; err_reg: err_gpio: omap_dss_put_device(ddata->in); return r; }
static int ws_eink_init_display(struct ws_eink_fb_par *par) { int ret; struct device *dev = &par->spi->dev; ret = devm_gpio_request_one(&par->spi->dev, par->rst, GPIOF_OUT_INIT_LOW, "ws_eink_rst"); if (ret) { dev_err(dev, "Couldn't request reset GPIO\n"); return ret; } ret = devm_gpio_request_one(&par->spi->dev, par->dc, GPIOF_OUT_INIT_LOW, "ws_eink_dc"); if (ret) { dev_err(dev, "Couldn't request data/command GPIO\n"); return ret; } ret = devm_gpio_request_one(&par->spi->dev, par->busy, GPIOF_IN, "ws_eink_busy"); if (ret) { dev_err(dev, "Couldn't request busy GPIO\n"); return ret; } ret = int_lut(par, lut_full_update, ARRAY_SIZE(lut_full_update)); if (ret) return ret; ret = clear_frame_memory(par, 0xFF); if (ret) return ret; ret = display_frame(par); if (ret) return ret; ret = int_lut(par, lut_partial_update, ARRAY_SIZE(lut_partial_update)); return ret; }
static int _gpio_request(struct lp8788_buck *buck, int gpio, char *name) { struct device *dev = buck->lp->dev; if (!gpio_is_valid(gpio)) { dev_err(dev, "invalid gpio: %d\n", gpio); return -EINVAL; } return devm_gpio_request_one(dev, gpio, DVS_LOW, name); }
static int panel_dpi_probe(struct platform_device *pdev) { struct panel_drv_data *ddata; struct omap_dss_device *dssdev; int r; ddata = devm_kzalloc(&pdev->dev, sizeof(*ddata), GFP_KERNEL); if (ddata == NULL) return -ENOMEM; platform_set_drvdata(pdev, ddata); if (dev_get_platdata(&pdev->dev)) { r = panel_dpi_probe_pdata(pdev); if (r) return r; } else if (pdev->dev.of_node) { r = panel_dpi_probe_of(pdev); if (r) return r; } else { return -ENODEV; } if (gpio_is_valid(ddata->backlight_gpio)) { r = devm_gpio_request_one(&pdev->dev, ddata->backlight_gpio, GPIOF_OUT_INIT_LOW, "panel backlight"); if (r) goto err_gpio; } dssdev = &ddata->dssdev; dssdev->dev = &pdev->dev; dssdev->driver = &panel_dpi_ops; dssdev->type = OMAP_DISPLAY_TYPE_DPI; dssdev->owner = THIS_MODULE; dssdev->panel.vm = ddata->vm; dssdev->phy.dpi.data_lines = ddata->data_lines; r = omapdss_register_display(dssdev); if (r) { dev_err(&pdev->dev, "Failed to register panel\n"); goto err_reg; } return 0; err_reg: err_gpio: omap_dss_put_device(ddata->in); return r; }
static int hdmic_probe(struct platform_device *pdev) { struct panel_drv_data *ddata; struct omap_dss_device *dssdev; int r; ddata = devm_kzalloc(&pdev->dev, sizeof(*ddata), GFP_KERNEL); if (!ddata) return -ENOMEM; platform_set_drvdata(pdev, ddata); ddata->dev = &pdev->dev; if (dev_get_platdata(&pdev->dev)) { r = hdmic_probe_pdata(pdev); if (r) return r; } else if (pdev->dev.of_node) { r = hdmic_probe_of(pdev); if (r) return r; } else { return -ENODEV; } if (gpio_is_valid(ddata->hpd_gpio)) { r = devm_gpio_request_one(&pdev->dev, ddata->hpd_gpio, GPIOF_DIR_IN, "hdmi_hpd"); if (r) goto err_reg; } ddata->timings = hdmic_default_timings; dssdev = &ddata->dssdev; dssdev->driver = &hdmic_driver; dssdev->dev = &pdev->dev; dssdev->type = OMAP_DISPLAY_TYPE_HDMI; dssdev->owner = THIS_MODULE; dssdev->panel.timings = hdmic_default_timings; r = omapdss_register_display(dssdev); if (r) { dev_err(&pdev->dev, "Failed to register panel\n"); goto err_reg; } return 0; err_reg: omap_dss_put_device(ddata->in); return r; }
static int cht_pwrbtn_probe(struct platform_device *pdev) { int ret; struct device *dev = &pdev->dev; struct input_dev *input; ret = devm_gpio_request_one(dev, CHT_PWRBTN_GPIO, GPIOF_DIR_IN | GPIOF_ACTIVE_LOW, CHT_PWRBTN_NAME); if (ret) { dev_err(dev, "Failed to request GPIO %d, error %d\n", CHT_PWRBTN_GPIO, ret); return ret; } input = devm_input_allocate_device(dev); if (!input) { dev_err(dev, "Failed to allocate input device\n"); return -ENOMEM; } input->name = CHT_PWRBTN_NAME; input->evbit[0] = BIT_MASK(EV_KEY); input_set_capability(input, EV_KEY, KEY_POWER); ret = gpio_to_irq(CHT_PWRBTN_GPIO); if (ret < 0) { dev_err(dev, "Unable to get irq number for GPIO %d, error %d\n", CHT_PWRBTN_GPIO, ret); return ret; } ret = devm_request_irq(dev, ret, cht_pwrbtn_irq, (IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING), CHT_PWRBTN_NAME, input); if (ret) { dev_err(dev, "Unable to request irq, error: %d\n", ret); return ret; } ret = input_register_device(input); if (ret) { dev_err(dev, "Unable to register input device, error: %d\n", ret); return ret; } platform_set_drvdata(pdev, input); device_init_wakeup(&pdev->dev, 1); dev_info(dev, "Driver successfully loaded"); return 0; }
int mmc_gpio_request_cd(struct mmc_host *host, unsigned int gpio) { struct mmc_gpio *ctx; int irq = gpio_to_irq(gpio); int ret; int irq_trigger_type; ret = mmc_gpio_alloc(host); if (ret < 0) return ret; host->cd_pin_depth = 0; spin_lock_init(&host->lock_cd_pin); ctx = host->slot.handler_priv; ret = devm_gpio_request_one(&host->class_dev, gpio, GPIOF_DIR_IN, ctx->cd_label); if (ret < 0) { return ret; } if (irq >= 0 && host->caps & MMC_CAP_NEEDS_POLL) irq = -EINVAL; ctx->cd_gpio = gpio; host->slot.cd_irq = irq; ret = mmc_gpio_get_status(host); if (ret < 0) return ret; irq_trigger_type = (ret == 0 ? IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING); ctx->status = ret; if (irq >= 0) { ret = devm_request_threaded_irq(&host->class_dev, irq, NULL, mmc_gpio_cd_irqt, irq_trigger_type | IRQF_ONESHOT, ctx->cd_label, host); if (ret < 0) irq = ret; } if (irq < 0) host->caps |= MMC_CAP_NEEDS_POLL; return 0; }
static int dw_mci_hs_cd_detect_init(struct dw_mci *host) { struct device_node *np = host->dev->of_node; int gpio; int err; if (host->pdata->quirks & DW_MCI_QUIRK_BROKEN_CARD_DETECTION) return 0; gpio = of_get_named_gpio(np, "cd-gpio", 0); if (gpio_is_valid(gpio)) { if (devm_gpio_request_one(host->dev, gpio, GPIOF_IN, "dw-mci-cd")) { dev_err(host->dev, "gpio [%d] request failed\n", gpio); } else { struct dw_mci_hs_priv_data *priv = host->priv; int shared_irq = 0; priv->gpio_cd = gpio; host->pdata->get_cd = dw_mci_hs_get_cd; if (of_property_read_u32(np, "shared-irq", &shared_irq)) { dev_info(host->dev, "shared-irq property not found, using " "shared_irq of 0 as default\n"); shared_irq = 0; } if(shared_irq) { err = devm_request_irq( host->dev, gpio_to_irq(gpio), dw_mci_hs_card_detect, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING | IRQF_NO_SUSPEND | IRQF_SHARED, DRIVER_NAME, host); } else { err = devm_request_irq( host->dev, gpio_to_irq(gpio), dw_mci_hs_card_detect, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING, DRIVER_NAME, host); } if (err) dev_warn(mmc_dev(host->dev), "request gpio irq error\n"); } } else { dev_info(host->dev, "cd gpio not available"); } return 0; }