void mmc_gpiod_request_cd_irq(struct mmc_host *host) { struct mmc_gpio *ctx = host->slot.handler_priv; int irq = -EINVAL; int ret; if (host->slot.cd_irq >= 0 || !ctx || !ctx->cd_gpio) return; /* * Do not use IRQ if the platform prefers to poll, e.g., because that * IRQ number is already used by another unit and cannot be shared. */ if (!(host->caps & MMC_CAP_NEEDS_POLL)) irq = gpiod_to_irq(ctx->cd_gpio); if (irq >= 0) { if (!ctx->cd_gpio_isr) ctx->cd_gpio_isr = mmc_gpio_cd_irqt; ret = devm_request_threaded_irq(host->parent, irq, NULL, ctx->cd_gpio_isr, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, ctx->cd_label, host); if (ret < 0) irq = ret; } host->slot.cd_irq = irq; if (irq < 0) host->caps |= MMC_CAP_NEEDS_POLL; }
void mmc_gpiod_request_cd_irq(struct mmc_host *host) { struct mmc_gpio *ctx = host->slot.handler_priv; int ret, irq; if (host->slot.cd_irq >= 0 || !ctx || !ctx->cd_gpio) return; irq = gpiod_to_irq(ctx->cd_gpio); /* * Even if gpiod_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; 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; } host->slot.cd_irq = irq; if (irq < 0) host->caps |= MMC_CAP_NEEDS_POLL; }
static int sdhci_acpi_add_own_cd(struct device *dev, struct mmc_host *mmc) { struct gpio_desc *desc; unsigned long flags; int err, irq; desc = devm_gpiod_get_index(dev, "sd_cd", 0); if (IS_ERR(desc)) { err = PTR_ERR(desc); goto out; } err = gpiod_direction_input(desc); if (err) goto out_free; irq = gpiod_to_irq(desc); 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_gpiod_put(dev, desc); out: dev_warn(dev, "failed to setup card detect wake up\n"); return err; }
static int max3355_probe(struct platform_device *pdev) { struct max3355_data *data; struct gpio_desc *gpiod; int irq, err; data = devm_kzalloc(&pdev->dev, sizeof(struct max3355_data), GFP_KERNEL); if (!data) return -ENOMEM; gpiod = devm_gpiod_get(&pdev->dev, "id", GPIOD_IN); if (IS_ERR(gpiod)) { dev_err(&pdev->dev, "failed to get ID_OUT GPIO\n"); return PTR_ERR(gpiod); } data->id_gpiod = gpiod; gpiod = devm_gpiod_get(&pdev->dev, "maxim,shdn", GPIOD_OUT_HIGH); if (IS_ERR(gpiod)) { dev_err(&pdev->dev, "failed to get SHDN# GPIO\n"); return PTR_ERR(gpiod); } data->shdn_gpiod = gpiod; data->edev = devm_extcon_dev_allocate(&pdev->dev, max3355_cable); if (IS_ERR(data->edev)) { dev_err(&pdev->dev, "failed to allocate extcon device\n"); return PTR_ERR(data->edev); } err = devm_extcon_dev_register(&pdev->dev, data->edev); if (err < 0) { dev_err(&pdev->dev, "failed to register extcon device\n"); return err; } irq = gpiod_to_irq(data->id_gpiod); if (irq < 0) { dev_err(&pdev->dev, "failed to translate ID_OUT GPIO to IRQ\n"); return irq; } err = devm_request_threaded_irq(&pdev->dev, irq, NULL, max3355_id_irq, IRQF_ONESHOT | IRQF_NO_SUSPEND | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, pdev->name, data); if (err < 0) { dev_err(&pdev->dev, "failed to request ID_OUT IRQ\n"); return err; } platform_set_drvdata(pdev, data); /* Perform initial detection */ max3355_id_irq(irq, data); return 0; }
/** * phy_mdm6600_init_irq() - initialize mdm6600 status IRQ lines * @ddata: device driver data */ static void phy_mdm6600_init_irq(struct phy_mdm6600 *ddata) { struct device *dev = ddata->dev; int i, error, irq; for (i = PHY_MDM6600_STATUS0; i <= PHY_MDM6600_STATUS2; i++) { struct gpio_desc *gpio = ddata->status_gpios->desc[i]; irq = gpiod_to_irq(gpio); if (irq <= 0) continue; error = devm_request_threaded_irq(dev, irq, NULL, phy_mdm6600_irq_thread, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, "mdm6600", ddata); if (error) dev_warn(dev, "no modem status irq%i: %i\n", irq, error); } }
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 usb_phy_generic_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct usb_phy_generic *nop; int err; nop = devm_kzalloc(dev, sizeof(*nop), GFP_KERNEL); if (!nop) return -ENOMEM; err = usb_phy_gen_create_phy(dev, nop, dev_get_platdata(&pdev->dev)); if (err) return err; if (nop->gpiod_vbus) { err = devm_request_threaded_irq(&pdev->dev, gpiod_to_irq(nop->gpiod_vbus), NULL, nop_gpio_vbus_thread, VBUS_IRQ_FLAGS, "vbus_detect", nop); if (err) { dev_err(&pdev->dev, "can't request irq %i, err: %d\n", gpiod_to_irq(nop->gpiod_vbus), err); return err; } nop->phy.otg->state = gpiod_get_value(nop->gpiod_vbus) ? OTG_STATE_B_PERIPHERAL : OTG_STATE_B_IDLE; } nop->phy.init = usb_gen_phy_init; nop->phy.shutdown = usb_gen_phy_shutdown; err = usb_add_phy_dev(&nop->phy); if (err) { dev_err(&pdev->dev, "can't register transceiver, err: %d\n", err); return err; } platform_set_drvdata(pdev, nop); return 0; }
static int hdmic_probe(struct platform_device *pdev) { struct panel_drv_data *ddata; struct omap_dss_device *dssdev; struct gpio_desc *gpio; int r; ddata = devm_kzalloc(&pdev->dev, sizeof(*ddata), GFP_KERNEL); if (!ddata) return -ENOMEM; platform_set_drvdata(pdev, ddata); ddata->dev = &pdev->dev; mutex_init(&ddata->hpd_lock); /* HPD GPIO */ gpio = devm_gpiod_get_optional(&pdev->dev, "hpd", GPIOD_IN); if (IS_ERR(gpio)) { dev_err(&pdev->dev, "failed to parse HPD gpio\n"); return PTR_ERR(gpio); } ddata->hpd_gpio = gpio; if (ddata->hpd_gpio) { r = devm_request_threaded_irq(&pdev->dev, gpiod_to_irq(ddata->hpd_gpio), NULL, hdmic_hpd_isr, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, "hdmic hpd", ddata); if (r) return r; } dssdev = &ddata->dssdev; dssdev->ops = &hdmic_ops; dssdev->dev = &pdev->dev; dssdev->type = OMAP_DISPLAY_TYPE_HDMI; dssdev->display = true; dssdev->owner = THIS_MODULE; dssdev->of_ports = BIT(0); dssdev->ops_flags = ddata->hpd_gpio ? OMAP_DSS_DEVICE_OP_DETECT | OMAP_DSS_DEVICE_OP_HPD : 0; omapdss_display_init(dssdev); omapdss_device_register(dssdev); return 0; }
struct mctrl_gpios *mctrl_gpio_init(struct uart_port *port, unsigned int idx) { struct mctrl_gpios *gpios; enum mctrl_gpio_idx i; gpios = mctrl_gpio_init_noauto(port->dev, idx); if (IS_ERR(gpios)) return gpios; gpios->port = port; for (i = 0; i < UART_GPIO_MAX; ++i) { int ret; if (!gpios->gpio[i] || mctrl_gpios_desc[i].dir_out) continue; ret = gpiod_to_irq(gpios->gpio[i]); if (ret <= 0) { dev_err(port->dev, "failed to find corresponding irq for %s (idx=%d, err=%d)\n", mctrl_gpios_desc[i].name, idx, ret); return ERR_PTR(ret); } gpios->irq[i] = ret; /* irqs should only be enabled in .enable_ms */ irq_set_status_flags(gpios->irq[i], IRQ_NOAUTOEN); ret = devm_request_irq(port->dev, gpios->irq[i], mctrl_gpio_irq_handle, IRQ_TYPE_EDGE_BOTH, dev_name(port->dev), gpios); if (ret) { /* alternatively implement polling */ dev_err(port->dev, "failed to request irq for %s (idx=%d, err=%d)\n", mctrl_gpios_desc[i].name, idx, ret); return ERR_PTR(ret); } } return gpios; }
static int gpio_charger_get_irq(struct device *dev, void *dev_id, struct gpio_desc *gpio) { int ret, irq = gpiod_to_irq(gpio); if (irq > 0) { ret = devm_request_any_context_irq(dev, irq, gpio_charger_irq, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, dev_name(dev), dev_id); if (ret < 0) { dev_warn(dev, "Failed to request irq: %d\n", ret); irq = 0; } } return irq; }
static int setup_gpio(struct pi433_device *device) { char name[5]; int retval; int i; const irq_handler_t DIO_irq_handler[NUM_DIO] = { DIO0_irq_handler, DIO1_irq_handler }; for (i = 0; i < NUM_DIO; i++) { /* "construct" name and get the gpio descriptor */ snprintf(name, sizeof(name), "DIO%d", i); device->gpiod[i] = gpiod_get(&device->spi->dev, name, 0 /*GPIOD_IN*/); if (device->gpiod[i] == ERR_PTR(-ENOENT)) { dev_dbg(&device->spi->dev, "Could not find entry for %s. Ignoring.", name); continue; } if (device->gpiod[i] == ERR_PTR(-EBUSY)) dev_dbg(&device->spi->dev, "%s is busy.", name); if (IS_ERR(device->gpiod[i])) { retval = PTR_ERR(device->gpiod[i]); /* release already allocated gpios */ for (i--; i >= 0; i--) { free_irq(device->irq_num[i], device); gpiod_put(device->gpiod[i]); } return retval; } /* configure the pin */ gpiod_unexport(device->gpiod[i]); retval = gpiod_direction_input(device->gpiod[i]); if (retval) return retval; /* configure irq */ device->irq_num[i] = gpiod_to_irq(device->gpiod[i]); if (device->irq_num[i] < 0) { device->gpiod[i] = ERR_PTR(-EINVAL); return device->irq_num[i]; } retval = request_irq(device->irq_num[i], DIO_irq_handler[i], 0, /* flags */ name, device); if (retval) return retval; dev_dbg(&device->spi->dev, "%s successfully configured", name); } return 0; }
static int nokia_bluetooth_serdev_probe(struct serdev_device *serdev) { struct device *dev = &serdev->dev; struct nokia_bt_dev *btdev; struct clk *sysclk; int err = 0; btdev = devm_kzalloc(dev, sizeof(*btdev), GFP_KERNEL); if (!btdev) return -ENOMEM; btdev->hu.serdev = btdev->serdev = serdev; serdev_device_set_drvdata(serdev, btdev); btdev->reset = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH); if (IS_ERR(btdev->reset)) { err = PTR_ERR(btdev->reset); dev_err(dev, "could not get reset gpio: %d", err); return err; } btdev->wakeup_host = devm_gpiod_get(dev, "host-wakeup", GPIOD_IN); if (IS_ERR(btdev->wakeup_host)) { err = PTR_ERR(btdev->wakeup_host); dev_err(dev, "could not get host wakeup gpio: %d", err); return err; } btdev->wake_irq = gpiod_to_irq(btdev->wakeup_host); err = devm_request_threaded_irq(dev, btdev->wake_irq, NULL, wakeup_handler, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, "wakeup", btdev); if (err) { dev_err(dev, "could request wakeup irq: %d", err); return err; } btdev->wakeup_bt = devm_gpiod_get(dev, "bluetooth-wakeup", GPIOD_OUT_LOW); if (IS_ERR(btdev->wakeup_bt)) { err = PTR_ERR(btdev->wakeup_bt); dev_err(dev, "could not get BT wakeup gpio: %d", err); return err; } sysclk = devm_clk_get(dev, "sysclk"); if (IS_ERR(sysclk)) { err = PTR_ERR(sysclk); dev_err(dev, "could not get sysclk: %d", err); return err; } clk_prepare_enable(sysclk); btdev->sysclk_speed = clk_get_rate(sysclk); clk_disable_unprepare(sysclk); skb_queue_head_init(&btdev->txq); btdev->hu.priv = btdev; btdev->hu.alignment = 2; /* Nokia H4+ is word aligned */ err = hci_uart_register_device(&btdev->hu, &nokia_proto); if (err) { dev_err(dev, "could not register bluetooth uart: %d", err); return err; } return 0; }
static int arche_platform_probe(struct platform_device *pdev) { struct arche_platform_drvdata *arche_pdata; struct device *dev = &pdev->dev; struct device_node *np = dev->of_node; int ret; unsigned int flags; arche_pdata = devm_kzalloc(&pdev->dev, sizeof(*arche_pdata), GFP_KERNEL); if (!arche_pdata) return -ENOMEM; /* setup svc reset gpio */ arche_pdata->is_reset_act_hi = of_property_read_bool(np, "svc,reset-active-high"); if (arche_pdata->is_reset_act_hi) flags = GPIOD_OUT_HIGH; else flags = GPIOD_OUT_LOW; arche_pdata->svc_reset = devm_gpiod_get(dev, "svc,reset", flags); if (IS_ERR(arche_pdata->svc_reset)) { ret = PTR_ERR(arche_pdata->svc_reset); dev_err(dev, "failed to request svc-reset GPIO: %d\n", ret); return ret; } arche_platform_set_state(arche_pdata, ARCHE_PLATFORM_STATE_OFF); arche_pdata->svc_sysboot = devm_gpiod_get(dev, "svc,sysboot", GPIOD_OUT_LOW); if (IS_ERR(arche_pdata->svc_sysboot)) { ret = PTR_ERR(arche_pdata->svc_sysboot); dev_err(dev, "failed to request sysboot0 GPIO: %d\n", ret); return ret; } /* setup the clock request gpio first */ arche_pdata->svc_refclk_req = devm_gpiod_get(dev, "svc,refclk-req", GPIOD_IN); if (IS_ERR(arche_pdata->svc_refclk_req)) { ret = PTR_ERR(arche_pdata->svc_refclk_req); dev_err(dev, "failed to request svc-clk-req GPIO: %d\n", ret); return ret; } /* setup refclk2 to follow the pin */ arche_pdata->svc_ref_clk = devm_clk_get(dev, "svc_ref_clk"); if (IS_ERR(arche_pdata->svc_ref_clk)) { ret = PTR_ERR(arche_pdata->svc_ref_clk); dev_err(dev, "failed to get svc_ref_clk: %d\n", ret); return ret; } platform_set_drvdata(pdev, arche_pdata); arche_pdata->num_apbs = of_get_child_count(np); dev_dbg(dev, "Number of APB's available - %d\n", arche_pdata->num_apbs); arche_pdata->wake_detect = devm_gpiod_get(dev, "svc,wake-detect", GPIOD_IN); if (IS_ERR(arche_pdata->wake_detect)) { ret = PTR_ERR(arche_pdata->wake_detect); dev_err(dev, "Failed requesting wake_detect GPIO: %d\n", ret); return ret; } arche_platform_set_wake_detect_state(arche_pdata, WD_STATE_IDLE); arche_pdata->dev = &pdev->dev; spin_lock_init(&arche_pdata->wake_lock); mutex_init(&arche_pdata->platform_state_mutex); arche_pdata->wake_detect_irq = gpiod_to_irq(arche_pdata->wake_detect); ret = devm_request_threaded_irq(dev, arche_pdata->wake_detect_irq, arche_platform_wd_irq, arche_platform_wd_irq_thread, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING | IRQF_ONESHOT, dev_name(dev), arche_pdata); if (ret) { dev_err(dev, "failed to request wake detect IRQ %d\n", ret); return ret; } disable_irq(arche_pdata->wake_detect_irq); ret = device_create_file(dev, &dev_attr_state); if (ret) { dev_err(dev, "failed to create state file in sysfs\n"); return ret; } ret = of_platform_populate(np, NULL, NULL, dev); if (ret) { dev_err(dev, "failed to populate child nodes %d\n", ret); goto err_device_remove; } arche_pdata->pm_notifier.notifier_call = arche_platform_pm_notifier; ret = register_pm_notifier(&arche_pdata->pm_notifier); if (ret) { dev_err(dev, "failed to register pm notifier %d\n", ret); goto err_device_remove; } /* Explicitly power off if requested */ if (!of_property_read_bool(pdev->dev.of_node, "arche,init-off")) { mutex_lock(&arche_pdata->platform_state_mutex); ret = arche_platform_coldboot_seq(arche_pdata); if (ret) { dev_err(dev, "Failed to cold boot svc %d\n", ret); goto err_coldboot; } arche_platform_wd_irq_en(arche_pdata); mutex_unlock(&arche_pdata->platform_state_mutex); } dev_info(dev, "Device registered successfully\n"); return 0; err_coldboot: mutex_unlock(&arche_pdata->platform_state_mutex); err_device_remove: device_remove_file(&pdev->dev, &dev_attr_state); return ret; }
static int rotary_encoder_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct rotary_encoder *encoder; struct input_dev *input; irq_handler_t handler; u32 steps_per_period; unsigned int i; int err; encoder = devm_kzalloc(dev, sizeof(struct rotary_encoder), GFP_KERNEL); if (!encoder) return -ENOMEM; mutex_init(&encoder->access_mutex); device_property_read_u32(dev, "rotary-encoder,steps", &encoder->steps); err = device_property_read_u32(dev, "rotary-encoder,steps-per-period", &steps_per_period); if (err) { /* * The 'half-period' property has been deprecated, you must * use 'steps-per-period' and set an appropriate value, but * we still need to parse it to maintain compatibility. If * neither property is present we fall back to the one step * per period behavior. */ steps_per_period = device_property_read_bool(dev, "rotary-encoder,half-period") ? 2 : 1; } encoder->rollover = device_property_read_bool(dev, "rotary-encoder,rollover"); if (!device_property_present(dev, "rotary-encoder,encoding") || !device_property_match_string(dev, "rotary-encoder,encoding", "gray")) { dev_info(dev, "gray"); encoder->encoding = ROTENC_GRAY; } else if (!device_property_match_string(dev, "rotary-encoder,encoding", "binary")) { dev_info(dev, "binary"); encoder->encoding = ROTENC_BINARY; } else { dev_err(dev, "unknown encoding setting\n"); return -EINVAL; } device_property_read_u32(dev, "linux,axis", &encoder->axis); encoder->relative_axis = device_property_read_bool(dev, "rotary-encoder,relative-axis"); encoder->gpios = devm_gpiod_get_array(dev, NULL, GPIOD_IN); if (IS_ERR(encoder->gpios)) { dev_err(dev, "unable to get gpios\n"); return PTR_ERR(encoder->gpios); } if (encoder->gpios->ndescs < 2) { dev_err(dev, "not enough gpios found\n"); return -EINVAL; } input = devm_input_allocate_device(dev); if (!input) return -ENOMEM; encoder->input = input; input->name = pdev->name; input->id.bustype = BUS_HOST; input->dev.parent = dev; if (encoder->relative_axis) input_set_capability(input, EV_REL, encoder->axis); else input_set_abs_params(input, encoder->axis, 0, encoder->steps, 0, 1); switch (steps_per_period >> (encoder->gpios->ndescs - 2)) { case 4: handler = &rotary_encoder_quarter_period_irq; encoder->last_stable = rotary_encoder_get_state(encoder); break; case 2: handler = &rotary_encoder_half_period_irq; encoder->last_stable = rotary_encoder_get_state(encoder); break; case 1: handler = &rotary_encoder_irq; break; default: dev_err(dev, "'%d' is not a valid steps-per-period value\n", steps_per_period); return -EINVAL; } encoder->irq = devm_kcalloc(dev, encoder->gpios->ndescs, sizeof(*encoder->irq), GFP_KERNEL); if (!encoder->irq) return -ENOMEM; for (i = 0; i < encoder->gpios->ndescs; ++i) { encoder->irq[i] = gpiod_to_irq(encoder->gpios->desc[i]); err = devm_request_threaded_irq(dev, encoder->irq[i], NULL, handler, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, DRV_NAME, encoder); if (err) { dev_err(dev, "unable to request IRQ %d (gpio#%d)\n", encoder->irq[i], i); return err; } } err = input_register_device(input); if (err) { dev_err(dev, "failed to register input device\n"); return err; } device_init_wakeup(dev, device_property_read_bool(dev, "wakeup-source")); platform_set_drvdata(pdev, encoder); return 0; }
static int gpio_charger_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; const struct gpio_charger_platform_data *pdata = dev->platform_data; struct power_supply_config psy_cfg = {}; struct gpio_charger *gpio_charger; struct power_supply_desc *charger_desc; unsigned long flags; int irq, ret; if (!pdata && !dev->of_node) { dev_err(dev, "No platform data\n"); return -ENOENT; } gpio_charger = devm_kzalloc(dev, sizeof(*gpio_charger), GFP_KERNEL); if (!gpio_charger) return -ENOMEM; /* * This will fetch a GPIO descriptor from device tree, ACPI or * boardfile descriptor tables. It's good to try this first. */ gpio_charger->gpiod = devm_gpiod_get(dev, NULL, GPIOD_IN); /* * If this fails and we're not using device tree, try the * legacy platform data method. */ if (IS_ERR(gpio_charger->gpiod) && !dev->of_node) { /* Non-DT: use legacy GPIO numbers */ if (!gpio_is_valid(pdata->gpio)) { dev_err(dev, "Invalid gpio pin in pdata\n"); return -EINVAL; } flags = GPIOF_IN; if (pdata->gpio_active_low) flags |= GPIOF_ACTIVE_LOW; ret = devm_gpio_request_one(dev, pdata->gpio, flags, dev_name(dev)); if (ret) { dev_err(dev, "Failed to request gpio pin: %d\n", ret); return ret; } /* Then convert this to gpiod for now */ gpio_charger->gpiod = gpio_to_desc(pdata->gpio); } else if (IS_ERR(gpio_charger->gpiod)) { /* Just try again if this happens */ if (PTR_ERR(gpio_charger->gpiod) == -EPROBE_DEFER) return -EPROBE_DEFER; dev_err(dev, "error getting GPIO descriptor\n"); return PTR_ERR(gpio_charger->gpiod); } charger_desc = &gpio_charger->charger_desc; charger_desc->properties = gpio_charger_properties; charger_desc->num_properties = ARRAY_SIZE(gpio_charger_properties); charger_desc->get_property = gpio_charger_get_property; psy_cfg.of_node = dev->of_node; psy_cfg.drv_data = gpio_charger; if (pdata) { charger_desc->name = pdata->name; charger_desc->type = pdata->type; psy_cfg.supplied_to = pdata->supplied_to; psy_cfg.num_supplicants = pdata->num_supplicants; } else { charger_desc->name = dev->of_node->name; charger_desc->type = gpio_charger_get_type(dev); } if (!charger_desc->name) charger_desc->name = pdev->name; gpio_charger->charger = devm_power_supply_register(dev, charger_desc, &psy_cfg); if (IS_ERR(gpio_charger->charger)) { ret = PTR_ERR(gpio_charger->charger); dev_err(dev, "Failed to register power supply: %d\n", ret); return ret; } irq = gpiod_to_irq(gpio_charger->gpiod); if (irq > 0) { ret = devm_request_any_context_irq(dev, irq, gpio_charger_irq, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, dev_name(dev), gpio_charger->charger); if (ret < 0) dev_warn(dev, "Failed to request irq: %d\n", ret); else gpio_charger->irq = irq; } platform_set_drvdata(pdev, gpio_charger); device_init_wakeup(dev, 1); return 0; }
static int sirf_probe(struct serdev_device *serdev) { struct device *dev = &serdev->dev; struct gnss_device *gdev; struct sirf_data *data; int ret; data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); if (!data) return -ENOMEM; gdev = gnss_allocate_device(dev); if (!gdev) return -ENOMEM; gdev->type = GNSS_TYPE_SIRF; gdev->ops = &sirf_gnss_ops; gnss_set_drvdata(gdev, data); data->serdev = serdev; data->gdev = gdev; init_waitqueue_head(&data->power_wait); serdev_device_set_drvdata(serdev, data); serdev_device_set_client_ops(serdev, &sirf_serdev_ops); ret = sirf_parse_dt(serdev); if (ret) goto err_put_device; data->vcc = devm_regulator_get(dev, "vcc"); if (IS_ERR(data->vcc)) { ret = PTR_ERR(data->vcc); goto err_put_device; } data->on_off = devm_gpiod_get_optional(dev, "sirf,onoff", GPIOD_OUT_LOW); if (IS_ERR(data->on_off)) goto err_put_device; if (data->on_off) { data->wakeup = devm_gpiod_get_optional(dev, "sirf,wakeup", GPIOD_IN); if (IS_ERR(data->wakeup)) goto err_put_device; /* * Configurations where WAKEUP has been left not connected, * are currently not supported. */ if (!data->wakeup) { dev_err(dev, "no wakeup gpio specified\n"); ret = -ENODEV; goto err_put_device; } } if (data->wakeup) { ret = gpiod_to_irq(data->wakeup); if (ret < 0) goto err_put_device; data->irq = ret; ret = devm_request_threaded_irq(dev, data->irq, NULL, sirf_wakeup_handler, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, "wakeup", data); if (ret) goto err_put_device; } if (data->on_off) { ret = regulator_enable(data->vcc); if (ret) goto err_put_device; /* Wait for chip to boot into hibernate mode */ msleep(SIRF_BOOT_DELAY); } if (IS_ENABLED(CONFIG_PM)) { pm_runtime_set_suspended(dev); /* clear runtime_error flag */ pm_runtime_enable(dev); } else { ret = sirf_runtime_resume(dev); if (ret < 0) goto err_disable_vcc; } ret = gnss_register_device(gdev); if (ret) goto err_disable_rpm; return 0; err_disable_rpm: if (IS_ENABLED(CONFIG_PM)) pm_runtime_disable(dev); else sirf_runtime_suspend(dev); err_disable_vcc: if (data->on_off) regulator_disable(data->vcc); err_put_device: gnss_put_device(data->gdev); return ret; }
static int gpio_keys_setup_key(struct platform_device *pdev, struct input_dev *input, struct gpio_keys_drvdata *ddata, const struct gpio_keys_button *button, int idx, struct fwnode_handle *child) { const char *desc = button->desc ? button->desc : "gpio_keys"; struct device *dev = &pdev->dev; struct gpio_button_data *bdata = &ddata->data[idx]; irq_handler_t isr; unsigned long irqflags; int irq; int error; bdata->input = input; bdata->button = button; spin_lock_init(&bdata->lock); if (child) { bdata->gpiod = devm_fwnode_get_gpiod_from_child(dev, NULL, child, GPIOD_IN, desc); if (IS_ERR(bdata->gpiod)) { error = PTR_ERR(bdata->gpiod); if (error == -ENOENT) { /* * GPIO is optional, we may be dealing with * purely interrupt-driven setup. */ bdata->gpiod = NULL; } else { if (error != -EPROBE_DEFER) dev_err(dev, "failed to get gpio: %d\n", error); return error; } } } else if (gpio_is_valid(button->gpio)) { /* * Legacy GPIO number, so request the GPIO here and * convert it to descriptor. */ unsigned flags = GPIOF_IN; if (button->active_low) flags |= GPIOF_ACTIVE_LOW; error = devm_gpio_request_one(dev, button->gpio, flags, desc); if (error < 0) { dev_err(dev, "Failed to request GPIO %d, error %d\n", button->gpio, error); return error; } bdata->gpiod = gpio_to_desc(button->gpio); if (!bdata->gpiod) return -EINVAL; } if (bdata->gpiod) { if (button->debounce_interval) { error = gpiod_set_debounce(bdata->gpiod, button->debounce_interval * 1000); /* use timer if gpiolib doesn't provide debounce */ if (error < 0) bdata->software_debounce = button->debounce_interval; } if (button->irq) { bdata->irq = button->irq; } else { irq = gpiod_to_irq(bdata->gpiod); if (irq < 0) { error = irq; dev_err(dev, "Unable to get irq number for GPIO %d, error %d\n", button->gpio, error); return error; } bdata->irq = irq; } INIT_DELAYED_WORK(&bdata->work, gpio_keys_gpio_work_func); isr = gpio_keys_gpio_isr; irqflags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING; } else { if (!button->irq) { dev_err(dev, "Found button without gpio or irq\n"); return -EINVAL; } bdata->irq = button->irq; if (button->type && button->type != EV_KEY) { dev_err(dev, "Only EV_KEY allowed for IRQ buttons.\n"); return -EINVAL; } bdata->release_delay = button->debounce_interval; setup_timer(&bdata->release_timer, gpio_keys_irq_timer, (unsigned long)bdata); isr = gpio_keys_irq_isr; irqflags = 0; } bdata->code = &ddata->keymap[idx]; *bdata->code = button->code; input_set_capability(input, button->type ?: EV_KEY, *bdata->code); /* * Install custom action to cancel release timer and * workqueue item. */ error = devm_add_action(dev, gpio_keys_quiesce_key, bdata); if (error) { dev_err(dev, "failed to register quiesce action, error: %d\n", error); return error; } /* * If platform has specified that the button can be disabled, * we don't want it to share the interrupt line. */ if (!button->can_disable) irqflags |= IRQF_SHARED; error = devm_request_any_context_irq(dev, bdata->irq, isr, irqflags, desc, bdata); if (error < 0) { dev_err(dev, "Unable to claim irq %d; error %d\n", bdata->irq, error); return error; } return 0; }
static int gpio_ir_recv_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct device_node *np = dev->of_node; struct gpio_rc_dev *gpio_dev; struct rc_dev *rcdev; int rc; if (!np) return -ENODEV; gpio_dev = devm_kzalloc(dev, sizeof(*gpio_dev), GFP_KERNEL); if (!gpio_dev) return -ENOMEM; gpio_dev->gpiod = devm_gpiod_get(dev, NULL, GPIOD_IN); if (IS_ERR(gpio_dev->gpiod)) { rc = PTR_ERR(gpio_dev->gpiod); /* Just try again if this happens */ if (rc != -EPROBE_DEFER) dev_err(dev, "error getting gpio (%d)\n", rc); return rc; } gpio_dev->irq = gpiod_to_irq(gpio_dev->gpiod); if (gpio_dev->irq < 0) return gpio_dev->irq; rcdev = devm_rc_allocate_device(dev, RC_DRIVER_IR_RAW); if (!rcdev) return -ENOMEM; rcdev->priv = gpio_dev; rcdev->device_name = GPIO_IR_DEVICE_NAME; rcdev->input_phys = GPIO_IR_DEVICE_NAME "/input0"; rcdev->input_id.bustype = BUS_HOST; rcdev->input_id.vendor = 0x0001; rcdev->input_id.product = 0x0001; rcdev->input_id.version = 0x0100; rcdev->dev.parent = dev; rcdev->driver_name = KBUILD_MODNAME; rcdev->min_timeout = 1; rcdev->timeout = IR_DEFAULT_TIMEOUT; rcdev->max_timeout = 10 * IR_DEFAULT_TIMEOUT; rcdev->allowed_protocols = RC_PROTO_BIT_ALL_IR_DECODER; rcdev->map_name = of_get_property(np, "linux,rc-map-name", NULL); if (!rcdev->map_name) rcdev->map_name = RC_MAP_EMPTY; gpio_dev->rcdev = rcdev; rc = devm_rc_register_device(dev, rcdev); if (rc < 0) { dev_err(dev, "failed to register rc device (%d)\n", rc); return rc; } platform_set_drvdata(pdev, gpio_dev); return devm_request_irq(dev, gpio_dev->irq, gpio_ir_recv_irq, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING, "gpio-ir-recv-irq", gpio_dev); }
/** * phy_mdm6600_device_power_on() - power on mdm6600 device * @ddata: device driver data * * To get the integrated USB phy in MDM6600 takes some hoops. We must ensure * the shared USB bootmode GPIOs are configured, then request modem start-up, * reset and power-up.. And then we need to recycle the shared USB bootmode * GPIOs as they are also used for Out of Band (OOB) wake for the USB and * TS 27.010 serial mux. */ static int phy_mdm6600_device_power_on(struct phy_mdm6600 *ddata) { struct gpio_desc *mode_gpio0, *mode_gpio1, *reset_gpio, *power_gpio; int error = 0, wakeirq; mode_gpio0 = ddata->mode_gpios->desc[PHY_MDM6600_MODE0]; mode_gpio1 = ddata->mode_gpios->desc[PHY_MDM6600_MODE1]; reset_gpio = ddata->ctrl_gpios[PHY_MDM6600_RESET]; power_gpio = ddata->ctrl_gpios[PHY_MDM6600_POWER]; /* * Shared GPIOs must be low for normal USB mode. After booting * they are used for OOB wake signaling. These can be also used * to configure USB flashing mode later on based on a module * parameter. */ gpiod_set_value_cansleep(mode_gpio0, 0); gpiod_set_value_cansleep(mode_gpio1, 0); /* Request start-up mode */ phy_mdm6600_cmd(ddata, PHY_MDM6600_CMD_NO_BYPASS); /* Request a reset first */ gpiod_set_value_cansleep(reset_gpio, 0); msleep(100); /* Toggle power GPIO to request mdm6600 to start */ gpiod_set_value_cansleep(power_gpio, 1); msleep(100); gpiod_set_value_cansleep(power_gpio, 0); /* * Looks like the USB PHY needs between 2.2 to 4 seconds. * If we try to use it before that, we will get L3 errors * from omap-usb-host trying to access the PHY. See also * phy_mdm6600_init() for -EPROBE_DEFER. */ msleep(PHY_MDM6600_PHY_DELAY_MS); ddata->enabled = true; /* Booting up the rest of MDM6600 will take total about 8 seconds */ dev_info(ddata->dev, "Waiting for power up request to complete..\n"); if (wait_for_completion_timeout(&ddata->ack, msecs_to_jiffies(PHY_MDM6600_ENABLED_DELAY_MS))) { if (ddata->status > PHY_MDM6600_STATUS_PANIC && ddata->status < PHY_MDM6600_STATUS_SHUTDOWN_ACK) dev_info(ddata->dev, "Powered up OK\n"); } else { ddata->enabled = false; error = -ETIMEDOUT; dev_err(ddata->dev, "Timed out powering up\n"); } /* Reconfigure mode1 GPIO as input for OOB wake */ gpiod_direction_input(mode_gpio1); wakeirq = gpiod_to_irq(mode_gpio1); if (wakeirq <= 0) return wakeirq; error = devm_request_threaded_irq(ddata->dev, wakeirq, NULL, phy_mdm6600_wakeirq_thread, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, "mdm6600-wake", ddata); if (error) dev_warn(ddata->dev, "no modem wakeirq irq%i: %i\n", wakeirq, error); ddata->running = true; return error; }
static int palmas_usb_probe(struct platform_device *pdev) { struct palmas *palmas = dev_get_drvdata(pdev->dev.parent); struct palmas_usb_platform_data *pdata = dev_get_platdata(&pdev->dev); struct device_node *node = pdev->dev.of_node; struct palmas_usb *palmas_usb; int status; palmas_usb = devm_kzalloc(&pdev->dev, sizeof(*palmas_usb), GFP_KERNEL); if (!palmas_usb) return -ENOMEM; if (node && !pdata) { palmas_usb->wakeup = of_property_read_bool(node, "ti,wakeup"); palmas_usb->enable_id_detection = of_property_read_bool(node, "ti,enable-id-detection"); palmas_usb->enable_vbus_detection = of_property_read_bool(node, "ti,enable-vbus-detection"); } else { palmas_usb->wakeup = true; palmas_usb->enable_id_detection = true; palmas_usb->enable_vbus_detection = true; if (pdata) palmas_usb->wakeup = pdata->wakeup; } palmas_usb->id_gpiod = devm_gpiod_get_optional(&pdev->dev, "id", GPIOD_IN); if (IS_ERR(palmas_usb->id_gpiod)) { dev_err(&pdev->dev, "failed to get id gpio\n"); return PTR_ERR(palmas_usb->id_gpiod); } palmas_usb->vbus_gpiod = devm_gpiod_get_optional(&pdev->dev, "vbus", GPIOD_IN); if (IS_ERR(palmas_usb->vbus_gpiod)) { dev_err(&pdev->dev, "failed to get vbus gpio\n"); return PTR_ERR(palmas_usb->vbus_gpiod); } if (palmas_usb->enable_id_detection && palmas_usb->id_gpiod) { palmas_usb->enable_id_detection = false; palmas_usb->enable_gpio_id_detection = true; } if (palmas_usb->enable_vbus_detection && palmas_usb->vbus_gpiod) { palmas_usb->enable_vbus_detection = false; palmas_usb->enable_gpio_vbus_detection = true; } if (palmas_usb->enable_gpio_id_detection) { u32 debounce; if (of_property_read_u32(node, "debounce-delay-ms", &debounce)) debounce = USB_GPIO_DEBOUNCE_MS; status = gpiod_set_debounce(palmas_usb->id_gpiod, debounce * 1000); if (status < 0) palmas_usb->sw_debounce_jiffies = msecs_to_jiffies(debounce); } INIT_DELAYED_WORK(&palmas_usb->wq_detectid, palmas_gpio_id_detect); palmas->usb = palmas_usb; palmas_usb->palmas = palmas; palmas_usb->dev = &pdev->dev; palmas_usb_wakeup(palmas, palmas_usb->wakeup); platform_set_drvdata(pdev, palmas_usb); palmas_usb->edev = devm_extcon_dev_allocate(&pdev->dev, palmas_extcon_cable); if (IS_ERR(palmas_usb->edev)) { dev_err(&pdev->dev, "failed to allocate extcon device\n"); return -ENOMEM; } status = devm_extcon_dev_register(&pdev->dev, palmas_usb->edev); if (status) { dev_err(&pdev->dev, "failed to register extcon device\n"); return status; } if (palmas_usb->enable_id_detection) { palmas_usb->id_otg_irq = regmap_irq_get_virq(palmas->irq_data, PALMAS_ID_OTG_IRQ); palmas_usb->id_irq = regmap_irq_get_virq(palmas->irq_data, PALMAS_ID_IRQ); status = devm_request_threaded_irq(palmas_usb->dev, palmas_usb->id_irq, NULL, palmas_id_irq_handler, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING | IRQF_ONESHOT, "palmas_usb_id", palmas_usb); if (status < 0) { dev_err(&pdev->dev, "can't get IRQ %d, err %d\n", palmas_usb->id_irq, status); return status; } } else if (palmas_usb->enable_gpio_id_detection) { palmas_usb->gpio_id_irq = gpiod_to_irq(palmas_usb->id_gpiod); if (palmas_usb->gpio_id_irq < 0) { dev_err(&pdev->dev, "failed to get id irq\n"); return palmas_usb->gpio_id_irq; } status = devm_request_threaded_irq(&pdev->dev, palmas_usb->gpio_id_irq, NULL, palmas_gpio_id_irq_handler, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, "palmas_usb_id", palmas_usb); if (status < 0) { dev_err(&pdev->dev, "failed to request handler for id irq\n"); return status; } } if (palmas_usb->enable_vbus_detection) { palmas_usb->vbus_otg_irq = regmap_irq_get_virq(palmas->irq_data, PALMAS_VBUS_OTG_IRQ); palmas_usb->vbus_irq = regmap_irq_get_virq(palmas->irq_data, PALMAS_VBUS_IRQ); status = devm_request_threaded_irq(palmas_usb->dev, palmas_usb->vbus_irq, NULL, palmas_vbus_irq_handler, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING | IRQF_ONESHOT, "palmas_usb_vbus", palmas_usb); if (status < 0) { dev_err(&pdev->dev, "can't get IRQ %d, err %d\n", palmas_usb->vbus_irq, status); return status; } } else if (palmas_usb->enable_gpio_vbus_detection) { /* remux GPIO_1 as VBUSDET */ status = palmas_update_bits(palmas, PALMAS_PU_PD_OD_BASE, PALMAS_PRIMARY_SECONDARY_PAD1, PALMAS_PRIMARY_SECONDARY_PAD1_GPIO_1_MASK, (1 << PALMAS_PRIMARY_SECONDARY_PAD1_GPIO_1_SHIFT)); if (status < 0) { dev_err(&pdev->dev, "can't remux GPIO1\n"); return status; } palmas_usb->vbus_otg_irq = regmap_irq_get_virq(palmas->irq_data, PALMAS_VBUS_OTG_IRQ); palmas_usb->gpio_vbus_irq = gpiod_to_irq(palmas_usb->vbus_gpiod); if (palmas_usb->gpio_vbus_irq < 0) { dev_err(&pdev->dev, "failed to get vbus irq\n"); return palmas_usb->gpio_vbus_irq; } status = devm_request_threaded_irq(&pdev->dev, palmas_usb->gpio_vbus_irq, NULL, palmas_vbus_irq_handler, IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING | IRQF_ONESHOT, "palmas_usb_vbus", palmas_usb); if (status < 0) { dev_err(&pdev->dev, "failed to request handler for vbus irq\n"); return status; } } palmas_enable_irq(palmas_usb); /* perform initial detection */ if (palmas_usb->enable_gpio_vbus_detection) palmas_vbus_irq_handler(palmas_usb->gpio_vbus_irq, palmas_usb); palmas_gpio_id_detect(&palmas_usb->wq_detectid.work); device_set_wakeup_capable(&pdev->dev, true); return 0; }
static int silead_ts_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct silead_ts_data *data; struct device *dev = &client->dev; int ret; if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C | I2C_FUNC_SMBUS_READ_I2C_BLOCK | I2C_FUNC_SMBUS_WRITE_I2C_BLOCK)) { dev_err(dev, "I2C functionality check failed\n"); return -ENXIO; } data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); i2c_set_clientdata(client, data); data->client = client; data->fw_name = SILEAD_FW_NAME; data->x_max = SILEAD_X_MAX; data->y_max = SILEAD_Y_MAX; data->max_fingers = SILEAD_MAX_FINGERS; data->pressure = SILEAD_PRESSURE; /* If the IRQ is not filled by DT or ACPI subsytem * try using the named GPIO */ if (client->irq <= 0) { data->gpio_irq = devm_gpiod_get(dev, SILEAD_IRQ_GPIO_NAME); if (IS_ERR(data->gpio_irq)) { dev_err(dev, "IRQ GPIO request failed\n"); return -ENODEV; } ret = gpiod_direction_input(data->gpio_irq); if (ret) { dev_err(dev, "IRQ GPIO direction set failed\n"); return ret; } client->irq = gpiod_to_irq(data->gpio_irq); if (client->irq <= 0) { dev_err(dev, "GPIO to IRQ translation failed %d\n", client->irq); return client->irq; } } /* Power GPIO pin */ if (client->dev.of_node) { ret = of_get_named_gpio_flags(client->dev.of_node, SILEAD_PWR_GPIO_NAME, 0, NULL); if (ret <= 0) { dev_err(&client->dev, "error getting gpio for %s\n", SILEAD_PWR_GPIO_NAME); return -ENODEV; } data->gpio_power = gpio_to_desc(ret); if (!data->gpio_power) return -ENODEV; } ret = gpiod_direction_output(data->gpio_power, 0); if (ret) { dev_err(dev, "Shutdown GPIO direction set failed\n"); return ret; } ret = silead_ts_setup(client); if (ret) return ret; ret = silead_ts_request_input_dev(data); if (ret) return ret; ret = devm_request_threaded_irq(dev, client->irq, NULL, silead_ts_irq_handler, IRQF_ONESHOT | IRQ_TYPE_EDGE_RISING, client->name, data); if (ret) { dev_err(dev, "IRQ request failed %d\n", ret); return ret; } dev_dbg(dev, "Probing succeded\n"); return 0; }