static int mma8452_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct mma8452_data *data; struct iio_dev *indio_dev; int ret; ret = i2c_smbus_read_byte_data(client, MMA8452_WHO_AM_I); if (ret < 0) return ret; if (ret != MMA8452_DEVICE_ID) 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 = &mma8452_info; indio_dev->name = id->name; indio_dev->dev.parent = &client->dev; indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->channels = mma8452_channels; indio_dev->num_channels = ARRAY_SIZE(mma8452_channels); indio_dev->available_scan_masks = mma8452_scan_masks; data->ctrl_reg1 = MMA8452_CTRL_ACTIVE | (MMA8452_CTRL_DR_DEFAULT << MMA8452_CTRL_DR_SHIFT); ret = i2c_smbus_write_byte_data(client, MMA8452_CTRL_REG1, data->ctrl_reg1); if (ret < 0) return ret; data->data_cfg = MMA8452_DATA_CFG_FS_2G; ret = i2c_smbus_write_byte_data(client, MMA8452_DATA_CFG, data->data_cfg); if (ret < 0) return ret; ret = iio_triggered_buffer_setup(indio_dev, NULL, mma8452_trigger_handler, NULL); if (ret < 0) return ret; ret = iio_device_register(indio_dev); if (ret < 0) goto buffer_cleanup; return 0; buffer_cleanup: iio_triggered_buffer_cleanup(indio_dev); return ret; }
static int st_hub_step_detector_probe(struct platform_device *pdev) { int err; struct iio_dev *indio_dev; struct st_hub_pdata_info *info; struct st_hub_sensor_data *adata; struct st_sensor_hub_callbacks callback; indio_dev = iio_device_alloc(sizeof(*adata)); if (!indio_dev) return -ENOMEM; platform_set_drvdata(pdev, indio_dev); indio_dev->channels = st_hub_step_detector_ch; indio_dev->num_channels = ARRAY_SIZE(st_hub_step_detector_ch); indio_dev->dev.parent = &pdev->dev; indio_dev->info = &st_hub_step_detector_info; indio_dev->name = pdev->name; indio_dev->modes = INDIO_DIRECT_MODE; adata = iio_priv(indio_dev); info = pdev->dev.platform_data; st_hub_get_common_data(info->hdata, info->index, &adata->cdata); err = st_hub_set_default_values(adata, info, indio_dev); if (err < 0) goto st_hub_deallocate_device; err = iio_triggered_buffer_setup(indio_dev, NULL, NULL, &st_hub_buffer_setup_ops); if (err) goto st_hub_deallocate_device; err = st_hub_setup_trigger_sensor(indio_dev, adata); if (err < 0) goto st_hub_clear_buffer; err = iio_device_register(indio_dev); if (err) goto st_hub_remove_trigger; callback.pdev = pdev; callback.push_data = &st_hub_step_detector_push_data; callback.push_event = &st_hub_step_detector_push_event; st_hub_register_callback(info->hdata, &callback, info->index); return 0; st_hub_remove_trigger: st_hub_remove_trigger(adata); st_hub_clear_buffer: iio_triggered_buffer_cleanup(indio_dev); st_hub_deallocate_device: iio_device_free(indio_dev); return err; }
int ad7606_register_ring_funcs_and_init(struct iio_dev *indio_dev) { struct ad7606_state *st = iio_priv(indio_dev); INIT_WORK(&st->poll_work, &ad7606_poll_bh_to_ring); return iio_triggered_buffer_setup(indio_dev, &ad7606_trigger_handler_th_bh, &ad7606_trigger_handler_th_bh, NULL); }
static int mag3110_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct mag3110_data *data; struct iio_dev *indio_dev; int ret; ret = i2c_smbus_read_byte_data(client, MAG3110_WHO_AM_I); if (ret < 0) return ret; if (ret != MAG3110_DEVICE_ID) 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 = &mag3110_info; indio_dev->name = id->name; indio_dev->dev.parent = &client->dev; indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->channels = mag3110_channels; indio_dev->num_channels = ARRAY_SIZE(mag3110_channels); indio_dev->available_scan_masks = mag3110_scan_masks; data->ctrl_reg1 = MAG3110_CTRL_DR_DEFAULT; ret = i2c_smbus_write_byte_data(client, MAG3110_CTRL_REG1, data->ctrl_reg1); if (ret < 0) return ret; ret = i2c_smbus_write_byte_data(client, MAG3110_CTRL_REG2, MAG3110_CTRL_AUTO_MRST_EN | MAG3110_CTRL_RAW); if (ret < 0) return ret; ret = iio_triggered_buffer_setup(indio_dev, NULL, mag3110_trigger_handler, NULL); if (ret < 0) return ret; ret = iio_device_register(indio_dev); if (ret < 0) goto buffer_cleanup; return 0; buffer_cleanup: iio_triggered_buffer_cleanup(indio_dev); return ret; }
int mma7455_core_probe(struct device *dev, struct regmap *regmap, const char *name) { struct mma7455_data *mma7455; struct iio_dev *indio_dev; unsigned int reg; int ret; ret = regmap_read(regmap, MMA7455_REG_WHOAMI, ®); if (ret) { dev_err(dev, "unable to read reg\n"); return ret; } if (reg != MMA7455_WHOAMI_ID) { dev_err(dev, "device id mismatch\n"); return -ENODEV; } indio_dev = devm_iio_device_alloc(dev, sizeof(*mma7455)); if (!indio_dev) return -ENOMEM; dev_set_drvdata(dev, indio_dev); mma7455 = iio_priv(indio_dev); mma7455->regmap = regmap; indio_dev->info = &mma7455_info; indio_dev->name = name; indio_dev->dev.parent = dev; indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->channels = mma7455_channels; indio_dev->num_channels = ARRAY_SIZE(mma7455_channels); indio_dev->available_scan_masks = mma7455_scan_masks; regmap_write(mma7455->regmap, MMA7455_REG_MCTL, MMA7455_MCTL_MODE_MEASURE); ret = iio_triggered_buffer_setup(indio_dev, NULL, mma7455_trigger_handler, NULL); if (ret) { dev_err(dev, "unable to setup triggered buffer\n"); return ret; } ret = iio_device_register(indio_dev); if (ret) { dev_err(dev, "unable to register device\n"); iio_triggered_buffer_cleanup(indio_dev); return ret; } return 0; }
static int mpl3115_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct mpl3115_data *data; struct iio_dev *indio_dev; int ret; ret = i2c_smbus_read_byte_data(client, MPL3115_WHO_AM_I); if (ret < 0) return ret; if (ret != MPL3115_DEVICE_ID) 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 = &mpl3115_info; indio_dev->name = id->name; indio_dev->dev.parent = &client->dev; indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->channels = mpl3115_channels; indio_dev->num_channels = ARRAY_SIZE(mpl3115_channels); /* software reset, I2C transfer is aborted (fails) */ i2c_smbus_write_byte_data(client, MPL3115_CTRL_REG1, MPL3115_CTRL_RESET); msleep(50); data->ctrl_reg1 = MPL3115_CTRL_OS_258MS; ret = i2c_smbus_write_byte_data(client, MPL3115_CTRL_REG1, data->ctrl_reg1); if (ret < 0) return ret; ret = iio_triggered_buffer_setup(indio_dev, NULL, mpl3115_trigger_handler, NULL); if (ret < 0) return ret; ret = iio_device_register(indio_dev); if (ret < 0) goto buffer_cleanup; return 0; buffer_cleanup: iio_triggered_buffer_cleanup(indio_dev); return ret; }
int hmc5843_common_probe(struct device *dev, struct regmap *regmap, enum hmc5843_ids id, const char *name) { struct hmc5843_data *data; struct iio_dev *indio_dev; int ret; indio_dev = devm_iio_device_alloc(dev, sizeof(*data)); if (!indio_dev) return -ENOMEM; dev_set_drvdata(dev, indio_dev); /* default settings at probe */ data = iio_priv(indio_dev); data->dev = dev; data->regmap = regmap; data->variant = &hmc5843_chip_info_tbl[id]; mutex_init(&data->lock); indio_dev->dev.parent = dev; indio_dev->name = name; indio_dev->info = &hmc5843_info; indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->channels = data->variant->channels; indio_dev->num_channels = 4; indio_dev->available_scan_masks = hmc5843_scan_masks; ret = hmc5843_init(data); if (ret < 0) return ret; ret = iio_triggered_buffer_setup(indio_dev, NULL, hmc5843_trigger_handler, NULL); if (ret < 0) goto buffer_setup_err; ret = iio_device_register(indio_dev); if (ret < 0) goto buffer_cleanup; return 0; buffer_cleanup: iio_triggered_buffer_cleanup(indio_dev); buffer_setup_err: hmc5843_set_mode(iio_priv(indio_dev), HMC5843_MODE_SLEEP); return ret; }
static int bma220_probe(struct spi_device *spi) { int ret; struct iio_dev *indio_dev; struct bma220_data *data; indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*data)); if (!indio_dev) { dev_err(&spi->dev, "iio allocation failed!\n"); return -ENOMEM; } data = iio_priv(indio_dev); data->spi_device = spi; spi_set_drvdata(spi, indio_dev); mutex_init(&data->lock); indio_dev->dev.parent = &spi->dev; indio_dev->info = &bma220_info; indio_dev->name = BMA220_DEVICE_NAME; indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->channels = bma220_channels; indio_dev->num_channels = ARRAY_SIZE(bma220_channels); indio_dev->available_scan_masks = bma220_accel_scan_masks; ret = bma220_init(data->spi_device); if (ret < 0) return ret; ret = iio_triggered_buffer_setup(indio_dev, iio_pollfunc_store_time, bma220_trigger_handler, NULL); if (ret < 0) { dev_err(&spi->dev, "iio triggered buffer setup failed\n"); goto err_suspend; } ret = iio_device_register(indio_dev); if (ret < 0) { dev_err(&spi->dev, "iio_device_register failed\n"); iio_triggered_buffer_cleanup(indio_dev); goto err_suspend; } return 0; err_suspend: return bma220_deinit(spi); }
static int hmc5843_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct hmc5843_data *data; struct iio_dev *indio_dev; int ret; indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); if (indio_dev == NULL) return -ENOMEM; /* default settings at probe */ data = iio_priv(indio_dev); data->client = client; data->variant = &hmc5843_chip_info_tbl[id->driver_data]; mutex_init(&data->lock); i2c_set_clientdata(client, indio_dev); indio_dev->info = &hmc5843_info; indio_dev->name = id->name; indio_dev->dev.parent = &client->dev; indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->channels = data->variant->channels; indio_dev->num_channels = 4; indio_dev->available_scan_masks = hmc5843_scan_masks; ret = hmc5843_init(data); if (ret < 0) return ret; ret = iio_triggered_buffer_setup(indio_dev, NULL, hmc5843_trigger_handler, NULL); if (ret < 0) return ret; ret = iio_device_register(indio_dev); if (ret < 0) goto buffer_cleanup; return 0; buffer_cleanup: iio_triggered_buffer_cleanup(indio_dev); return ret; }
/** * adis_setup_buffer_and_trigger() - Sets up buffer and trigger for the adis device * @adis: The adis device. * @indio_dev: The IIO device. * @trigger_handler: Optional trigger handler, may be NULL. * * Returns 0 on success, a negative error code otherwise. * * This function sets up the buffer and trigger for a adis devices. If * 'trigger_handler' is NULL the default trigger handler will be used. The * default trigger handler will simply read the registers assigned to the * currently active channels. * * adis_cleanup_buffer_and_trigger() should be called to free the resources * allocated by this function. */ int adis_setup_buffer_and_trigger(struct adis *adis, struct iio_dev *indio_dev, irqreturn_t (*trigger_handler)(int, void *)) { int ret; if (!trigger_handler) trigger_handler = adis_trigger_handler; ret = iio_triggered_buffer_setup(indio_dev, &iio_pollfunc_store_time, trigger_handler, NULL); if (ret) return ret; if (adis->spi->irq) { ret = adis_probe_trigger(adis, indio_dev); if (ret) goto error_buffer_cleanup; } return 0; error_buffer_cleanup: iio_triggered_buffer_cleanup(indio_dev); return ret; }
static int nuc970_adc_probe(struct platform_device *pdev) { struct iio_dev *indio_dev; struct nuc970_adc_device *info = NULL; int ret = -ENODEV; struct resource *res; int irq; indio_dev = iio_device_alloc(sizeof(struct nuc970_adc_device)); if (indio_dev == NULL) { dev_err(&pdev->dev, "failed to allocate iio device\n"); ret = -ENOMEM; goto err_ret; } info = iio_priv(indio_dev); /* map the registers */ res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (res == NULL) { dev_err(&pdev->dev, "cannot find IO resource\n"); ret = -ENOENT; goto err_ret; } info->regs = ioremap(res->start, resource_size(res)); if (info->regs == NULL) { dev_err(&pdev->dev, "cannot map IO\n"); ret = -ENXIO; goto err_ret; } indio_dev->dev.parent = &pdev->dev; indio_dev->name = dev_name(&pdev->dev); indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->info = &nuc970_adc_info; #ifdef CONFIG_BOARD_TOMATO indio_dev->num_channels = 4; #else indio_dev->num_channels = 8; #endif indio_dev->channels = nuc970_adc_iio_channels; indio_dev->masklength = indio_dev->num_channels - 1; /* find the clock and enable it */ info->eclk=clk_get(NULL, "adc_eclk"); clk_prepare(info->eclk); clk_enable(info->eclk); info->clk=clk_get(NULL, "adc"); clk_prepare(info->clk); clk_enable(info->clk); clk_set_rate(info->eclk, 1000000); irq = platform_get_irq(pdev, 0); if (irq < 0) { dev_err(&pdev->dev, "no irq resource?\n"); ret = irq; goto err_ret; } info->irq = irq; init_completion(&info->completion); ret = request_irq(info->irq, nuc970_adc_isr, 0, dev_name(&pdev->dev), info); if (ret < 0) { dev_err(&pdev->dev, "failed requesting irq, irq = %d\n", info->irq); goto err_ret; } #ifdef CONFIG_NUC970_NADC_BANDGAP writel(3, info->regs + CTL); //enable AD_EN #endif #ifdef CONFIG_NUC970_NADC_VREF writel(1, info->regs + CTL); //enable AD_EN #endif #ifdef CONFIG_NUC970_NADC_I33V writel(0x3<<6, info->regs + CONF); //select AGND33 vs AVDD33 writel(1, info->regs + CTL); //enable AD_EN, disable bandgap #endif writel(1, info->regs + IER); //enable M_IEN ret = iio_triggered_buffer_setup(indio_dev, &iio_pollfunc_store_time, &nuc970_trigger_handler, &nuc970_ring_setup_ops); if (ret) goto err_free_channels; ret = iio_device_register(indio_dev); if (ret < 0) { printk("Couldn't register NC970 ADC..\n"); goto err_free_channels; } platform_set_drvdata(pdev, indio_dev); writel((readl(info->regs + CONF) | 1<<2), info->regs + CONF); //enable NACEN printk("%s: nuc970 Normal ADC adapter\n", indio_dev->name); return 0; err_free_channels: nuc970_adc_channels_remove(indio_dev); iio_device_free(indio_dev); err_ret: return ret; }
static int vf610_adc_probe(struct platform_device *pdev) { struct vf610_adc *info; struct iio_dev *indio_dev; struct resource *mem; int irq; int ret; indio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(struct vf610_adc)); if (!indio_dev) { dev_err(&pdev->dev, "Failed allocating iio device\n"); return -ENOMEM; } info = iio_priv(indio_dev); info->dev = &pdev->dev; mem = platform_get_resource(pdev, IORESOURCE_MEM, 0); info->regs = devm_ioremap_resource(&pdev->dev, mem); if (IS_ERR(info->regs)) return PTR_ERR(info->regs); irq = platform_get_irq(pdev, 0); if (irq < 0) { dev_err(&pdev->dev, "no irq resource?\n"); return irq; } ret = devm_request_irq(info->dev, irq, vf610_adc_isr, 0, dev_name(&pdev->dev), indio_dev); if (ret < 0) { dev_err(&pdev->dev, "failed requesting irq, irq = %d\n", irq); return ret; } info->clk = devm_clk_get(&pdev->dev, "adc"); if (IS_ERR(info->clk)) { dev_err(&pdev->dev, "failed getting clock, err = %ld\n", PTR_ERR(info->clk)); return PTR_ERR(info->clk); } info->vref = devm_regulator_get(&pdev->dev, "vref"); if (IS_ERR(info->vref)) return PTR_ERR(info->vref); ret = regulator_enable(info->vref); if (ret) return ret; info->vref_uv = regulator_get_voltage(info->vref); of_property_read_u32_array(pdev->dev.of_node, "fsl,adck-max-frequency", info->max_adck_rate, 3); ret = of_property_read_u32(pdev->dev.of_node, "min-sample-time", &info->adc_feature.default_sample_time); if (ret) info->adc_feature.default_sample_time = DEFAULT_SAMPLE_TIME; platform_set_drvdata(pdev, indio_dev); init_completion(&info->completion); indio_dev->name = dev_name(&pdev->dev); indio_dev->dev.parent = &pdev->dev; indio_dev->dev.of_node = pdev->dev.of_node; indio_dev->info = &vf610_adc_iio_info; indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->channels = vf610_adc_iio_channels; indio_dev->num_channels = ARRAY_SIZE(vf610_adc_iio_channels); ret = clk_prepare_enable(info->clk); if (ret) { dev_err(&pdev->dev, "Could not prepare or enable the clock.\n"); goto error_adc_clk_enable; } vf610_adc_cfg_init(info); vf610_adc_hw_init(info); ret = iio_triggered_buffer_setup(indio_dev, &iio_pollfunc_store_time, NULL, &iio_triggered_buffer_setup_ops); if (ret < 0) { dev_err(&pdev->dev, "Couldn't initialise the buffer\n"); goto error_iio_device_register; } ret = iio_device_register(indio_dev); if (ret) { dev_err(&pdev->dev, "Couldn't register the device.\n"); goto error_adc_buffer_init; } return 0; error_adc_buffer_init: iio_triggered_buffer_cleanup(indio_dev); error_iio_device_register: clk_disable_unprepare(info->clk); error_adc_clk_enable: regulator_disable(info->vref); return ret; }
int st_press_allocate_ring(struct iio_dev *indio_dev) { return iio_triggered_buffer_setup(indio_dev, &iio_pollfunc_store_time, &st_sensors_trigger_handler, &st_press_buffer_setup_ops); }
static int cros_ec_sensors_probe(struct platform_device *pdev) { struct device *dev = &pdev->dev; struct cros_ec_dev *ec_dev = dev_get_drvdata(dev->parent); struct cros_ec_device *ec_device; struct iio_dev *indio_dev; struct cros_ec_sensors_state *state; struct iio_chan_spec *channel; int ret, i; if (!ec_dev || !ec_dev->ec_dev) { dev_warn(&pdev->dev, "No CROS EC device found.\n"); return -EINVAL; } ec_device = ec_dev->ec_dev; indio_dev = devm_iio_device_alloc(&pdev->dev, sizeof(*state)); if (!indio_dev) return -ENOMEM; ret = cros_ec_sensors_core_init(pdev, indio_dev, true); if (ret) return ret; indio_dev->info = &ec_sensors_info; state = iio_priv(indio_dev); for (channel = state->channels, i = CROS_EC_SENSOR_X; i < CROS_EC_SENSOR_MAX_AXIS; i++, channel++) { /* Common part */ channel->info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_CALIBBIAS); channel->info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SCALE) | BIT(IIO_CHAN_INFO_FREQUENCY) | BIT(IIO_CHAN_INFO_SAMP_FREQ); channel->scan_type.realbits = CROS_EC_SENSOR_BITS; channel->scan_type.storagebits = CROS_EC_SENSOR_BITS; channel->scan_index = i; channel->ext_info = cros_ec_sensors_ext_info; channel->modified = 1; channel->channel2 = IIO_MOD_X + i; channel->scan_type.sign = 's'; /* Sensor specific */ switch (state->core.type) { case MOTIONSENSE_TYPE_ACCEL: channel->type = IIO_ACCEL; break; case MOTIONSENSE_TYPE_GYRO: channel->type = IIO_ANGL_VEL; break; case MOTIONSENSE_TYPE_MAG: channel->type = IIO_MAGN; break; default: dev_err(&pdev->dev, "Unknown motion sensor\n"); return -EINVAL; } } /* Timestamp */ channel->type = IIO_TIMESTAMP; channel->channel = -1; channel->scan_index = CROS_EC_SENSOR_MAX_AXIS; channel->scan_type.sign = 's'; channel->scan_type.realbits = 64; channel->scan_type.storagebits = 64; indio_dev->channels = state->channels; indio_dev->num_channels = CROS_EC_SENSORS_MAX_CHANNELS; /* There is only enough room for accel and gyro in the io space */ if ((state->core.ec->cmd_readmem != NULL) && (state->core.type != MOTIONSENSE_TYPE_MAG)) state->core.read_ec_sensors_data = cros_ec_sensors_read_lpc; else state->core.read_ec_sensors_data = cros_ec_sensors_read_cmd; ret = iio_triggered_buffer_setup(indio_dev, NULL, cros_ec_sensors_capture, NULL); if (ret) return ret; ret = iio_device_register(indio_dev); if (ret) goto error_uninit_buffer; return 0; error_uninit_buffer: iio_triggered_buffer_cleanup(indio_dev); return ret; }
int ad799x_register_ring_funcs_and_init(struct iio_dev *indio_dev) { return iio_triggered_buffer_setup(indio_dev, NULL, &ad799x_trigger_handler, NULL); }
static int ad7298_probe(struct spi_device *spi) { struct ad7298_platform_data *pdata = spi->dev.platform_data; struct ad7298_state *st; struct iio_dev *indio_dev = iio_device_alloc(sizeof(*st)); int ret; if (indio_dev == NULL) return -ENOMEM; st = iio_priv(indio_dev); if (pdata && pdata->ext_ref) st->ext_ref = AD7298_EXTREF; if (st->ext_ref) { st->reg = regulator_get(&spi->dev, "vref"); if (IS_ERR(st->reg)) { ret = PTR_ERR(st->reg); goto error_free; } ret = regulator_enable(st->reg); if (ret) goto error_put_reg; } spi_set_drvdata(spi, indio_dev); st->spi = spi; indio_dev->name = spi_get_device_id(spi)->name; indio_dev->dev.parent = &spi->dev; indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->channels = ad7298_channels; indio_dev->num_channels = ARRAY_SIZE(ad7298_channels); indio_dev->info = &ad7298_info; /* Setup default message */ st->scan_single_xfer[0].tx_buf = &st->tx_buf[0]; st->scan_single_xfer[0].len = 2; st->scan_single_xfer[0].cs_change = 1; st->scan_single_xfer[1].tx_buf = &st->tx_buf[1]; st->scan_single_xfer[1].len = 2; st->scan_single_xfer[1].cs_change = 1; st->scan_single_xfer[2].rx_buf = &st->rx_buf[0]; st->scan_single_xfer[2].len = 2; spi_message_init(&st->scan_single_msg); spi_message_add_tail(&st->scan_single_xfer[0], &st->scan_single_msg); spi_message_add_tail(&st->scan_single_xfer[1], &st->scan_single_msg); spi_message_add_tail(&st->scan_single_xfer[2], &st->scan_single_msg); ret = iio_triggered_buffer_setup(indio_dev, NULL, &ad7298_trigger_handler, NULL); if (ret) goto error_disable_reg; ret = iio_device_register(indio_dev); if (ret) goto error_cleanup_ring; return 0; error_cleanup_ring: iio_triggered_buffer_cleanup(indio_dev); error_disable_reg: if (st->ext_ref) regulator_disable(st->reg); error_put_reg: if (st->ext_ref) regulator_put(st->reg); error_free: iio_device_free(indio_dev); return ret; }
static int adc108s102_probe(struct spi_device *spi) { struct adc108s102_state *st; struct iio_dev *indio_dev; int ret; indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st)); if (!indio_dev) return -ENOMEM; st = iio_priv(indio_dev); if (ACPI_COMPANION(&spi->dev)) { st->va_millivolt = ADC108S102_VA_MV_ACPI_DEFAULT; } else { st->reg = devm_regulator_get(&spi->dev, "vref"); if (IS_ERR(st->reg)) return PTR_ERR(st->reg); ret = regulator_enable(st->reg); if (ret < 0) { dev_err(&spi->dev, "Cannot enable vref regulator\n"); return ret; } ret = regulator_get_voltage(st->reg); if (ret < 0) { dev_err(&spi->dev, "vref get voltage failed\n"); return ret; } st->va_millivolt = ret / 1000; } spi_set_drvdata(spi, indio_dev); st->spi = spi; indio_dev->name = spi->modalias; indio_dev->dev.parent = &spi->dev; indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->channels = adc108s102_channels; indio_dev->num_channels = ARRAY_SIZE(adc108s102_channels); indio_dev->info = &adc108s102_info; /* Setup default message */ st->scan_single_xfer.tx_buf = st->tx_buf; st->scan_single_xfer.rx_buf = st->rx_buf; st->scan_single_xfer.len = 2 * sizeof(st->tx_buf[0]); spi_message_init_with_transfers(&st->scan_single_msg, &st->scan_single_xfer, 1); ret = iio_triggered_buffer_setup(indio_dev, NULL, &adc108s102_trigger_handler, NULL); if (ret) goto error_disable_reg; ret = iio_device_register(indio_dev); if (ret) { dev_err(&spi->dev, "Failed to register IIO device\n"); goto error_cleanup_triggered_buffer; } return 0; error_cleanup_triggered_buffer: iio_triggered_buffer_cleanup(indio_dev); error_disable_reg: regulator_disable(st->reg); return ret; }
static int mma8452_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct mma8452_data *data; struct iio_dev *indio_dev; int ret; ret = i2c_smbus_read_byte_data(client, MMA8452_WHO_AM_I); if (ret < 0) return ret; if (ret != MMA8452_DEVICE_ID) 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 = &mma8452_info; indio_dev->name = id->name; indio_dev->dev.parent = &client->dev; indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->channels = mma8452_channels; indio_dev->num_channels = ARRAY_SIZE(mma8452_channels); indio_dev->available_scan_masks = mma8452_scan_masks; ret = mma8452_reset(client); if (ret < 0) return ret; data->data_cfg = MMA8452_DATA_CFG_FS_2G; ret = i2c_smbus_write_byte_data(client, MMA8452_DATA_CFG, data->data_cfg); if (ret < 0) return ret; /* * By default set transient threshold to max to avoid events if * enabling without configuring threshold. */ ret = i2c_smbus_write_byte_data(client, MMA8452_TRANSIENT_THS, MMA8452_TRANSIENT_THS_MASK); if (ret < 0) return ret; if (client->irq) { /* * Although we enable the transient interrupt source once and * for all here the transient event detection itself is not * enabled until userspace asks for it by * mma8452_write_event_config() */ int supported_interrupts = MMA8452_INT_DRDY | MMA8452_INT_TRANS; int enabled_interrupts = MMA8452_INT_TRANS; /* Assume wired to INT1 pin */ ret = i2c_smbus_write_byte_data(client, MMA8452_CTRL_REG5, supported_interrupts); if (ret < 0) return ret; ret = i2c_smbus_write_byte_data(client, MMA8452_CTRL_REG4, enabled_interrupts); if (ret < 0) return ret; ret = mma8452_trigger_setup(indio_dev); if (ret < 0) return ret; } data->ctrl_reg1 = MMA8452_CTRL_ACTIVE | (MMA8452_CTRL_DR_DEFAULT << MMA8452_CTRL_DR_SHIFT); ret = i2c_smbus_write_byte_data(client, MMA8452_CTRL_REG1, data->ctrl_reg1); if (ret < 0) goto trigger_cleanup; ret = iio_triggered_buffer_setup(indio_dev, NULL, mma8452_trigger_handler, NULL); if (ret < 0) goto trigger_cleanup; if (client->irq) { ret = devm_request_threaded_irq(&client->dev, client->irq, NULL, mma8452_interrupt, IRQF_TRIGGER_LOW | IRQF_ONESHOT, client->name, indio_dev); if (ret) goto buffer_cleanup; } ret = iio_device_register(indio_dev); if (ret < 0) goto buffer_cleanup; return 0; buffer_cleanup: iio_triggered_buffer_cleanup(indio_dev); trigger_cleanup: mma8452_trigger_cleanup(indio_dev); return ret; }
int mpu3050_common_probe(struct device *dev, struct regmap *map, int irq, const char *name) { struct iio_dev *indio_dev; struct mpu3050 *mpu3050; unsigned int val; int ret; indio_dev = devm_iio_device_alloc(dev, sizeof(*mpu3050)); if (!indio_dev) return -ENOMEM; mpu3050 = iio_priv(indio_dev); mpu3050->dev = dev; mpu3050->map = map; mutex_init(&mpu3050->lock); /* Default fullscale: 2000 degrees per second */ mpu3050->fullscale = FS_2000_DPS; /* 1 kHz, divide by 100, default frequency = 10 Hz */ mpu3050->lpf = MPU3050_DLPF_CFG_188HZ; mpu3050->divisor = 99; /* Read the mounting matrix, if present */ ret = of_iio_read_mount_matrix(dev, "mount-matrix", &mpu3050->orientation); if (ret) return ret; /* Fetch and turn on regulators */ mpu3050->regs[0].supply = mpu3050_reg_vdd; mpu3050->regs[1].supply = mpu3050_reg_vlogic; ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(mpu3050->regs), mpu3050->regs); if (ret) { dev_err(dev, "Cannot get regulators\n"); return ret; } ret = mpu3050_power_up(mpu3050); if (ret) return ret; ret = regmap_read(map, MPU3050_CHIP_ID_REG, &val); if (ret) { dev_err(dev, "could not read device ID\n"); ret = -ENODEV; goto err_power_down; } if ((val & MPU3050_CHIP_ID_MASK) != MPU3050_CHIP_ID) { dev_err(dev, "unsupported chip id %02x\n", (u8)(val & MPU3050_CHIP_ID_MASK)); ret = -ENODEV; goto err_power_down; } ret = regmap_read(map, MPU3050_PRODUCT_ID_REG, &val); if (ret) { dev_err(dev, "could not read device ID\n"); ret = -ENODEV; goto err_power_down; } dev_info(dev, "found MPU-3050 part no: %d, version: %d\n", ((val >> 4) & 0xf), (val & 0xf)); ret = mpu3050_hw_init(mpu3050); if (ret) goto err_power_down; indio_dev->dev.parent = dev; indio_dev->channels = mpu3050_channels; indio_dev->num_channels = ARRAY_SIZE(mpu3050_channels); indio_dev->info = &mpu3050_info; indio_dev->available_scan_masks = mpu3050_scan_masks; indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->name = name; ret = iio_triggered_buffer_setup(indio_dev, iio_pollfunc_store_time, mpu3050_trigger_handler, &mpu3050_buffer_setup_ops); if (ret) { dev_err(dev, "triggered buffer setup failed\n"); goto err_power_down; } ret = iio_device_register(indio_dev); if (ret) { dev_err(dev, "device register failed\n"); goto err_cleanup_buffer; } dev_set_drvdata(dev, indio_dev); /* Check if we have an assigned IRQ to use as trigger */ if (irq) { ret = mpu3050_trigger_probe(indio_dev, irq); if (ret) dev_err(dev, "failed to register trigger\n"); } /* Enable runtime PM */ pm_runtime_get_noresume(dev); pm_runtime_set_active(dev); pm_runtime_enable(dev); /* * Set autosuspend to two orders of magnitude larger than the * start-up time. 100ms start-up time means 10000ms autosuspend, * i.e. 10 seconds. */ pm_runtime_set_autosuspend_delay(dev, 10000); pm_runtime_use_autosuspend(dev); pm_runtime_put(dev); return 0; err_cleanup_buffer: iio_triggered_buffer_cleanup(indio_dev); err_power_down: mpu3050_power_down(mpu3050); return ret; }
static int adc1x8s102_probe(struct spi_device *spi) { struct adc1x8s102_platform_data *pdata = spi->dev.platform_data; struct adc1x8s102_state *st; struct iio_dev *indio_dev = iio_device_alloc(sizeof(*st)); int ret; if (NULL == indio_dev) { dev_crit(&spi->dev, "Cannot allocate memory for indio_dev\n"); return -ENOMEM; } st = iio_priv(indio_dev); if (NULL == pdata) { dev_err(&spi->dev, "Cannot get adc1x8s102 platform data\n"); return -EFAULT; } st->ext_vin = pdata->ext_vin; /* Use regulator, if available. */ st->reg = regulator_get(&spi->dev, "vref"); if (IS_ERR(st->reg)) { ret = PTR_ERR(st->reg); dev_warn(&spi->dev, "Cannot get 'vref' regulator\n"); goto error_free; } ret = regulator_enable(st->reg); if (ret < 0) { dev_warn(&spi->dev, "Cannot enable vref regulator\n"); goto error_put_reg; } spi_set_drvdata(spi, indio_dev); st->spi = spi; indio_dev->name = spi_get_device_id(spi)->name; indio_dev->dev.parent = &spi->dev; indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->channels = adc1x8s102_channels; indio_dev->num_channels = ARRAY_SIZE(adc1x8s102_channels); indio_dev->info = &adc1x8s102_info; /* Setup default message */ st->scan_single_xfer.tx_buf = st->tx_buf; st->scan_single_xfer.rx_buf = st->rx_buf; st->scan_single_xfer.len = 2 * sizeof(__be16); st->scan_single_xfer.cs_change = 0; spi_message_init(&st->scan_single_msg); spi_message_add_tail(&st->scan_single_xfer, &st->scan_single_msg); ret = iio_triggered_buffer_setup(indio_dev, NULL, &adc1x8s102_trigger_handler, NULL); if (ret) goto error_disable_reg; ret = iio_device_register(indio_dev); if (ret) { dev_err(&spi->dev, "Failed to register IIO device\n"); goto error_cleanup_ring; } return 0; error_cleanup_ring: iio_triggered_buffer_cleanup(indio_dev); error_disable_reg: regulator_disable(st->reg); error_put_reg: regulator_put(st->reg); error_free: iio_device_free(indio_dev); return ret; }
static int mma8452_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct mma8452_data *data; struct iio_dev *indio_dev; int ret; const struct of_device_id *match; match = of_match_device(mma8452_dt_ids, &client->dev); if (!match) { dev_err(&client->dev, "unknown device model\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->lock); data->chip_info = match->data; ret = i2c_smbus_read_byte_data(client, MMA8452_WHO_AM_I); if (ret < 0) return ret; switch (ret) { case MMA8452_DEVICE_ID: case MMA8453_DEVICE_ID: case MMA8652_DEVICE_ID: case MMA8653_DEVICE_ID: if (ret == data->chip_info->chip_id) break; default: return -ENODEV; } dev_info(&client->dev, "registering %s accelerometer; ID 0x%x\n", match->compatible, data->chip_info->chip_id); i2c_set_clientdata(client, indio_dev); indio_dev->info = &mma8452_info; indio_dev->name = id->name; indio_dev->dev.parent = &client->dev; indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->channels = data->chip_info->channels; indio_dev->num_channels = data->chip_info->num_channels; indio_dev->available_scan_masks = mma8452_scan_masks; ret = mma8452_reset(client); if (ret < 0) return ret; data->data_cfg = MMA8452_DATA_CFG_FS_2G; ret = i2c_smbus_write_byte_data(client, MMA8452_DATA_CFG, data->data_cfg); if (ret < 0) return ret; /* * By default set transient threshold to max to avoid events if * enabling without configuring threshold. */ ret = i2c_smbus_write_byte_data(client, MMA8452_TRANSIENT_THS, MMA8452_TRANSIENT_THS_MASK); if (ret < 0) return ret; if (client->irq) { /* * Although we enable the interrupt sources once and for * all here the event detection itself is not enabled until * userspace asks for it by mma8452_write_event_config() */ int supported_interrupts = MMA8452_INT_DRDY | MMA8452_INT_TRANS | MMA8452_INT_FF_MT; int enabled_interrupts = MMA8452_INT_TRANS | MMA8452_INT_FF_MT; int irq2; irq2 = of_irq_get_byname(client->dev.of_node, "INT2"); if (irq2 == client->irq) { dev_dbg(&client->dev, "using interrupt line INT2\n"); } else { ret = i2c_smbus_write_byte_data(client, MMA8452_CTRL_REG5, supported_interrupts); if (ret < 0) return ret; dev_dbg(&client->dev, "using interrupt line INT1\n"); } ret = i2c_smbus_write_byte_data(client, MMA8452_CTRL_REG4, enabled_interrupts); if (ret < 0) return ret; ret = mma8452_trigger_setup(indio_dev); if (ret < 0) return ret; } data->ctrl_reg1 = MMA8452_CTRL_ACTIVE | (MMA8452_CTRL_DR_DEFAULT << MMA8452_CTRL_DR_SHIFT); ret = i2c_smbus_write_byte_data(client, MMA8452_CTRL_REG1, data->ctrl_reg1); if (ret < 0) goto trigger_cleanup; ret = iio_triggered_buffer_setup(indio_dev, NULL, mma8452_trigger_handler, NULL); if (ret < 0) goto trigger_cleanup; if (client->irq) { ret = devm_request_threaded_irq(&client->dev, client->irq, NULL, mma8452_interrupt, IRQF_TRIGGER_LOW | IRQF_ONESHOT, client->name, indio_dev); if (ret) goto buffer_cleanup; } ret = iio_device_register(indio_dev); if (ret < 0) goto buffer_cleanup; return 0; buffer_cleanup: iio_triggered_buffer_cleanup(indio_dev); trigger_cleanup: mma8452_trigger_cleanup(indio_dev); return ret; }