static void yas_work_func(struct work_struct *work)
{
struct yas_data acc[1];
struct yas_state *st =
container_of((struct delayed_work *)work,
struct yas_state, work);
struct iio_dev *indio_dev = iio_priv_to_dev(st);
uint32_t time_before, time_after;
int32_t delay;
int ret, i;
time_before = jiffies_to_msecs(jiffies);
mutex_lock(&st->lock);
ret = st->acc.measure(acc, 1);
if (ret == 1) {
for (i = 0; i < 3; i++)
st->compass_data[i]
= acc[0].xyz.v[i] - st->calib_bias[i];
}
mutex_unlock(&st->lock);
if (ret == 1)
yas_data_rdy_trig_poll(indio_dev);
time_after = jiffies_to_msecs(jiffies);
delay = MSEC_PER_SEC / st->sampling_frequency
- (time_after - time_before);
if (delay <= 0)
delay = 1;
schedule_delayed_work(&st->work, msecs_to_jiffies(delay));
}
int ad7887_scan_from_ring(struct ad7887_state *st, long mask)
{
struct iio_ring_buffer *ring = iio_priv_to_dev(st)->ring;
int count = 0, ret;
u16 *ring_data;
if (!(ring->scan_mask & mask)) {
ret = -EBUSY;
goto error_ret;
}
ring_data = kmalloc(ring->access->get_bytes_per_datum(ring),
GFP_KERNEL);
if (ring_data == NULL) {
ret = -ENOMEM;
goto error_ret;
}
ret = ring->access->read_last(ring, (u8 *) ring_data);
if (ret)
goto error_free_ring_data;
/* for single channel scan the result is stored with zero offset */
if ((ring->scan_mask == ((1 << 1) | (1 << 0))) && (mask == (1 << 1)))
count = 1;
ret = be16_to_cpu(ring_data[count]);
error_free_ring_data:
kfree(ring_data);
error_ret:
return ret;
}
int ad799x_single_channel_from_ring(struct ad799x_state *st, long mask)
{
struct iio_ring_buffer *ring = iio_priv_to_dev(st)->ring;
int count = 0, ret;
u16 *ring_data;
if (!(ring->scan_mask & mask)) {
ret = -EBUSY;
goto error_ret;
}
ring_data = kmalloc(ring->access->get_bytes_per_datum(ring),
GFP_KERNEL);
if (ring_data == NULL) {
ret = -ENOMEM;
goto error_ret;
}
ret = ring->access->read_last(ring, (u8 *) ring_data);
if (ret)
goto error_free_ring_data;
/* Need a count of channels prior to this one */
mask >>= 1;
while (mask) {
if (mask & ring->scan_mask)
count++;
mask >>= 1;
}
ret = be16_to_cpu(ring_data[count]);
error_free_ring_data:
kfree(ring_data);
error_ret:
return ret;
}
static int __devexit isl29028_remove(struct i2c_client *client)
{
struct isl29028_chip *chip = i2c_get_clientdata(client);
struct iio_dev *indio_dev;
indio_dev = iio_priv_to_dev(chip);
dev_dbg(&client->dev, "%s()\n", __func__);
iio_device_unregister(indio_dev);
if (chip->irq > 0)
free_irq(chip->irq, chip);
kfree(chip);
return 0;
}
/**
* ad7606_poll_bh_to_ring() bh of trigger launched polling to ring buffer
* @work_s: the work struct through which this was scheduled
*
* Currently there is no option in this driver to disable the saving of
* timestamps within the ring.
* I think the one copy of this at a time was to avoid problems if the
* trigger was set far too high and the reads then locked up the computer.
**/
static void ad7606_poll_bh_to_ring(struct work_struct *work_s)
{
struct ad7606_state *st = container_of(work_s, struct ad7606_state,
poll_work);
struct iio_dev *indio_dev = iio_priv_to_dev(st);
struct iio_buffer *ring = indio_dev->buffer;
s64 time_ns;
__u8 *buf;
int ret;
buf = kzalloc(ring->access->get_bytes_per_datum(ring),
GFP_KERNEL);
if (buf == NULL)
return;
if (gpio_is_valid(st->pdata->gpio_frstdata)) {
ret = st->bops->read_block(st->dev, 1, buf);
if (ret)
goto done;
if (!gpio_get_value(st->pdata->gpio_frstdata)) {
/* This should never happen. However
* some signal glitch caused by bad PCB desgin or
* electrostatic discharge, could cause an extra read
* or clock. This allows recovery.
*/
ad7606_reset(st);
goto done;
}
ret = st->bops->read_block(st->dev,
st->chip_info->num_channels - 1, buf + 2);
if (ret)
goto done;
} else {
ret = st->bops->read_block(st->dev,
st->chip_info->num_channels, buf);
if (ret)
goto done;
}
time_ns = iio_get_time_ns();
if (ring->scan_timestamp)
*((s64 *)(buf + ring->access->get_bytes_per_datum(ring) -
sizeof(s64))) = time_ns;
ring->access->store_to(indio_dev->buffer, buf, time_ns);
done:
gpio_set_value(st->pdata->gpio_convst, 0);
iio_trigger_notify_done(indio_dev->trig);
kfree(buf);
}
static void ak89xx_work_func(struct work_struct *work)
{
struct inv_ak89xx_state_s *st =
container_of((struct delayed_work *)work,
struct inv_ak89xx_state_s, work);
struct iio_dev *indio_dev = iio_priv_to_dev(st);
unsigned long delay = msecs_to_jiffies(st->delay);
mutex_lock(&indio_dev->mlock);
if (!(iio_buffer_enabled(indio_dev)))
goto error_ret;
st->timestamp = get_time_ns();
schedule_delayed_work(&st->work, delay);
inv_read_ak89xx_fifo(indio_dev);
INV_I2C_INC_COMPASSIRQ();
error_ret:
mutex_unlock(&indio_dev->mlock);
}
static void yas_work_func(struct work_struct *work)
{
struct yas_data mag[1];
struct yas_state *st = container_of((struct delayed_work *)work,
struct yas_state, work);
struct iio_dev *indio_dev = iio_priv_to_dev(st);
int ret, i;
mutex_lock(&st->lock);
ret = st->mag.measure(mag, 1);
if (ret == 1) {
for (i = 0; i < 3; i++)
st->compass_data[i] = mag[0].xyz.v[i];
}
mutex_unlock(&st->lock);
if (ret == 1)
yas_data_rdy_trig_poll(indio_dev);
else
pr_err("[SENSOR] %s: ret %d\n", __func__, ret);
schedule_delayed_work(&st->work, msecs_to_jiffies(st->poll_delay));
}
int max1363_single_channel_from_ring(long mask, struct max1363_state *st)
{
struct iio_ring_buffer *ring = iio_priv_to_dev(st)->ring;
int count = 0, ret;
u8 *ring_data;
if (!(st->current_mode->modemask & mask)) {
ret = -EBUSY;
goto error_ret;
}
ring_data = kmalloc(ring->access->get_bytes_per_datum(ring),
GFP_KERNEL);
if (ring_data == NULL) {
ret = -ENOMEM;
goto error_ret;
}
ret = ring->access->read_last(ring, ring_data);
if (ret)
goto error_free_ring_data;
/* Need a count of channels prior to this one */
mask >>= 1;
while (mask) {
if (mask & st->current_mode->modemask)
count++;
mask >>= 1;
}
if (st->chip_info->bits != 8)
ret = ((int)(ring_data[count*2 + 0] & 0x0F) << 8)
+ (int)(ring_data[count*2 + 1]);
else
ret = ring_data[count];
error_free_ring_data:
kfree(ring_data);
error_ret:
return ret;
}
