Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Support code for Analog Devices Sigma-Delta ADCs
0004  *
0005  * Copyright 2012 Analog Devices Inc.
0006  *  Author: Lars-Peter Clausen <lars@metafoo.de>
0007  */
0008 
0009 #include <linux/align.h>
0010 #include <linux/interrupt.h>
0011 #include <linux/device.h>
0012 #include <linux/kernel.h>
0013 #include <linux/slab.h>
0014 #include <linux/spi/spi.h>
0015 #include <linux/err.h>
0016 #include <linux/module.h>
0017 
0018 #include <linux/iio/iio.h>
0019 #include <linux/iio/sysfs.h>
0020 #include <linux/iio/buffer.h>
0021 #include <linux/iio/trigger.h>
0022 #include <linux/iio/trigger_consumer.h>
0023 #include <linux/iio/triggered_buffer.h>
0024 #include <linux/iio/adc/ad_sigma_delta.h>
0025 
0026 #include <asm/unaligned.h>
0027 
0028 
0029 #define AD_SD_COMM_CHAN_MASK    0x3
0030 
0031 #define AD_SD_REG_COMM      0x00
0032 #define AD_SD_REG_DATA      0x03
0033 
0034 /**
0035  * ad_sd_set_comm() - Set communications register
0036  *
0037  * @sigma_delta: The sigma delta device
0038  * @comm: New value for the communications register
0039  */
0040 void ad_sd_set_comm(struct ad_sigma_delta *sigma_delta, uint8_t comm)
0041 {
0042     /* Some variants use the lower two bits of the communications register
0043      * to select the channel */
0044     sigma_delta->comm = comm & AD_SD_COMM_CHAN_MASK;
0045 }
0046 EXPORT_SYMBOL_NS_GPL(ad_sd_set_comm, IIO_AD_SIGMA_DELTA);
0047 
0048 /**
0049  * ad_sd_write_reg() - Write a register
0050  *
0051  * @sigma_delta: The sigma delta device
0052  * @reg: Address of the register
0053  * @size: Size of the register (0-3)
0054  * @val: Value to write to the register
0055  *
0056  * Returns 0 on success, an error code otherwise.
0057  **/
0058 int ad_sd_write_reg(struct ad_sigma_delta *sigma_delta, unsigned int reg,
0059     unsigned int size, unsigned int val)
0060 {
0061     uint8_t *data = sigma_delta->tx_buf;
0062     struct spi_transfer t = {
0063         .tx_buf     = data,
0064         .len        = size + 1,
0065         .cs_change  = sigma_delta->keep_cs_asserted,
0066     };
0067     struct spi_message m;
0068     int ret;
0069 
0070     data[0] = (reg << sigma_delta->info->addr_shift) | sigma_delta->comm;
0071 
0072     switch (size) {
0073     case 3:
0074         put_unaligned_be24(val, &data[1]);
0075         break;
0076     case 2:
0077         put_unaligned_be16(val, &data[1]);
0078         break;
0079     case 1:
0080         data[1] = val;
0081         break;
0082     case 0:
0083         break;
0084     default:
0085         return -EINVAL;
0086     }
0087 
0088     spi_message_init(&m);
0089     spi_message_add_tail(&t, &m);
0090 
0091     if (sigma_delta->bus_locked)
0092         ret = spi_sync_locked(sigma_delta->spi, &m);
0093     else
0094         ret = spi_sync(sigma_delta->spi, &m);
0095 
0096     return ret;
0097 }
0098 EXPORT_SYMBOL_NS_GPL(ad_sd_write_reg, IIO_AD_SIGMA_DELTA);
0099 
0100 static int ad_sd_read_reg_raw(struct ad_sigma_delta *sigma_delta,
0101     unsigned int reg, unsigned int size, uint8_t *val)
0102 {
0103     uint8_t *data = sigma_delta->tx_buf;
0104     int ret;
0105     struct spi_transfer t[] = {
0106         {
0107             .tx_buf = data,
0108             .len = 1,
0109         }, {
0110             .rx_buf = val,
0111             .len = size,
0112             .cs_change = sigma_delta->bus_locked,
0113         },
0114     };
0115     struct spi_message m;
0116 
0117     spi_message_init(&m);
0118 
0119     if (sigma_delta->info->has_registers) {
0120         data[0] = reg << sigma_delta->info->addr_shift;
0121         data[0] |= sigma_delta->info->read_mask;
0122         data[0] |= sigma_delta->comm;
0123         spi_message_add_tail(&t[0], &m);
0124     }
0125     spi_message_add_tail(&t[1], &m);
0126 
0127     if (sigma_delta->bus_locked)
0128         ret = spi_sync_locked(sigma_delta->spi, &m);
0129     else
0130         ret = spi_sync(sigma_delta->spi, &m);
0131 
0132     return ret;
0133 }
0134 
0135 /**
0136  * ad_sd_read_reg() - Read a register
0137  *
0138  * @sigma_delta: The sigma delta device
0139  * @reg: Address of the register
0140  * @size: Size of the register (1-4)
0141  * @val: Read value
0142  *
0143  * Returns 0 on success, an error code otherwise.
0144  **/
0145 int ad_sd_read_reg(struct ad_sigma_delta *sigma_delta,
0146     unsigned int reg, unsigned int size, unsigned int *val)
0147 {
0148     int ret;
0149 
0150     ret = ad_sd_read_reg_raw(sigma_delta, reg, size, sigma_delta->rx_buf);
0151     if (ret < 0)
0152         goto out;
0153 
0154     switch (size) {
0155     case 4:
0156         *val = get_unaligned_be32(sigma_delta->rx_buf);
0157         break;
0158     case 3:
0159         *val = get_unaligned_be24(sigma_delta->rx_buf);
0160         break;
0161     case 2:
0162         *val = get_unaligned_be16(sigma_delta->rx_buf);
0163         break;
0164     case 1:
0165         *val = sigma_delta->rx_buf[0];
0166         break;
0167     default:
0168         ret = -EINVAL;
0169         break;
0170     }
0171 
0172 out:
0173     return ret;
0174 }
0175 EXPORT_SYMBOL_NS_GPL(ad_sd_read_reg, IIO_AD_SIGMA_DELTA);
0176 
0177 /**
0178  * ad_sd_reset() - Reset the serial interface
0179  *
0180  * @sigma_delta: The sigma delta device
0181  * @reset_length: Number of SCLKs with DIN = 1
0182  *
0183  * Returns 0 on success, an error code otherwise.
0184  **/
0185 int ad_sd_reset(struct ad_sigma_delta *sigma_delta,
0186     unsigned int reset_length)
0187 {
0188     uint8_t *buf;
0189     unsigned int size;
0190     int ret;
0191 
0192     size = DIV_ROUND_UP(reset_length, 8);
0193     buf = kcalloc(size, sizeof(*buf), GFP_KERNEL);
0194     if (!buf)
0195         return -ENOMEM;
0196 
0197     memset(buf, 0xff, size);
0198     ret = spi_write(sigma_delta->spi, buf, size);
0199     kfree(buf);
0200 
0201     return ret;
0202 }
0203 EXPORT_SYMBOL_NS_GPL(ad_sd_reset, IIO_AD_SIGMA_DELTA);
0204 
0205 int ad_sd_calibrate(struct ad_sigma_delta *sigma_delta,
0206     unsigned int mode, unsigned int channel)
0207 {
0208     int ret;
0209     unsigned long timeout;
0210 
0211     ret = ad_sigma_delta_set_channel(sigma_delta, channel);
0212     if (ret)
0213         return ret;
0214 
0215     spi_bus_lock(sigma_delta->spi->master);
0216     sigma_delta->bus_locked = true;
0217     sigma_delta->keep_cs_asserted = true;
0218     reinit_completion(&sigma_delta->completion);
0219 
0220     ret = ad_sigma_delta_set_mode(sigma_delta, mode);
0221     if (ret < 0)
0222         goto out;
0223 
0224     sigma_delta->irq_dis = false;
0225     enable_irq(sigma_delta->spi->irq);
0226     timeout = wait_for_completion_timeout(&sigma_delta->completion, 2 * HZ);
0227     if (timeout == 0) {
0228         sigma_delta->irq_dis = true;
0229         disable_irq_nosync(sigma_delta->spi->irq);
0230         ret = -EIO;
0231     } else {
0232         ret = 0;
0233     }
0234 out:
0235     sigma_delta->keep_cs_asserted = false;
0236     ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_IDLE);
0237     sigma_delta->bus_locked = false;
0238     spi_bus_unlock(sigma_delta->spi->master);
0239 
0240     return ret;
0241 }
0242 EXPORT_SYMBOL_NS_GPL(ad_sd_calibrate, IIO_AD_SIGMA_DELTA);
0243 
0244 /**
0245  * ad_sd_calibrate_all() - Performs channel calibration
0246  * @sigma_delta: The sigma delta device
0247  * @cb: Array of channels and calibration type to perform
0248  * @n: Number of items in cb
0249  *
0250  * Returns 0 on success, an error code otherwise.
0251  **/
0252 int ad_sd_calibrate_all(struct ad_sigma_delta *sigma_delta,
0253     const struct ad_sd_calib_data *cb, unsigned int n)
0254 {
0255     unsigned int i;
0256     int ret;
0257 
0258     for (i = 0; i < n; i++) {
0259         ret = ad_sd_calibrate(sigma_delta, cb[i].mode, cb[i].channel);
0260         if (ret)
0261             return ret;
0262     }
0263 
0264     return 0;
0265 }
0266 EXPORT_SYMBOL_NS_GPL(ad_sd_calibrate_all, IIO_AD_SIGMA_DELTA);
0267 
0268 /**
0269  * ad_sigma_delta_single_conversion() - Performs a single data conversion
0270  * @indio_dev: The IIO device
0271  * @chan: The conversion is done for this channel
0272  * @val: Pointer to the location where to store the read value
0273  *
0274  * Returns: 0 on success, an error value otherwise.
0275  */
0276 int ad_sigma_delta_single_conversion(struct iio_dev *indio_dev,
0277     const struct iio_chan_spec *chan, int *val)
0278 {
0279     struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev);
0280     unsigned int sample, raw_sample;
0281     unsigned int data_reg;
0282     int ret = 0;
0283 
0284     if (iio_buffer_enabled(indio_dev))
0285         return -EBUSY;
0286 
0287     mutex_lock(&indio_dev->mlock);
0288     ad_sigma_delta_set_channel(sigma_delta, chan->address);
0289 
0290     spi_bus_lock(sigma_delta->spi->master);
0291     sigma_delta->bus_locked = true;
0292     sigma_delta->keep_cs_asserted = true;
0293     reinit_completion(&sigma_delta->completion);
0294 
0295     ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_SINGLE);
0296 
0297     sigma_delta->irq_dis = false;
0298     enable_irq(sigma_delta->spi->irq);
0299     ret = wait_for_completion_interruptible_timeout(
0300             &sigma_delta->completion, HZ);
0301 
0302     if (ret == 0)
0303         ret = -EIO;
0304     if (ret < 0)
0305         goto out;
0306 
0307     if (sigma_delta->info->data_reg != 0)
0308         data_reg = sigma_delta->info->data_reg;
0309     else
0310         data_reg = AD_SD_REG_DATA;
0311 
0312     ret = ad_sd_read_reg(sigma_delta, data_reg,
0313         DIV_ROUND_UP(chan->scan_type.realbits + chan->scan_type.shift, 8),
0314         &raw_sample);
0315 
0316 out:
0317     if (!sigma_delta->irq_dis) {
0318         disable_irq_nosync(sigma_delta->spi->irq);
0319         sigma_delta->irq_dis = true;
0320     }
0321 
0322     sigma_delta->keep_cs_asserted = false;
0323     ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_IDLE);
0324     sigma_delta->bus_locked = false;
0325     spi_bus_unlock(sigma_delta->spi->master);
0326     mutex_unlock(&indio_dev->mlock);
0327 
0328     if (ret)
0329         return ret;
0330 
0331     sample = raw_sample >> chan->scan_type.shift;
0332     sample &= (1 << chan->scan_type.realbits) - 1;
0333     *val = sample;
0334 
0335     ret = ad_sigma_delta_postprocess_sample(sigma_delta, raw_sample);
0336     if (ret)
0337         return ret;
0338 
0339     return IIO_VAL_INT;
0340 }
0341 EXPORT_SYMBOL_NS_GPL(ad_sigma_delta_single_conversion, IIO_AD_SIGMA_DELTA);
0342 
0343 static int ad_sd_buffer_postenable(struct iio_dev *indio_dev)
0344 {
0345     struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev);
0346     unsigned int i, slot, samples_buf_size;
0347     unsigned int channel;
0348     uint8_t *samples_buf;
0349     int ret;
0350 
0351     if (sigma_delta->num_slots == 1) {
0352         channel = find_first_bit(indio_dev->active_scan_mask,
0353                      indio_dev->masklength);
0354         ret = ad_sigma_delta_set_channel(sigma_delta,
0355                          indio_dev->channels[channel].address);
0356         if (ret)
0357             return ret;
0358         slot = 1;
0359     } else {
0360         /*
0361          * At this point update_scan_mode already enabled the required channels.
0362          * For sigma-delta sequencer drivers with multiple slots, an update_scan_mode
0363          * implementation is mandatory.
0364          */
0365         slot = 0;
0366         for_each_set_bit(i, indio_dev->active_scan_mask, indio_dev->masklength) {
0367             sigma_delta->slots[slot] = indio_dev->channels[i].address;
0368             slot++;
0369         }
0370     }
0371 
0372     sigma_delta->active_slots = slot;
0373     sigma_delta->current_slot = 0;
0374 
0375     if (sigma_delta->active_slots > 1) {
0376         ret = ad_sigma_delta_append_status(sigma_delta, true);
0377         if (ret)
0378             return ret;
0379     }
0380 
0381     samples_buf_size = ALIGN(slot * indio_dev->channels[0].scan_type.storagebits, 8);
0382     samples_buf_size += sizeof(int64_t);
0383     samples_buf = devm_krealloc(&sigma_delta->spi->dev, sigma_delta->samples_buf,
0384                     samples_buf_size, GFP_KERNEL);
0385     if (!samples_buf)
0386         return -ENOMEM;
0387 
0388     sigma_delta->samples_buf = samples_buf;
0389 
0390     spi_bus_lock(sigma_delta->spi->master);
0391     sigma_delta->bus_locked = true;
0392     sigma_delta->keep_cs_asserted = true;
0393 
0394     ret = ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_CONTINUOUS);
0395     if (ret)
0396         goto err_unlock;
0397 
0398     sigma_delta->irq_dis = false;
0399     enable_irq(sigma_delta->spi->irq);
0400 
0401     return 0;
0402 
0403 err_unlock:
0404     spi_bus_unlock(sigma_delta->spi->master);
0405 
0406     return ret;
0407 }
0408 
0409 static int ad_sd_buffer_postdisable(struct iio_dev *indio_dev)
0410 {
0411     struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev);
0412 
0413     reinit_completion(&sigma_delta->completion);
0414     wait_for_completion_timeout(&sigma_delta->completion, HZ);
0415 
0416     if (!sigma_delta->irq_dis) {
0417         disable_irq_nosync(sigma_delta->spi->irq);
0418         sigma_delta->irq_dis = true;
0419     }
0420 
0421     sigma_delta->keep_cs_asserted = false;
0422     ad_sigma_delta_set_mode(sigma_delta, AD_SD_MODE_IDLE);
0423 
0424     if (sigma_delta->status_appended)
0425         ad_sigma_delta_append_status(sigma_delta, false);
0426 
0427     ad_sigma_delta_disable_all(sigma_delta);
0428     sigma_delta->bus_locked = false;
0429     return spi_bus_unlock(sigma_delta->spi->master);
0430 }
0431 
0432 static irqreturn_t ad_sd_trigger_handler(int irq, void *p)
0433 {
0434     struct iio_poll_func *pf = p;
0435     struct iio_dev *indio_dev = pf->indio_dev;
0436     struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev);
0437     uint8_t *data = sigma_delta->rx_buf;
0438     unsigned int transfer_size;
0439     unsigned int sample_size;
0440     unsigned int sample_pos;
0441     unsigned int status_pos;
0442     unsigned int reg_size;
0443     unsigned int data_reg;
0444 
0445     reg_size = indio_dev->channels[0].scan_type.realbits +
0446             indio_dev->channels[0].scan_type.shift;
0447     reg_size = DIV_ROUND_UP(reg_size, 8);
0448 
0449     if (sigma_delta->info->data_reg != 0)
0450         data_reg = sigma_delta->info->data_reg;
0451     else
0452         data_reg = AD_SD_REG_DATA;
0453 
0454     /* Status word will be appended to the sample during transfer */
0455     if (sigma_delta->status_appended)
0456         transfer_size = reg_size + 1;
0457     else
0458         transfer_size = reg_size;
0459 
0460     switch (reg_size) {
0461     case 4:
0462     case 2:
0463     case 1:
0464         status_pos = reg_size;
0465         ad_sd_read_reg_raw(sigma_delta, data_reg, transfer_size, &data[0]);
0466         break;
0467     case 3:
0468         /*
0469          * Data array after transfer will look like (if status is appended):
0470          * data[] = { [0][sample][sample][sample][status] }
0471          * Keeping the first byte 0 shifts the status postion by 1 byte to the right.
0472          */
0473         status_pos = reg_size + 1;
0474 
0475         /* We store 24 bit samples in a 32 bit word. Keep the upper
0476          * byte set to zero. */
0477         ad_sd_read_reg_raw(sigma_delta, data_reg, transfer_size, &data[1]);
0478         break;
0479     }
0480 
0481     /*
0482      * For devices sampling only one channel at
0483      * once, there is no need for sample number tracking.
0484      */
0485     if (sigma_delta->active_slots == 1) {
0486         iio_push_to_buffers_with_timestamp(indio_dev, data, pf->timestamp);
0487         goto irq_handled;
0488     }
0489 
0490     if (sigma_delta->status_appended) {
0491         u8 converted_channel;
0492 
0493         converted_channel = data[status_pos] & sigma_delta->info->status_ch_mask;
0494         if (converted_channel != sigma_delta->slots[sigma_delta->current_slot]) {
0495             /*
0496              * Desync occurred during continuous sampling of multiple channels.
0497              * Drop this incomplete sample and start from first channel again.
0498              */
0499 
0500             sigma_delta->current_slot = 0;
0501             goto irq_handled;
0502         }
0503     }
0504 
0505     sample_size = indio_dev->channels[0].scan_type.storagebits / 8;
0506     sample_pos = sample_size * sigma_delta->current_slot;
0507     memcpy(&sigma_delta->samples_buf[sample_pos], data, sample_size);
0508     sigma_delta->current_slot++;
0509 
0510     if (sigma_delta->current_slot == sigma_delta->active_slots) {
0511         sigma_delta->current_slot = 0;
0512         iio_push_to_buffers_with_timestamp(indio_dev, sigma_delta->samples_buf,
0513                            pf->timestamp);
0514     }
0515 
0516 irq_handled:
0517     iio_trigger_notify_done(indio_dev->trig);
0518     sigma_delta->irq_dis = false;
0519     enable_irq(sigma_delta->spi->irq);
0520 
0521     return IRQ_HANDLED;
0522 }
0523 
0524 static bool ad_sd_validate_scan_mask(struct iio_dev *indio_dev, const unsigned long *mask)
0525 {
0526     struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev);
0527 
0528     return bitmap_weight(mask, indio_dev->masklength) <= sigma_delta->num_slots;
0529 }
0530 
0531 static const struct iio_buffer_setup_ops ad_sd_buffer_setup_ops = {
0532     .postenable = &ad_sd_buffer_postenable,
0533     .postdisable = &ad_sd_buffer_postdisable,
0534     .validate_scan_mask = &ad_sd_validate_scan_mask,
0535 };
0536 
0537 static irqreturn_t ad_sd_data_rdy_trig_poll(int irq, void *private)
0538 {
0539     struct ad_sigma_delta *sigma_delta = private;
0540 
0541     complete(&sigma_delta->completion);
0542     disable_irq_nosync(irq);
0543     sigma_delta->irq_dis = true;
0544     iio_trigger_poll(sigma_delta->trig);
0545 
0546     return IRQ_HANDLED;
0547 }
0548 
0549 /**
0550  * ad_sd_validate_trigger() - validate_trigger callback for ad_sigma_delta devices
0551  * @indio_dev: The IIO device
0552  * @trig: The new trigger
0553  *
0554  * Returns: 0 if the 'trig' matches the trigger registered by the ad_sigma_delta
0555  * device, -EINVAL otherwise.
0556  */
0557 int ad_sd_validate_trigger(struct iio_dev *indio_dev, struct iio_trigger *trig)
0558 {
0559     struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev);
0560 
0561     if (sigma_delta->trig != trig)
0562         return -EINVAL;
0563 
0564     return 0;
0565 }
0566 EXPORT_SYMBOL_NS_GPL(ad_sd_validate_trigger, IIO_AD_SIGMA_DELTA);
0567 
0568 static int devm_ad_sd_probe_trigger(struct device *dev, struct iio_dev *indio_dev)
0569 {
0570     struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev);
0571     int ret;
0572 
0573     if (dev != &sigma_delta->spi->dev) {
0574         dev_err(dev, "Trigger parent should be '%s', got '%s'\n",
0575             dev_name(dev), dev_name(&sigma_delta->spi->dev));
0576         return -EFAULT;
0577     }
0578 
0579     sigma_delta->trig = devm_iio_trigger_alloc(dev, "%s-dev%d", indio_dev->name,
0580                            iio_device_id(indio_dev));
0581     if (sigma_delta->trig == NULL)
0582         return -ENOMEM;
0583 
0584     init_completion(&sigma_delta->completion);
0585 
0586     sigma_delta->irq_dis = true;
0587     ret = devm_request_irq(dev, sigma_delta->spi->irq,
0588                    ad_sd_data_rdy_trig_poll,
0589                    sigma_delta->info->irq_flags | IRQF_NO_AUTOEN,
0590                    indio_dev->name,
0591                    sigma_delta);
0592     if (ret)
0593         return ret;
0594 
0595     iio_trigger_set_drvdata(sigma_delta->trig, sigma_delta);
0596 
0597     ret = devm_iio_trigger_register(dev, sigma_delta->trig);
0598     if (ret)
0599         return ret;
0600 
0601     /* select default trigger */
0602     indio_dev->trig = iio_trigger_get(sigma_delta->trig);
0603 
0604     return 0;
0605 }
0606 
0607 /**
0608  * devm_ad_sd_setup_buffer_and_trigger() - Device-managed buffer & trigger setup
0609  * @dev: Device object to which to bind the life-time of the resources attached
0610  * @indio_dev: The IIO device
0611  */
0612 int devm_ad_sd_setup_buffer_and_trigger(struct device *dev, struct iio_dev *indio_dev)
0613 {
0614     struct ad_sigma_delta *sigma_delta = iio_device_get_drvdata(indio_dev);
0615     int ret;
0616 
0617     sigma_delta->slots = devm_kcalloc(dev, sigma_delta->num_slots,
0618                       sizeof(*sigma_delta->slots), GFP_KERNEL);
0619     if (!sigma_delta->slots)
0620         return -ENOMEM;
0621 
0622     ret = devm_iio_triggered_buffer_setup(dev, indio_dev,
0623                           &iio_pollfunc_store_time,
0624                           &ad_sd_trigger_handler,
0625                           &ad_sd_buffer_setup_ops);
0626     if (ret)
0627         return ret;
0628 
0629     return devm_ad_sd_probe_trigger(dev, indio_dev);
0630 }
0631 EXPORT_SYMBOL_NS_GPL(devm_ad_sd_setup_buffer_and_trigger, IIO_AD_SIGMA_DELTA);
0632 
0633 /**
0634  * ad_sd_init() - Initializes a ad_sigma_delta struct
0635  * @sigma_delta: The ad_sigma_delta device
0636  * @indio_dev: The IIO device which the Sigma Delta device is used for
0637  * @spi: The SPI device for the ad_sigma_delta device
0638  * @info: Device specific callbacks and options
0639  *
0640  * This function needs to be called before any other operations are performed on
0641  * the ad_sigma_delta struct.
0642  */
0643 int ad_sd_init(struct ad_sigma_delta *sigma_delta, struct iio_dev *indio_dev,
0644     struct spi_device *spi, const struct ad_sigma_delta_info *info)
0645 {
0646     sigma_delta->spi = spi;
0647     sigma_delta->info = info;
0648 
0649     /* If the field is unset in ad_sigma_delta_info, asume there can only be 1 slot. */
0650     if (!info->num_slots)
0651         sigma_delta->num_slots = 1;
0652     else
0653         sigma_delta->num_slots = info->num_slots;
0654 
0655     if (sigma_delta->num_slots > 1) {
0656         if (!indio_dev->info->update_scan_mode) {
0657             dev_err(&spi->dev, "iio_dev lacks update_scan_mode().\n");
0658             return -EINVAL;
0659         }
0660 
0661         if (!info->disable_all) {
0662             dev_err(&spi->dev, "ad_sigma_delta_info lacks disable_all().\n");
0663             return -EINVAL;
0664         }
0665     }
0666 
0667     iio_device_set_drvdata(indio_dev, sigma_delta);
0668 
0669     return 0;
0670 }
0671 EXPORT_SYMBOL_NS_GPL(ad_sd_init, IIO_AD_SIGMA_DELTA);
0672 
0673 MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
0674 MODULE_DESCRIPTION("Analog Devices Sigma-Delta ADCs");
0675 MODULE_LICENSE("GPL v2");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!