static int st_nci_i2c_acpi_request_resources(struct i2c_client *client) { struct st_nci_i2c_phy *phy = i2c_get_clientdata(client); struct gpio_desc *gpiod_reset; struct device *dev = &client->dev; u8 tmp; /* Get RESET GPIO from ACPI */ gpiod_reset = devm_gpiod_get_index(dev, ST_NCI_GPIO_NAME_RESET, 1, GPIOD_OUT_HIGH); if (IS_ERR(gpiod_reset)) { nfc_err(dev, "Unable to get RESET GPIO\n"); return -ENODEV; } phy->gpio_reset = desc_to_gpio(gpiod_reset); phy->irq_polarity = irq_get_trigger_type(client->irq); phy->se_status.is_ese_present = false; phy->se_status.is_uicc_present = false; if (device_property_present(dev, "ese-present")) { device_property_read_u8(dev, "ese-present", &tmp); phy->se_status.is_ese_present = tmp; } if (device_property_present(dev, "uicc-present")) { device_property_read_u8(dev, "uicc-present", &tmp); phy->se_status.is_uicc_present = tmp; } return 0; }
static int cpcap_init_irq_chip(struct cpcap_ddata *cpcap, int irq_chip, int irq_start, int nr_irqs) { struct regmap_irq_chip *chip = &cpcap_irq_chip[irq_chip]; int i, ret; for (i = irq_start; i < irq_start + nr_irqs; i++) { struct regmap_irq *rirq = &cpcap->irqs[i]; cpcap_init_one_regmap_irq(cpcap, rirq, irq_start, i); } chip->irqs = &cpcap->irqs[irq_start]; chip->num_irqs = nr_irqs; chip->irq_drv_data = cpcap; ret = devm_regmap_add_irq_chip(&cpcap->spi->dev, cpcap->regmap, cpcap->spi->irq, irq_get_trigger_type(cpcap->spi->irq) | IRQF_SHARED, -1, chip, &cpcap->irqdata[irq_chip]); if (ret) { dev_err(&cpcap->spi->dev, "could not add irq chip %i: %i\n", irq_chip, ret); 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 u32 check_ppi_trigger(int irq) { u32 flags = irq_get_trigger_type(irq); if (flags != IRQF_TRIGGER_HIGH && flags != IRQF_TRIGGER_LOW) { pr_warn("WARNING: Invalid trigger for IRQ%d, assuming level low\n", irq); pr_warn("WARNING: Please fix your firmware\n"); flags = IRQF_TRIGGER_LOW; } return flags; }
static int st21nfcb_nci_i2c_of_request_resources(struct i2c_client *client) { struct st21nfcb_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(&client->dev, gpio, "clf_reset"); if (r) { nfc_err(&client->dev, "Failed to request reset pin\n"); return -ENODEV; } r = gpio_direction_output(gpio, 1); if (r) { nfc_err(&client->dev, "Failed to set reset pin direction as output\n"); return -ENODEV; } phy->gpio_reset = gpio; /* IRQ */ r = irq_of_parse_and_map(pp, 0); if (r < 0) { nfc_err(&client->dev, "Unable to get irq, error: %d\n", r); return r; } phy->irq_polarity = irq_get_trigger_type(r); client->irq = r; return 0; }
static int st_nci_spi_of_request_resources(struct spi_device *dev) { struct st_nci_spi_phy *phy = spi_get_drvdata(dev); struct device_node *pp; int gpio; int r; pp = dev->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(&dev->dev, "Failed to retrieve reset-gpios from device tree\n"); return gpio; } /* GPIO request and configuration */ r = devm_gpio_request_one(&dev->dev, gpio, GPIOF_OUT_INIT_HIGH, "clf_reset"); if (r) { nfc_err(&dev->dev, "Failed to request reset pin\n"); return r; } phy->gpio_reset = gpio; phy->irq_polarity = irq_get_trigger_type(dev->irq); phy->se_status.is_ese_present = of_property_read_bool(pp, "ese-present"); phy->se_status.is_uicc_present = of_property_read_bool(pp, "uicc-present"); return 0; }
static int wl1271_probe(struct spi_device *spi) { struct wl12xx_spi_glue *glue; struct wlcore_platdev_data *pdev_data; struct resource res[1]; int ret; pdev_data = devm_kzalloc(&spi->dev, sizeof(*pdev_data), GFP_KERNEL); if (!pdev_data) return -ENOMEM; pdev_data->if_ops = &spi_ops; glue = devm_kzalloc(&spi->dev, sizeof(*glue), GFP_KERNEL); if (!glue) { dev_err(&spi->dev, "can't allocate glue\n"); return -ENOMEM; } glue->dev = &spi->dev; spi_set_drvdata(spi, glue); /* This is the only SPI value that we need to set here, the rest * comes from the board-peripherals file */ spi->bits_per_word = 32; glue->reg = devm_regulator_get(&spi->dev, "vwlan"); if (PTR_ERR(glue->reg) == -EPROBE_DEFER) return -EPROBE_DEFER; if (IS_ERR(glue->reg)) { dev_err(glue->dev, "can't get regulator\n"); return PTR_ERR(glue->reg); } ret = wlcore_probe_of(spi, glue, pdev_data); if (ret) { dev_err(glue->dev, "can't get device tree parameters (%d)\n", ret); return ret; } ret = spi_setup(spi); if (ret < 0) { dev_err(glue->dev, "spi_setup failed\n"); return ret; } glue->core = platform_device_alloc(pdev_data->family->name, PLATFORM_DEVID_AUTO); if (!glue->core) { dev_err(glue->dev, "can't allocate platform_device\n"); return -ENOMEM; } glue->core->dev.parent = &spi->dev; memset(res, 0x00, sizeof(res)); res[0].start = spi->irq; res[0].flags = IORESOURCE_IRQ | irq_get_trigger_type(spi->irq); res[0].name = "irq"; ret = platform_device_add_resources(glue->core, res, ARRAY_SIZE(res)); if (ret) { dev_err(glue->dev, "can't add resources\n"); goto out_dev_put; } ret = platform_device_add_data(glue->core, pdev_data, sizeof(*pdev_data)); if (ret) { dev_err(glue->dev, "can't add platform data\n"); goto out_dev_put; } ret = platform_device_add(glue->core); if (ret) { dev_err(glue->dev, "can't register platform device\n"); goto out_dev_put; } return 0; out_dev_put: platform_device_put(glue->core); return ret; }
static int nokia_modem_probe(struct device *dev) { struct device_node *np; struct nokia_modem_device *modem; struct hsi_client *cl = to_hsi_client(dev); struct hsi_port *port = hsi_get_port(cl); int irq, pflags, err; struct hsi_board_info ssip; struct hsi_board_info cmtspeech; np = dev->of_node; if (!np) { dev_err(dev, "device tree node not found\n"); return -ENXIO; } modem = devm_kzalloc(dev, sizeof(*modem), GFP_KERNEL); if (!modem) { dev_err(dev, "Could not allocate memory for nokia_modem_device\n"); return -ENOMEM; } dev_set_drvdata(dev, modem); modem->device = dev; irq = irq_of_parse_and_map(np, 0); if (!irq) { dev_err(dev, "Invalid rst_ind interrupt (%d)\n", irq); return -EINVAL; } modem->nokia_modem_rst_ind_irq = irq; pflags = irq_get_trigger_type(irq); tasklet_init(&modem->nokia_modem_rst_ind_tasklet, do_nokia_modem_rst_ind_tasklet, (unsigned long)modem); err = devm_request_irq(dev, irq, nokia_modem_rst_ind_isr, pflags, "modem_rst_ind", modem); if (err < 0) { dev_err(dev, "Request rst_ind irq(%d) failed (flags %d)\n", irq, pflags); return err; } enable_irq_wake(irq); if(pm) { err = nokia_modem_gpio_probe(dev); if (err < 0) { dev_err(dev, "Could not probe GPIOs\n"); goto error1; } } ssip.name = "ssi-protocol"; ssip.tx_cfg = cl->tx_cfg; ssip.rx_cfg = cl->rx_cfg; ssip.platform_data = NULL; ssip.archdata = NULL; modem->ssi_protocol = hsi_new_client(port, &ssip); if (!modem->ssi_protocol) { dev_err(dev, "Could not register ssi-protocol device\n"); err = -ENOMEM; goto error2; } err = device_attach(&modem->ssi_protocol->device); if (err == 0) { dev_dbg(dev, "Missing ssi-protocol driver\n"); err = -EPROBE_DEFER; goto error3; } else if (err < 0) { dev_err(dev, "Could not load ssi-protocol driver (%d)\n", err); goto error3; } cmtspeech.name = "cmt-speech"; cmtspeech.tx_cfg = cl->tx_cfg; cmtspeech.rx_cfg = cl->rx_cfg; cmtspeech.platform_data = NULL; cmtspeech.archdata = NULL; modem->cmt_speech = hsi_new_client(port, &cmtspeech); if (!modem->cmt_speech) { dev_err(dev, "Could not register cmt-speech device\n"); err = -ENOMEM; goto error3; } err = device_attach(&modem->cmt_speech->device); if (err == 0) { dev_dbg(dev, "Missing cmt-speech driver\n"); err = -EPROBE_DEFER; goto error4; } else if (err < 0) { dev_err(dev, "Could not load cmt-speech driver (%d)\n", err); goto error4; } dev_info(dev, "Registered Nokia HSI modem\n"); return 0; error4: hsi_remove_client(&modem->cmt_speech->device, NULL); error3: hsi_remove_client(&modem->ssi_protocol->device, NULL); error2: nokia_modem_gpio_unexport(dev); error1: disable_irq_wake(modem->nokia_modem_rst_ind_irq); tasklet_kill(&modem->nokia_modem_rst_ind_tasklet); return err; }