Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * Driver for the Allegro MicroSystems ALS31300 3-D Linear Hall Effect Sensor
4 *
5 * Copyright (c) 2024 Linaro Limited
6 */
7
8#include <linux/bits.h>
9#include <linux/bitfield.h>
10#include <linux/delay.h>
11#include <linux/module.h>
12#include <linux/i2c.h>
13#include <linux/regmap.h>
14#include <linux/pm.h>
15#include <linux/pm_runtime.h>
16#include <linux/regulator/consumer.h>
17#include <linux/types.h>
18#include <linux/units.h>
19
20#include <linux/iio/buffer.h>
21#include <linux/iio/iio.h>
22#include <linux/iio/trigger_consumer.h>
23#include <linux/iio/triggered_buffer.h>
24
25/*
26 * The Allegro MicroSystems ALS31300 has an EEPROM space to configure how
27 * the device works and how the interrupt line behaves.
28 * Only the default setup with external trigger is supported.
29 *
30 * While the bindings supports declaring an interrupt line, those
31 * events are not supported.
32 *
33 * It should be possible to adapt the driver to the current
34 * device EEPROM setup at runtime.
35 */
36
37#define ALS31300_EEPROM_CONFIG 0x02
38#define ALS31300_EEPROM_INTERRUPT 0x03
39#define ALS31300_EEPROM_CUSTOMER_1 0x0d
40#define ALS31300_EEPROM_CUSTOMER_2 0x0e
41#define ALS31300_EEPROM_CUSTOMER_3 0x0f
42#define ALS31300_VOL_MODE 0x27
43#define ALS31300_VOL_MODE_LPDCM GENMASK(6, 4)
44#define ALS31300_LPDCM_INACTIVE_0_5_MS 0
45#define ALS31300_LPDCM_INACTIVE_1_0_MS 1
46#define ALS31300_LPDCM_INACTIVE_5_0_MS 2
47#define ALS31300_LPDCM_INACTIVE_10_0_MS 3
48#define ALS31300_LPDCM_INACTIVE_50_0_MS 4
49#define ALS31300_LPDCM_INACTIVE_100_0_MS 5
50#define ALS31300_LPDCM_INACTIVE_500_0_MS 6
51#define ALS31300_LPDCM_INACTIVE_1000_0_MS 7
52#define ALS31300_VOL_MODE_SLEEP GENMASK(1, 0)
53#define ALS31300_VOL_MODE_ACTIVE_MODE 0
54#define ALS31300_VOL_MODE_SLEEP_MODE 1
55#define ALS31300_VOL_MODE_LPDCM_MODE 2
56#define ALS31300_VOL_MSB 0x28
57#define ALS31300_VOL_MSB_TEMPERATURE GENMASK(5, 0)
58#define ALS31300_VOL_MSB_INTERRUPT BIT(6)
59#define ALS31300_VOL_MSB_NEW_DATA BIT(7)
60#define ALS31300_VOL_MSB_Z_AXIS GENMASK(15, 8)
61#define ALS31300_VOL_MSB_Y_AXIS GENMASK(23, 16)
62#define ALS31300_VOL_MSB_X_AXIS GENMASK(31, 24)
63#define ALS31300_VOL_LSB 0x29
64#define ALS31300_VOL_LSB_TEMPERATURE GENMASK(5, 0)
65#define ALS31300_VOL_LSB_HALL_STATUS GENMASK(7, 7)
66#define ALS31300_VOL_LSB_Z_AXIS GENMASK(11, 8)
67#define ALS31300_VOL_LSB_Y_AXIS GENMASK(15, 12)
68#define ALS31300_VOL_LSB_X_AXIS GENMASK(19, 16)
69#define ALS31300_VOL_LSB_INTERRUPT_WRITE BIT(20)
70#define ALS31300_CUSTOMER_ACCESS 0x35
71
72#define ALS31300_DATA_X_GET(b) \
73 sign_extend32(FIELD_GET(ALS31300_VOL_MSB_X_AXIS, b[0]) << 4 | \
74 FIELD_GET(ALS31300_VOL_LSB_X_AXIS, b[1]), 11)
75#define ALS31300_DATA_Y_GET(b) \
76 sign_extend32(FIELD_GET(ALS31300_VOL_MSB_Y_AXIS, b[0]) << 4 | \
77 FIELD_GET(ALS31300_VOL_LSB_Y_AXIS, b[1]), 11)
78#define ALS31300_DATA_Z_GET(b) \
79 sign_extend32(FIELD_GET(ALS31300_VOL_MSB_Z_AXIS, b[0]) << 4 | \
80 FIELD_GET(ALS31300_VOL_LSB_Z_AXIS, b[1]), 11)
81#define ALS31300_TEMPERATURE_GET(b) \
82 (FIELD_GET(ALS31300_VOL_MSB_TEMPERATURE, b[0]) << 6 | \
83 FIELD_GET(ALS31300_VOL_LSB_TEMPERATURE, b[1]))
84
85enum als31300_channels {
86 TEMPERATURE = 0,
87 AXIS_X,
88 AXIS_Y,
89 AXIS_Z,
90};
91
92struct als31300_variant_info {
93 u8 sensitivity;
94};
95
96struct als31300_data {
97 struct device *dev;
98 /* protects power on/off the device and access HW */
99 struct mutex mutex;
100 const struct als31300_variant_info *variant_info;
101 struct regmap *map;
102};
103
104/* The whole measure is split into 2x32-bit registers, we need to read them both at once */
105static int als31300_get_measure(struct als31300_data *data,
106 u16 *t, s16 *x, s16 *y, s16 *z)
107{
108 u32 buf[2];
109 int ret, err;
110
111 guard(mutex)(&data->mutex);
112
113 ret = pm_runtime_resume_and_get(data->dev);
114 if (ret)
115 return ret;
116
117 /*
118 * Loop until data is valid, new data should have the
119 * ALS31300_VOL_MSB_NEW_DATA bit set to 1.
120 * Max update rate is 2KHz, wait up to 1ms.
121 */
122 ret = read_poll_timeout(regmap_bulk_read, err,
123 err || FIELD_GET(ALS31300_VOL_MSB_NEW_DATA, buf[0]),
124 20, USEC_PER_MSEC, false,
125 data->map, ALS31300_VOL_MSB, buf, ARRAY_SIZE(buf));
126 /* Bail out on read_poll_timeout() error */
127 if (ret)
128 goto out;
129
130 /* Bail out on regmap_bulk_read() error */
131 if (err) {
132 dev_err(data->dev, "read data failed, error %d\n", ret);
133 ret = err;
134 goto out;
135 }
136
137 *t = ALS31300_TEMPERATURE_GET(buf);
138 *x = ALS31300_DATA_X_GET(buf);
139 *y = ALS31300_DATA_Y_GET(buf);
140 *z = ALS31300_DATA_Z_GET(buf);
141
142out:
143 pm_runtime_put_autosuspend(data->dev);
144
145 return ret;
146}
147
148static int als31300_read_raw(struct iio_dev *indio_dev,
149 const struct iio_chan_spec *chan, int *val,
150 int *val2, long mask)
151{
152 struct als31300_data *data = iio_priv(indio_dev);
153 s16 x, y, z;
154 u16 t;
155 int ret;
156
157 switch (mask) {
158 case IIO_CHAN_INFO_RAW:
159 ret = als31300_get_measure(data, &t, &x, &y, &z);
160 if (ret)
161 return ret;
162
163 switch (chan->address) {
164 case TEMPERATURE:
165 *val = t;
166 return IIO_VAL_INT;
167 case AXIS_X:
168 *val = x;
169 return IIO_VAL_INT;
170 case AXIS_Y:
171 *val = y;
172 return IIO_VAL_INT;
173 case AXIS_Z:
174 *val = z;
175 return IIO_VAL_INT;
176 default:
177 return -EINVAL;
178 }
179 case IIO_CHAN_INFO_SCALE:
180 switch (chan->type) {
181 case IIO_TEMP:
182 /*
183 * Fractional part of:
184 * 1000 * 302 * (value - 1708)
185 * temp = ----------------------------
186 * 4096
187 * to convert temperature in millicelcius.
188 */
189 *val = MILLI * 302;
190 *val2 = 4096;
191 return IIO_VAL_FRACTIONAL;
192 case IIO_MAGN:
193 /*
194 * Devices are configured in factory
195 * with different sensitivities:
196 * - 500 GAUSS <-> 4 LSB/Gauss
197 * - 1000 GAUSS <-> 2 LSB/Gauss
198 * - 2000 GAUSS <-> 1 LSB/Gauss
199 * with translates by a division of the returned
200 * value to get Gauss value.
201 * The sensitivity cannot be read at runtime
202 * so the value depends on the model compatible
203 * or device id.
204 */
205 *val = 1;
206 *val2 = data->variant_info->sensitivity;
207 return IIO_VAL_FRACTIONAL;
208 default:
209 return -EINVAL;
210 }
211 case IIO_CHAN_INFO_OFFSET:
212 switch (chan->type) {
213 case IIO_TEMP:
214 *val = -1708;
215 return IIO_VAL_INT;
216 default:
217 return -EINVAL;
218 }
219 default:
220 return -EINVAL;
221 }
222}
223
224static irqreturn_t als31300_trigger_handler(int irq, void *p)
225{
226 struct iio_poll_func *pf = p;
227 struct iio_dev *indio_dev = pf->indio_dev;
228 struct als31300_data *data = iio_priv(indio_dev);
229 struct {
230 u16 temperature;
231 s16 channels[3];
232 aligned_s64 timestamp;
233 } scan;
234 s16 x, y, z;
235 int ret;
236 u16 t;
237
238 ret = als31300_get_measure(data, &t, &x, &y, &z);
239 if (ret)
240 goto trigger_out;
241
242 scan.temperature = t;
243 scan.channels[0] = x;
244 scan.channels[1] = y;
245 scan.channels[2] = z;
246 iio_push_to_buffers_with_ts(indio_dev, &scan, sizeof(scan), pf->timestamp);
247
248trigger_out:
249 iio_trigger_notify_done(indio_dev->trig);
250
251 return IRQ_HANDLED;
252}
253
254#define ALS31300_AXIS_CHANNEL(axis, index) \
255 { \
256 .type = IIO_MAGN, \
257 .modified = 1, \
258 .channel2 = IIO_MOD_##axis, \
259 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
260 BIT(IIO_CHAN_INFO_SCALE), \
261 .address = index, \
262 .scan_index = index, \
263 .scan_type = { \
264 .sign = 's', \
265 .realbits = 12, \
266 .storagebits = 16, \
267 .endianness = IIO_CPU, \
268 }, \
269 }
270
271static const struct iio_chan_spec als31300_channels[] = {
272 {
273 .type = IIO_TEMP,
274 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
275 BIT(IIO_CHAN_INFO_SCALE) |
276 BIT(IIO_CHAN_INFO_OFFSET),
277 .address = TEMPERATURE,
278 .scan_index = TEMPERATURE,
279 .scan_type = {
280 .sign = 'u',
281 .realbits = 16,
282 .storagebits = 16,
283 .endianness = IIO_CPU,
284 },
285 },
286 ALS31300_AXIS_CHANNEL(X, AXIS_X),
287 ALS31300_AXIS_CHANNEL(Y, AXIS_Y),
288 ALS31300_AXIS_CHANNEL(Z, AXIS_Z),
289 IIO_CHAN_SOFT_TIMESTAMP(4),
290};
291
292static const struct iio_info als31300_info = {
293 .read_raw = als31300_read_raw,
294};
295
296static int als31300_set_operating_mode(struct als31300_data *data,
297 unsigned int val)
298{
299 int ret;
300
301 ret = regmap_update_bits(data->map, ALS31300_VOL_MODE,
302 ALS31300_VOL_MODE_SLEEP, val);
303 if (ret) {
304 dev_err(data->dev, "failed to set operating mode (%pe)\n", ERR_PTR(ret));
305 return ret;
306 }
307
308 /* The time it takes to exit sleep mode is equivalent to Power-On Delay Time */
309 if (val == ALS31300_VOL_MODE_ACTIVE_MODE)
310 fsleep(600);
311
312 return 0;
313}
314
315static void als31300_power_down(void *data)
316{
317 als31300_set_operating_mode(data, ALS31300_VOL_MODE_SLEEP_MODE);
318}
319
320static const struct iio_buffer_setup_ops als31300_setup_ops = {};
321
322static const unsigned long als31300_scan_masks[] = { GENMASK(3, 0), 0 };
323
324static bool als31300_volatile_reg(struct device *dev, unsigned int reg)
325{
326 return reg == ALS31300_VOL_MSB || reg == ALS31300_VOL_LSB;
327}
328
329static const struct regmap_config als31300_regmap_config = {
330 .reg_bits = 8,
331 .val_bits = 32,
332 .max_register = ALS31300_CUSTOMER_ACCESS,
333 .volatile_reg = als31300_volatile_reg,
334};
335
336static int als31300_probe(struct i2c_client *i2c)
337{
338 struct device *dev = &i2c->dev;
339 struct als31300_data *data;
340 struct iio_dev *indio_dev;
341 int ret;
342
343 indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
344 if (!indio_dev)
345 return -ENOMEM;
346
347 data = iio_priv(indio_dev);
348 data->dev = dev;
349 i2c_set_clientdata(i2c, indio_dev);
350
351 ret = devm_mutex_init(dev, &data->mutex);
352 if (ret)
353 return ret;
354
355 data->variant_info = i2c_get_match_data(i2c);
356 if (!data->variant_info)
357 return -EINVAL;
358
359 data->map = devm_regmap_init_i2c(i2c, &als31300_regmap_config);
360 if (IS_ERR(data->map))
361 return dev_err_probe(dev, PTR_ERR(data->map),
362 "failed to allocate register map\n");
363
364 ret = devm_regulator_get_enable(dev, "vcc");
365 if (ret)
366 return dev_err_probe(dev, ret, "failed to enable regulator\n");
367
368 ret = als31300_set_operating_mode(data, ALS31300_VOL_MODE_ACTIVE_MODE);
369 if (ret)
370 return dev_err_probe(dev, ret, "failed to power on device\n");
371
372 ret = devm_add_action_or_reset(dev, als31300_power_down, data);
373 if (ret)
374 return ret;
375
376 indio_dev->info = &als31300_info;
377 indio_dev->modes = INDIO_DIRECT_MODE;
378 indio_dev->name = i2c->name;
379 indio_dev->channels = als31300_channels;
380 indio_dev->num_channels = ARRAY_SIZE(als31300_channels);
381 indio_dev->available_scan_masks = als31300_scan_masks;
382
383 ret = devm_iio_triggered_buffer_setup(dev, indio_dev,
384 iio_pollfunc_store_time,
385 als31300_trigger_handler,
386 &als31300_setup_ops);
387 if (ret < 0)
388 return dev_err_probe(dev, ret, "iio triggered buffer setup failed\n");
389
390 ret = pm_runtime_set_active(dev);
391 if (ret < 0)
392 return ret;
393
394 ret = devm_pm_runtime_enable(dev);
395 if (ret)
396 return ret;
397
398 pm_runtime_get_noresume(dev);
399 pm_runtime_set_autosuspend_delay(dev, 200);
400 pm_runtime_use_autosuspend(dev);
401
402 pm_runtime_put_autosuspend(dev);
403
404 ret = devm_iio_device_register(dev, indio_dev);
405 if (ret)
406 return dev_err_probe(dev, ret, "device register failed\n");
407
408 return 0;
409}
410
411static int als31300_runtime_suspend(struct device *dev)
412{
413 struct iio_dev *indio_dev = dev_get_drvdata(dev);
414 struct als31300_data *data = iio_priv(indio_dev);
415
416 return als31300_set_operating_mode(data, ALS31300_VOL_MODE_SLEEP_MODE);
417}
418
419static int als31300_runtime_resume(struct device *dev)
420{
421 struct iio_dev *indio_dev = dev_get_drvdata(dev);
422 struct als31300_data *data = iio_priv(indio_dev);
423
424 return als31300_set_operating_mode(data, ALS31300_VOL_MODE_ACTIVE_MODE);
425}
426
427static DEFINE_RUNTIME_DEV_PM_OPS(als31300_pm_ops,
428 als31300_runtime_suspend, als31300_runtime_resume,
429 NULL);
430
431static const struct als31300_variant_info al31300_variant_500 = {
432 .sensitivity = 4,
433};
434
435static const struct als31300_variant_info al31300_variant_1000 = {
436 .sensitivity = 2,
437};
438
439static const struct als31300_variant_info al31300_variant_2000 = {
440 .sensitivity = 1,
441};
442
443static const struct i2c_device_id als31300_id[] = {
444 {
445 .name = "als31300-500",
446 .driver_data = (kernel_ulong_t)&al31300_variant_500,
447 },
448 {
449 .name = "als31300-1000",
450 .driver_data = (kernel_ulong_t)&al31300_variant_1000,
451 },
452 {
453 .name = "als31300-2000",
454 .driver_data = (kernel_ulong_t)&al31300_variant_2000,
455 },
456 { }
457};
458MODULE_DEVICE_TABLE(i2c, als31300_id);
459
460static const struct of_device_id als31300_of_match[] = {
461 {
462 .compatible = "allegromicro,als31300-500",
463 .data = &al31300_variant_500,
464 },
465 {
466 .compatible = "allegromicro,als31300-1000",
467 .data = &al31300_variant_1000,
468 },
469 {
470 .compatible = "allegromicro,als31300-2000",
471 .data = &al31300_variant_2000,
472 },
473 { }
474};
475MODULE_DEVICE_TABLE(of, als31300_of_match);
476
477static struct i2c_driver als31300_driver = {
478 .driver = {
479 .name = "als31300",
480 .of_match_table = als31300_of_match,
481 .pm = pm_ptr(&als31300_pm_ops),
482 },
483 .probe = als31300_probe,
484 .id_table = als31300_id,
485};
486module_i2c_driver(als31300_driver);
487
488MODULE_LICENSE("GPL");
489MODULE_DESCRIPTION("ALS31300 3-D Linear Hall Effect Driver");
490MODULE_AUTHOR("Neil Armstrong <neil.armstrong@linaro.org>");