static int cpcap_rtc_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct cpcap_rtc *rtc; int err; rtc = devm_kzalloc(dev, sizeof(*rtc), GFP_KERNEL); if (!rtc) return -ENOMEM; rtc->regmap = dev_get_regmap(dev->parent, NULL); if (!rtc->regmap) return -ENODEV; platform_set_drvdata(pdev, rtc); rtc->rtc_dev = devm_rtc_device_register(dev, "cpcap_rtc", &cpcap_rtc_ops, THIS_MODULE); if (IS_ERR(rtc->rtc_dev)) return PTR_ERR(rtc->rtc_dev); err = cpcap_get_vendor(dev, rtc->regmap, &rtc->vendor); if (err) return err; rtc->alarm_irq = platform_get_irq(pdev, 0); err = devm_request_threaded_irq(dev, rtc->alarm_irq, NULL, cpcap_rtc_alarm_irq, IRQF_TRIGGER_NONE, "rtc_alarm", rtc); if (err) { dev_err(dev, "Could not request alarm irq: %d\n", err); return err; } disable_irq(rtc->alarm_irq); /* Stock Android uses the 1 Hz interrupt for "secure clock daemon", * which is not supported by the mainline kernel. The mainline kernel * does not use the irq at the moment, but we explicitly request and * disable it, so that its masked and does not wake up the processor * every second. */ rtc->update_irq = platform_get_irq(pdev, 1); err = devm_request_threaded_irq(dev, rtc->update_irq, NULL, cpcap_rtc_update_irq, IRQF_TRIGGER_NONE, "rtc_1hz", rtc); if (err) { dev_err(dev, "Could not request update irq: %d\n", err); return err; } disable_irq(rtc->update_irq); err = device_init_wakeup(dev, 1); if (err) { dev_err(dev, "wakeup initialization failed (%d)\n", err); /* ignore error and continue without wakeup support */ } return 0; }
static int __devinit pm805_codec_probe(struct platform_device *pdev) { struct pm80x_chip *chip = dev_get_drvdata(pdev->dev.parent); struct pm805_priv *pm805; int ret, irq_short1, irq_short2; pm805 = devm_kzalloc(&pdev->dev, sizeof(struct pm805_priv), GFP_KERNEL); if (pm805 == NULL) return -ENOMEM; pm805->chip = chip; pm805->regmap = chip->regmap; /* refer to drivers/mfd/88pm805.c for irq resource */ irq_short1 = platform_get_irq(pdev, 1); if (irq_short1 < 0) dev_err(&pdev->dev, "No IRQ resource for audio short 1!\n"); irq_short2 = platform_get_irq(pdev, 2); if (irq_short2 < 0) dev_err(&pdev->dev, "No IRQ resource for audio short 2!\n"); pm805->irq_audio_short1 = irq_short1 + chip->irq_base; pm805->irq_audio_short2 = irq_short2 + chip->irq_base; INIT_WORK(&pm805->work_short, pm805_short_work); ret = devm_request_threaded_irq(&pdev->dev, pm805->irq_audio_short1, NULL, pm805_short_handler, IRQF_ONESHOT, "audio_short1", pm805); if (ret < 0) dev_err(&pdev->dev, "Failed to request IRQ: #%d: %d\n", pm805->irq_audio_short1, ret); ret = devm_request_threaded_irq(&pdev->dev, pm805->irq_audio_short2, NULL, pm805_short_handler, IRQF_ONESHOT, "audio_short2", pm805); if (ret < 0) dev_err(&pdev->dev, "Failed to request IRQ: #%d: %d\n", pm805->irq_audio_short2, ret); platform_set_drvdata(pdev, pm805); return snd_soc_register_codec(&pdev->dev, &soc_codec_dev_pm805, pm805_dai, ARRAY_SIZE(pm805_dai)); }
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); } }
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 st21nfcb_nci_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct st21nfcb_i2c_phy *phy; struct st21nfcb_nfc_platform_data *pdata; int r; dev_dbg(&client->dev, "%s\n", __func__); dev_dbg(&client->dev, "IRQ: %d\n", client->irq); if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { nfc_err(&client->dev, "Need I2C_FUNC_I2C\n"); return -ENODEV; } phy = devm_kzalloc(&client->dev, sizeof(struct st21nfcb_i2c_phy), GFP_KERNEL); if (!phy) { nfc_err(&client->dev, "Cannot allocate memory for st21nfcb i2c phy.\n"); return -ENOMEM; } phy->i2c_dev = client; i2c_set_clientdata(client, phy); pdata = client->dev.platform_data; if (!pdata && client->dev.of_node) { r = st21nfcb_nci_i2c_of_request_resources(client); if (r) { nfc_err(&client->dev, "No platform data\n"); return r; } } else if (pdata) { r = st21nfcb_nci_i2c_request_resources(client); if (r) { nfc_err(&client->dev, "Cannot get platform resources\n"); return r; } } else { nfc_err(&client->dev, "st21nfcb platform resources not available\n"); return -ENODEV; } r = devm_request_threaded_irq(&client->dev, client->irq, NULL, st21nfcb_nci_irq_thread_fn, phy->irq_polarity | IRQF_ONESHOT, ST21NFCB_NCI_DRIVER_NAME, phy); if (r < 0) { nfc_err(&client->dev, "Unable to register IRQ handler\n"); return r; } return ndlc_probe(phy, &i2c_phy_ops, &client->dev, ST21NFCB_FRAME_HEADROOM, ST21NFCB_FRAME_TAILROOM, &phy->ndlc); }
static int retu_pwrbutton_probe(struct platform_device *pdev) { struct retu_dev *rdev = dev_get_drvdata(pdev->dev.parent); struct input_dev *idev; int irq; int error; irq = platform_get_irq(pdev, 0); if (irq < 0) return irq; idev = devm_input_allocate_device(&pdev->dev); if (!idev) return -ENOMEM; idev->name = "retu-pwrbutton"; idev->dev.parent = &pdev->dev; input_set_capability(idev, EV_KEY, KEY_POWER); input_set_drvdata(idev, rdev); error = devm_request_threaded_irq(&pdev->dev, irq, NULL, retu_pwrbutton_irq, 0, "retu-pwrbutton", idev); if (error) return error; error = input_register_device(idev); if (error) return error; return 0; }
static int da9052_rtc_probe(struct platform_device *pdev) { struct da9052_rtc *rtc; int ret; rtc = devm_kzalloc(&pdev->dev, sizeof(struct da9052_rtc), GFP_KERNEL); if (!rtc) return -ENOMEM; rtc->da9052 = dev_get_drvdata(pdev->dev.parent); platform_set_drvdata(pdev, rtc); rtc->irq = platform_get_irq_byname(pdev, "ALM"); ret = devm_request_threaded_irq(&pdev->dev, rtc->irq, NULL, da9052_rtc_irq, IRQF_TRIGGER_LOW | IRQF_ONESHOT, "ALM", rtc); if (ret != 0) { rtc_err(rtc->da9052, "irq registration failed: %d\n", ret); return ret; } rtc->rtc = rtc_device_register(pdev->name, &pdev->dev, &da9052_rtc_ops, THIS_MODULE); if (IS_ERR(rtc->rtc)) return PTR_ERR(rtc->rtc); return 0; }
static int ds3232_probe(struct device *dev, struct regmap *regmap, int irq, const char *name) { struct ds3232 *ds3232; int ret; ds3232 = devm_kzalloc(dev, sizeof(*ds3232), GFP_KERNEL); if (!ds3232) return -ENOMEM; ds3232->regmap = regmap; ds3232->irq = irq; ds3232->dev = dev; dev_set_drvdata(dev, ds3232); ret = ds3232_check_rtc_status(dev); if (ret) return ret; if (ds3232->irq > 0) { ret = devm_request_threaded_irq(dev, ds3232->irq, NULL, ds3232_irq, IRQF_SHARED | IRQF_ONESHOT, name, dev); if (ret) { ds3232->irq = 0; dev_err(dev, "unable to request IRQ\n"); } else device_init_wakeup(dev, 1); } ds3232->rtc = devm_rtc_device_register(dev, name, &ds3232_rtc_ops, THIS_MODULE); return PTR_ERR_OR_ZERO(ds3232->rtc); }
static int chtdc_ti_pwrbtn_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct intel_soc_pmic *pmic = dev_get_drvdata(dev->parent); struct input_dev *input; int irq, err; irq = platform_get_irq(pdev, 0); if (irq < 0) return irq; input = devm_input_allocate_device(dev); if (!input) return -ENOMEM; input->name = pdev->name; input->phys = "power-button/input0"; input->id.bustype = BUS_HOST; input_set_capability(input, EV_KEY, KEY_POWER); err = input_register_device(input); if (err) return err; dev_set_drvdata(dev, pmic->regmap); err = devm_request_threaded_irq(dev, irq, NULL, chtdc_ti_pwrbtn_interrupt, 0, KBUILD_MODNAME, input); if (err) return err; device_init_wakeup(dev, true); dev_pm_set_wake_irq(dev, irq); return 0; }
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; }
static int register_dprc_irq_handler(struct fsl_mc_device *mc_dev) { int error; struct fsl_mc_device_irq *irq = mc_dev->irqs[0]; WARN_ON(mc_dev->obj_desc.irq_count != 1); /* * NOTE: devm_request_threaded_irq() invokes the device-specific * function that programs the MSI physically in the device */ error = devm_request_threaded_irq(&mc_dev->dev, irq->msi_desc->irq, dprc_irq0_handler, dprc_irq0_handler_thread, IRQF_NO_SUSPEND | IRQF_ONESHOT, "FSL MC DPRC irq0", &mc_dev->dev); if (error < 0) { dev_err(&mc_dev->dev, "devm_request_threaded_irq() failed: %d\n", error); return error; } return 0; }
int wcd9xxx_spmi_request_irq(int irq, irq_handler_t handler, const char *name, void *priv) { int rc; map.linuxirq[irq] = spmi_get_irq_byname(map.spmi[BIT_BYTE(irq)], NULL, irq_names[irq]); rc = devm_request_threaded_irq(&map.spmi[BIT_BYTE(irq)]->dev, map.linuxirq[irq], NULL, wcd9xxx_spmi_irq_handler, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, name, priv); if (rc < 0) { dev_err(&map.spmi[BIT_BYTE(irq)]->dev, "Can't request %d IRQ\n", irq); return rc; } dev_dbg(&map.spmi[BIT_BYTE(irq)]->dev, "irq %d linuxIRQ: %d\n", irq, map.linuxirq[irq]); map.mask[BIT_BYTE(irq)] &= ~BYTE_BIT_MASK(irq); map.handler[irq] = handler; enable_irq_wake(map.linuxirq[irq]); 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 error; 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); if (!data) return -ENOMEM; i2c_set_clientdata(client, data); data->client = client; error = silead_ts_set_default_fw_name(data, id); if (error) return error; silead_ts_read_props(client); /* We must have the IRQ provided by DT or ACPI subsytem */ if (client->irq <= 0) return -ENODEV; /* Power GPIO pin */ data->gpio_power = devm_gpiod_get_optional(dev, "power", GPIOD_OUT_LOW); if (IS_ERR(data->gpio_power)) { if (PTR_ERR(data->gpio_power) != -EPROBE_DEFER) dev_err(dev, "Shutdown GPIO request failed\n"); return PTR_ERR(data->gpio_power); } error = silead_ts_setup(client); if (error) return error; error = silead_ts_request_input_dev(data); if (error) return error; error = devm_request_threaded_irq(dev, client->irq, NULL, silead_ts_threaded_irq_handler, IRQF_ONESHOT, client->name, data); if (error) { if (error != -EPROBE_DEFER) dev_err(dev, "IRQ request failed %d\n", error); return error; } return 0; }
int mc13xxx_irq_request(struct mc13xxx *mc13xxx, int irq, irq_handler_t handler, const char *name, void *dev) { int virq = regmap_irq_get_virq(mc13xxx->irq_data, irq); return devm_request_threaded_irq(mc13xxx->dev, virq, NULL, handler, IRQF_ONESHOT, name, dev); }
static int st_nci_spi_probe(struct spi_device *dev) { struct st_nci_spi_phy *phy; int r; dev_dbg(&dev->dev, "%s\n", __func__); dev_dbg(&dev->dev, "IRQ: %d\n", dev->irq); /* Check SPI platform functionnalities */ if (!dev) { pr_debug("%s: dev is NULL. Device is not accessible.\n", __func__); return -ENODEV; } phy = devm_kzalloc(&dev->dev, sizeof(struct st_nci_spi_phy), GFP_KERNEL); if (!phy) return -ENOMEM; phy->spi_dev = dev; spi_set_drvdata(dev, phy); r = devm_acpi_dev_add_driver_gpios(&dev->dev, acpi_st_nci_gpios); if (r) dev_dbg(&dev->dev, "Unable to add GPIO mapping table\n"); /* Get RESET GPIO */ phy->gpiod_reset = devm_gpiod_get(&dev->dev, "reset", GPIOD_OUT_HIGH); if (IS_ERR(phy->gpiod_reset)) { nfc_err(&dev->dev, "Unable to get RESET GPIO\n"); return PTR_ERR(phy->gpiod_reset); } phy->se_status.is_ese_present = device_property_read_bool(&dev->dev, "ese-present"); phy->se_status.is_uicc_present = device_property_read_bool(&dev->dev, "uicc-present"); r = ndlc_probe(phy, &spi_phy_ops, &dev->dev, ST_NCI_FRAME_HEADROOM, ST_NCI_FRAME_TAILROOM, &phy->ndlc, &phy->se_status); if (r < 0) { nfc_err(&dev->dev, "Unable to register ndlc layer\n"); return r; } phy->irq_active = true; r = devm_request_threaded_irq(&dev->dev, dev->irq, NULL, st_nci_irq_thread_fn, IRQF_ONESHOT, ST_NCI_SPI_DRIVER_NAME, phy); if (r < 0) nfc_err(&dev->dev, "Unable to register IRQ handler\n"); return r; }
/* configuration api for buffer mode */ static int qpnp_hap_buffer_config(struct qpnp_hap *hap) { u8 reg = 0; int rc, i, temp; /* Configure the WAVE_REPEAT register */ if (hap->wave_rep_cnt < QPNP_HAP_WAV_REP_MIN) hap->wave_rep_cnt = QPNP_HAP_WAV_REP_MIN; else if (hap->wave_rep_cnt > QPNP_HAP_WAV_REP_MAX) hap->wave_rep_cnt = QPNP_HAP_WAV_REP_MAX; if (hap->wave_s_rep_cnt < QPNP_HAP_WAV_S_REP_MIN) hap->wave_s_rep_cnt = QPNP_HAP_WAV_S_REP_MIN; else if (hap->wave_s_rep_cnt > QPNP_HAP_WAV_S_REP_MAX) hap->wave_s_rep_cnt = QPNP_HAP_WAV_S_REP_MAX; rc = qpnp_hap_read_reg(hap, ®, QPNP_HAP_WAV_REP_REG(hap->base)); if (rc < 0) return rc; reg &= QPNP_HAP_WAV_REP_MASK; temp = fls(hap->wave_rep_cnt) - 1; reg |= (temp << QPNP_HAP_WAV_REP_SHFT); reg &= QPNP_HAP_WAV_S_REP_MASK; temp = fls(hap->wave_s_rep_cnt) - 1; reg |= temp; rc = qpnp_hap_write_reg(hap, ®, QPNP_HAP_WAV_REP_REG(hap->base)); if (rc) return rc; /* Configure WAVE_SAMPLE1 to WAVE_SAMPLE8 register */ for (i = 0, reg = 0; i < QPNP_HAP_WAV_SAMP_LEN; i++) { reg = hap->wave_samp[i]; rc = qpnp_hap_write_reg(hap, ®, QPNP_HAP_WAV_S_REG_BASE(hap->base) + i); if (rc) return rc; } /* setup play irq */ if (hap->use_play_irq) { rc = devm_request_threaded_irq(&hap->spmi->dev, hap->play_irq, NULL, qpnp_hap_play_irq, QPNP_IRQ_FLAGS, "qpnp_play_irq", hap); if (rc < 0) { dev_err(&hap->spmi->dev, "Unable to request play(%d) IRQ(err:%d)\n", hap->play_irq, rc); return rc; } } hap->buffer_cfg_state = true; return 0; }
static int max8997_rtc_probe(struct platform_device *pdev) { struct max8997_dev *max8997 = dev_get_drvdata(pdev->dev.parent); struct max8997_rtc_info *info; int ret, virq; info = devm_kzalloc(&pdev->dev, sizeof(struct max8997_rtc_info), GFP_KERNEL); if (!info) return -ENOMEM; mutex_init(&info->lock); info->dev = &pdev->dev; info->max8997 = max8997; info->rtc = max8997->rtc; platform_set_drvdata(pdev, info); ret = max8997_rtc_init_reg(info); if (ret < 0) { dev_err(&pdev->dev, "Failed to initialize RTC reg:%d\n", ret); return ret; } max8997_rtc_enable_wtsr(info, true); max8997_rtc_enable_smpl(info, true); device_init_wakeup(&pdev->dev, 1); info->rtc_dev = devm_rtc_device_register(&pdev->dev, "max8997-rtc", &max8997_rtc_ops, THIS_MODULE); if (IS_ERR(info->rtc_dev)) { ret = PTR_ERR(info->rtc_dev); dev_err(&pdev->dev, "Failed to register RTC device: %d\n", ret); return ret; } virq = irq_create_mapping(max8997->irq_domain, MAX8997_PMICIRQ_RTCA1); if (!virq) { dev_err(&pdev->dev, "Failed to create mapping alarm IRQ\n"); ret = -ENXIO; goto err_out; } info->virq = virq; ret = devm_request_threaded_irq(&pdev->dev, virq, NULL, max8997_rtc_alarm_irq, 0, "rtc-alarm0", info); if (ret < 0) dev_err(&pdev->dev, "Failed to request alarm IRQ: %d: %d\n", info->virq, ret); err_out: 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 rc5t583_rtc_probe(struct platform_device *pdev) { struct rc5t583 *rc5t583 = dev_get_drvdata(pdev->dev.parent); struct rc5t583_rtc *ricoh_rtc; struct rc5t583_platform_data *pmic_plat_data; int ret; int irq; ricoh_rtc = devm_kzalloc(&pdev->dev, sizeof(struct rc5t583_rtc), GFP_KERNEL); if (!ricoh_rtc) return -ENOMEM; platform_set_drvdata(pdev, ricoh_rtc); /* Clear pending interrupts */ ret = regmap_write(rc5t583->regmap, RC5T583_RTC_CTL2, 0); if (ret < 0) return ret; /* clear RTC Adjust register */ ret = regmap_write(rc5t583->regmap, RC5T583_RTC_ADJ, 0); if (ret < 0) { dev_err(&pdev->dev, "unable to program rtc_adjust reg\n"); return -EBUSY; } pmic_plat_data = dev_get_platdata(rc5t583->dev); irq = pmic_plat_data->irq_base; if (irq <= 0) { dev_warn(&pdev->dev, "Wake up is not possible as irq = %d\n", irq); return ret; } irq += RC5T583_IRQ_YALE; ret = devm_request_threaded_irq(&pdev->dev, irq, NULL, rc5t583_rtc_interrupt, IRQF_TRIGGER_LOW, "rtc-rc5t583", &pdev->dev); if (ret < 0) { dev_err(&pdev->dev, "IRQ is not free.\n"); return ret; } device_init_wakeup(&pdev->dev, 1); ricoh_rtc->rtc = devm_rtc_device_register(&pdev->dev, pdev->name, &rc5t583_rtc_ops, THIS_MODULE); if (IS_ERR(ricoh_rtc->rtc)) { ret = PTR_ERR(ricoh_rtc->rtc); dev_err(&pdev->dev, "RTC device register: err %d\n", ret); return ret; } return 0; }
static int hym8563_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct hym8563 *hym8563; int ret; hym8563 = devm_kzalloc(&client->dev, sizeof(*hym8563), GFP_KERNEL); if (!hym8563) return -ENOMEM; hym8563->client = client; i2c_set_clientdata(client, hym8563); device_set_wakeup_capable(&client->dev, true); ret = hym8563_init_device(client); if (ret) { dev_err(&client->dev, "could not init device, %d\n", ret); return ret; } ret = devm_request_threaded_irq(&client->dev, client->irq, NULL, hym8563_irq, IRQF_TRIGGER_LOW | IRQF_ONESHOT, client->name, hym8563); if (ret < 0) { dev_err(&client->dev, "irq %d request failed, %d\n", client->irq, ret); return ret; } /* check state of calendar information */ ret = i2c_smbus_read_byte_data(client, HYM8563_SEC); if (ret < 0) return ret; hym8563->valid = !(ret & HYM8563_SEC_VL); dev_dbg(&client->dev, "rtc information is %s\n", hym8563->valid ? "valid" : "invalid"); hym8563->rtc = devm_rtc_device_register(&client->dev, client->name, &hym8563_rtc_ops, THIS_MODULE); if (IS_ERR(hym8563->rtc)) return PTR_ERR(hym8563->rtc); /* the hym8563 alarm only supports a minute accuracy */ hym8563->rtc->uie_unsupported = 1; #ifdef CONFIG_COMMON_CLK hym8563_clkout_register_clk(hym8563); #endif return 0; }
static int rx8010_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent); struct rx8010_data *rx8010; int err = 0; if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_I2C_BLOCK)) { dev_err(&adapter->dev, "doesn't support required functionality\n"); return -EIO; } rx8010 = devm_kzalloc(&client->dev, sizeof(struct rx8010_data), GFP_KERNEL); if (!rx8010) return -ENOMEM; rx8010->client = client; i2c_set_clientdata(client, rx8010); err = rx8010_init_client(client); if (err) return err; if (client->irq > 0) { dev_info(&client->dev, "IRQ %d supplied\n", client->irq); err = devm_request_threaded_irq(&client->dev, client->irq, NULL, rx8010_irq_1_handler, IRQF_TRIGGER_LOW | IRQF_ONESHOT, "rx8010", client); if (err) { dev_err(&client->dev, "unable to request IRQ\n"); client->irq = 0; } else { rx8010_rtc_ops.read_alarm = rx8010_read_alarm; rx8010_rtc_ops.set_alarm = rx8010_set_alarm; rx8010_rtc_ops.alarm_irq_enable = rx8010_alarm_irq_enable; } } rx8010->rtc = devm_rtc_device_register(&client->dev, client->name, &rx8010_rtc_ops, THIS_MODULE); if (IS_ERR(rx8010->rtc)) { dev_err(&client->dev, "unable to register the class device\n"); return PTR_ERR(rx8010->rtc); } rx8010->rtc->max_user_freq = 1; return err; }
static int nfcmrvl_i2c_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct nfcmrvl_i2c_drv_data *drv_data; struct nfcmrvl_platform_data *pdata; struct nfcmrvl_platform_data config; int ret; if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { nfc_err(&client->dev, "Need I2C_FUNC_I2C\n"); return -ENODEV; } drv_data = devm_kzalloc(&client->dev, sizeof(*drv_data), GFP_KERNEL); if (!drv_data) return -ENOMEM; drv_data->i2c = client; drv_data->dev = &client->dev; drv_data->priv = NULL; i2c_set_clientdata(client, drv_data); pdata = client->dev.platform_data; if (!pdata && client->dev.of_node) if (nfcmrvl_i2c_parse_dt(client->dev.of_node, &config) == 0) pdata = &config; if (!pdata) return -EINVAL; /* Request the read IRQ */ ret = devm_request_threaded_irq(&drv_data->i2c->dev, pdata->irq, NULL, nfcmrvl_i2c_int_irq_thread_fn, pdata->irq_polarity | IRQF_ONESHOT, "nfcmrvl_i2c_int", drv_data); if (ret < 0) { nfc_err(&drv_data->i2c->dev, "Unable to register IRQ handler\n"); return ret; } drv_data->priv = nfcmrvl_nci_register_dev(NFCMRVL_PHY_I2C, drv_data, &i2c_ops, &drv_data->i2c->dev, pdata); if (IS_ERR(drv_data->priv)) return PTR_ERR(drv_data->priv); drv_data->priv->support_fw_dnld = true; return 0; }
static int max8998_rtc_probe(struct platform_device *pdev) { struct max8998_dev *max8998 = dev_get_drvdata(pdev->dev.parent); struct max8998_platform_data *pdata = max8998->pdata; struct max8998_rtc_info *info; int ret; info = devm_kzalloc(&pdev->dev, sizeof(struct max8998_rtc_info), GFP_KERNEL); if (!info) return -ENOMEM; info->dev = &pdev->dev; info->max8998 = max8998; info->rtc = max8998->rtc; platform_set_drvdata(pdev, info); info->rtc_dev = devm_rtc_device_register(&pdev->dev, "max8998-rtc", &max8998_rtc_ops, THIS_MODULE); if (IS_ERR(info->rtc_dev)) { ret = PTR_ERR(info->rtc_dev); dev_err(&pdev->dev, "Failed to register RTC device: %d\n", ret); return ret; } if (!max8998->irq_domain) goto no_irq; info->irq = irq_create_mapping(max8998->irq_domain, MAX8998_IRQ_ALARM0); if (!info->irq) { dev_warn(&pdev->dev, "Failed to map alarm IRQ\n"); goto no_irq; } ret = devm_request_threaded_irq(&pdev->dev, info->irq, NULL, max8998_rtc_alarm_irq, 0, "rtc-alarm0", info); if (ret < 0) dev_err(&pdev->dev, "Failed to request alarm IRQ: %d: %d\n", info->irq, ret); no_irq: dev_info(&pdev->dev, "RTC CHIP NAME: %s\n", pdev->id_entry->name); if (pdata && pdata->rtc_delay) { info->lp3974_bug_workaround = true; dev_warn(&pdev->dev, "LP3974 with RTC REGERR option." " RTC updates will be extremely slow.\n"); } return 0; }
static int stih_cec_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct resource *res; struct stih_cec *cec; int ret; cec = devm_kzalloc(dev, sizeof(*cec), GFP_KERNEL); if (!cec) return -ENOMEM; cec->dev = dev; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); cec->regs = devm_ioremap_resource(dev, res); if (IS_ERR(cec->regs)) return PTR_ERR(cec->regs); cec->irq = platform_get_irq(pdev, 0); if (cec->irq < 0) return cec->irq; ret = devm_request_threaded_irq(dev, cec->irq, stih_cec_irq_handler, stih_cec_irq_handler_thread, 0, pdev->name, cec); if (ret) return ret; cec->clk = devm_clk_get(dev, "cec-clk"); if (IS_ERR(cec->clk)) { dev_err(dev, "Cannot get cec clock\n"); return PTR_ERR(cec->clk); } cec->adap = cec_allocate_adapter(&sti_cec_adap_ops, cec, CEC_NAME, CEC_CAP_LOG_ADDRS | CEC_CAP_PASSTHROUGH | CEC_CAP_PHYS_ADDR | CEC_CAP_TRANSMIT, 1, &pdev->dev); ret = PTR_ERR_OR_ZERO(cec->adap); if (ret) return ret; ret = cec_register_adapter(cec->adap); if (ret) { cec_delete_adapter(cec->adap); return ret; } platform_set_drvdata(pdev, cec); 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; }
static int goodix_ts_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct goodix_ts_data *ts; unsigned long irq_flags; int error; u16 version_info; dev_dbg(&client->dev, "I2C Address: 0x%02x\n", client->addr); if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { dev_err(&client->dev, "I2C check functionality failed.\n"); return -ENXIO; } ts = devm_kzalloc(&client->dev, sizeof(*ts), GFP_KERNEL); if (!ts) return -ENOMEM; ts->client = client; i2c_set_clientdata(client, ts); error = goodix_i2c_test(client); if (error) { dev_err(&client->dev, "I2C communication failure: %d\n", error); return error; } error = goodix_read_version(client, &version_info); if (error) { dev_err(&client->dev, "Read version failed.\n"); return error; } goodix_read_config(ts); error = goodix_request_input_dev(ts); if (error) return error; irq_flags = goodix_irq_flags[ts->int_trigger_type] | IRQF_ONESHOT; error = devm_request_threaded_irq(&ts->client->dev, client->irq, NULL, goodix_ts_irq_handler, irq_flags, client->name, ts); if (error) { dev_err(&client->dev, "request IRQ failed: %d\n", error); return error; } return 0; }
int wcd9xxx_spmi_request_irq(int irq, irq_handler_t handler, const char *name, void *priv) { int rc; #ifdef VENDOR_EDIT //[email protected], 2015/07/01, Add for system not reume when in sleep mode unsigned long irq_flags; if (strcmp(name, "mbhc sw intr")) { irq_flags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT; } else { irq_flags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT | IRQF_NO_SUSPEND; } #endif /* VENDOR_EDIT */ map.linuxirq[irq] = spmi_get_irq_byname(map.spmi[BIT_BYTE(irq)], NULL, irq_names[irq]); #ifndef VENDOR_EDIT //[email protected], 2015/07/01, Modify for system not reume when in sleep mode /* rc = devm_request_threaded_irq(&map.spmi[BIT_BYTE(irq)]->dev, map.linuxirq[irq], NULL, wcd9xxx_spmi_irq_handler, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, name, priv); */ #else /* VENDOR_EDIT */ rc = devm_request_threaded_irq(&map.spmi[BIT_BYTE(irq)]->dev, map.linuxirq[irq], NULL, wcd9xxx_spmi_irq_handler, IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | IRQF_ONESHOT, name, priv); #endif /* VENDOR_EDIT */ if (rc < 0) { dev_err(&map.spmi[BIT_BYTE(irq)]->dev, "Can't request %d IRQ\n", irq); return rc; } dev_dbg(&map.spmi[BIT_BYTE(irq)]->dev, "irq %d linuxIRQ: %d\n", irq, map.linuxirq[irq]); map.mask[BIT_BYTE(irq)] &= ~BYTE_BIT_MASK(irq); map.handler[irq] = handler; enable_irq_wake(map.linuxirq[irq]); return 0; }
static int hisi_thermal_probe(struct platform_device *pdev) { struct hisi_thermal_data *data; int (*platform_probe)(struct hisi_thermal_data *); struct device *dev = &pdev->dev; int ret; data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); if (!data) return -ENOMEM; data->pdev = pdev; platform_set_drvdata(pdev, data); platform_probe = of_device_get_match_data(dev); if (!platform_probe) { dev_err(dev, "failed to get probe func\n"); return -EINVAL; } ret = platform_probe(data); if (ret) return ret; ret = hisi_thermal_register_sensor(pdev, data, &data->sensor); if (ret) { dev_err(dev, "failed to register thermal sensor: %d\n", ret); return ret; } ret = data->enable_sensor(data); if (ret) { dev_err(dev, "Failed to setup the sensor: %d\n", ret); return ret; } if (data->irq) { ret = devm_request_threaded_irq(dev, data->irq, NULL, hisi_thermal_alarm_irq_thread, IRQF_ONESHOT, "hisi_thermal", data); if (ret < 0) { dev_err(dev, "failed to request alarm irq: %d\n", ret); return ret; } } hisi_thermal_toggle_sensor(&data->sensor, true); 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; }