1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16#include <linux/module.h>
17#include <linux/i2c.h>
18#include <linux/iio/iio.h>
19#include <linux/iio/sysfs.h>
20#include <linux/iio/trigger_consumer.h>
21#include <linux/iio/buffer.h>
22#include <linux/iio/triggered_buffer.h>
23#include <linux/delay.h>
24
25#define MPL3115_STATUS 0x00
26#define MPL3115_OUT_PRESS 0x01
27#define MPL3115_OUT_TEMP 0x04
28#define MPL3115_WHO_AM_I 0x0c
29#define MPL3115_CTRL_REG1 0x26
30
31#define MPL3115_DEVICE_ID 0xc4
32
33#define MPL3115_STATUS_PRESS_RDY BIT(2)
34#define MPL3115_STATUS_TEMP_RDY BIT(1)
35
36#define MPL3115_CTRL_RESET BIT(2)
37#define MPL3115_CTRL_OST BIT(1)
38#define MPL3115_CTRL_ACTIVE BIT(0)
39#define MPL3115_CTRL_OS_258MS (BIT(5) | BIT(4))
40
41struct mpl3115_data {
42 struct i2c_client *client;
43 struct mutex lock;
44 u8 ctrl_reg1;
45};
46
47static int mpl3115_request(struct mpl3115_data *data)
48{
49 int ret, tries = 15;
50
51
52 ret = i2c_smbus_write_byte_data(data->client, MPL3115_CTRL_REG1,
53 data->ctrl_reg1 | MPL3115_CTRL_OST);
54 if (ret < 0)
55 return ret;
56
57 while (tries-- > 0) {
58 ret = i2c_smbus_read_byte_data(data->client, MPL3115_CTRL_REG1);
59 if (ret < 0)
60 return ret;
61
62 if (!(ret & MPL3115_CTRL_OST))
63 break;
64 msleep(20);
65 }
66
67 if (tries < 0) {
68 dev_err(&data->client->dev, "data not ready\n");
69 return -EIO;
70 }
71
72 return 0;
73}
74
75static int mpl3115_read_raw(struct iio_dev *indio_dev,
76 struct iio_chan_spec const *chan,
77 int *val, int *val2, long mask)
78{
79 struct mpl3115_data *data = iio_priv(indio_dev);
80 __be32 tmp = 0;
81 int ret;
82
83 switch (mask) {
84 case IIO_CHAN_INFO_RAW:
85 if (iio_buffer_enabled(indio_dev))
86 return -EBUSY;
87
88 switch (chan->type) {
89 case IIO_PRESSURE:
90 mutex_lock(&data->lock);
91 ret = mpl3115_request(data);
92 if (ret < 0) {
93 mutex_unlock(&data->lock);
94 return ret;
95 }
96 ret = i2c_smbus_read_i2c_block_data(data->client,
97 MPL3115_OUT_PRESS, 3, (u8 *) &tmp);
98 mutex_unlock(&data->lock);
99 if (ret < 0)
100 return ret;
101 *val = be32_to_cpu(tmp) >> 12;
102 return IIO_VAL_INT;
103 case IIO_TEMP:
104 mutex_lock(&data->lock);
105 ret = mpl3115_request(data);
106 if (ret < 0) {
107 mutex_unlock(&data->lock);
108 return ret;
109 }
110 ret = i2c_smbus_read_i2c_block_data(data->client,
111 MPL3115_OUT_TEMP, 2, (u8 *) &tmp);
112 mutex_unlock(&data->lock);
113 if (ret < 0)
114 return ret;
115 *val = sign_extend32(be32_to_cpu(tmp) >> 20, 11);
116 return IIO_VAL_INT;
117 default:
118 return -EINVAL;
119 }
120 case IIO_CHAN_INFO_SCALE:
121 switch (chan->type) {
122 case IIO_PRESSURE:
123 *val = 0;
124 *val2 = 250;
125 return IIO_VAL_INT_PLUS_MICRO;
126 case IIO_TEMP:
127 *val = 0;
128 *val2 = 62500;
129 return IIO_VAL_INT_PLUS_MICRO;
130 default:
131 return -EINVAL;
132 }
133 }
134 return -EINVAL;
135}
136
137static irqreturn_t mpl3115_trigger_handler(int irq, void *p)
138{
139 struct iio_poll_func *pf = p;
140 struct iio_dev *indio_dev = pf->indio_dev;
141 struct mpl3115_data *data = iio_priv(indio_dev);
142 u8 buffer[16];
143 int ret, pos = 0;
144
145 mutex_lock(&data->lock);
146 ret = mpl3115_request(data);
147 if (ret < 0) {
148 mutex_unlock(&data->lock);
149 goto done;
150 }
151
152 memset(buffer, 0, sizeof(buffer));
153 if (test_bit(0, indio_dev->active_scan_mask)) {
154 ret = i2c_smbus_read_i2c_block_data(data->client,
155 MPL3115_OUT_PRESS, 3, &buffer[pos]);
156 if (ret < 0) {
157 mutex_unlock(&data->lock);
158 goto done;
159 }
160 pos += 4;
161 }
162
163 if (test_bit(1, indio_dev->active_scan_mask)) {
164 ret = i2c_smbus_read_i2c_block_data(data->client,
165 MPL3115_OUT_TEMP, 2, &buffer[pos]);
166 if (ret < 0) {
167 mutex_unlock(&data->lock);
168 goto done;
169 }
170 }
171 mutex_unlock(&data->lock);
172
173 iio_push_to_buffers_with_timestamp(indio_dev, buffer,
174 iio_get_time_ns());
175
176done:
177 iio_trigger_notify_done(indio_dev->trig);
178 return IRQ_HANDLED;
179}
180
181static const struct iio_chan_spec mpl3115_channels[] = {
182 {
183 .type = IIO_PRESSURE,
184 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
185 BIT(IIO_CHAN_INFO_SCALE),
186 .scan_index = 0,
187 .scan_type = {
188 .sign = 'u',
189 .realbits = 20,
190 .storagebits = 32,
191 .shift = 12,
192 .endianness = IIO_BE,
193 }
194 },
195 {
196 .type = IIO_TEMP,
197 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW),
198 BIT(IIO_CHAN_INFO_SCALE),
199 .scan_index = 1,
200 .scan_type = {
201 .sign = 's',
202 .realbits = 12,
203 .storagebits = 16,
204 .shift = 4,
205 .endianness = IIO_BE,
206 }
207 },
208 IIO_CHAN_SOFT_TIMESTAMP(2),
209};
210
211static const struct iio_info mpl3115_info = {
212 .read_raw = &mpl3115_read_raw,
213 .driver_module = THIS_MODULE,
214};
215
216static int mpl3115_probe(struct i2c_client *client,
217 const struct i2c_device_id *id)
218{
219 struct mpl3115_data *data;
220 struct iio_dev *indio_dev;
221 int ret;
222
223 ret = i2c_smbus_read_byte_data(client, MPL3115_WHO_AM_I);
224 if (ret < 0)
225 return ret;
226 if (ret != MPL3115_DEVICE_ID)
227 return -ENODEV;
228
229 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
230 if (!indio_dev)
231 return -ENOMEM;
232
233 data = iio_priv(indio_dev);
234 data->client = client;
235 mutex_init(&data->lock);
236
237 i2c_set_clientdata(client, indio_dev);
238 indio_dev->info = &mpl3115_info;
239 indio_dev->name = id->name;
240 indio_dev->dev.parent = &client->dev;
241 indio_dev->modes = INDIO_DIRECT_MODE;
242 indio_dev->channels = mpl3115_channels;
243 indio_dev->num_channels = ARRAY_SIZE(mpl3115_channels);
244
245
246 i2c_smbus_write_byte_data(client, MPL3115_CTRL_REG1,
247 MPL3115_CTRL_RESET);
248 msleep(50);
249
250 data->ctrl_reg1 = MPL3115_CTRL_OS_258MS;
251 ret = i2c_smbus_write_byte_data(client, MPL3115_CTRL_REG1,
252 data->ctrl_reg1);
253 if (ret < 0)
254 return ret;
255
256 ret = iio_triggered_buffer_setup(indio_dev, NULL,
257 mpl3115_trigger_handler, NULL);
258 if (ret < 0)
259 return ret;
260
261 ret = iio_device_register(indio_dev);
262 if (ret < 0)
263 goto buffer_cleanup;
264 return 0;
265
266buffer_cleanup:
267 iio_triggered_buffer_cleanup(indio_dev);
268 return ret;
269}
270
271static int mpl3115_standby(struct mpl3115_data *data)
272{
273 return i2c_smbus_write_byte_data(data->client, MPL3115_CTRL_REG1,
274 data->ctrl_reg1 & ~MPL3115_CTRL_ACTIVE);
275}
276
277static int mpl3115_remove(struct i2c_client *client)
278{
279 struct iio_dev *indio_dev = i2c_get_clientdata(client);
280
281 iio_device_unregister(indio_dev);
282 iio_triggered_buffer_cleanup(indio_dev);
283 mpl3115_standby(iio_priv(indio_dev));
284
285 return 0;
286}
287
288#ifdef CONFIG_PM_SLEEP
289static int mpl3115_suspend(struct device *dev)
290{
291 return mpl3115_standby(iio_priv(i2c_get_clientdata(
292 to_i2c_client(dev))));
293}
294
295static int mpl3115_resume(struct device *dev)
296{
297 struct mpl3115_data *data = iio_priv(i2c_get_clientdata(
298 to_i2c_client(dev)));
299
300 return i2c_smbus_write_byte_data(data->client, MPL3115_CTRL_REG1,
301 data->ctrl_reg1);
302}
303
304static SIMPLE_DEV_PM_OPS(mpl3115_pm_ops, mpl3115_suspend, mpl3115_resume);
305#define MPL3115_PM_OPS (&mpl3115_pm_ops)
306#else
307#define MPL3115_PM_OPS NULL
308#endif
309
310static const struct i2c_device_id mpl3115_id[] = {
311 { "mpl3115", 0 },
312 { }
313};
314MODULE_DEVICE_TABLE(i2c, mpl3115_id);
315
316static struct i2c_driver mpl3115_driver = {
317 .driver = {
318 .name = "mpl3115",
319 .pm = MPL3115_PM_OPS,
320 },
321 .probe = mpl3115_probe,
322 .remove = mpl3115_remove,
323 .id_table = mpl3115_id,
324};
325module_i2c_driver(mpl3115_driver);
326
327MODULE_AUTHOR("Peter Meerwald <pmeerw@pmeerw.net>");
328MODULE_DESCRIPTION("Freescale MPL3115 pressure/temperature driver");
329MODULE_LICENSE("GPL");
330
