1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * MMC5633 - MEMSIC 3-axis Magnetic Sensor
4 *
5 * Copyright (c) 2015, Intel Corporation.
6 * Copyright (c) 2025, NXP
7 *
8 * IIO driver for MMC5633, base on mmc35240.c
9 */
10
11 #include <linux/array_size.h>
12 #include <linux/bitfield.h>
13 #include <linux/bits.h>
14 #include <linux/cleanup.h>
15 #include <linux/delay.h>
16 #include <linux/device.h>
17 #include <linux/dev_printk.h>
18 #include <linux/err.h>
19 #include <linux/errno.h>
20 #include <linux/i2c.h>
21 #include <linux/i3c/device.h>
22 #include <linux/iio/iio.h>
23 #include <linux/iio/sysfs.h>
24 #include <linux/init.h>
25 #include <linux/iopoll.h>
26 #include <linux/module.h>
27 #include <linux/mutex.h>
28 #include <linux/pm.h>
29 #include <linux/regmap.h>
30 #include <linux/time.h>
31 #include <linux/types.h>
32 #include <linux/unaligned.h>
33
34 #define MMC5633_REG_XOUT0 0x00
35 #define MMC5633_REG_XOUT1 0x01
36 #define MMC5633_REG_YOUT0 0x02
37 #define MMC5633_REG_YOUT1 0x03
38 #define MMC5633_REG_ZOUT0 0x04
39 #define MMC5633_REG_ZOUT1 0x05
40 #define MMC5633_REG_XOUT2 0x06
41 #define MMC5633_REG_YOUT2 0x07
42 #define MMC5633_REG_ZOUT2 0x08
43 #define MMC5633_REG_TOUT 0x09
44
45 #define MMC5633_REG_STATUS1 0x18
46 #define MMC5633_REG_STATUS0 0x19
47 #define MMC5633_REG_CTRL0 0x1b
48 #define MMC5633_REG_CTRL1 0x1c
49 #define MMC5633_REG_CTRL2 0x1d
50
51 #define MMC5633_REG_ID 0x39
52
53 #define MMC5633_STATUS1_MEAS_T_DONE_BIT BIT(7)
54 #define MMC5633_STATUS1_MEAS_M_DONE_BIT BIT(6)
55
56 #define MMC5633_CTRL0_CMM_FREQ_EN BIT(7)
57 #define MMC5633_CTRL0_AUTO_ST_EN BIT(6)
58 #define MMC5633_CTRL0_AUTO_SR_EN BIT(5)
59 #define MMC5633_CTRL0_RESET BIT(4)
60 #define MMC5633_CTRL0_SET BIT(3)
61 #define MMC5633_CTRL0_MEAS_T BIT(1)
62 #define MMC5633_CTRL0_MEAS_M BIT(0)
63
64 #define MMC5633_CTRL1_BW_MASK GENMASK(1, 0)
65
66 #define MMC5633_WAIT_SET_RESET_US (1 * USEC_PER_MSEC)
67
68 #define MMC5633_HDR_CTRL0_MEAS_M 0x01
69 #define MMC5633_HDR_CTRL0_MEAS_T 0x03
70 #define MMC5633_HDR_CTRL0_SET 0x05
71 #define MMC5633_HDR_CTRL0_RESET 0x07
72
73 enum mmc5633_axis {
74 MMC5633_AXIS_X,
75 MMC5633_AXIS_Y,
76 MMC5633_AXIS_Z,
77 MMC5633_TEMPERATURE,
78 };
79
80 struct mmc5633_data {
81 struct regmap *regmap;
82 struct i3c_device *i3cdev;
83 struct mutex mutex; /* protect to finish one whole measurement */
84 };
85
86 static int mmc5633_samp_freq[][2] = {
87 { 1, 200000 },
88 { 2, 0 },
89 { 3, 500000 },
90 { 6, 600000 },
91 };
92
93 #define MMC5633_CHANNEL(_axis) { \
94 .type = IIO_MAGN, \
95 .modified = 1, \
96 .channel2 = IIO_MOD_ ## _axis, \
97 .address = MMC5633_AXIS_ ## _axis, \
98 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
99 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SAMP_FREQ) | \
100 BIT(IIO_CHAN_INFO_SCALE), \
101 }
102
103 static const struct iio_chan_spec mmc5633_channels[] = {
104 MMC5633_CHANNEL(X),
105 MMC5633_CHANNEL(Y),
106 MMC5633_CHANNEL(Z),
107 {
108 .type = IIO_TEMP,
109 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) |
110 BIT(IIO_CHAN_INFO_SCALE) |
111 BIT(IIO_CHAN_INFO_OFFSET),
112 .address = MMC5633_TEMPERATURE,
113 },
114 };
115
mmc5633_get_samp_freq_index(struct mmc5633_data * data,int val,int val2)116 static int mmc5633_get_samp_freq_index(struct mmc5633_data *data,
117 int val, int val2)
118 {
119 unsigned int i;
120
121 for (i = 0; i < ARRAY_SIZE(mmc5633_samp_freq); i++)
122 if (mmc5633_samp_freq[i][0] == val &&
123 mmc5633_samp_freq[i][1] == val2)
124 return i;
125 return -EINVAL;
126 }
127
mmc5633_init(struct mmc5633_data * data)128 static int mmc5633_init(struct mmc5633_data *data)
129 {
130 unsigned int reg_id;
131 int ret;
132
133 ret = regmap_read(data->regmap, MMC5633_REG_ID, ®_id);
134 if (ret)
135 return dev_err_probe(regmap_get_device(data->regmap), ret,
136 "Error reading product id\n");
137
138 /*
139 * Make sure we restore sensor characteristics, by doing
140 * a SET/RESET sequence, the axis polarity being naturally
141 * aligned after RESET.
142 */
143 ret = regmap_write(data->regmap, MMC5633_REG_CTRL0, MMC5633_CTRL0_SET);
144 if (ret)
145 return ret;
146
147 /*
148 * Minimum time interval between SET or RESET to other operations is
149 * 1ms according to Operating Timing Diagram in datasheet.
150 */
151 fsleep(MMC5633_WAIT_SET_RESET_US);
152
153 ret = regmap_write(data->regmap, MMC5633_REG_CTRL0, MMC5633_CTRL0_RESET);
154 if (ret)
155 return ret;
156
157 /* set default sampling frequency */
158 return regmap_update_bits(data->regmap, MMC5633_REG_CTRL1,
159 MMC5633_CTRL1_BW_MASK,
160 FIELD_PREP(MMC5633_CTRL1_BW_MASK, 0));
161 }
162
mmc5633_take_measurement(struct mmc5633_data * data,int address)163 static int mmc5633_take_measurement(struct mmc5633_data *data, int address)
164 {
165 unsigned int reg_status, val;
166 int ret;
167
168 val = (address == MMC5633_TEMPERATURE) ? MMC5633_CTRL0_MEAS_T : MMC5633_CTRL0_MEAS_M;
169 ret = regmap_write(data->regmap, MMC5633_REG_CTRL0, val);
170 if (ret < 0)
171 return ret;
172
173 val = (address == MMC5633_TEMPERATURE) ?
174 MMC5633_STATUS1_MEAS_T_DONE_BIT : MMC5633_STATUS1_MEAS_M_DONE_BIT;
175 ret = regmap_read_poll_timeout(data->regmap, MMC5633_REG_STATUS1, reg_status,
176 reg_status & val,
177 10 * USEC_PER_MSEC,
178 100 * 10 * USEC_PER_MSEC);
179 if (ret) {
180 dev_err(regmap_get_device(data->regmap), "data not ready\n");
181 return ret;
182 }
183
184 return 0;
185 }
186
mmc5633_is_support_hdr(struct mmc5633_data * data)187 static bool mmc5633_is_support_hdr(struct mmc5633_data *data)
188 {
189 if (!data->i3cdev)
190 return false;
191
192 return i3c_device_get_supported_xfer_mode(data->i3cdev) & BIT(I3C_HDR_DDR);
193 }
194
mmc5633_read_measurement(struct mmc5633_data * data,int address,void * buf,size_t sz)195 static int mmc5633_read_measurement(struct mmc5633_data *data, int address, void *buf, size_t sz)
196 {
197 struct device *dev = regmap_get_device(data->regmap);
198 u8 data_cmd[2], status[2];
199 unsigned int val, ready;
200 int ret;
201
202 if (mmc5633_is_support_hdr(data)) {
203 struct i3c_xfer xfers_wr_cmd[] = {
204 {
205 .cmd = 0x3b,
206 .len = 2,
207 .data.out = data_cmd,
208 }
209 };
210 struct i3c_xfer xfers_rd_sta_cmd[] = {
211 {
212 .cmd = 0x23 | BIT(7), /* RDSTA CMD */
213 .len = 2,
214 .data.in = status,
215 },
216 };
217 struct i3c_xfer xfers_rd_data_cmd[] = {
218 {
219 .cmd = 0x22 | BIT(7), /* RDLONG CMD */
220 .len = sz,
221 .data.in = buf,
222 },
223 };
224
225 data_cmd[0] = 0;
226 data_cmd[1] = (address == MMC5633_TEMPERATURE) ?
227 MMC5633_HDR_CTRL0_MEAS_T : MMC5633_HDR_CTRL0_MEAS_M;
228
229 ret = i3c_device_do_xfers(data->i3cdev, xfers_wr_cmd,
230 ARRAY_SIZE(xfers_wr_cmd), I3C_HDR_DDR);
231 if (ret < 0)
232 return ret;
233
234 ready = (address == MMC5633_TEMPERATURE) ?
235 MMC5633_STATUS1_MEAS_T_DONE_BIT : MMC5633_STATUS1_MEAS_M_DONE_BIT;
236 ret = read_poll_timeout(i3c_device_do_xfers, val,
237 val || (status[0] & ready),
238 10 * USEC_PER_MSEC,
239 100 * 10 * USEC_PER_MSEC, 0,
240 data->i3cdev, xfers_rd_sta_cmd,
241 ARRAY_SIZE(xfers_rd_sta_cmd), I3C_HDR_DDR);
242 if (ret) {
243 dev_err(dev, "data not ready\n");
244 return ret;
245 }
246 if (val) {
247 dev_err(dev, "i3c transfer error\n");
248 return val;
249 }
250 return i3c_device_do_xfers(data->i3cdev, xfers_rd_data_cmd,
251 ARRAY_SIZE(xfers_rd_data_cmd), I3C_HDR_DDR);
252 }
253
254 /* Fallback to use SDR/I2C mode */
255 ret = mmc5633_take_measurement(data, address);
256 if (ret < 0)
257 return ret;
258
259 if (address == MMC5633_TEMPERATURE)
260 /*
261 * Put tempeature to last byte of buff to align HDR case.
262 * I3C will early terminate data read if previous data is not
263 * available.
264 */
265 return regmap_bulk_read(data->regmap, MMC5633_REG_TOUT, buf + sz - 1, 1);
266
267 return regmap_bulk_read(data->regmap, MMC5633_REG_XOUT0, buf, sz);
268 }
269
270 /* X,Y,Z 3 channels, each channel has 3 byte and TEMP */
271 #define MMC5633_ALL_SIZE (3 * 3 + 1)
272
mmc5633_get_raw(struct mmc5633_data * data,int index,unsigned char * buf,int * val)273 static int mmc5633_get_raw(struct mmc5633_data *data, int index, unsigned char *buf, int *val)
274 {
275 if (index == MMC5633_TEMPERATURE) {
276 *val = buf[MMC5633_ALL_SIZE - 1];
277 return 0;
278 }
279 /*
280 * X[19..12] X[11..4] Y[19..12] Y[11..4] Z[19..12] Z[11..4] X[3..0] Y[3..0] Z[3..0]
281 */
282 *val = get_unaligned_be16(buf + 2 * index) << 4;
283 *val |= buf[index + 6] >> 4;
284
285 return 0;
286 }
287
mmc5633_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)288 static int mmc5633_read_raw(struct iio_dev *indio_dev,
289 struct iio_chan_spec const *chan, int *val,
290 int *val2, long mask)
291 {
292 struct mmc5633_data *data = iio_priv(indio_dev);
293 char buf[MMC5633_ALL_SIZE];
294 unsigned int reg, i;
295 int ret;
296
297 switch (mask) {
298 case IIO_CHAN_INFO_RAW:
299 scoped_guard(mutex, &data->mutex) {
300 ret = mmc5633_read_measurement(data, chan->address, buf, MMC5633_ALL_SIZE);
301 if (ret < 0)
302 return ret;
303 }
304
305 ret = mmc5633_get_raw(data, chan->address, buf, val);
306 if (ret < 0)
307 return ret;
308 return IIO_VAL_INT;
309 case IIO_CHAN_INFO_SCALE:
310 if (chan->type == IIO_MAGN) {
311 *val = 0;
312 *val2 = 62500;
313 } else {
314 *val = 0;
315 *val2 = 800000000; /* 0.8C */
316 }
317 return IIO_VAL_INT_PLUS_NANO;
318 case IIO_CHAN_INFO_OFFSET:
319 if (chan->type == IIO_TEMP) {
320 *val = -75;
321 return IIO_VAL_INT;
322 }
323 return -EINVAL;
324 case IIO_CHAN_INFO_SAMP_FREQ:
325 scoped_guard(mutex, &data->mutex) {
326 ret = regmap_read(data->regmap, MMC5633_REG_CTRL1, ®);
327 if (ret < 0)
328 return ret;
329 }
330
331 i = FIELD_GET(MMC5633_CTRL1_BW_MASK, reg);
332 if (i >= ARRAY_SIZE(mmc5633_samp_freq))
333 return -EINVAL;
334
335 *val = mmc5633_samp_freq[i][0];
336 *val2 = mmc5633_samp_freq[i][1];
337 return IIO_VAL_INT_PLUS_MICRO;
338 default:
339 return -EINVAL;
340 }
341 }
342
mmc5633_write_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int val,int val2,long mask)343 static int mmc5633_write_raw(struct iio_dev *indio_dev,
344 struct iio_chan_spec const *chan, int val,
345 int val2, long mask)
346 {
347 struct mmc5633_data *data = iio_priv(indio_dev);
348 int ret;
349
350 switch (mask) {
351 case IIO_CHAN_INFO_SAMP_FREQ: {
352 ret = mmc5633_get_samp_freq_index(data, val, val2);
353 if (ret < 0)
354 return ret;
355
356 guard(mutex)(&data->mutex);
357
358 return regmap_update_bits(data->regmap, MMC5633_REG_CTRL1,
359 MMC5633_CTRL1_BW_MASK,
360 FIELD_PREP(MMC5633_CTRL1_BW_MASK, ret));
361 }
362 default:
363 return -EINVAL;
364 }
365 }
366
mmc5633_read_avail(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,const int ** vals,int * type,int * length,long mask)367 static int mmc5633_read_avail(struct iio_dev *indio_dev,
368 struct iio_chan_spec const *chan,
369 const int **vals, int *type, int *length,
370 long mask)
371 {
372 switch (mask) {
373 case IIO_CHAN_INFO_SAMP_FREQ:
374 *vals = (const int *)mmc5633_samp_freq;
375 *length = ARRAY_SIZE(mmc5633_samp_freq) * 2;
376 *type = IIO_VAL_INT_PLUS_MICRO;
377 return IIO_AVAIL_LIST;
378 default:
379 return -EINVAL;
380 }
381 }
382
383 static const struct iio_info mmc5633_info = {
384 .read_raw = mmc5633_read_raw,
385 .write_raw = mmc5633_write_raw,
386 .read_avail = mmc5633_read_avail,
387 };
388
mmc5633_is_writeable_reg(struct device * dev,unsigned int reg)389 static bool mmc5633_is_writeable_reg(struct device *dev, unsigned int reg)
390 {
391 switch (reg) {
392 case MMC5633_REG_CTRL0:
393 case MMC5633_REG_CTRL1:
394 return true;
395 default:
396 return false;
397 }
398 }
399
mmc5633_is_readable_reg(struct device * dev,unsigned int reg)400 static bool mmc5633_is_readable_reg(struct device *dev, unsigned int reg)
401 {
402 switch (reg) {
403 case MMC5633_REG_XOUT0:
404 case MMC5633_REG_XOUT1:
405 case MMC5633_REG_YOUT0:
406 case MMC5633_REG_YOUT1:
407 case MMC5633_REG_ZOUT0:
408 case MMC5633_REG_ZOUT1:
409 case MMC5633_REG_XOUT2:
410 case MMC5633_REG_YOUT2:
411 case MMC5633_REG_ZOUT2:
412 case MMC5633_REG_TOUT:
413 case MMC5633_REG_STATUS1:
414 case MMC5633_REG_ID:
415 return true;
416 default:
417 return false;
418 }
419 }
420
mmc5633_is_volatile_reg(struct device * dev,unsigned int reg)421 static bool mmc5633_is_volatile_reg(struct device *dev, unsigned int reg)
422 {
423 switch (reg) {
424 case MMC5633_REG_CTRL0:
425 case MMC5633_REG_CTRL1:
426 return false;
427 default:
428 return true;
429 }
430 }
431
432 static const struct reg_default mmc5633_reg_defaults[] = {
433 { MMC5633_REG_CTRL0, 0x00 },
434 { MMC5633_REG_CTRL1, 0x00 },
435 };
436
437 static const struct regmap_config mmc5633_regmap_config = {
438 .name = "mmc5633_regmap",
439
440 .reg_bits = 8,
441 .val_bits = 8,
442
443 .max_register = MMC5633_REG_ID,
444 .cache_type = REGCACHE_MAPLE,
445
446 .writeable_reg = mmc5633_is_writeable_reg,
447 .readable_reg = mmc5633_is_readable_reg,
448 .volatile_reg = mmc5633_is_volatile_reg,
449
450 .reg_defaults = mmc5633_reg_defaults,
451 .num_reg_defaults = ARRAY_SIZE(mmc5633_reg_defaults),
452 };
453
mmc5633_common_probe(struct regmap * regmap,char * name,struct i3c_device * i3cdev)454 static int mmc5633_common_probe(struct regmap *regmap, char *name,
455 struct i3c_device *i3cdev)
456 {
457 struct device *dev = regmap_get_device(regmap);
458 struct mmc5633_data *data;
459 struct iio_dev *indio_dev;
460 int ret;
461
462 indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
463 if (!indio_dev)
464 return -ENOMEM;
465
466 data = iio_priv(indio_dev);
467
468 data->regmap = regmap;
469 data->i3cdev = i3cdev;
470
471 ret = devm_mutex_init(dev, &data->mutex);
472 if (ret)
473 return ret;
474
475 indio_dev->info = &mmc5633_info;
476 indio_dev->name = name;
477 indio_dev->channels = mmc5633_channels;
478 indio_dev->num_channels = ARRAY_SIZE(mmc5633_channels);
479 indio_dev->modes = INDIO_DIRECT_MODE;
480
481 ret = mmc5633_init(data);
482 if (ret < 0)
483 return dev_err_probe(dev, ret, "mmc5633 chip init failed\n");
484
485 return devm_iio_device_register(dev, indio_dev);
486 }
487
mmc5633_suspend(struct device * dev)488 static int mmc5633_suspend(struct device *dev)
489 {
490 struct regmap *regmap = dev_get_regmap(dev, NULL);
491
492 regcache_cache_only(regmap, true);
493
494 return 0;
495 }
496
mmc5633_resume(struct device * dev)497 static int mmc5633_resume(struct device *dev)
498 {
499 struct regmap *regmap = dev_get_regmap(dev, NULL);
500 int ret;
501
502 regcache_mark_dirty(regmap);
503 ret = regcache_sync_region(regmap, MMC5633_REG_CTRL0, MMC5633_REG_CTRL1);
504 if (ret)
505 dev_err(dev, "Failed to restore control registers\n");
506
507 regcache_cache_only(regmap, false);
508
509 return 0;
510 }
511
mmc5633_i2c_probe(struct i2c_client * client)512 static int mmc5633_i2c_probe(struct i2c_client *client)
513 {
514 struct device *dev = &client->dev;
515 struct regmap *regmap;
516
517 regmap = devm_regmap_init_i2c(client, &mmc5633_regmap_config);
518 if (IS_ERR(regmap))
519 return dev_err_probe(dev, PTR_ERR(regmap), "regmap init failed\n");
520
521 return mmc5633_common_probe(regmap, client->name, NULL);
522 }
523
524 static DEFINE_SIMPLE_DEV_PM_OPS(mmc5633_pm_ops, mmc5633_suspend, mmc5633_resume);
525
526 static const struct of_device_id mmc5633_of_match[] = {
527 { .compatible = "memsic,mmc5603" },
528 { .compatible = "memsic,mmc5633" },
529 { }
530 };
531 MODULE_DEVICE_TABLE(of, mmc5633_of_match);
532
533 static const struct i2c_device_id mmc5633_i2c_id[] = {
534 { .name = "mmc5603" },
535 { .name = "mmc5633" },
536 { }
537 };
538 MODULE_DEVICE_TABLE(i2c, mmc5633_i2c_id);
539
540 static struct i2c_driver mmc5633_i2c_driver = {
541 .driver = {
542 .name = "mmc5633_i2c",
543 .of_match_table = mmc5633_of_match,
544 .pm = pm_sleep_ptr(&mmc5633_pm_ops),
545 },
546 .probe = mmc5633_i2c_probe,
547 .id_table = mmc5633_i2c_id,
548 };
549
550 static const struct i3c_device_id mmc5633_i3c_ids[] = {
551 I3C_DEVICE(0x0251, 0x0000, NULL),
552 { }
553 };
554 MODULE_DEVICE_TABLE(i3c, mmc5633_i3c_ids);
555
mmc5633_i3c_probe(struct i3c_device * i3cdev)556 static int mmc5633_i3c_probe(struct i3c_device *i3cdev)
557 {
558 struct device *dev = i3cdev_to_dev(i3cdev);
559 struct regmap *regmap;
560 char *name;
561
562 name = devm_kasprintf(dev, GFP_KERNEL, "mmc5633_%s", dev_name(dev));
563 if (!name)
564 return -ENOMEM;
565
566 regmap = devm_regmap_init_i3c(i3cdev, &mmc5633_regmap_config);
567 if (IS_ERR(regmap))
568 return dev_err_probe(dev, PTR_ERR(regmap),
569 "Failed to register i3c regmap\n");
570
571 return mmc5633_common_probe(regmap, name, i3cdev);
572 }
573
574 static struct i3c_driver mmc5633_i3c_driver = {
575 .driver = {
576 .name = "mmc5633_i3c",
577 },
578 .probe = mmc5633_i3c_probe,
579 .id_table = mmc5633_i3c_ids,
580 };
581 module_i3c_i2c_driver(mmc5633_i3c_driver, &mmc5633_i2c_driver)
582
583 MODULE_AUTHOR("Frank Li <Frank.li@nxp.com>");
584 MODULE_DESCRIPTION("MEMSIC MMC5633 magnetic sensor driver");
585 MODULE_LICENSE("GPL");
586