static int vprbrd_adc_probe(struct platform_device *pdev) { struct vprbrd *vb = dev_get_drvdata(pdev->dev.parent); struct vprbrd_adc *adc; struct iio_dev *indio_dev; int ret; /* registering iio */ indio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(*adc)); if (!indio_dev) { dev_err(&pdev->dev, "failed allocating iio device\n"); return -ENOMEM; } adc = iio_priv(indio_dev); adc->vb = vb; indio_dev->name = "viperboard adc"; indio_dev->dev.parent = &pdev->dev; indio_dev->info = &vprbrd_adc_iio_info; indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->channels = vprbrd_adc_iio_channels; indio_dev->num_channels = ARRAY_SIZE(vprbrd_adc_iio_channels); ret = devm_iio_device_register(&pdev->dev, indio_dev); if (ret) { dev_err(&pdev->dev, "could not register iio (adc)"); return ret; } return 0; }
static int stx104_probe(struct device *dev, unsigned int id) { struct iio_dev *indio_dev; struct stx104_iio *priv; indio_dev = devm_iio_device_alloc(dev, sizeof(*priv)); if (!indio_dev) return -ENOMEM; if (!devm_request_region(dev, base[id], STX104_EXTENT, dev_name(dev))) { dev_err(dev, "Unable to lock port addresses (0x%X-0x%X)\n", base[id], base[id] + STX104_EXTENT); return -EBUSY; } indio_dev->info = &stx104_info; indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->channels = stx104_channels; indio_dev->num_channels = STX104_NUM_CHAN; indio_dev->name = dev_name(dev); priv = iio_priv(indio_dev); priv->base = base[id]; /* initialize DAC output to 0V */ outw(0, base[id] + 4); outw(0, base[id] + 6); return devm_iio_device_register(dev, indio_dev); }
static int si7020_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct iio_dev *indio_dev; struct i2c_client **data; int ret; if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WRITE_BYTE | I2C_FUNC_SMBUS_READ_WORD_DATA)) return -EOPNOTSUPP; /* Reset device, loads default settings. */ ret = i2c_smbus_write_byte(client, SI7020CMD_RESET); if (ret < 0) return ret; /* Wait the maximum power-up time after software reset. */ msleep(15); indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); if (!indio_dev) return -ENOMEM; data = iio_priv(indio_dev); *data = client; indio_dev->dev.parent = &client->dev; indio_dev->name = dev_name(&client->dev); indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->info = &si7020_info; indio_dev->channels = si7020_channels; indio_dev->num_channels = ARRAY_SIZE(si7020_channels); return devm_iio_device_register(&client->dev, indio_dev); }
static int mcp3422_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct iio_dev *indio_dev; struct mcp3422 *adc; int err; u8 config; if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) return -ENODEV; indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*adc)); if (!indio_dev) return -ENOMEM; adc = iio_priv(indio_dev); adc->i2c = client; adc->id = (u8)(id->driver_data); mutex_init(&adc->lock); indio_dev->dev.parent = &client->dev; indio_dev->name = dev_name(&client->dev); indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->info = &mcp3422_info; switch (adc->id) { case 2: case 3: case 6: case 7: indio_dev->channels = mcp3422_channels; indio_dev->num_channels = ARRAY_SIZE(mcp3422_channels); break; case 4: case 8: indio_dev->channels = mcp3424_channels; indio_dev->num_channels = ARRAY_SIZE(mcp3424_channels); break; } /* meaningful default configuration */ config = (MCP3422_CONT_SAMPLING | MCP3422_CHANNEL_VALUE(1) | MCP3422_PGA_VALUE(MCP3422_PGA_1) | MCP3422_SAMPLE_RATE_VALUE(MCP3422_SRATE_240)); mcp3422_update_config(adc, config); err = devm_iio_device_register(&client->dev, indio_dev); if (err < 0) return err; i2c_set_clientdata(client, indio_dev); return 0; }
static int dht11_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct device_node *node = dev->of_node; struct dht11 *dht11; struct iio_dev *iio; int ret; iio = devm_iio_device_alloc(dev, sizeof(*dht11)); if (!iio) { dev_err(dev, "Failed to allocate IIO device\n"); return -ENOMEM; } dht11 = iio_priv(iio); dht11->dev = dev; ret = of_get_gpio(node, 0); if (ret < 0) return ret; dht11->gpio = ret; ret = devm_gpio_request_one(dev, dht11->gpio, GPIOF_IN, pdev->name); if (ret) return ret; dht11->irq = gpio_to_irq(dht11->gpio); if (dht11->irq < 0) { dev_err(dev, "GPIO %d has no interrupt\n", dht11->gpio); return -EINVAL; } dht11->timestamp = ktime_get_real_ns() - DHT11_DATA_VALID_TIME - 1; dht11->num_edges = -1; platform_set_drvdata(pdev, iio); init_completion(&dht11->completion); mutex_init(&dht11->lock); iio->name = pdev->name; iio->dev.parent = &pdev->dev; iio->info = &dht11_iio_info; iio->modes = INDIO_DIRECT_MODE; iio->channels = dht11_chan_spec; iio->num_channels = ARRAY_SIZE(dht11_chan_spec); return devm_iio_device_register(dev, iio); }
static int isl29028_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct isl29028_chip *chip; struct iio_dev *indio_dev; int ret; indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*chip)); if (!indio_dev) { dev_err(&client->dev, "iio allocation fails\n"); return -ENOMEM; } chip = iio_priv(indio_dev); i2c_set_clientdata(client, indio_dev); mutex_init(&chip->lock); chip->regmap = devm_regmap_init_i2c(client, &isl29028_regmap_config); if (IS_ERR(chip->regmap)) { ret = PTR_ERR(chip->regmap); dev_err(&client->dev, "regmap initialization failed: %d\n", ret); return ret; } ret = isl29028_chip_init(chip); if (ret < 0) { dev_err(&client->dev, "chip initialization failed: %d\n", ret); return ret; } indio_dev->info = &isl29028_info; indio_dev->channels = isl29028_channels; indio_dev->num_channels = ARRAY_SIZE(isl29028_channels); indio_dev->name = id->name; indio_dev->dev.parent = &client->dev; indio_dev->modes = INDIO_DIRECT_MODE; ret = devm_iio_device_register(indio_dev->dev.parent, indio_dev); if (ret < 0) { dev_err(&client->dev, "iio registration fails with error %d\n", ret); return ret; } return 0; }
static int tsys02d_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct ms_ht_dev *dev_data; struct iio_dev *indio_dev; int ret; u64 serial_number; if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WRITE_BYTE_DATA | I2C_FUNC_SMBUS_WRITE_BYTE | I2C_FUNC_SMBUS_READ_I2C_BLOCK)) { dev_err(&client->dev, "Adapter does not support some i2c transaction\n"); return -EOPNOTSUPP; } indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*dev_data)); if (!indio_dev) return -ENOMEM; dev_data = iio_priv(indio_dev); dev_data->client = client; dev_data->res_index = 0; mutex_init(&dev_data->lock); indio_dev->info = &tsys02d_info; indio_dev->name = id->name; indio_dev->dev.parent = &client->dev; indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->channels = tsys02d_channels; indio_dev->num_channels = ARRAY_SIZE(tsys02d_channels); i2c_set_clientdata(client, indio_dev); ret = ms_sensors_reset(client, TSYS02D_RESET, 15000); if (ret) return ret; ret = ms_sensors_read_serial(client, &serial_number); if (ret) return ret; dev_info(&client->dev, "Serial number : %llx", serial_number); return devm_iio_device_register(&client->dev, indio_dev); }
static int srf08_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct iio_dev *indio_dev; struct srf08_data *data; int ret; if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_BYTE_DATA | I2C_FUNC_SMBUS_WRITE_BYTE_DATA | I2C_FUNC_SMBUS_READ_WORD_DATA)) return -ENODEV; indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); if (!indio_dev) return -ENOMEM; data = iio_priv(indio_dev); i2c_set_clientdata(client, indio_dev); data->client = client; indio_dev->name = "srf08"; indio_dev->dev.parent = &client->dev; indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->info = &srf08_info; indio_dev->channels = srf08_channels; indio_dev->num_channels = ARRAY_SIZE(srf08_channels); mutex_init(&data->lock); /* * set default values of device here * these register values cannot be read from the hardware * therefore set driver specific default values */ ret = srf08_write_range_mm(data, SRF08_DEFAULT_RANGE); if (ret < 0) return ret; ret = srf08_write_sensitivity(data, SRF08_DEFAULT_GAIN); if (ret < 0) return ret; return devm_iio_device_register(&client->dev, indio_dev); }
int ade7854_probe(struct iio_dev *indio_dev, struct device *dev) { int ret; struct ade7854_state *st = iio_priv(indio_dev); /* setup the industrialio driver allocated elements */ mutex_init(&st->buf_lock); indio_dev->dev.parent = dev; indio_dev->info = &ade7854_info; indio_dev->modes = INDIO_DIRECT_MODE; ret = devm_iio_device_register(dev, indio_dev); if (ret) return ret; /* Get the device into a sane initial state */ return ade7854_initial_setup(indio_dev); }
static int zopt2201_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct zopt2201_data *data; struct iio_dev *indio_dev; int ret; if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_READ_I2C_BLOCK)) return -EOPNOTSUPP; ret = i2c_smbus_read_byte_data(client, ZOPT2201_PART_ID); if (ret < 0) return ret; if (ret != ZOPT2201_PART_NUMBER) return -ENODEV; indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); if (!indio_dev) return -ENOMEM; data = iio_priv(indio_dev); i2c_set_clientdata(client, indio_dev); data->client = client; mutex_init(&data->lock); indio_dev->dev.parent = &client->dev; indio_dev->info = &zopt2201_info; indio_dev->channels = zopt2201_channels; indio_dev->num_channels = ARRAY_SIZE(zopt2201_channels); indio_dev->name = ZOPT2201_DRV_NAME; indio_dev->modes = INDIO_DIRECT_MODE; data->rate = ZOPT2201_MEAS_FREQ_100MS; ret = zopt2201_set_resolution(data, ZOPT2201_MEAS_RES_18BIT); if (ret < 0) return ret; ret = zopt2201_set_gain(data, ZOPT2201_LS_GAIN_3); if (ret < 0) return ret; return devm_iio_device_register(&client->dev, indio_dev); }
static int hp206c_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct iio_dev *indio_dev; struct hp206c_data *data; int ret; if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE | I2C_FUNC_SMBUS_BYTE_DATA | I2C_FUNC_SMBUS_READ_I2C_BLOCK)) { dev_err(&client->dev, "Adapter does not support " "all required i2c functionality\n"); return -ENODEV; } indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); if (!indio_dev) return -ENOMEM; data = iio_priv(indio_dev); data->client = client; mutex_init(&data->mutex); indio_dev->info = &hp206c_info; indio_dev->name = id->name; indio_dev->dev.parent = &client->dev; indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->channels = hp206c_channels; indio_dev->num_channels = ARRAY_SIZE(hp206c_channels); i2c_set_clientdata(client, indio_dev); /* Do a soft reset on probe */ ret = hp206c_soft_reset(indio_dev); if (ret) { dev_err(&client->dev, "Failed to reset on startup: %d\n", ret); return -ENODEV; } return devm_iio_device_register(&client->dev, indio_dev); }
static int t5403_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct t5403_data *data; struct iio_dev *indio_dev; int ret; if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WORD_DATA | I2C_FUNC_SMBUS_I2C_BLOCK)) return -ENODEV; ret = i2c_smbus_read_byte_data(client, T5403_SLAVE_ADDR); if (ret < 0) return ret; if ((ret & T5403_I2C_MASK) != T5403_I2C_ADDR) return -ENODEV; indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); if (!indio_dev) return -ENOMEM; data = iio_priv(indio_dev); data->client = client; mutex_init(&data->lock); i2c_set_clientdata(client, indio_dev); indio_dev->info = &t5403_info; indio_dev->name = id->name; indio_dev->dev.parent = &client->dev; indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->channels = t5403_channels; indio_dev->num_channels = ARRAY_SIZE(t5403_channels); data->mode = T5403_MODE_STANDARD; ret = i2c_smbus_read_i2c_block_data(data->client, T5403_CALIB_DATA, sizeof(data->c), (u8 *) data->c); if (ret < 0) return ret; return devm_iio_device_register(&client->dev, indio_dev); }
static int si7005_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct iio_dev *indio_dev; struct si7005_data *data; int ret; if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WORD_DATA)) return -ENODEV; indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); if (!indio_dev) return -ENOMEM; data = iio_priv(indio_dev); i2c_set_clientdata(client, indio_dev); data->client = client; mutex_init(&data->lock); indio_dev->dev.parent = &client->dev; indio_dev->name = dev_name(&client->dev); indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->info = &si7005_info; indio_dev->channels = si7005_channels; indio_dev->num_channels = ARRAY_SIZE(si7005_channels); ret = i2c_smbus_read_byte_data(client, SI7005_ID); if (ret < 0) return ret; if (ret != SI7005_ID_7005 && ret != SI7005_ID_7015) return -ENODEV; ret = i2c_smbus_read_byte_data(client, SI7005_CONFIG); if (ret < 0) return ret; data->config = ret; return devm_iio_device_register(&client->dev, indio_dev); }
static int adis16130_probe(struct spi_device *spi) { struct adis16130_state *st; struct iio_dev *indio_dev; /* setup the industrialio driver allocated elements */ indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st)); if (!indio_dev) return -ENOMEM; st = iio_priv(indio_dev); /* this is only used for removal purposes */ spi_set_drvdata(spi, indio_dev); st->us = spi; mutex_init(&st->buf_lock); indio_dev->name = spi->dev.driver->name; indio_dev->channels = adis16130_channels; indio_dev->num_channels = ARRAY_SIZE(adis16130_channels); indio_dev->dev.parent = &spi->dev; indio_dev->info = &adis16130_info; indio_dev->modes = INDIO_DIRECT_MODE; return devm_iio_device_register(&spi->dev, indio_dev); }
static int ak8975_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct ak8975_data *data; struct iio_dev *indio_dev; int eoc_gpio; int err; char *name = NULL; /* Grab and set up the supplied GPIO. */ if (client->dev.platform_data) eoc_gpio = *(int *)(client->dev.platform_data); else if (client->dev.of_node) eoc_gpio = of_get_gpio(client->dev.of_node, 0); else eoc_gpio = -1; if (eoc_gpio == -EPROBE_DEFER) return -EPROBE_DEFER; /* We may not have a GPIO based IRQ to scan, that is fine, we will poll if so */ if (gpio_is_valid(eoc_gpio)) { err = devm_gpio_request_one(&client->dev, eoc_gpio, GPIOF_IN, "ak_8975"); if (err < 0) { dev_err(&client->dev, "failed to request GPIO %d, error %d\n", eoc_gpio, err); return err; } } /* Register with IIO */ indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); if (indio_dev == NULL) return -ENOMEM; data = iio_priv(indio_dev); i2c_set_clientdata(client, indio_dev); data->client = client; data->eoc_gpio = eoc_gpio; data->eoc_irq = 0; /* id will be NULL when enumerated via ACPI */ if (id) { data->chipset = (enum asahi_compass_chipset)(id->driver_data); name = (char *) id->name; } else if (ACPI_HANDLE(&client->dev)) name = ak8975_match_acpi_device(&client->dev, &data->chipset); else return -ENOSYS; dev_dbg(&client->dev, "Asahi compass chip %s\n", name); /* Perform some basic start-of-day setup of the device. */ err = ak8975_setup(client); if (err < 0) { dev_err(&client->dev, "AK8975 initialization fails\n"); return err; } data->client = client; mutex_init(&data->lock); data->eoc_gpio = eoc_gpio; indio_dev->dev.parent = &client->dev; indio_dev->channels = ak8975_channels; indio_dev->num_channels = ARRAY_SIZE(ak8975_channels); indio_dev->info = &ak8975_info; indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->name = name; err = devm_iio_device_register(&client->dev, indio_dev); if (err < 0) return err; return 0; }
static int iadc_probe(struct platform_device *pdev) { struct device_node *node = pdev->dev.of_node; struct device *dev = &pdev->dev; struct iio_dev *indio_dev; struct iadc_chip *iadc; int ret, irq_eoc; u32 res; indio_dev = devm_iio_device_alloc(dev, sizeof(*iadc)); if (!indio_dev) return -ENOMEM; iadc = iio_priv(indio_dev); iadc->dev = dev; iadc->regmap = dev_get_regmap(dev->parent, NULL); if (!iadc->regmap) return -ENODEV; init_completion(&iadc->complete); mutex_init(&iadc->lock); ret = of_property_read_u32(node, "reg", &res); if (ret < 0) return -ENODEV; iadc->base = res; ret = iadc_version_check(iadc); if (ret < 0) return -ENODEV; ret = iadc_rsense_read(iadc, node); if (ret < 0) return -ENODEV; dev_dbg(iadc->dev, "sense resistors %d and %d micro Ohm\n", iadc->rsense[IADC_INT_RSENSE], iadc->rsense[IADC_EXT_RSENSE]); irq_eoc = platform_get_irq(pdev, 0); if (irq_eoc == -EPROBE_DEFER) return irq_eoc; if (irq_eoc < 0) iadc->poll_eoc = true; ret = iadc_reset(iadc); if (ret < 0) { dev_err(dev, "reset failed\n"); return ret; } if (!iadc->poll_eoc) { ret = devm_request_irq(dev, irq_eoc, iadc_isr, 0, "spmi-iadc", iadc); if (!ret) enable_irq_wake(irq_eoc); else return ret; } else { device_init_wakeup(iadc->dev, 1); } ret = iadc_update_offset(iadc); if (ret < 0) { dev_err(dev, "failed offset calibration\n"); return ret; } indio_dev->dev.parent = dev; indio_dev->dev.of_node = node; indio_dev->name = pdev->name; indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->info = &iadc_info; indio_dev->channels = iadc_channels; indio_dev->num_channels = ARRAY_SIZE(iadc_channels); return devm_iio_device_register(dev, indio_dev); }
static int lpc32xx_adc_probe(struct platform_device *pdev) { struct lpc32xx_adc_state *st = NULL; struct resource *res; int retval = -ENODEV; struct iio_dev *iodev = NULL; int irq; res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (!res) { dev_err(&pdev->dev, "failed to get platform I/O memory\n"); return -ENXIO; } iodev = devm_iio_device_alloc(&pdev->dev, sizeof(*st)); if (!iodev) return -ENOMEM; st = iio_priv(iodev); st->adc_base = devm_ioremap(&pdev->dev, res->start, resource_size(res)); if (!st->adc_base) { dev_err(&pdev->dev, "failed mapping memory\n"); return -EBUSY; } st->clk = devm_clk_get(&pdev->dev, NULL); if (IS_ERR(st->clk)) { dev_err(&pdev->dev, "failed getting clock\n"); return PTR_ERR(st->clk); } irq = platform_get_irq(pdev, 0); if (irq <= 0) { dev_err(&pdev->dev, "failed getting interrupt resource\n"); return -ENXIO; } retval = devm_request_irq(&pdev->dev, irq, lpc32xx_adc_isr, 0, LPC32XXAD_NAME, st); if (retval < 0) { dev_err(&pdev->dev, "failed requesting interrupt\n"); return retval; } st->vref = devm_regulator_get(&pdev->dev, "vref"); if (IS_ERR(st->vref)) { iodev->channels = lpc32xx_adc_iio_channels; dev_info(&pdev->dev, "Missing vref regulator: No scaling available\n"); } else { iodev->channels = lpc32xx_adc_iio_scale_channels; } platform_set_drvdata(pdev, iodev); init_completion(&st->completion); iodev->name = LPC32XXAD_NAME; iodev->dev.parent = &pdev->dev; iodev->info = &lpc32xx_adc_iio_info; iodev->modes = INDIO_DIRECT_MODE; iodev->num_channels = ARRAY_SIZE(lpc32xx_adc_iio_channels); retval = devm_iio_device_register(&pdev->dev, iodev); if (retval) return retval; dev_info(&pdev->dev, "LPC32XX ADC driver loaded, IRQ %d\n", irq); return 0; }
static int stx104_probe(struct device *dev, unsigned int id) { struct iio_dev *indio_dev; struct stx104_iio *priv; struct stx104_gpio *stx104gpio; int err; indio_dev = devm_iio_device_alloc(dev, sizeof(*priv)); if (!indio_dev) return -ENOMEM; stx104gpio = devm_kzalloc(dev, sizeof(*stx104gpio), GFP_KERNEL); if (!stx104gpio) return -ENOMEM; if (!devm_request_region(dev, base[id], STX104_EXTENT, dev_name(dev))) { dev_err(dev, "Unable to lock port addresses (0x%X-0x%X)\n", base[id], base[id] + STX104_EXTENT); return -EBUSY; } indio_dev->info = &stx104_info; indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->channels = stx104_channels; indio_dev->num_channels = STX104_NUM_CHAN; indio_dev->name = dev_name(dev); priv = iio_priv(indio_dev); priv->base = base[id]; /* initialize DAC output to 0V */ outw(0, base[id] + 4); outw(0, base[id] + 6); err = devm_iio_device_register(dev, indio_dev); if (err) { dev_err(dev, "IIO device registering failed (%d)\n", err); return err; } stx104gpio->chip.label = dev_name(dev); stx104gpio->chip.parent = dev; stx104gpio->chip.owner = THIS_MODULE; stx104gpio->chip.base = -1; stx104gpio->chip.ngpio = 8; stx104gpio->chip.get_direction = stx104_gpio_get_direction; stx104gpio->chip.direction_input = stx104_gpio_direction_input; stx104gpio->chip.direction_output = stx104_gpio_direction_output; stx104gpio->chip.get = stx104_gpio_get; stx104gpio->chip.set = stx104_gpio_set; stx104gpio->base = base[id] + 3; stx104gpio->out_state = 0x0; spin_lock_init(&stx104gpio->lock); dev_set_drvdata(dev, stx104gpio); err = gpiochip_add_data(&stx104gpio->chip, stx104gpio); if (err) { dev_err(dev, "GPIO registering failed (%d)\n", err); return err; } return 0; }
static int sc27xx_adc_probe(struct platform_device *pdev) { struct device_node *np = pdev->dev.of_node; struct sc27xx_adc_data *sc27xx_data; struct iio_dev *indio_dev; int ret; indio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(*sc27xx_data)); if (!indio_dev) return -ENOMEM; sc27xx_data = iio_priv(indio_dev); sc27xx_data->regmap = dev_get_regmap(pdev->dev.parent, NULL); if (!sc27xx_data->regmap) { dev_err(&pdev->dev, "failed to get ADC regmap\n"); return -ENODEV; } ret = of_property_read_u32(np, "reg", &sc27xx_data->base); if (ret) { dev_err(&pdev->dev, "failed to get ADC base address\n"); return ret; } sc27xx_data->irq = platform_get_irq(pdev, 0); if (sc27xx_data->irq < 0) { dev_err(&pdev->dev, "failed to get ADC irq number\n"); return sc27xx_data->irq; } ret = of_hwspin_lock_get_id(np, 0); if (ret < 0) { dev_err(&pdev->dev, "failed to get hwspinlock id\n"); return ret; } sc27xx_data->hwlock = hwspin_lock_request_specific(ret); if (!sc27xx_data->hwlock) { dev_err(&pdev->dev, "failed to request hwspinlock\n"); return -ENXIO; } ret = devm_add_action(&pdev->dev, sc27xx_adc_free_hwlock, sc27xx_data->hwlock); if (ret) { sc27xx_adc_free_hwlock(sc27xx_data->hwlock); dev_err(&pdev->dev, "failed to add hwspinlock action\n"); return ret; } init_completion(&sc27xx_data->completion); sc27xx_data->dev = &pdev->dev; ret = sc27xx_adc_enable(sc27xx_data); if (ret) { dev_err(&pdev->dev, "failed to enable ADC module\n"); return ret; } ret = devm_add_action(&pdev->dev, sc27xx_adc_disable, sc27xx_data); if (ret) { sc27xx_adc_disable(sc27xx_data); dev_err(&pdev->dev, "failed to add ADC disable action\n"); return ret; } ret = devm_request_threaded_irq(&pdev->dev, sc27xx_data->irq, NULL, sc27xx_adc_isr, IRQF_ONESHOT, pdev->name, sc27xx_data); if (ret) { dev_err(&pdev->dev, "failed to request ADC irq\n"); return ret; } indio_dev->dev.parent = &pdev->dev; indio_dev->name = dev_name(&pdev->dev); indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->info = &sc27xx_info; indio_dev->channels = sc27xx_channels; indio_dev->num_channels = ARRAY_SIZE(sc27xx_channels); ret = devm_iio_device_register(&pdev->dev, indio_dev); if (ret) dev_err(&pdev->dev, "could not register iio (ADC)"); return ret; }