Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 1 | /* |
| 2 | * iio/adc/ad799x.c |
Michael Hennerich | d22fd9c | 2011-05-18 14:41:52 +0100 | [diff] [blame] | 3 | * Copyright (C) 2010-1011 Michael Hennerich, Analog Devices Inc. |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 4 | * |
| 5 | * based on iio/adc/max1363 |
| 6 | * Copyright (C) 2008-2010 Jonathan Cameron |
| 7 | * |
| 8 | * based on linux/drivers/i2c/chips/max123x |
| 9 | * Copyright (C) 2002-2004 Stefan Eletzhofer |
| 10 | * |
| 11 | * based on linux/drivers/acron/char/pcf8583.c |
| 12 | * Copyright (C) 2000 Russell King |
| 13 | * |
| 14 | * This program is free software; you can redistribute it and/or modify |
| 15 | * it under the terms of the GNU General Public License version 2 as |
| 16 | * published by the Free Software Foundation. |
| 17 | * |
| 18 | * ad799x.c |
| 19 | * |
| 20 | * Support for ad7991, ad7995, ad7999, ad7992, ad7993, ad7994, ad7997, |
| 21 | * ad7998 and similar chips. |
| 22 | * |
| 23 | */ |
| 24 | |
| 25 | #include <linux/interrupt.h> |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 26 | #include <linux/device.h> |
| 27 | #include <linux/kernel.h> |
| 28 | #include <linux/sysfs.h> |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 29 | #include <linux/i2c.h> |
| 30 | #include <linux/regulator/consumer.h> |
| 31 | #include <linux/slab.h> |
| 32 | #include <linux/types.h> |
| 33 | #include <linux/err.h> |
Paul Gortmaker | 99c9785 | 2011-07-03 15:49:50 -0400 | [diff] [blame] | 34 | #include <linux/module.h> |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 35 | |
Jonathan Cameron | 06458e2 | 2012-04-25 15:54:58 +0100 | [diff] [blame] | 36 | #include <linux/iio/iio.h> |
| 37 | #include <linux/iio/sysfs.h> |
| 38 | #include <linux/iio/events.h> |
| 39 | #include <linux/iio/buffer.h> |
Jonathan Cameron | cdf3870 | 2011-08-12 17:08:43 +0100 | [diff] [blame] | 40 | |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 41 | #include "ad799x.h" |
| 42 | |
| 43 | /* |
| 44 | * ad799x register access by I2C |
| 45 | */ |
| 46 | static int ad799x_i2c_read16(struct ad799x_state *st, u8 reg, u16 *data) |
| 47 | { |
| 48 | struct i2c_client *client = st->client; |
| 49 | int ret = 0; |
| 50 | |
Lars-Peter Clausen | 34244cec | 2013-03-26 18:43:00 +0000 | [diff] [blame] | 51 | ret = i2c_smbus_read_word_swapped(client, reg); |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 52 | if (ret < 0) { |
| 53 | dev_err(&client->dev, "I2C read error\n"); |
| 54 | return ret; |
| 55 | } |
| 56 | |
Lars-Peter Clausen | 34244cec | 2013-03-26 18:43:00 +0000 | [diff] [blame] | 57 | *data = (u16)ret; |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 58 | |
| 59 | return 0; |
| 60 | } |
| 61 | |
| 62 | static int ad799x_i2c_read8(struct ad799x_state *st, u8 reg, u8 *data) |
| 63 | { |
| 64 | struct i2c_client *client = st->client; |
| 65 | int ret = 0; |
| 66 | |
Michael Hennerich | aecac19 | 2010-10-06 10:25:49 +0200 | [diff] [blame] | 67 | ret = i2c_smbus_read_byte_data(client, reg); |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 68 | if (ret < 0) { |
| 69 | dev_err(&client->dev, "I2C read error\n"); |
| 70 | return ret; |
| 71 | } |
| 72 | |
Michael Hennerich | aecac19 | 2010-10-06 10:25:49 +0200 | [diff] [blame] | 73 | *data = (u8)ret; |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 74 | |
| 75 | return 0; |
| 76 | } |
| 77 | |
| 78 | static int ad799x_i2c_write16(struct ad799x_state *st, u8 reg, u16 data) |
| 79 | { |
| 80 | struct i2c_client *client = st->client; |
| 81 | int ret = 0; |
| 82 | |
Lars-Peter Clausen | 34244cec | 2013-03-26 18:43:00 +0000 | [diff] [blame] | 83 | ret = i2c_smbus_write_word_swapped(client, reg, data); |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 84 | if (ret < 0) |
| 85 | dev_err(&client->dev, "I2C write error\n"); |
| 86 | |
| 87 | return ret; |
| 88 | } |
| 89 | |
| 90 | static int ad799x_i2c_write8(struct ad799x_state *st, u8 reg, u8 data) |
| 91 | { |
| 92 | struct i2c_client *client = st->client; |
| 93 | int ret = 0; |
| 94 | |
| 95 | ret = i2c_smbus_write_byte_data(client, reg, data); |
| 96 | if (ret < 0) |
| 97 | dev_err(&client->dev, "I2C write error\n"); |
| 98 | |
| 99 | return ret; |
| 100 | } |
| 101 | |
Lars-Peter Clausen | ae3805c | 2012-06-18 18:33:56 +0200 | [diff] [blame] | 102 | static int ad7997_8_update_scan_mode(struct iio_dev *indio_dev, |
| 103 | const unsigned long *scan_mask) |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 104 | { |
Lars-Peter Clausen | ae3805c | 2012-06-18 18:33:56 +0200 | [diff] [blame] | 105 | struct ad799x_state *st = iio_priv(indio_dev); |
| 106 | |
Lars-Peter Clausen | d8dca33 | 2013-03-26 18:43:00 +0000 | [diff] [blame] | 107 | kfree(st->rx_buf); |
| 108 | st->rx_buf = kmalloc(indio_dev->scan_bytes, GFP_KERNEL); |
| 109 | if (!st->rx_buf) |
| 110 | return -ENOMEM; |
| 111 | |
| 112 | st->transfer_size = bitmap_weight(scan_mask, indio_dev->masklength) * 2; |
| 113 | |
Lars-Peter Clausen | ae3805c | 2012-06-18 18:33:56 +0200 | [diff] [blame] | 114 | switch (st->id) { |
| 115 | case ad7997: |
| 116 | case ad7998: |
| 117 | return ad799x_i2c_write16(st, AD7998_CONF_REG, |
| 118 | st->config | (*scan_mask << AD799X_CHANNEL_SHIFT)); |
| 119 | default: |
| 120 | break; |
| 121 | } |
| 122 | |
| 123 | return 0; |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 124 | } |
| 125 | |
Michael Hennerich | d22fd9c | 2011-05-18 14:41:52 +0100 | [diff] [blame] | 126 | static int ad799x_scan_direct(struct ad799x_state *st, unsigned ch) |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 127 | { |
Michael Hennerich | d22fd9c | 2011-05-18 14:41:52 +0100 | [diff] [blame] | 128 | u16 rxbuf; |
| 129 | u8 cmd; |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 130 | int ret; |
| 131 | |
Michael Hennerich | d22fd9c | 2011-05-18 14:41:52 +0100 | [diff] [blame] | 132 | switch (st->id) { |
| 133 | case ad7991: |
| 134 | case ad7995: |
| 135 | case ad7999: |
| 136 | cmd = st->config | ((1 << ch) << AD799X_CHANNEL_SHIFT); |
| 137 | break; |
| 138 | case ad7992: |
| 139 | case ad7993: |
| 140 | case ad7994: |
| 141 | cmd = (1 << ch) << AD799X_CHANNEL_SHIFT; |
| 142 | break; |
| 143 | case ad7997: |
| 144 | case ad7998: |
| 145 | cmd = (ch << AD799X_CHANNEL_SHIFT) | AD7997_8_READ_SINGLE; |
| 146 | break; |
| 147 | default: |
| 148 | return -EINVAL; |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 149 | } |
| 150 | |
Michael Hennerich | d22fd9c | 2011-05-18 14:41:52 +0100 | [diff] [blame] | 151 | ret = ad799x_i2c_read16(st, cmd, &rxbuf); |
| 152 | if (ret < 0) |
| 153 | return ret; |
| 154 | |
| 155 | return rxbuf; |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 156 | } |
| 157 | |
Jonathan Cameron | 84f79ec | 2011-10-06 17:14:37 +0100 | [diff] [blame] | 158 | static int ad799x_read_raw(struct iio_dev *indio_dev, |
Michael Hennerich | d22fd9c | 2011-05-18 14:41:52 +0100 | [diff] [blame] | 159 | struct iio_chan_spec const *chan, |
| 160 | int *val, |
| 161 | int *val2, |
| 162 | long m) |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 163 | { |
Michael Hennerich | d22fd9c | 2011-05-18 14:41:52 +0100 | [diff] [blame] | 164 | int ret; |
Jonathan Cameron | 84f79ec | 2011-10-06 17:14:37 +0100 | [diff] [blame] | 165 | struct ad799x_state *st = iio_priv(indio_dev); |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 166 | |
Michael Hennerich | d22fd9c | 2011-05-18 14:41:52 +0100 | [diff] [blame] | 167 | switch (m) { |
Jonathan Cameron | b11f98f | 2012-04-15 17:41:18 +0100 | [diff] [blame] | 168 | case IIO_CHAN_INFO_RAW: |
Jonathan Cameron | 84f79ec | 2011-10-06 17:14:37 +0100 | [diff] [blame] | 169 | mutex_lock(&indio_dev->mlock); |
| 170 | if (iio_buffer_enabled(indio_dev)) |
Jonathan Cameron | 729bbf5 | 2011-12-05 22:18:24 +0000 | [diff] [blame] | 171 | ret = -EBUSY; |
Michael Hennerich | d22fd9c | 2011-05-18 14:41:52 +0100 | [diff] [blame] | 172 | else |
Jonathan Cameron | 58dffae | 2011-09-30 10:05:37 +0100 | [diff] [blame] | 173 | ret = ad799x_scan_direct(st, chan->scan_index); |
Jonathan Cameron | 84f79ec | 2011-10-06 17:14:37 +0100 | [diff] [blame] | 174 | mutex_unlock(&indio_dev->mlock); |
Michael Hennerich | d22fd9c | 2011-05-18 14:41:52 +0100 | [diff] [blame] | 175 | |
Michael Hennerich | aecac19 | 2010-10-06 10:25:49 +0200 | [diff] [blame] | 176 | if (ret < 0) |
Michael Hennerich | d22fd9c | 2011-05-18 14:41:52 +0100 | [diff] [blame] | 177 | return ret; |
Jonathan Cameron | 5357ba3 | 2011-09-30 10:05:32 +0100 | [diff] [blame] | 178 | *val = (ret >> chan->scan_type.shift) & |
| 179 | RES_MASK(chan->scan_type.realbits); |
Michael Hennerich | d22fd9c | 2011-05-18 14:41:52 +0100 | [diff] [blame] | 180 | return IIO_VAL_INT; |
Jonathan Cameron | c8a9f80 | 2011-10-26 17:41:36 +0100 | [diff] [blame] | 181 | case IIO_CHAN_INFO_SCALE: |
Lars-Peter Clausen | b740f48 | 2013-09-28 10:31:00 +0100 | [diff] [blame] | 182 | *val = st->int_vref_mv; |
| 183 | *val2 = chan->scan_type.realbits; |
| 184 | return IIO_VAL_FRACTIONAL_LOG2; |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 185 | } |
Michael Hennerich | d22fd9c | 2011-05-18 14:41:52 +0100 | [diff] [blame] | 186 | return -EINVAL; |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 187 | } |
Jonathan Cameron | 24cba40 | 2011-09-30 10:05:33 +0100 | [diff] [blame] | 188 | static const unsigned int ad7998_frequencies[] = { |
| 189 | [AD7998_CYC_DIS] = 0, |
| 190 | [AD7998_CYC_TCONF_32] = 15625, |
| 191 | [AD7998_CYC_TCONF_64] = 7812, |
| 192 | [AD7998_CYC_TCONF_128] = 3906, |
| 193 | [AD7998_CYC_TCONF_512] = 976, |
| 194 | [AD7998_CYC_TCONF_1024] = 488, |
| 195 | [AD7998_CYC_TCONF_2048] = 244, |
| 196 | }; |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 197 | static ssize_t ad799x_read_frequency(struct device *dev, |
| 198 | struct device_attribute *attr, |
| 199 | char *buf) |
| 200 | { |
Lars-Peter Clausen | 62c5183 | 2012-05-12 15:39:42 +0200 | [diff] [blame] | 201 | struct iio_dev *indio_dev = dev_to_iio_dev(dev); |
Jonathan Cameron | 84f79ec | 2011-10-06 17:14:37 +0100 | [diff] [blame] | 202 | struct ad799x_state *st = iio_priv(indio_dev); |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 203 | |
Jonathan Cameron | 24cba40 | 2011-09-30 10:05:33 +0100 | [diff] [blame] | 204 | int ret; |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 205 | u8 val; |
| 206 | ret = ad799x_i2c_read8(st, AD7998_CYCLE_TMR_REG, &val); |
| 207 | if (ret) |
| 208 | return ret; |
| 209 | |
| 210 | val &= AD7998_CYC_MASK; |
| 211 | |
Jonathan Cameron | 24cba40 | 2011-09-30 10:05:33 +0100 | [diff] [blame] | 212 | return sprintf(buf, "%u\n", ad7998_frequencies[val]); |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 213 | } |
| 214 | |
| 215 | static ssize_t ad799x_write_frequency(struct device *dev, |
| 216 | struct device_attribute *attr, |
| 217 | const char *buf, |
| 218 | size_t len) |
| 219 | { |
Lars-Peter Clausen | 62c5183 | 2012-05-12 15:39:42 +0200 | [diff] [blame] | 220 | struct iio_dev *indio_dev = dev_to_iio_dev(dev); |
Jonathan Cameron | 84f79ec | 2011-10-06 17:14:37 +0100 | [diff] [blame] | 221 | struct ad799x_state *st = iio_priv(indio_dev); |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 222 | |
| 223 | long val; |
Jonathan Cameron | 24cba40 | 2011-09-30 10:05:33 +0100 | [diff] [blame] | 224 | int ret, i; |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 225 | u8 t; |
| 226 | |
Aida Mynzhasova | f86f836 | 2013-05-07 00:04:41 +0400 | [diff] [blame] | 227 | ret = kstrtol(buf, 10, &val); |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 228 | if (ret) |
| 229 | return ret; |
| 230 | |
Jonathan Cameron | 84f79ec | 2011-10-06 17:14:37 +0100 | [diff] [blame] | 231 | mutex_lock(&indio_dev->mlock); |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 232 | ret = ad799x_i2c_read8(st, AD7998_CYCLE_TMR_REG, &t); |
| 233 | if (ret) |
| 234 | goto error_ret_mutex; |
| 235 | /* Wipe the bits clean */ |
| 236 | t &= ~AD7998_CYC_MASK; |
| 237 | |
Jonathan Cameron | 24cba40 | 2011-09-30 10:05:33 +0100 | [diff] [blame] | 238 | for (i = 0; i < ARRAY_SIZE(ad7998_frequencies); i++) |
| 239 | if (val == ad7998_frequencies[i]) |
| 240 | break; |
| 241 | if (i == ARRAY_SIZE(ad7998_frequencies)) { |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 242 | ret = -EINVAL; |
| 243 | goto error_ret_mutex; |
| 244 | } |
Jonathan Cameron | 24cba40 | 2011-09-30 10:05:33 +0100 | [diff] [blame] | 245 | t |= i; |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 246 | ret = ad799x_i2c_write8(st, AD7998_CYCLE_TMR_REG, t); |
| 247 | |
| 248 | error_ret_mutex: |
Jonathan Cameron | 84f79ec | 2011-10-06 17:14:37 +0100 | [diff] [blame] | 249 | mutex_unlock(&indio_dev->mlock); |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 250 | |
| 251 | return ret ? ret : len; |
| 252 | } |
| 253 | |
Jonathan Cameron | 84f79ec | 2011-10-06 17:14:37 +0100 | [diff] [blame] | 254 | static int ad799x_read_event_config(struct iio_dev *indio_dev, |
Lars-Peter Clausen | 5b9e048 | 2013-10-07 15:11:00 +0100 | [diff] [blame] | 255 | const struct iio_chan_spec *chan, |
| 256 | enum iio_event_type type, |
| 257 | enum iio_event_direction dir) |
Jonathan Cameron | 231c5c3 | 2011-09-30 10:05:35 +0100 | [diff] [blame] | 258 | { |
| 259 | return 1; |
| 260 | } |
| 261 | |
Lars-Peter Clausen | ba1d796 | 2013-10-07 15:11:00 +0100 | [diff] [blame] | 262 | static unsigned int ad799x_threshold_reg(const struct iio_chan_spec *chan, |
| 263 | enum iio_event_direction dir, |
| 264 | enum iio_event_info info) |
Lars-Peter Clausen | 69582b8 | 2013-10-07 15:11:00 +0100 | [diff] [blame] | 265 | { |
Lars-Peter Clausen | ba1d796 | 2013-10-07 15:11:00 +0100 | [diff] [blame] | 266 | switch (info) { |
| 267 | case IIO_EV_INFO_VALUE: |
| 268 | if (dir == IIO_EV_DIR_FALLING) |
| 269 | return AD7998_DATALOW_REG(chan->channel); |
| 270 | else |
| 271 | return AD7998_DATAHIGH_REG(chan->channel); |
| 272 | case IIO_EV_INFO_HYSTERESIS: |
| 273 | return AD7998_HYST_REG(chan->channel); |
| 274 | default: |
| 275 | return -EINVAL; |
| 276 | } |
| 277 | |
| 278 | return 0; |
Lars-Peter Clausen | 69582b8 | 2013-10-07 15:11:00 +0100 | [diff] [blame] | 279 | } |
Jonathan Cameron | 231c5c3 | 2011-09-30 10:05:35 +0100 | [diff] [blame] | 280 | |
| 281 | static int ad799x_write_event_value(struct iio_dev *indio_dev, |
Lars-Peter Clausen | 5b9e048 | 2013-10-07 15:11:00 +0100 | [diff] [blame] | 282 | const struct iio_chan_spec *chan, |
| 283 | enum iio_event_type type, |
| 284 | enum iio_event_direction dir, |
| 285 | enum iio_event_info info, |
| 286 | int val, int val2) |
Jonathan Cameron | 231c5c3 | 2011-09-30 10:05:35 +0100 | [diff] [blame] | 287 | { |
| 288 | int ret; |
| 289 | struct ad799x_state *st = iio_priv(indio_dev); |
Jonathan Cameron | 231c5c3 | 2011-09-30 10:05:35 +0100 | [diff] [blame] | 290 | |
| 291 | mutex_lock(&indio_dev->mlock); |
Lars-Peter Clausen | ba1d796 | 2013-10-07 15:11:00 +0100 | [diff] [blame] | 292 | ret = ad799x_i2c_write16(st, ad799x_threshold_reg(chan, dir, info), |
| 293 | val); |
Jonathan Cameron | 231c5c3 | 2011-09-30 10:05:35 +0100 | [diff] [blame] | 294 | mutex_unlock(&indio_dev->mlock); |
| 295 | |
| 296 | return ret; |
| 297 | } |
| 298 | |
| 299 | static int ad799x_read_event_value(struct iio_dev *indio_dev, |
Lars-Peter Clausen | 5b9e048 | 2013-10-07 15:11:00 +0100 | [diff] [blame] | 300 | const struct iio_chan_spec *chan, |
| 301 | enum iio_event_type type, |
| 302 | enum iio_event_direction dir, |
| 303 | enum iio_event_info info, |
| 304 | int *val, int *val2) |
Jonathan Cameron | 231c5c3 | 2011-09-30 10:05:35 +0100 | [diff] [blame] | 305 | { |
| 306 | int ret; |
| 307 | struct ad799x_state *st = iio_priv(indio_dev); |
Jonathan Cameron | 231c5c3 | 2011-09-30 10:05:35 +0100 | [diff] [blame] | 308 | u16 valin; |
| 309 | |
| 310 | mutex_lock(&indio_dev->mlock); |
Lars-Peter Clausen | ba1d796 | 2013-10-07 15:11:00 +0100 | [diff] [blame] | 311 | ret = ad799x_i2c_read16(st, ad799x_threshold_reg(chan, dir, info), |
| 312 | &valin); |
Jonathan Cameron | 231c5c3 | 2011-09-30 10:05:35 +0100 | [diff] [blame] | 313 | mutex_unlock(&indio_dev->mlock); |
| 314 | if (ret < 0) |
| 315 | return ret; |
| 316 | *val = valin; |
| 317 | |
Lars-Peter Clausen | 5b9e048 | 2013-10-07 15:11:00 +0100 | [diff] [blame] | 318 | return IIO_VAL_INT; |
Jonathan Cameron | 231c5c3 | 2011-09-30 10:05:35 +0100 | [diff] [blame] | 319 | } |
| 320 | |
Jonathan Cameron | 72148f6 | 2011-05-18 14:41:15 +0100 | [diff] [blame] | 321 | static irqreturn_t ad799x_event_handler(int irq, void *private) |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 322 | { |
Jonathan Cameron | 72148f6 | 2011-05-18 14:41:15 +0100 | [diff] [blame] | 323 | struct iio_dev *indio_dev = private; |
Jonathan Cameron | d8aea29 | 2011-06-27 13:07:20 +0100 | [diff] [blame] | 324 | struct ad799x_state *st = iio_priv(private); |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 325 | u8 status; |
Jonathan Cameron | 72148f6 | 2011-05-18 14:41:15 +0100 | [diff] [blame] | 326 | int i, ret; |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 327 | |
Jonathan Cameron | 72148f6 | 2011-05-18 14:41:15 +0100 | [diff] [blame] | 328 | ret = ad799x_i2c_read8(st, AD7998_ALERT_STAT_REG, &status); |
| 329 | if (ret) |
Lars-Peter Clausen | f654a7e | 2012-07-04 17:09:00 +0100 | [diff] [blame] | 330 | goto done; |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 331 | |
| 332 | if (!status) |
Lars-Peter Clausen | f654a7e | 2012-07-04 17:09:00 +0100 | [diff] [blame] | 333 | goto done; |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 334 | |
| 335 | ad799x_i2c_write8(st, AD7998_ALERT_STAT_REG, AD7998_ALERT_STAT_CLEAR); |
| 336 | |
| 337 | for (i = 0; i < 8; i++) { |
| 338 | if (status & (1 << i)) |
Jonathan Cameron | 5aa9618 | 2011-08-30 12:41:06 +0100 | [diff] [blame] | 339 | iio_push_event(indio_dev, |
Jonathan Cameron | 72148f6 | 2011-05-18 14:41:15 +0100 | [diff] [blame] | 340 | i & 0x1 ? |
Jonathan Cameron | 6835cb6 | 2011-09-27 09:56:41 +0100 | [diff] [blame] | 341 | IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, |
Jonathan Cameron | cdf3870 | 2011-08-12 17:08:43 +0100 | [diff] [blame] | 342 | (i >> 1), |
| 343 | IIO_EV_TYPE_THRESH, |
| 344 | IIO_EV_DIR_RISING) : |
Jonathan Cameron | 6835cb6 | 2011-09-27 09:56:41 +0100 | [diff] [blame] | 345 | IIO_UNMOD_EVENT_CODE(IIO_VOLTAGE, |
Jonathan Cameron | cdf3870 | 2011-08-12 17:08:43 +0100 | [diff] [blame] | 346 | (i >> 1), |
| 347 | IIO_EV_TYPE_THRESH, |
| 348 | IIO_EV_DIR_FALLING), |
Jonathan Cameron | 72148f6 | 2011-05-18 14:41:15 +0100 | [diff] [blame] | 349 | iio_get_time_ns()); |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 350 | } |
| 351 | |
Lars-Peter Clausen | f654a7e | 2012-07-04 17:09:00 +0100 | [diff] [blame] | 352 | done: |
Jonathan Cameron | 72148f6 | 2011-05-18 14:41:15 +0100 | [diff] [blame] | 353 | return IRQ_HANDLED; |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 354 | } |
| 355 | |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 356 | static IIO_DEV_ATTR_SAMP_FREQ(S_IWUSR | S_IRUGO, |
| 357 | ad799x_read_frequency, |
| 358 | ad799x_write_frequency); |
| 359 | static IIO_CONST_ATTR_SAMP_FREQ_AVAIL("15625 7812 3906 1953 976 488 244 0"); |
| 360 | |
Lars-Peter Clausen | ba1d796 | 2013-10-07 15:11:00 +0100 | [diff] [blame] | 361 | static struct attribute *ad799x_event_attributes[] = { |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 362 | &iio_dev_attr_sampling_frequency.dev_attr.attr, |
| 363 | &iio_const_attr_sampling_frequency_available.dev_attr.attr, |
| 364 | NULL, |
| 365 | }; |
| 366 | |
Lars-Peter Clausen | ba1d796 | 2013-10-07 15:11:00 +0100 | [diff] [blame] | 367 | static struct attribute_group ad799x_event_attrs_group = { |
| 368 | .attrs = ad799x_event_attributes, |
Jonathan Cameron | 8e7d967 | 2011-08-30 12:32:45 +0100 | [diff] [blame] | 369 | .name = "events", |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 370 | }; |
| 371 | |
Jonathan Cameron | 6fe8135 | 2011-05-18 14:42:37 +0100 | [diff] [blame] | 372 | static const struct iio_info ad7991_info = { |
| 373 | .read_raw = &ad799x_read_raw, |
| 374 | .driver_module = THIS_MODULE, |
| 375 | }; |
| 376 | |
Jonathan Cameron | 6fe8135 | 2011-05-18 14:42:37 +0100 | [diff] [blame] | 377 | static const struct iio_info ad7993_4_7_8_info = { |
| 378 | .read_raw = &ad799x_read_raw, |
Lars-Peter Clausen | ba1d796 | 2013-10-07 15:11:00 +0100 | [diff] [blame] | 379 | .event_attrs = &ad799x_event_attrs_group, |
Lars-Peter Clausen | cb95585 | 2013-12-07 10:45:00 +0000 | [diff] [blame] | 380 | .read_event_config = &ad799x_read_event_config, |
| 381 | .read_event_value = &ad799x_read_event_value, |
| 382 | .write_event_value = &ad799x_write_event_value, |
Jonathan Cameron | 6fe8135 | 2011-05-18 14:42:37 +0100 | [diff] [blame] | 383 | .driver_module = THIS_MODULE, |
Lars-Peter Clausen | ae3805c | 2012-06-18 18:33:56 +0200 | [diff] [blame] | 384 | .update_scan_mode = ad7997_8_update_scan_mode, |
Jonathan Cameron | 6fe8135 | 2011-05-18 14:42:37 +0100 | [diff] [blame] | 385 | }; |
| 386 | |
Lars-Peter Clausen | 5b9e048 | 2013-10-07 15:11:00 +0100 | [diff] [blame] | 387 | static const struct iio_event_spec ad799x_events[] = { |
| 388 | { |
| 389 | .type = IIO_EV_TYPE_THRESH, |
| 390 | .dir = IIO_EV_DIR_RISING, |
| 391 | .mask_separate = BIT(IIO_EV_INFO_VALUE) | |
| 392 | BIT(IIO_EV_INFO_ENABLE), |
| 393 | }, { |
| 394 | .type = IIO_EV_TYPE_THRESH, |
| 395 | .dir = IIO_EV_DIR_FALLING, |
Hartmut Knaack | d180371 | 2014-08-02 00:07:00 +0100 | [diff] [blame] | 396 | .mask_separate = BIT(IIO_EV_INFO_VALUE) | |
Lars-Peter Clausen | 5b9e048 | 2013-10-07 15:11:00 +0100 | [diff] [blame] | 397 | BIT(IIO_EV_INFO_ENABLE), |
Lars-Peter Clausen | ba1d796 | 2013-10-07 15:11:00 +0100 | [diff] [blame] | 398 | }, { |
| 399 | .type = IIO_EV_TYPE_THRESH, |
| 400 | .dir = IIO_EV_DIR_EITHER, |
| 401 | .mask_separate = BIT(IIO_EV_INFO_HYSTERESIS), |
Lars-Peter Clausen | 5b9e048 | 2013-10-07 15:11:00 +0100 | [diff] [blame] | 402 | }, |
| 403 | }; |
Jonathan Cameron | 231c5c3 | 2011-09-30 10:05:35 +0100 | [diff] [blame] | 404 | |
Lars-Peter Clausen | 5b9e048 | 2013-10-07 15:11:00 +0100 | [diff] [blame] | 405 | #define _AD799X_CHANNEL(_index, _realbits, _ev_spec, _num_ev_spec) { \ |
Lars-Peter Clausen | ae6d6489 | 2013-03-26 18:43:00 +0000 | [diff] [blame] | 406 | .type = IIO_VOLTAGE, \ |
| 407 | .indexed = 1, \ |
| 408 | .channel = (_index), \ |
| 409 | .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ |
Lars-Peter Clausen | d00698d | 2013-03-26 18:43:00 +0000 | [diff] [blame] | 410 | .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \ |
Lars-Peter Clausen | ae6d6489 | 2013-03-26 18:43:00 +0000 | [diff] [blame] | 411 | .scan_index = (_index), \ |
Jonathan Cameron | 83d5f32 | 2013-12-11 18:45:00 +0000 | [diff] [blame] | 412 | .scan_type = { \ |
| 413 | .sign = 'u', \ |
| 414 | .realbits = (_realbits), \ |
| 415 | .storagebits = 16, \ |
| 416 | .shift = 12 - (_realbits), \ |
| 417 | .endianness = IIO_BE, \ |
| 418 | }, \ |
Lars-Peter Clausen | 5b9e048 | 2013-10-07 15:11:00 +0100 | [diff] [blame] | 419 | .event_spec = _ev_spec, \ |
| 420 | .num_event_specs = _num_ev_spec, \ |
Lars-Peter Clausen | ae6d6489 | 2013-03-26 18:43:00 +0000 | [diff] [blame] | 421 | } |
| 422 | |
Lars-Peter Clausen | 5b9e048 | 2013-10-07 15:11:00 +0100 | [diff] [blame] | 423 | #define AD799X_CHANNEL(_index, _realbits) \ |
| 424 | _AD799X_CHANNEL(_index, _realbits, NULL, 0) |
| 425 | |
| 426 | #define AD799X_CHANNEL_WITH_EVENTS(_index, _realbits) \ |
| 427 | _AD799X_CHANNEL(_index, _realbits, ad799x_events, \ |
| 428 | ARRAY_SIZE(ad799x_events)) |
| 429 | |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 430 | static const struct ad799x_chip_info ad799x_chip_info_tbl[] = { |
| 431 | [ad7991] = { |
Jonathan Cameron | 7c626f5 | 2011-09-30 10:05:31 +0100 | [diff] [blame] | 432 | .channel = { |
Lars-Peter Clausen | 5b9e048 | 2013-10-07 15:11:00 +0100 | [diff] [blame] | 433 | AD799X_CHANNEL(0, 12), |
| 434 | AD799X_CHANNEL(1, 12), |
| 435 | AD799X_CHANNEL(2, 12), |
| 436 | AD799X_CHANNEL(3, 12), |
Lars-Peter Clausen | ae6d6489 | 2013-03-26 18:43:00 +0000 | [diff] [blame] | 437 | IIO_CHAN_SOFT_TIMESTAMP(4), |
Jonathan Cameron | 7c626f5 | 2011-09-30 10:05:31 +0100 | [diff] [blame] | 438 | }, |
Michael Hennerich | d22fd9c | 2011-05-18 14:41:52 +0100 | [diff] [blame] | 439 | .num_channels = 5, |
Jonathan Cameron | 6fe8135 | 2011-05-18 14:42:37 +0100 | [diff] [blame] | 440 | .info = &ad7991_info, |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 441 | }, |
| 442 | [ad7995] = { |
Jonathan Cameron | 7c626f5 | 2011-09-30 10:05:31 +0100 | [diff] [blame] | 443 | .channel = { |
Lars-Peter Clausen | 5b9e048 | 2013-10-07 15:11:00 +0100 | [diff] [blame] | 444 | AD799X_CHANNEL(0, 10), |
| 445 | AD799X_CHANNEL(1, 10), |
| 446 | AD799X_CHANNEL(2, 10), |
| 447 | AD799X_CHANNEL(3, 10), |
Lars-Peter Clausen | ae6d6489 | 2013-03-26 18:43:00 +0000 | [diff] [blame] | 448 | IIO_CHAN_SOFT_TIMESTAMP(4), |
Jonathan Cameron | 7c626f5 | 2011-09-30 10:05:31 +0100 | [diff] [blame] | 449 | }, |
Michael Hennerich | d22fd9c | 2011-05-18 14:41:52 +0100 | [diff] [blame] | 450 | .num_channels = 5, |
Jonathan Cameron | 6fe8135 | 2011-05-18 14:42:37 +0100 | [diff] [blame] | 451 | .info = &ad7991_info, |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 452 | }, |
| 453 | [ad7999] = { |
Jonathan Cameron | 7c626f5 | 2011-09-30 10:05:31 +0100 | [diff] [blame] | 454 | .channel = { |
Lars-Peter Clausen | 5b9e048 | 2013-10-07 15:11:00 +0100 | [diff] [blame] | 455 | AD799X_CHANNEL(0, 8), |
| 456 | AD799X_CHANNEL(1, 8), |
| 457 | AD799X_CHANNEL(2, 8), |
| 458 | AD799X_CHANNEL(3, 8), |
Lars-Peter Clausen | ae6d6489 | 2013-03-26 18:43:00 +0000 | [diff] [blame] | 459 | IIO_CHAN_SOFT_TIMESTAMP(4), |
Jonathan Cameron | 7c626f5 | 2011-09-30 10:05:31 +0100 | [diff] [blame] | 460 | }, |
Michael Hennerich | d22fd9c | 2011-05-18 14:41:52 +0100 | [diff] [blame] | 461 | .num_channels = 5, |
Jonathan Cameron | 6fe8135 | 2011-05-18 14:42:37 +0100 | [diff] [blame] | 462 | .info = &ad7991_info, |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 463 | }, |
| 464 | [ad7992] = { |
Jonathan Cameron | 7c626f5 | 2011-09-30 10:05:31 +0100 | [diff] [blame] | 465 | .channel = { |
Lars-Peter Clausen | 5b9e048 | 2013-10-07 15:11:00 +0100 | [diff] [blame] | 466 | AD799X_CHANNEL_WITH_EVENTS(0, 12), |
| 467 | AD799X_CHANNEL_WITH_EVENTS(1, 12), |
Lars-Peter Clausen | ae6d6489 | 2013-03-26 18:43:00 +0000 | [diff] [blame] | 468 | IIO_CHAN_SOFT_TIMESTAMP(3), |
Jonathan Cameron | 7c626f5 | 2011-09-30 10:05:31 +0100 | [diff] [blame] | 469 | }, |
Michael Hennerich | d22fd9c | 2011-05-18 14:41:52 +0100 | [diff] [blame] | 470 | .num_channels = 3, |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 471 | .default_config = AD7998_ALERT_EN, |
Lars-Peter Clausen | ba1d796 | 2013-10-07 15:11:00 +0100 | [diff] [blame] | 472 | .info = &ad7993_4_7_8_info, |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 473 | }, |
| 474 | [ad7993] = { |
Jonathan Cameron | 7c626f5 | 2011-09-30 10:05:31 +0100 | [diff] [blame] | 475 | .channel = { |
Lars-Peter Clausen | 5b9e048 | 2013-10-07 15:11:00 +0100 | [diff] [blame] | 476 | AD799X_CHANNEL_WITH_EVENTS(0, 10), |
| 477 | AD799X_CHANNEL_WITH_EVENTS(1, 10), |
| 478 | AD799X_CHANNEL_WITH_EVENTS(2, 10), |
| 479 | AD799X_CHANNEL_WITH_EVENTS(3, 10), |
Lars-Peter Clausen | ae6d6489 | 2013-03-26 18:43:00 +0000 | [diff] [blame] | 480 | IIO_CHAN_SOFT_TIMESTAMP(4), |
Jonathan Cameron | 7c626f5 | 2011-09-30 10:05:31 +0100 | [diff] [blame] | 481 | }, |
Michael Hennerich | d22fd9c | 2011-05-18 14:41:52 +0100 | [diff] [blame] | 482 | .num_channels = 5, |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 483 | .default_config = AD7998_ALERT_EN, |
Jonathan Cameron | 6fe8135 | 2011-05-18 14:42:37 +0100 | [diff] [blame] | 484 | .info = &ad7993_4_7_8_info, |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 485 | }, |
| 486 | [ad7994] = { |
Jonathan Cameron | 7c626f5 | 2011-09-30 10:05:31 +0100 | [diff] [blame] | 487 | .channel = { |
Lars-Peter Clausen | 5b9e048 | 2013-10-07 15:11:00 +0100 | [diff] [blame] | 488 | AD799X_CHANNEL_WITH_EVENTS(0, 12), |
| 489 | AD799X_CHANNEL_WITH_EVENTS(1, 12), |
| 490 | AD799X_CHANNEL_WITH_EVENTS(2, 12), |
| 491 | AD799X_CHANNEL_WITH_EVENTS(3, 12), |
Lars-Peter Clausen | ae6d6489 | 2013-03-26 18:43:00 +0000 | [diff] [blame] | 492 | IIO_CHAN_SOFT_TIMESTAMP(4), |
Jonathan Cameron | 7c626f5 | 2011-09-30 10:05:31 +0100 | [diff] [blame] | 493 | }, |
Michael Hennerich | d22fd9c | 2011-05-18 14:41:52 +0100 | [diff] [blame] | 494 | .num_channels = 5, |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 495 | .default_config = AD7998_ALERT_EN, |
Jonathan Cameron | 6fe8135 | 2011-05-18 14:42:37 +0100 | [diff] [blame] | 496 | .info = &ad7993_4_7_8_info, |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 497 | }, |
| 498 | [ad7997] = { |
Jonathan Cameron | 7c626f5 | 2011-09-30 10:05:31 +0100 | [diff] [blame] | 499 | .channel = { |
Lars-Peter Clausen | 5b9e048 | 2013-10-07 15:11:00 +0100 | [diff] [blame] | 500 | AD799X_CHANNEL_WITH_EVENTS(0, 10), |
| 501 | AD799X_CHANNEL_WITH_EVENTS(1, 10), |
| 502 | AD799X_CHANNEL_WITH_EVENTS(2, 10), |
| 503 | AD799X_CHANNEL_WITH_EVENTS(3, 10), |
| 504 | AD799X_CHANNEL(4, 10), |
| 505 | AD799X_CHANNEL(5, 10), |
| 506 | AD799X_CHANNEL(6, 10), |
| 507 | AD799X_CHANNEL(7, 10), |
Lars-Peter Clausen | ae6d6489 | 2013-03-26 18:43:00 +0000 | [diff] [blame] | 508 | IIO_CHAN_SOFT_TIMESTAMP(8), |
Jonathan Cameron | 7c626f5 | 2011-09-30 10:05:31 +0100 | [diff] [blame] | 509 | }, |
Michael Hennerich | d22fd9c | 2011-05-18 14:41:52 +0100 | [diff] [blame] | 510 | .num_channels = 9, |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 511 | .default_config = AD7998_ALERT_EN, |
Jonathan Cameron | 6fe8135 | 2011-05-18 14:42:37 +0100 | [diff] [blame] | 512 | .info = &ad7993_4_7_8_info, |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 513 | }, |
| 514 | [ad7998] = { |
Jonathan Cameron | 7c626f5 | 2011-09-30 10:05:31 +0100 | [diff] [blame] | 515 | .channel = { |
Lars-Peter Clausen | 5b9e048 | 2013-10-07 15:11:00 +0100 | [diff] [blame] | 516 | AD799X_CHANNEL_WITH_EVENTS(0, 12), |
| 517 | AD799X_CHANNEL_WITH_EVENTS(1, 12), |
| 518 | AD799X_CHANNEL_WITH_EVENTS(2, 12), |
| 519 | AD799X_CHANNEL_WITH_EVENTS(3, 12), |
| 520 | AD799X_CHANNEL(4, 12), |
| 521 | AD799X_CHANNEL(5, 12), |
| 522 | AD799X_CHANNEL(6, 12), |
| 523 | AD799X_CHANNEL(7, 12), |
Lars-Peter Clausen | ae6d6489 | 2013-03-26 18:43:00 +0000 | [diff] [blame] | 524 | IIO_CHAN_SOFT_TIMESTAMP(8), |
Jonathan Cameron | 7c626f5 | 2011-09-30 10:05:31 +0100 | [diff] [blame] | 525 | }, |
Michael Hennerich | d22fd9c | 2011-05-18 14:41:52 +0100 | [diff] [blame] | 526 | .num_channels = 9, |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 527 | .default_config = AD7998_ALERT_EN, |
Jonathan Cameron | 6fe8135 | 2011-05-18 14:42:37 +0100 | [diff] [blame] | 528 | .info = &ad7993_4_7_8_info, |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 529 | }, |
| 530 | }; |
| 531 | |
Bill Pemberton | 4ae1c61 | 2012-11-19 13:21:57 -0500 | [diff] [blame] | 532 | static int ad799x_probe(struct i2c_client *client, |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 533 | const struct i2c_device_id *id) |
| 534 | { |
Jonathan Cameron | 26d25ae | 2011-09-02 17:14:40 +0100 | [diff] [blame] | 535 | int ret; |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 536 | struct ad799x_platform_data *pdata = client->dev.platform_data; |
Michael Hennerich | 1bf7ac7 | 2011-05-18 14:41:53 +0100 | [diff] [blame] | 537 | struct ad799x_state *st; |
Sachin Kamat | 6a88fa4 | 2013-08-31 18:12:00 +0100 | [diff] [blame] | 538 | struct iio_dev *indio_dev; |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 539 | |
Sachin Kamat | 6a88fa4 | 2013-08-31 18:12:00 +0100 | [diff] [blame] | 540 | indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*st)); |
Michael Hennerich | 1bf7ac7 | 2011-05-18 14:41:53 +0100 | [diff] [blame] | 541 | if (indio_dev == NULL) |
| 542 | return -ENOMEM; |
| 543 | |
| 544 | st = iio_priv(indio_dev); |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 545 | /* this is only used for device removal purposes */ |
Michael Hennerich | 1bf7ac7 | 2011-05-18 14:41:53 +0100 | [diff] [blame] | 546 | i2c_set_clientdata(client, indio_dev); |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 547 | |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 548 | st->id = id->driver_data; |
| 549 | st->chip_info = &ad799x_chip_info_tbl[st->id]; |
| 550 | st->config = st->chip_info->default_config; |
| 551 | |
| 552 | /* TODO: Add pdata options for filtering and bit delay */ |
| 553 | |
Lars-Peter Clausen | 8c7e862 | 2013-03-26 18:43:00 +0000 | [diff] [blame] | 554 | if (!pdata) |
| 555 | return -EINVAL; |
| 556 | |
| 557 | st->int_vref_mv = pdata->vref_mv; |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 558 | |
Sachin Kamat | 6a88fa4 | 2013-08-31 18:12:00 +0100 | [diff] [blame] | 559 | st->reg = devm_regulator_get(&client->dev, "vcc"); |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 560 | if (!IS_ERR(st->reg)) { |
| 561 | ret = regulator_enable(st->reg); |
| 562 | if (ret) |
Sachin Kamat | 6a88fa4 | 2013-08-31 18:12:00 +0100 | [diff] [blame] | 563 | return ret; |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 564 | } |
| 565 | st->client = client; |
| 566 | |
Michael Hennerich | 1bf7ac7 | 2011-05-18 14:41:53 +0100 | [diff] [blame] | 567 | indio_dev->dev.parent = &client->dev; |
| 568 | indio_dev->name = id->name; |
Jonathan Cameron | 6fe8135 | 2011-05-18 14:42:37 +0100 | [diff] [blame] | 569 | indio_dev->info = st->chip_info->info; |
Jonathan Cameron | 6fe8135 | 2011-05-18 14:42:37 +0100 | [diff] [blame] | 570 | |
Michael Hennerich | 1bf7ac7 | 2011-05-18 14:41:53 +0100 | [diff] [blame] | 571 | indio_dev->modes = INDIO_DIRECT_MODE; |
Michael Hennerich | 1bf7ac7 | 2011-05-18 14:41:53 +0100 | [diff] [blame] | 572 | indio_dev->channels = st->chip_info->channel; |
| 573 | indio_dev->num_channels = st->chip_info->num_channels; |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 574 | |
Michael Hennerich | 1bf7ac7 | 2011-05-18 14:41:53 +0100 | [diff] [blame] | 575 | ret = ad799x_register_ring_funcs_and_init(indio_dev); |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 576 | if (ret) |
Michael Hennerich | 1bf7ac7 | 2011-05-18 14:41:53 +0100 | [diff] [blame] | 577 | goto error_disable_reg; |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 578 | |
Jonathan Cameron | 6fe8135 | 2011-05-18 14:42:37 +0100 | [diff] [blame] | 579 | if (client->irq > 0) { |
Jonathan Cameron | 72148f6 | 2011-05-18 14:41:15 +0100 | [diff] [blame] | 580 | ret = request_threaded_irq(client->irq, |
| 581 | NULL, |
| 582 | ad799x_event_handler, |
| 583 | IRQF_TRIGGER_FALLING | |
| 584 | IRQF_ONESHOT, |
| 585 | client->name, |
Michael Hennerich | 1bf7ac7 | 2011-05-18 14:41:53 +0100 | [diff] [blame] | 586 | indio_dev); |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 587 | if (ret) |
| 588 | goto error_cleanup_ring; |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 589 | } |
Jonathan Cameron | 26d25ae | 2011-09-02 17:14:40 +0100 | [diff] [blame] | 590 | ret = iio_device_register(indio_dev); |
| 591 | if (ret) |
| 592 | goto error_free_irq; |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 593 | |
| 594 | return 0; |
Michael Hennerich | 1bf7ac7 | 2011-05-18 14:41:53 +0100 | [diff] [blame] | 595 | |
Jonathan Cameron | 26d25ae | 2011-09-02 17:14:40 +0100 | [diff] [blame] | 596 | error_free_irq: |
Hartmut Knaack | 38408d0 | 2014-01-01 23:04:00 +0000 | [diff] [blame] | 597 | if (client->irq > 0) |
| 598 | free_irq(client->irq, indio_dev); |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 599 | error_cleanup_ring: |
Michael Hennerich | 1bf7ac7 | 2011-05-18 14:41:53 +0100 | [diff] [blame] | 600 | ad799x_ring_cleanup(indio_dev); |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 601 | error_disable_reg: |
| 602 | if (!IS_ERR(st->reg)) |
| 603 | regulator_disable(st->reg); |
Michael Hennerich | 1bf7ac7 | 2011-05-18 14:41:53 +0100 | [diff] [blame] | 604 | |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 605 | return ret; |
| 606 | } |
| 607 | |
Bill Pemberton | 447d4f2 | 2012-11-19 13:26:37 -0500 | [diff] [blame] | 608 | static int ad799x_remove(struct i2c_client *client) |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 609 | { |
Michael Hennerich | 1bf7ac7 | 2011-05-18 14:41:53 +0100 | [diff] [blame] | 610 | struct iio_dev *indio_dev = i2c_get_clientdata(client); |
| 611 | struct ad799x_state *st = iio_priv(indio_dev); |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 612 | |
Jonathan Cameron | d2fffd6 | 2011-10-14 14:46:58 +0100 | [diff] [blame] | 613 | iio_device_unregister(indio_dev); |
Jonathan Cameron | 6fe8135 | 2011-05-18 14:42:37 +0100 | [diff] [blame] | 614 | if (client->irq > 0) |
Jonathan Cameron | 72148f6 | 2011-05-18 14:41:15 +0100 | [diff] [blame] | 615 | free_irq(client->irq, indio_dev); |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 616 | |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 617 | ad799x_ring_cleanup(indio_dev); |
Sachin Kamat | 6a88fa4 | 2013-08-31 18:12:00 +0100 | [diff] [blame] | 618 | if (!IS_ERR(st->reg)) |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 619 | regulator_disable(st->reg); |
Lars-Peter Clausen | d8dca33 | 2013-03-26 18:43:00 +0000 | [diff] [blame] | 620 | kfree(st->rx_buf); |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 621 | |
| 622 | return 0; |
| 623 | } |
| 624 | |
| 625 | static const struct i2c_device_id ad799x_id[] = { |
| 626 | { "ad7991", ad7991 }, |
| 627 | { "ad7995", ad7995 }, |
| 628 | { "ad7999", ad7999 }, |
| 629 | { "ad7992", ad7992 }, |
| 630 | { "ad7993", ad7993 }, |
| 631 | { "ad7994", ad7994 }, |
| 632 | { "ad7997", ad7997 }, |
| 633 | { "ad7998", ad7998 }, |
| 634 | {} |
| 635 | }; |
| 636 | |
| 637 | MODULE_DEVICE_TABLE(i2c, ad799x_id); |
| 638 | |
| 639 | static struct i2c_driver ad799x_driver = { |
| 640 | .driver = { |
| 641 | .name = "ad799x", |
| 642 | }, |
| 643 | .probe = ad799x_probe, |
Bill Pemberton | e543acf | 2012-11-19 13:21:38 -0500 | [diff] [blame] | 644 | .remove = ad799x_remove, |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 645 | .id_table = ad799x_id, |
| 646 | }; |
Lars-Peter Clausen | 6e5af18 | 2011-11-16 10:13:38 +0100 | [diff] [blame] | 647 | module_i2c_driver(ad799x_driver); |
Michael Hennerich | 985dbe7 | 2010-10-01 16:41:51 +0200 | [diff] [blame] | 648 | |
| 649 | MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>"); |
| 650 | MODULE_DESCRIPTION("Analog Devices AD799x ADC"); |
| 651 | MODULE_LICENSE("GPL v2"); |