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 = iio_device_register(indio_dev); if (ret) goto error_free_dev; /* Get the device into a sane initial state */ ret = ade7854_initial_setup(indio_dev); if (ret) goto error_unreg_dev; return 0; error_unreg_dev: iio_device_unregister(indio_dev); error_free_dev: iio_device_free(indio_dev); return ret; }
static int __devinit ad5624r_probe(struct spi_device *spi) { struct ad5624r_state *st; struct iio_dev *indio_dev; struct regulator *reg; int ret, voltage_uv = 0; reg = regulator_get(&spi->dev, "vcc"); if (!IS_ERR(reg)) { ret = regulator_enable(reg); if (ret) goto error_put_reg; voltage_uv = regulator_get_voltage(reg); } indio_dev = iio_allocate_device(sizeof(*st)); if (indio_dev == NULL) { ret = -ENOMEM; goto error_disable_reg; } st = iio_priv(indio_dev); st->reg = reg; spi_set_drvdata(spi, indio_dev); st->chip_info = &ad5624r_chip_info_tbl[spi_get_device_id(spi)->driver_data]; if (voltage_uv) st->vref_mv = voltage_uv / 1000; else st->vref_mv = st->chip_info->int_vref_mv; st->us = spi; indio_dev->dev.parent = &spi->dev; indio_dev->name = spi_get_device_id(spi)->name; indio_dev->info = &ad5624r_info; indio_dev->modes = INDIO_DIRECT_MODE; ret = iio_device_register(indio_dev); if (ret) goto error_free_dev; ret = ad5624r_spi_write(spi, AD5624R_CMD_INTERNAL_REFER_SETUP, 0, !!voltage_uv, 16); if (ret) goto error_free_dev; return 0; error_free_dev: iio_free_device(indio_dev); error_disable_reg: if (!IS_ERR(reg)) regulator_disable(reg); error_put_reg: if (!IS_ERR(reg)) regulator_put(reg); return ret; }
static int __devinit adis16130_probe(struct spi_device *spi) { int ret; struct adis16130_state *st; struct iio_dev *indio_dev; /* setup the industrialio driver allocated elements */ indio_dev = iio_allocate_device(sizeof(*st)); if (indio_dev == NULL) { ret = -ENOMEM; goto error_ret; } 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->dev.parent = &spi->dev; indio_dev->info = &adis16130_info; indio_dev->modes = INDIO_DIRECT_MODE; st->mode = 1; ret = iio_device_register(indio_dev); if (ret) goto error_free_dev; return 0; error_free_dev: iio_free_device(indio_dev); error_ret: return ret; }
static int vcnl4000_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct vcnl4000_data *data; struct iio_dev *indio_dev; int ret; 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; ret = i2c_smbus_read_byte_data(data->client, VCNL4000_PROD_REV); if (ret < 0) return ret; dev_info(&client->dev, "VCNL4000 Ambient light/proximity sensor, Prod %02x, Rev: %02x\n", ret >> 4, ret & 0xf); indio_dev->dev.parent = &client->dev; indio_dev->info = &vcnl4000_info; indio_dev->channels = vcnl4000_channels; indio_dev->num_channels = ARRAY_SIZE(vcnl4000_channels); indio_dev->name = VCNL4000_DRV_NAME; indio_dev->modes = INDIO_DIRECT_MODE; return iio_device_register(indio_dev); }
int st_gyro_common_probe(struct iio_dev *indio_dev) { struct st_sensor_data *gdata = iio_priv(indio_dev); int irq = gdata->get_irq_data_ready(indio_dev); int err; indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->info = &gyro_info; mutex_init(&gdata->tb.buf_lock); st_sensors_power_enable(indio_dev); err = st_sensors_check_device_support(indio_dev, ARRAY_SIZE(st_gyro_sensors_settings), st_gyro_sensors_settings); if (err < 0) return err; gdata->num_data_channels = ST_GYRO_NUMBER_DATA_CHANNELS; gdata->multiread_bit = gdata->sensor_settings->multi_read_bit; indio_dev->channels = gdata->sensor_settings->ch; indio_dev->num_channels = ST_SENSORS_NUMBER_ALL_CHANNELS; gdata->current_fullscale = (struct st_sensor_fullscale_avl *) &gdata->sensor_settings->fs.fs_avl[0]; gdata->odr = gdata->sensor_settings->odr.odr_avl[0].hz; err = st_sensors_init_sensor(indio_dev, (struct st_sensors_platform_data *)&gyro_pdata); if (err < 0) return err; err = st_gyro_allocate_ring(indio_dev); if (err < 0) return err; if (irq > 0) { err = st_sensors_allocate_trigger(indio_dev, ST_GYRO_TRIGGER_OPS); if (err < 0) goto st_gyro_probe_trigger_error; } err = iio_device_register(indio_dev); if (err) goto st_gyro_device_register_error; dev_info(&indio_dev->dev, "registered gyroscope %s\n", indio_dev->name); return 0; st_gyro_device_register_error: if (irq > 0) st_sensors_deallocate_trigger(indio_dev); st_gyro_probe_trigger_error: st_gyro_deallocate_ring(indio_dev); return err; }
static int max517_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct max517_data *data; struct max517_platform_data *platform_data = client->dev.platform_data; int err; data = kzalloc(sizeof(struct max517_data), GFP_KERNEL); if (!data) { err = -ENOMEM; goto exit; } i2c_set_clientdata(client, data); data->client = client; data->indio_dev = iio_allocate_device(0); if (data->indio_dev == NULL) { err = -ENOMEM; goto exit_free_data; } /* establish that the iio_dev is a child of the i2c device */ data->indio_dev->dev.parent = &client->dev; /* reduced attribute set for MAX517 */ if (id->driver_data == ID_MAX517) data->indio_dev->info = &max517_info; else data->indio_dev->info = &max518_info; data->indio_dev->dev_data = (void *)(data); data->indio_dev->modes = INDIO_DIRECT_MODE; /* * Reference voltage on MAX518 and default is 5V, else take vref_mv * from platform_data */ if (id->driver_data == ID_MAX518 || !platform_data) { data->vref_mv[0] = data->vref_mv[1] = 5000; /* mV */ } else { data->vref_mv[0] = platform_data->vref_mv[0]; data->vref_mv[1] = platform_data->vref_mv[1]; } err = iio_device_register(data->indio_dev); if (err) goto exit_free_device; dev_info(&client->dev, "DAC registered\n"); return 0; exit_free_device: iio_free_device(data->indio_dev); exit_free_data: kfree(data); exit: return err; }
static int ad5930_probe(struct spi_device *spi) { struct ad5930_state *st; struct iio_dev *idev; int ret = 0; idev = iio_device_alloc(sizeof(*st)); if (idev == NULL) { ret = -ENOMEM; goto error_ret; } spi_set_drvdata(spi, idev); st = iio_priv(idev); mutex_init(&st->lock); st->sdev = spi; idev->dev.parent = &spi->dev; idev->info = &ad5930_info; idev->modes = INDIO_DIRECT_MODE; ret = iio_device_register(idev); if (ret) goto error_free_dev; spi->max_speed_hz = 2000000; spi->mode = SPI_MODE_3; spi->bits_per_word = 16; spi_setup(spi); return 0; error_free_dev: iio_device_free(idev); error_ret: return ret; }
static int ad9852_probe(struct spi_device *spi) { struct ad9852_state *st; struct iio_dev *idev; int ret = 0; idev = devm_iio_device_alloc(&spi->dev, sizeof(*st)); if (!idev) return -ENOMEM; st = iio_priv(idev); spi_set_drvdata(spi, idev); mutex_init(&st->lock); st->sdev = spi; idev->dev.parent = &spi->dev; idev->info = &ad9852_info; idev->modes = INDIO_DIRECT_MODE; ret = iio_device_register(idev); if (ret) return ret; spi->max_speed_hz = 2000000; spi->mode = SPI_MODE_3; spi->bits_per_word = 8; spi_setup(spi); ad9852_init(st); return 0; }
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 = iio_device_register(indio_dev); if (ret) { dev_err(&pdev->dev, "could not register iio (adc)"); return ret; } platform_set_drvdata(pdev, indio_dev); return 0; }
static int max5487_spi_probe(struct spi_device *spi) { struct iio_dev *indio_dev; struct max5487_data *data; const struct spi_device_id *id = spi_get_device_id(spi); int ret; indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*data)); if (!indio_dev) return -ENOMEM; dev_set_drvdata(&spi->dev, indio_dev); data = iio_priv(indio_dev); data->spi = spi; data->kohms = id->driver_data; indio_dev->info = &max5487_info; indio_dev->name = id->name; indio_dev->dev.parent = &spi->dev; indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->channels = max5487_channels; indio_dev->num_channels = ARRAY_SIZE(max5487_channels); /* restore both wiper regs from NV regs */ ret = max5487_write_cmd(data->spi, MAX5487_COPY_NV_TO_AB); if (ret < 0) return ret; return iio_device_register(indio_dev); }
static int __devinit isl29018_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct isl29018_chip *chip; int err; chip = kzalloc(sizeof (struct isl29018_chip), GFP_KERNEL); if (!chip) { dev_err(&client->dev, "Memory allocation fails\n"); err = -ENOMEM; goto exit; } i2c_set_clientdata(client, chip); chip->pdata = client->dev.platform_data; chip->client = client; mutex_init(&chip->lock); chip->range = ISL29018_DEFAULT_RANGE; chip->adc_bit = ISL29018_DEFAULT_RESOLUTION; chip->enable_ls = 0; err = isl29018_chip_init(client); if (err) goto exit_free; chip->indio_dev = iio_allocate_device(); if (!chip->indio_dev) { dev_err(&client->dev, "iio allocation fails\n"); goto exit_free; } chip->indio_dev->attrs = &isl29108_group; chip->indio_dev->dev.parent = &client->dev; chip->indio_dev->dev_data = (void *)(chip); chip->indio_dev->driver_module = THIS_MODULE; chip->indio_dev->modes = INDIO_DIRECT_MODE; err = iio_device_register(chip->indio_dev); if (err) { dev_err(&client->dev, "iio registration fails\n"); goto exit_iio_free; } chip->early_suspend.suspend = isl29018_early_suspend; chip->early_suspend.resume = isl29018_late_resume; register_early_suspend(&(chip->early_suspend)); if (chip->pdata && chip->pdata->power_off) chip->pdata->power_off(); return 0; exit_iio_free: iio_free_device(chip->indio_dev); exit_free: kfree(chip); exit: return err; }
int st_magn_common_probe(struct iio_dev *indio_dev) { struct st_sensor_data *mdata = iio_priv(indio_dev); int irq = mdata->get_irq_data_ready(indio_dev); int err; indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->info = &magn_info; mutex_init(&mdata->tb.buf_lock); st_sensors_power_enable(indio_dev); err = st_sensors_check_device_support(indio_dev, ARRAY_SIZE(st_magn_sensors_settings), st_magn_sensors_settings); if (err < 0) return err; mdata->num_data_channels = ST_MAGN_NUMBER_DATA_CHANNELS; mdata->multiread_bit = mdata->sensor_settings->multi_read_bit; indio_dev->channels = mdata->sensor_settings->ch; indio_dev->num_channels = ST_SENSORS_NUMBER_ALL_CHANNELS; mdata->current_fullscale = (struct st_sensor_fullscale_avl *) &mdata->sensor_settings->fs.fs_avl[0]; mdata->odr = mdata->sensor_settings->odr.odr_avl[0].hz; err = st_sensors_init_sensor(indio_dev, NULL); if (err < 0) return err; err = st_magn_allocate_ring(indio_dev); if (err < 0) return err; if (irq > 0) { err = st_sensors_allocate_trigger(indio_dev, NULL); if (err < 0) goto st_magn_probe_trigger_error; } err = iio_device_register(indio_dev); if (err) goto st_magn_device_register_error; dev_info(&indio_dev->dev, "registered magnetometer %s\n", indio_dev->name); return 0; st_magn_device_register_error: if (irq > 0) st_sensors_deallocate_trigger(indio_dev); st_magn_probe_trigger_error: st_magn_deallocate_ring(indio_dev); return err; }
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 mcp3422_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct iio_dev *iio; struct mcp3422 *adc; int err; u8 config; if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) return -ENODEV; iio = iio_device_alloc(sizeof(*adc)); if (!iio) return -ENOMEM; adc = iio_priv(iio); adc->i2c = client; mutex_init(&adc->lock); iio->dev.parent = &client->dev; iio->name = dev_name(&client->dev); iio->modes = INDIO_DIRECT_MODE; iio->info = &mcp3422_info; switch ((unsigned int)(id->driver_data)) { case 2: case 3: iio->channels = mcp3422_channels; iio->num_channels = ARRAY_SIZE(mcp3422_channels); break; case 4: iio->channels = mcp3424_channels; iio->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 = iio_device_register(iio); if (err < 0) goto iio_free; i2c_set_clientdata(client, iio); return 0; iio_free: iio_device_free(iio); return err; }
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; }
static int pa12203001_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct pa12203001_data *data; struct iio_dev *indio_dev; int ret; indio_dev = devm_iio_device_alloc(&client->dev, sizeof(struct pa12203001_data)); if (!indio_dev) return -ENOMEM; data = iio_priv(indio_dev); i2c_set_clientdata(client, indio_dev); data->client = client; data->map = devm_regmap_init_i2c(client, &pa12203001_regmap_config); if (IS_ERR(data->map)) return PTR_ERR(data->map); mutex_init(&data->lock); indio_dev->dev.parent = &client->dev; indio_dev->info = &pa12203001_info; indio_dev->name = PA12203001_DRIVER_NAME; indio_dev->channels = pa12203001_channels; indio_dev->num_channels = ARRAY_SIZE(pa12203001_channels); indio_dev->modes = INDIO_DIRECT_MODE; ret = pa12203001_init(indio_dev); if (ret < 0) return ret; ret = pa12203001_power_chip(indio_dev, PA12203001_CHIP_ENABLE); if (ret < 0) return ret; ret = pm_runtime_set_active(&client->dev); if (ret < 0) goto out_err; pm_runtime_enable(&client->dev); pm_runtime_set_autosuspend_delay(&client->dev, PA12203001_SLEEP_DELAY_MS); pm_runtime_use_autosuspend(&client->dev); ret = iio_device_register(indio_dev); if (ret < 0) goto out_err; return 0; out_err: pa12203001_power_chip(indio_dev, PA12203001_CHIP_DISABLE); return ret; }
static int __devinit crystalcove_gpadc_probe(struct platform_device *pdev) { int err; struct gpadc_info *info; struct iio_dev *indio_dev; intel_mid_pmic_writeb(MADCIRQ0, 0x00); intel_mid_pmic_writeb(MADCIRQ1, 0x00); indio_dev = iio_allocate_device(sizeof(struct gpadc_info)); if (indio_dev == NULL) { dev_err(&pdev->dev, "allocating iio device failed\n"); return -ENOMEM; } info = iio_priv(indio_dev); mutex_init(&info->lock); init_waitqueue_head(&info->wait); info->dev = &pdev->dev; info->irq = platform_get_irq(pdev, 0); err = request_threaded_irq(info->irq, NULL, gpadc_isr, IRQF_ONESHOT, "adc", indio_dev); if (err) { dev_err(&pdev->dev, "unable to register irq %d\n", info->irq); goto err_free_device; } platform_set_drvdata(pdev, indio_dev); indio_dev->dev.parent = &pdev->dev; indio_dev->name = pdev->name; indio_dev->channels = crystalcove_adc_channels; indio_dev->num_channels = ARRAY_SIZE(crystalcove_adc_channels); indio_dev->info = &crystalcove_adc_info; indio_dev->modes = INDIO_DIRECT_MODE; err = iio_map_array_register(indio_dev, iio_maps); if (err) goto err_release_irq; err = iio_device_register(indio_dev); if (err < 0) goto err_array_unregister; dev_info(&pdev->dev, "crystalcove adc probed\n"); return 0; err_array_unregister: iio_map_array_unregister(indio_dev, iio_maps); err_release_irq: free_irq(info->irq, info); err_free_device: iio_free_device(indio_dev); return err; }
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 isl29018_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct isl29018_chip *chip; struct iio_dev *indio_dev; int err; indio_dev = iio_device_alloc(sizeof(*chip)); if (indio_dev == NULL) { dev_err(&client->dev, "iio allocation fails\n"); err = -ENOMEM; goto exit; } chip = iio_priv(indio_dev); i2c_set_clientdata(client, indio_dev); chip->dev = &client->dev; mutex_init(&chip->lock); chip->lux_scale = 1; chip->range = 1000; chip->adc_bit = 16; chip->suspended = false; chip->regmap = devm_regmap_init_i2c(client, &isl29018_regmap_config); if (IS_ERR(chip->regmap)) { err = PTR_ERR(chip->regmap); dev_err(chip->dev, "regmap initialization failed: %d\n", err); goto exit; } err = isl29018_chip_init(chip); if (err) goto exit_iio_free; indio_dev->info = &isl29108_info; indio_dev->channels = isl29018_channels; indio_dev->num_channels = ARRAY_SIZE(isl29018_channels); indio_dev->name = id->name; indio_dev->dev.parent = &client->dev; indio_dev->modes = INDIO_DIRECT_MODE; err = iio_device_register(indio_dev); if (err) { dev_err(&client->dev, "iio registration fails\n"); goto exit_iio_free; } return 0; exit_iio_free: iio_device_free(indio_dev); exit: return err; }
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 ade7854_probe(struct ade7854_state *st, struct device *dev) { int ret; /* Allocate the comms buffers */ st->rx = kzalloc(sizeof(*st->rx)*ADE7854_MAX_RX, GFP_KERNEL); if (st->rx == NULL) { ret = -ENOMEM; goto error_free_st; } st->tx = kzalloc(sizeof(*st->tx)*ADE7854_MAX_TX, GFP_KERNEL); if (st->tx == NULL) { ret = -ENOMEM; goto error_free_rx; } mutex_init(&st->buf_lock); /* setup the industrialio driver allocated elements */ st->indio_dev = iio_allocate_device(); if (st->indio_dev == NULL) { ret = -ENOMEM; goto error_free_tx; } st->indio_dev->dev.parent = dev; st->indio_dev->attrs = &ade7854_attribute_group; st->indio_dev->dev_data = (void *)(st); st->indio_dev->driver_module = THIS_MODULE; st->indio_dev->modes = INDIO_DIRECT_MODE; ret = iio_device_register(st->indio_dev); if (ret) goto error_free_dev; /* Get the device into a sane initial state */ ret = ade7854_initial_setup(st); if (ret) goto error_unreg_dev; return 0; error_unreg_dev: iio_device_unregister(st->indio_dev); error_free_dev: iio_free_device(st->indio_dev); error_free_tx: kfree(st->tx); error_free_rx: kfree(st->rx); error_free_st: kfree(st); return ret; }
static int __devinit tiadc_probe(struct platform_device *pdev) { struct iio_dev *indio_dev; struct tiadc_device *adc_dev; struct ti_tscadc_dev *tscadc_dev = pdev->dev.platform_data; struct mfd_tscadc_board *pdata; int err; pdata = tscadc_dev->dev->platform_data; if (!pdata || !pdata->adc_init) { dev_err(&pdev->dev, "Could not find platform data\n"); return -EINVAL; } indio_dev = iio_device_alloc(sizeof(struct tiadc_device)); if (indio_dev == NULL) { dev_err(&pdev->dev, "failed to allocate iio device\n"); err = -ENOMEM; goto err_ret; } adc_dev = iio_priv(indio_dev); adc_dev->mfd_tscadc = tscadc_dev; adc_dev->channels = pdata->adc_init->adc_channels; indio_dev->dev.parent = &pdev->dev; indio_dev->name = dev_name(&pdev->dev); indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->info = &tiadc_info; tiadc_step_config(adc_dev); err = tiadc_channel_init(indio_dev, adc_dev); if (err < 0) goto err_free_device; err = iio_device_register(indio_dev); if (err) goto err_free_channels; platform_set_drvdata(pdev, indio_dev); dev_info(&pdev->dev, "Initialized\n"); return 0; err_free_channels: tiadc_channels_remove(indio_dev); err_free_device: iio_device_free(indio_dev); err_ret: return err; }
int st_gyro_common_probe(struct iio_dev *indio_dev, struct st_sensors_platform_data *pdata) { int err; struct st_sensor_data *gdata = iio_priv(indio_dev); indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->info = &gyro_info; err = st_sensors_check_device_support(indio_dev, ARRAY_SIZE(st_gyro_sensors), st_gyro_sensors); if (err < 0) goto st_gyro_common_probe_error; gdata->num_data_channels = ST_GYRO_NUMBER_DATA_CHANNELS; gdata->multiread_bit = gdata->sensor->multi_read_bit; indio_dev->channels = gdata->sensor->ch; indio_dev->num_channels = ST_SENSORS_NUMBER_ALL_CHANNELS; gdata->current_fullscale = (struct st_sensor_fullscale_avl *) &gdata->sensor->fs.fs_avl[0]; gdata->odr = gdata->sensor->odr.odr_avl[0].hz; err = st_sensors_init_sensor(indio_dev, pdata); if (err < 0) goto st_gyro_common_probe_error; if (gdata->get_irq_data_ready(indio_dev) > 0) { err = st_gyro_allocate_ring(indio_dev); if (err < 0) goto st_gyro_common_probe_error; err = st_sensors_allocate_trigger(indio_dev, ST_GYRO_TRIGGER_OPS); if (err < 0) goto st_gyro_probe_trigger_error; } err = iio_device_register(indio_dev); if (err) goto st_gyro_device_register_error; return err; st_gyro_device_register_error: if (gdata->get_irq_data_ready(indio_dev) > 0) st_sensors_deallocate_trigger(indio_dev); st_gyro_probe_trigger_error: if (gdata->get_irq_data_ready(indio_dev) > 0) st_gyro_deallocate_ring(indio_dev); st_gyro_common_probe_error: return err; }
static int mlx90614_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct iio_dev *indio_dev; struct mlx90614_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); data->wakeup_gpio = mlx90614_probe_wakeup(client); mlx90614_wakeup(data); indio_dev->dev.parent = &client->dev; indio_dev->name = id->name; indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->info = &mlx90614_info; ret = mlx90614_probe_num_ir_sensors(client); switch (ret) { case 0: dev_dbg(&client->dev, "Found single sensor"); indio_dev->channels = mlx90614_channels; indio_dev->num_channels = 2; break; case 1: dev_dbg(&client->dev, "Found dual sensor"); indio_dev->channels = mlx90614_channels; indio_dev->num_channels = 3; break; default: return ret; } if (data->wakeup_gpio) { pm_runtime_set_autosuspend_delay(&client->dev, MLX90614_AUTOSLEEP_DELAY); pm_runtime_use_autosuspend(&client->dev); pm_runtime_set_active(&client->dev); pm_runtime_enable(&client->dev); } return iio_device_register(indio_dev); }
static int max517_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct max517_data *data; struct iio_dev *indio_dev; struct max517_platform_data *platform_data = client->dev.platform_data; int err; indio_dev = iio_device_alloc(sizeof(*data)); if (indio_dev == NULL) { err = -ENOMEM; goto exit; } data = iio_priv(indio_dev); i2c_set_clientdata(client, indio_dev); data->client = client; /* establish that the iio_dev is a child of the i2c device */ indio_dev->dev.parent = &client->dev; /* reduced channel set for MAX517 */ if (id->driver_data == ID_MAX517) indio_dev->num_channels = 1; else indio_dev->num_channels = 2; indio_dev->channels = max517_channels; indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->info = &max517_info; /* * Reference voltage on MAX518 and default is 5V, else take vref_mv * from platform_data */ if (id->driver_data == ID_MAX518 || !platform_data) { data->vref_mv[0] = data->vref_mv[1] = 5000; /* mV */ } else { data->vref_mv[0] = platform_data->vref_mv[0]; data->vref_mv[1] = platform_data->vref_mv[1]; } err = iio_device_register(indio_dev); if (err) goto exit_free_device; dev_info(&client->dev, "DAC registered\n"); return 0; exit_free_device: iio_device_free(indio_dev); exit: return err; }
static int adis16400_probe(struct spi_device *spi) { struct adis16400_state *st; struct iio_dev *indio_dev; int ret; indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st)); if (indio_dev == NULL) return -ENOMEM; st = iio_priv(indio_dev); /* this is only used for removal purposes */ spi_set_drvdata(spi, indio_dev); /* setup the industrialio driver allocated elements */ st->variant = &adis16400_chips[spi_get_device_id(spi)->driver_data]; indio_dev->dev.parent = &spi->dev; indio_dev->name = spi_get_device_id(spi)->name; indio_dev->channels = st->variant->channels; indio_dev->num_channels = st->variant->num_channels; indio_dev->info = &adis16400_info; indio_dev->modes = INDIO_DIRECT_MODE; if (!(st->variant->flags & ADIS16400_NO_BURST)) { adis16400_setup_chan_mask(st); indio_dev->available_scan_masks = st->avail_scan_mask; } ret = adis_init(&st->adis, indio_dev, spi, &adis16400_data); if (ret) return ret; ret = adis_setup_buffer_and_trigger(&st->adis, indio_dev, adis16400_trigger_handler); if (ret) return ret; /* Get the device into a sane initial state */ ret = adis16400_initial_setup(indio_dev); if (ret) goto error_cleanup_buffer; ret = iio_device_register(indio_dev); if (ret) goto error_cleanup_buffer; adis16400_debugfs_init(indio_dev); return 0; error_cleanup_buffer: adis_cleanup_buffer_and_trigger(&st->adis, indio_dev); return ret; }
int st_accel_common_probe(struct iio_dev *indio_dev) { int err; struct st_sensor_data *adata = iio_priv(indio_dev); indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->info = &accel_info; err = st_sensors_check_device_support(indio_dev, ARRAY_SIZE(st_accel_sensors), st_accel_sensors); if (err < 0) goto st_accel_common_probe_error; adata->multiread_bit = adata->sensor->multi_read_bit; indio_dev->channels = adata->sensor->ch; indio_dev->num_channels = ST_SENSORS_NUMBER_ALL_CHANNELS; adata->current_fullscale = (struct st_sensor_fullscale_avl *) &adata->sensor->fs.fs_avl[0]; adata->odr = adata->sensor->odr.odr_avl[0].hz; err = st_sensors_init_sensor(indio_dev); if (err < 0) goto st_accel_common_probe_error; if (adata->get_irq_data_ready(indio_dev) > 0) { err = st_accel_allocate_ring(indio_dev); if (err < 0) goto st_accel_common_probe_error; err = st_sensors_allocate_trigger(indio_dev, &st_accel_trigger_ops); if (err < 0) goto st_accel_probe_trigger_error; } err = iio_device_register(indio_dev); if (err) goto st_accel_device_register_error; return err; st_accel_device_register_error: if (adata->get_irq_data_ready(indio_dev) > 0) st_sensors_deallocate_trigger(indio_dev); st_accel_probe_trigger_error: if (adata->get_irq_data_ready(indio_dev) > 0) st_accel_deallocate_ring(indio_dev); st_accel_common_probe_error: return err; }
static int da280_probe(struct i2c_client *client, const struct i2c_device_id *id) { int ret; struct iio_dev *indio_dev; struct da280_data *data; enum da280_chipset chip; ret = i2c_smbus_read_byte_data(client, DA280_REG_CHIP_ID); if (ret != DA280_CHIP_ID) return (ret < 0) ? ret : -ENODEV; indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); if (!indio_dev) return -ENOMEM; data = iio_priv(indio_dev); data->client = client; i2c_set_clientdata(client, indio_dev); indio_dev->dev.parent = &client->dev; indio_dev->info = &da280_info; indio_dev->modes = INDIO_DIRECT_MODE; indio_dev->channels = da280_channels; if (ACPI_HANDLE(&client->dev)) { chip = da280_match_acpi_device(&client->dev); } else { chip = id->driver_data; } if (chip == da226) { indio_dev->name = "da226"; indio_dev->num_channels = 2; } else { indio_dev->name = "da280"; indio_dev->num_channels = 3; } ret = da280_enable(client, true); if (ret < 0) return ret; ret = iio_device_register(indio_dev); if (ret < 0) { dev_err(&client->dev, "device_register failed\n"); da280_enable(client, false); } return ret; }
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 = iio_device_alloc(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); chip->dev = &client->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(chip->dev, "regmap initialization failed: %d\n", ret); goto exit_iio_free; } ret = isl29028_chip_init(chip); if (ret < 0) { dev_err(chip->dev, "chip initialization failed: %d\n", ret); goto exit_iio_free; } 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 = iio_device_register(indio_dev); if (ret < 0) { dev_err(chip->dev, "iio registration fails with error %d\n", ret); goto exit_iio_free; } return 0; exit_iio_free: iio_device_free(indio_dev); return ret; }