?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
perf intel-pt: Factor out intel_pt_8b_tsc()
[linux/fpc-iii.git] / drivers / iio / magnetometer / mag3110.c
blobdd990cdb04a8bd09deafff59c7ddad39fe4085c7
1 /*
2 * mag3110.c - Support for Freescale MAG3110 magnetometer sensor
3 *
4 * Copyright (c) 2013 Peter Meerwald <pmeerw@pmeerw.net>
5 *
6 * This file is subject to the terms and conditions of version 2 of
7 * the GNU General Public License. See the file COPYING in the main
8 * directory of this archive for more details.
9 *
10 * (7-bit I2C slave address 0x0e)
11 *
12 * TODO: irq, user offset, oversampling, continuous mode
13 */
14
15 #include <linux/module.h>
16 #include <linux/i2c.h>
17 #include <linux/iio/iio.h>
18 #include <linux/iio/sysfs.h>
19 #include <linux/iio/trigger_consumer.h>
20 #include <linux/iio/buffer.h>
21 #include <linux/iio/triggered_buffer.h>
22 #include <linux/delay.h>
23 #include <linux/regulator/consumer.h>
24
25 #define MAG3110_STATUS 0x00
26 #define MAG3110_OUT_X 0x01 /* MSB first */
27 #define MAG3110_OUT_Y 0x03
28 #define MAG3110_OUT_Z 0x05
29 #define MAG3110_WHO_AM_I 0x07
30 #define MAG3110_SYSMOD 0x08
31 #define MAG3110_OFF_X 0x09 /* MSB first */
32 #define MAG3110_OFF_Y 0x0b
33 #define MAG3110_OFF_Z 0x0d
34 #define MAG3110_DIE_TEMP 0x0f
35 #define MAG3110_CTRL_REG1 0x10
36 #define MAG3110_CTRL_REG2 0x11
37
38 #define MAG3110_STATUS_DRDY (BIT(2) | BIT(1) | BIT(0))
39
40 #define MAG3110_CTRL_DR_MASK (BIT(7) | BIT(6) | BIT(5))
41 #define MAG3110_CTRL_DR_SHIFT 5
42 #define MAG3110_CTRL_DR_DEFAULT 0
43
44 #define MAG3110_SYSMOD_MODE_MASK GENMASK(1, 0)
45
46 #define MAG3110_CTRL_TM BIT(1) /* trigger single measurement */
47 #define MAG3110_CTRL_AC BIT(0) /* continuous measurements */
48
49 #define MAG3110_CTRL_AUTO_MRST_EN BIT(7) /* magnetic auto-reset */
50 #define MAG3110_CTRL_RAW BIT(5) /* measurements not user-offset corrected */
51
52 #define MAG3110_DEVICE_ID 0xc4
53
54 /* Each client has this additional data */
55 struct mag3110_data {
56 struct i2c_client *client;
57 struct mutex lock;
58 u8 ctrl_reg1;
59 int sleep_val;
60 struct regulator *vdd_reg;
61 struct regulator *vddio_reg;
62 };
63
64 static int mag3110_request(struct mag3110_data *data)
65 {
66 int ret, tries = 150;
67
68 if ((data->ctrl_reg1 & MAG3110_CTRL_AC) == 0) {
69 /* trigger measurement */
70 ret = i2c_smbus_write_byte_data(data->client, MAG3110_CTRL_REG1,
71 data->ctrl_reg1 | MAG3110_CTRL_TM);
72 if (ret < 0)
73 return ret;
74 }
75
76 while (tries-- > 0) {
77 ret = i2c_smbus_read_byte_data(data->client, MAG3110_STATUS);
78 if (ret < 0)
79 return ret;
80 /* wait for data ready */
81 if ((ret & MAG3110_STATUS_DRDY) == MAG3110_STATUS_DRDY)
82 break;
83
84 if (data->sleep_val <= 20)
85 usleep_range(data->sleep_val * 250, data->sleep_val * 500);
86 else
87 msleep(20);
88 }
89
90 if (tries < 0) {
91 dev_err(&data->client->dev, "data not ready\n");
92 return -EIO;
93 }
94
95 return 0;
96 }
97
98 static int mag3110_read(struct mag3110_data *data, __be16 buf[3])
99 {
100 int ret;
101
102 mutex_lock(&data->lock);
103 ret = mag3110_request(data);
104 if (ret < 0) {
105 mutex_unlock(&data->lock);
106 return ret;
107 }
108 ret = i2c_smbus_read_i2c_block_data(data->client,
109 MAG3110_OUT_X, 3 * sizeof(__be16), (u8 *) buf);
110 mutex_unlock(&data->lock);
111
112 return ret;
113 }
114
115 static ssize_t mag3110_show_int_plus_micros(char *buf,
116 const int (*vals)[2], int n)
117 {
118 size_t len = 0;
119
120 while (n-- > 0)
121 len += scnprintf(buf + len, PAGE_SIZE - len,
122 "%d.%06d ", vals[n][0], vals[n][1]);
123
124 /* replace trailing space by newline */
125 buf[len - 1] = '\n';
126
127 return len;
128 }
129
130 static int mag3110_get_int_plus_micros_index(const int (*vals)[2], int n,
131 int val, int val2)
132 {
133 while (n-- > 0)
134 if (val == vals[n][0] && val2 == vals[n][1])
135 return n;
136
137 return -EINVAL;
138 }
139
140 static const int mag3110_samp_freq[8][2] = {
141 {80, 0}, {40, 0}, {20, 0}, {10, 0}, {5, 0}, {2, 500000},
142 {1, 250000}, {0, 625000}
143 };
144
145 static ssize_t mag3110_show_samp_freq_avail(struct device *dev,
146 struct device_attribute *attr, char *buf)
147 {
148 return mag3110_show_int_plus_micros(buf, mag3110_samp_freq, 8);
149 }
150
151 static IIO_DEV_ATTR_SAMP_FREQ_AVAIL(mag3110_show_samp_freq_avail);
152
153 static int mag3110_get_samp_freq_index(struct mag3110_data *data,
154 int val, int val2)
155 {
156 return mag3110_get_int_plus_micros_index(mag3110_samp_freq, 8, val,
157 val2);
158 }
159
160 static int mag3110_calculate_sleep(struct mag3110_data *data)
161 {
162 int ret, i = data->ctrl_reg1 >> MAG3110_CTRL_DR_SHIFT;
163
164 if (mag3110_samp_freq[i][0] > 0)
165 ret = 1000 / mag3110_samp_freq[i][0];
166 else
167 ret = 1000;
168
169 return ret == 0 ? 1 : ret;
170 }
171
172 static int mag3110_standby(struct mag3110_data *data)
173 {
174 return i2c_smbus_write_byte_data(data->client, MAG3110_CTRL_REG1,
175 data->ctrl_reg1 & ~MAG3110_CTRL_AC);
176 }
177
178 static int mag3110_wait_standby(struct mag3110_data *data)
179 {
180 int ret, tries = 30;
181
182 /*
183 * Takes up to 1/ODR to come out of active mode into stby
184 * Longest expected period is 12.5seconds.
185 * We'll sleep for 500ms between checks
186 */
187 while (tries-- > 0) {
188 ret = i2c_smbus_read_byte_data(data->client, MAG3110_SYSMOD);
189 if (ret < 0) {
190 dev_err(&data->client->dev, "i2c error\n");
191 return ret;
192 }
193 /* wait for standby */
194 if ((ret & MAG3110_SYSMOD_MODE_MASK) == 0)
195 break;
196
197 msleep_interruptible(500);
198 }
199
200 if (tries < 0) {
201 dev_err(&data->client->dev, "device not entering standby mode\n");
202 return -EIO;
203 }
204
205 return 0;
206 }
207
208 static int mag3110_active(struct mag3110_data *data)
209 {
210 return i2c_smbus_write_byte_data(data->client, MAG3110_CTRL_REG1,
211 data->ctrl_reg1);
212 }
213
214 /* returns >0 if active, 0 if in standby and <0 on error */
215 static int mag3110_is_active(struct mag3110_data *data)
216 {
217 int reg;
218
219 reg = i2c_smbus_read_byte_data(data->client, MAG3110_CTRL_REG1);
220 if (reg < 0)
221 return reg;
222
223 return reg & MAG3110_CTRL_AC;
224 }
225
226 static int mag3110_change_config(struct mag3110_data *data, u8 reg, u8 val)
227 {
228 int ret;
229 int is_active;
230
231 mutex_lock(&data->lock);
232
233 is_active = mag3110_is_active(data);
234 if (is_active < 0) {
235 ret = is_active;
236 goto fail;
237 }
238
239 /* config can only be changed when in standby */
240 if (is_active > 0) {
241 ret = mag3110_standby(data);
242 if (ret < 0)
243 goto fail;
244 }
245
246 /*
247 * After coming out of active we must wait for the part
248 * to transition to STBY. This can take up to 1 /ODR to occur
249 */
250 ret = mag3110_wait_standby(data);
251 if (ret < 0)
252 goto fail;
253
254 ret = i2c_smbus_write_byte_data(data->client, reg, val);
255 if (ret < 0)
256 goto fail;
257
258 if (is_active > 0) {
259 ret = mag3110_active(data);
260 if (ret < 0)
261 goto fail;
262 }
263
264 ret = 0;
265 fail:
266 mutex_unlock(&data->lock);
267
268 return ret;
269 }
270
271 static int mag3110_read_raw(struct iio_dev *indio_dev,
272 struct iio_chan_spec const *chan,
273 int *val, int *val2, long mask)
274 {
275 struct mag3110_data *data = iio_priv(indio_dev);
276 __be16 buffer[3];
277 int i, ret;
278
279 switch (mask) {
280 case IIO_CHAN_INFO_RAW:
281 ret = iio_device_claim_direct_mode(indio_dev);
282 if (ret)
283 return ret;
284
285 switch (chan->type) {
286 case IIO_MAGN: /* in 0.1 uT / LSB */
287 ret = mag3110_read(data, buffer);
288 if (ret < 0)
289 goto release;
290 *val = sign_extend32(
291 be16_to_cpu(buffer[chan->scan_index]), 15);
292 ret = IIO_VAL_INT;
293 break;
294 case IIO_TEMP: /* in 1 C / LSB */
295 mutex_lock(&data->lock);
296 ret = mag3110_request(data);
297 if (ret < 0) {
298 mutex_unlock(&data->lock);
299 goto release;
300 }
301 ret = i2c_smbus_read_byte_data(data->client,
302 MAG3110_DIE_TEMP);
303 mutex_unlock(&data->lock);
304 if (ret < 0)
305 goto release;
306 *val = sign_extend32(ret, 7);
307 ret = IIO_VAL_INT;
308 break;
309 default:
310 ret = -EINVAL;
311 }
312 release:
313 iio_device_release_direct_mode(indio_dev);
314 return ret;
315
316 case IIO_CHAN_INFO_SCALE:
317 switch (chan->type) {
318 case IIO_MAGN:
319 *val = 0;
320 *val2 = 1000;
321 return IIO_VAL_INT_PLUS_MICRO;
322 case IIO_TEMP:
323 *val = 1000;
324 return IIO_VAL_INT;
325 default:
326 return -EINVAL;
327 }
328 case IIO_CHAN_INFO_SAMP_FREQ:
329 i = data->ctrl_reg1 >> MAG3110_CTRL_DR_SHIFT;
330 *val = mag3110_samp_freq[i][0];
331 *val2 = mag3110_samp_freq[i][1];
332 return IIO_VAL_INT_PLUS_MICRO;
333 case IIO_CHAN_INFO_CALIBBIAS:
334 ret = i2c_smbus_read_word_swapped(data->client,
335 MAG3110_OFF_X + 2 * chan->scan_index);
336 if (ret < 0)
337 return ret;
338 *val = sign_extend32(ret >> 1, 14);
339 return IIO_VAL_INT;
340 }
341 return -EINVAL;
342 }
343
344 static int mag3110_write_raw(struct iio_dev *indio_dev,
345 struct iio_chan_spec const *chan,
346 int val, int val2, long mask)
347 {
348 struct mag3110_data *data = iio_priv(indio_dev);
349 int rate, ret;
350
351 ret = iio_device_claim_direct_mode(indio_dev);
352 if (ret)
353 return ret;
354
355 switch (mask) {
356 case IIO_CHAN_INFO_SAMP_FREQ:
357 rate = mag3110_get_samp_freq_index(data, val, val2);
358 if (rate < 0) {
359 ret = -EINVAL;
360 break;
361 }
362 data->ctrl_reg1 &= 0xff & ~MAG3110_CTRL_DR_MASK
363 & ~MAG3110_CTRL_AC;
364 data->ctrl_reg1 |= rate << MAG3110_CTRL_DR_SHIFT;
365 data->sleep_val = mag3110_calculate_sleep(data);
366 if (data->sleep_val < 40)
367 data->ctrl_reg1 |= MAG3110_CTRL_AC;
368
369 ret = mag3110_change_config(data, MAG3110_CTRL_REG1,
370 data->ctrl_reg1);
371 break;
372 case IIO_CHAN_INFO_CALIBBIAS:
373 if (val < -10000 || val > 10000) {
374 ret = -EINVAL;
375 break;
376 }
377 ret = i2c_smbus_write_word_swapped(data->client,
378 MAG3110_OFF_X + 2 * chan->scan_index, val << 1);
379 break;
380 default:
381 ret = -EINVAL;
382 break;
383 }
384 iio_device_release_direct_mode(indio_dev);
385 return ret;
386 }
387
388 static irqreturn_t mag3110_trigger_handler(int irq, void *p)
389 {
390 struct iio_poll_func *pf = p;
391 struct iio_dev *indio_dev = pf->indio_dev;
392 struct mag3110_data *data = iio_priv(indio_dev);
393 u8 buffer[16]; /* 3 16-bit channels + 1 byte temp + padding + ts */
394 int ret;
395
396 ret = mag3110_read(data, (__be16 *) buffer);
397 if (ret < 0)
398 goto done;
399
400 if (test_bit(3, indio_dev->active_scan_mask)) {
401 ret = i2c_smbus_read_byte_data(data->client,
402 MAG3110_DIE_TEMP);
403 if (ret < 0)
404 goto done;
405 buffer[6] = ret;
406 }
407
408 iio_push_to_buffers_with_timestamp(indio_dev, buffer,
409 iio_get_time_ns(indio_dev));
410
411 done:
412 iio_trigger_notify_done(indio_dev->trig);
413 return IRQ_HANDLED;
414 }
415
416 #define MAG3110_CHANNEL(axis, idx) { \
417 .type = IIO_MAGN, \
418 .modified = 1, \
419 .channel2 = IIO_MOD_##axis, \
420 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
421 BIT(IIO_CHAN_INFO_CALIBBIAS), \
422 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SAMP_FREQ) | \
423 BIT(IIO_CHAN_INFO_SCALE), \
424 .scan_index = idx, \
425 .scan_type = { \
426 .sign = 's', \
427 .realbits = 16, \
428 .storagebits = 16, \
429 .endianness = IIO_BE, \
430 }, \
431 }
432
433 static const struct iio_chan_spec mag3110_channels[] = {
434 MAG3110_CHANNEL(X, 0),
435 MAG3110_CHANNEL(Y, 1),
436 MAG3110_CHANNEL(Z, 2),
437 {
438 .type = IIO_TEMP,
439 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
440 BIT(IIO_CHAN_INFO_SCALE),
441 .scan_index = 3,
442 .scan_type = {
443 .sign = 's',
444 .realbits = 8,
445 .storagebits = 8,
446 },
447 },
448 IIO_CHAN_SOFT_TIMESTAMP(4),
449 };
450
451 static struct attribute *mag3110_attributes[] = {
452 &iio_dev_attr_sampling_frequency_available.dev_attr.attr,
453 NULL
454 };
455
456 static const struct attribute_group mag3110_group = {
457 .attrs = mag3110_attributes,
458 };
459
460 static const struct iio_info mag3110_info = {
461 .attrs = &mag3110_group,
462 .read_raw = &mag3110_read_raw,
463 .write_raw = &mag3110_write_raw,
464 };
465
466 static const unsigned long mag3110_scan_masks[] = {0x7, 0xf, 0};
467
468 static int mag3110_probe(struct i2c_client *client,
469 const struct i2c_device_id *id)
470 {
471 struct mag3110_data *data;
472 struct iio_dev *indio_dev;
473 int ret;
474
475 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
476 if (!indio_dev)
477 return -ENOMEM;
478
479 data = iio_priv(indio_dev);
480
481 data->vdd_reg = devm_regulator_get(&client->dev, "vdd");
482 if (IS_ERR(data->vdd_reg)) {
483 if (PTR_ERR(data->vdd_reg) == -EPROBE_DEFER)
484 return -EPROBE_DEFER;
485
486 dev_err(&client->dev, "failed to get VDD regulator!\n");
487 return PTR_ERR(data->vdd_reg);
488 }
489
490 data->vddio_reg = devm_regulator_get(&client->dev, "vddio");
491 if (IS_ERR(data->vddio_reg)) {
492 if (PTR_ERR(data->vddio_reg) == -EPROBE_DEFER)
493 return -EPROBE_DEFER;
494
495 dev_err(&client->dev, "failed to get VDDIO regulator!\n");
496 return PTR_ERR(data->vddio_reg);
497 }
498
499 ret = regulator_enable(data->vdd_reg);
500 if (ret) {
501 dev_err(&client->dev, "failed to enable VDD regulator!\n");
502 return ret;
503 }
504
505 ret = regulator_enable(data->vddio_reg);
506 if (ret) {
507 dev_err(&client->dev, "failed to enable VDDIO regulator!\n");
508 goto disable_regulator_vdd;
509 }
510
511 ret = i2c_smbus_read_byte_data(client, MAG3110_WHO_AM_I);
512 if (ret < 0)
513 goto disable_regulators;
514 if (ret != MAG3110_DEVICE_ID) {
515 ret = -ENODEV;
516 goto disable_regulators;
517 }
518
519 data->client = client;
520 mutex_init(&data->lock);
521
522 i2c_set_clientdata(client, indio_dev);
523 indio_dev->info = &mag3110_info;
524 indio_dev->name = id->name;
525 indio_dev->dev.parent = &client->dev;
526 indio_dev->modes = INDIO_DIRECT_MODE;
527 indio_dev->channels = mag3110_channels;
528 indio_dev->num_channels = ARRAY_SIZE(mag3110_channels);
529 indio_dev->available_scan_masks = mag3110_scan_masks;
530
531 data->ctrl_reg1 = MAG3110_CTRL_DR_DEFAULT << MAG3110_CTRL_DR_SHIFT;
532 data->sleep_val = mag3110_calculate_sleep(data);
533 if (data->sleep_val < 40)
534 data->ctrl_reg1 |= MAG3110_CTRL_AC;
535
536 ret = mag3110_change_config(data, MAG3110_CTRL_REG1, data->ctrl_reg1);
537 if (ret < 0)
538 goto disable_regulators;
539
540 ret = i2c_smbus_write_byte_data(client, MAG3110_CTRL_REG2,
541 MAG3110_CTRL_AUTO_MRST_EN);
542 if (ret < 0)
543 goto standby_on_error;
544
545 ret = iio_triggered_buffer_setup(indio_dev, NULL,
546 mag3110_trigger_handler, NULL);
547 if (ret < 0)
548 goto standby_on_error;
549
550 ret = iio_device_register(indio_dev);
551 if (ret < 0)
552 goto buffer_cleanup;
553 return 0;
554
555 buffer_cleanup:
556 iio_triggered_buffer_cleanup(indio_dev);
557 standby_on_error:
558 mag3110_standby(iio_priv(indio_dev));
559 disable_regulators:
560 regulator_disable(data->vddio_reg);
561 disable_regulator_vdd:
562 regulator_disable(data->vdd_reg);
563
564 return ret;
565 }
566
567 static int mag3110_remove(struct i2c_client *client)
568 {
569 struct iio_dev *indio_dev = i2c_get_clientdata(client);
570 struct mag3110_data *data = iio_priv(indio_dev);
571
572 iio_device_unregister(indio_dev);
573 iio_triggered_buffer_cleanup(indio_dev);
574 mag3110_standby(iio_priv(indio_dev));
575 regulator_disable(data->vddio_reg);
576 regulator_disable(data->vdd_reg);
577
578 return 0;
579 }
580
581 #ifdef CONFIG_PM_SLEEP
582 static int mag3110_suspend(struct device *dev)
583 {
584 struct mag3110_data *data = iio_priv(i2c_get_clientdata(
585 to_i2c_client(dev)));
586 int ret;
587
588 ret = mag3110_standby(iio_priv(i2c_get_clientdata(
589 to_i2c_client(dev))));
590 if (ret)
591 return ret;
592
593 ret = regulator_disable(data->vddio_reg);
594 if (ret) {
595 dev_err(dev, "failed to disable VDDIO regulator\n");
596 return ret;
597 }
598
599 ret = regulator_disable(data->vdd_reg);
600 if (ret) {
601 dev_err(dev, "failed to disable VDD regulator\n");
602 return ret;
603 }
604
605 return 0;
606 }
607
608 static int mag3110_resume(struct device *dev)
609 {
610 struct mag3110_data *data = iio_priv(i2c_get_clientdata(
611 to_i2c_client(dev)));
612 int ret;
613
614 ret = regulator_enable(data->vdd_reg);
615 if (ret) {
616 dev_err(dev, "failed to enable VDD regulator\n");
617 return ret;
618 }
619
620 ret = regulator_enable(data->vddio_reg);
621 if (ret) {
622 dev_err(dev, "failed to enable VDDIO regulator\n");
623 regulator_disable(data->vdd_reg);
624 return ret;
625 }
626
627 return i2c_smbus_write_byte_data(data->client, MAG3110_CTRL_REG1,
628 data->ctrl_reg1);
629 }
630
631 static SIMPLE_DEV_PM_OPS(mag3110_pm_ops, mag3110_suspend, mag3110_resume);
632 #define MAG3110_PM_OPS (&mag3110_pm_ops)
633 #else
634 #define MAG3110_PM_OPS NULL
635 #endif
636
637 static const struct i2c_device_id mag3110_id[] = {
638 { "mag3110", 0 },
639 { }
640 };
641 MODULE_DEVICE_TABLE(i2c, mag3110_id);
642
643 static const struct of_device_id mag3110_of_match[] = {
644 { .compatible = "fsl,mag3110" },
645 { }
646 };
647 MODULE_DEVICE_TABLE(of, mag3110_of_match);
648
649 static struct i2c_driver mag3110_driver = {
650 .driver = {
651 .name = "mag3110",
652 .of_match_table = mag3110_of_match,
653 .pm = MAG3110_PM_OPS,
654 },
655 .probe = mag3110_probe,
656 .remove = mag3110_remove,
657 .id_table = mag3110_id,
658 };
659 module_i2c_driver(mag3110_driver);
660
661 MODULE_AUTHOR("Peter Meerwald <pmeerw@pmeerw.net>");
662 MODULE_DESCRIPTION("Freescale MAG3110 magnetometer driver");
663 MODULE_LICENSE("GPL");
Linux with added FPC-III support