// SPDX-License-Identifier: GPL-2.0-only /* * af8133j.c - Voltafield AF8133J magnetometer driver * * Copyright 2021 Icenowy Zheng * Copyright 2024 Ondřej Jirman */ #include #include #include #include #include #include #include #include #include #include #define AF8133J_REG_OUT 0x03 #define AF8133J_REG_PCODE 0x00 #define AF8133J_REG_PCODE_VAL 0x5e #define AF8133J_REG_STATUS 0x02 #define AF8133J_REG_STATUS_ACQ BIT(0) #define AF8133J_REG_STATE 0x0a #define AF8133J_REG_STATE_STBY 0x00 #define AF8133J_REG_STATE_WORK 0x01 #define AF8133J_REG_RANGE 0x0b #define AF8133J_REG_RANGE_22G 0x12 #define AF8133J_REG_RANGE_12G 0x34 #define AF8133J_REG_SWR 0x11 #define AF8133J_REG_SWR_PERFORM 0x81 static const char * const af8133j_supply_names[] = { "avdd", "dvdd", }; struct af8133j_data { struct i2c_client *client; struct regmap *regmap; /* * Protect device internal state between starting a measurement * and reading the result. */ struct mutex mutex; struct iio_mount_matrix orientation; struct gpio_desc *reset_gpiod; struct regulator_bulk_data supplies[ARRAY_SIZE(af8133j_supply_names)]; u8 range; }; enum af8133j_axis { AXIS_X = 0, AXIS_Y, AXIS_Z, }; static struct iio_mount_matrix * af8133j_get_mount_matrix(struct iio_dev *indio_dev, const struct iio_chan_spec *chan) { struct af8133j_data *data = iio_priv(indio_dev); return &data->orientation; } static const struct iio_chan_spec_ext_info af8133j_ext_info[] = { IIO_MOUNT_MATRIX(IIO_SHARED_BY_DIR, af8133j_get_mount_matrix), { } }; #define AF8133J_CHANNEL(_si, _axis) { \ .type = IIO_MAGN, \ .modified = 1, \ .channel2 = IIO_MOD_ ## _axis, \ .address = AXIS_ ## _axis, \ .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \ .info_mask_shared_by_type_available = BIT(IIO_CHAN_INFO_SCALE), \ .ext_info = af8133j_ext_info, \ .scan_index = _si, \ .scan_type = { \ .sign = 's', \ .realbits = 16, \ .storagebits = 16, \ .endianness = IIO_LE, \ }, \ } static const struct iio_chan_spec af8133j_channels[] = { AF8133J_CHANNEL(0, X), AF8133J_CHANNEL(1, Y), AF8133J_CHANNEL(2, Z), IIO_CHAN_SOFT_TIMESTAMP(3), }; static int af8133j_product_check(struct af8133j_data *data) { struct device *dev = &data->client->dev; unsigned int val; int ret; ret = regmap_read(data->regmap, AF8133J_REG_PCODE, &val); if (ret) { dev_err(dev, "Error reading product code (%d)\n", ret); return ret; } if (val != AF8133J_REG_PCODE_VAL) { dev_warn(dev, "Invalid product code (0x%02x)\n", val); return 0; /* Allow unknown ID so fallback compatibles work */ } return 0; } static int af8133j_reset(struct af8133j_data *data) { struct device *dev = &data->client->dev; int ret; if (data->reset_gpiod) { /* If we have GPIO reset line, use it */ gpiod_set_value_cansleep(data->reset_gpiod, 1); udelay(10); gpiod_set_value_cansleep(data->reset_gpiod, 0); } else { /* Otherwise use software reset */ ret = regmap_write(data->regmap, AF8133J_REG_SWR, AF8133J_REG_SWR_PERFORM); if (ret) { dev_err(dev, "Failed to reset the chip\n"); return ret; } } /* Wait for reset to finish */ usleep_range(1000, 1100); /* Restore range setting */ if (data->range == AF8133J_REG_RANGE_22G) { ret = regmap_write(data->regmap, AF8133J_REG_RANGE, data->range); if (ret) return ret; } return 0; } static void af8133j_power_down(struct af8133j_data *data) { gpiod_set_value_cansleep(data->reset_gpiod, 1); regulator_bulk_disable(ARRAY_SIZE(data->supplies), data->supplies); } static int af8133j_power_up(struct af8133j_data *data) { struct device *dev = &data->client->dev; int ret; ret = regulator_bulk_enable(ARRAY_SIZE(data->supplies), data->supplies); if (ret) { dev_err(dev, "Could not enable regulators\n"); return ret; } gpiod_set_value_cansleep(data->reset_gpiod, 0); /* Wait for power on reset */ usleep_range(15000, 16000); ret = af8133j_reset(data); if (ret) { af8133j_power_down(data); return ret; } return 0; } static int af8133j_take_measurement(struct af8133j_data *data) { unsigned int val; int ret; ret = regmap_write(data->regmap, AF8133J_REG_STATE, AF8133J_REG_STATE_WORK); if (ret) return ret; /* The datasheet says "Mesaure Time <1.5ms" */ ret = regmap_read_poll_timeout(data->regmap, AF8133J_REG_STATUS, val, val & AF8133J_REG_STATUS_ACQ, 500, 1500); if (ret) return ret; ret = regmap_write(data->regmap, AF8133J_REG_STATE, AF8133J_REG_STATE_STBY); if (ret) return ret; return 0; } static int af8133j_read_measurement(struct af8133j_data *data, __le16 buf[3]) { struct device *dev = &data->client->dev; int ret; ret = pm_runtime_resume_and_get(dev); if (ret) { /* * Ignore EACCES because that happens when RPM is disabled * during system sleep, while userspace leave eg. hrtimer * trigger attached and IIO core keeps trying to do measurements. */ if (ret != -EACCES) dev_err(dev, "Failed to power on (%d)\n", ret); return ret; } scoped_guard(mutex, &data->mutex) { ret = af8133j_take_measurement(data); if (ret) goto out_rpm_put; ret = regmap_bulk_read(data->regmap, AF8133J_REG_OUT, buf, sizeof(__le16) * 3); } out_rpm_put: pm_runtime_mark_last_busy(dev); pm_runtime_put_autosuspend(dev); return ret; } static const int af8133j_scales[][2] = { [0] = { 0, 366210 }, /* 12 gauss */ [1] = { 0, 671386 }, /* 22 gauss */ }; static int af8133j_read_raw(struct iio_dev *indio_dev, struct iio_chan_spec const *chan, int *val, int *val2, long mask) { struct af8133j_data *data = iio_priv(indio_dev); __le16 buf[3]; int ret; switch (mask) { case IIO_CHAN_INFO_RAW: ret = af8133j_read_measurement(data, buf); if (ret) return ret; *val = sign_extend32(le16_to_cpu(buf[chan->address]), chan->scan_type.realbits - 1); return IIO_VAL_INT; case IIO_CHAN_INFO_SCALE: *val = 0; if (data->range == AF8133J_REG_RANGE_12G) *val2 = af8133j_scales[0][1]; else *val2 = af8133j_scales[1][1]; return IIO_VAL_INT_PLUS_NANO; default: return -EINVAL; } } static int af8133j_read_avail(struct iio_dev *indio_dev, struct iio_chan_spec const *chan, const int **vals, int *type, int *length, long mask) { switch (mask) { case IIO_CHAN_INFO_SCALE: *vals = (const int *)af8133j_scales; *length = ARRAY_SIZE(af8133j_scales) * 2; *type = IIO_VAL_INT_PLUS_NANO; return IIO_AVAIL_LIST; default: return -EINVAL; } } static int af8133j_set_scale(struct af8133j_data *data, unsigned int val, unsigned int val2) { struct device *dev = &data->client->dev; u8 range; int ret = 0; if (af8133j_scales[0][0] == val && af8133j_scales[0][1] == val2) range = AF8133J_REG_RANGE_12G; else if (af8133j_scales[1][0] == val && af8133j_scales[1][1] == val2) range = AF8133J_REG_RANGE_22G; else return -EINVAL; pm_runtime_disable(dev); /* * When suspended, just store the new range to data->range to be * applied later during power up. */ if (!pm_runtime_status_suspended(dev)) scoped_guard(mutex, &data->mutex) ret = regmap_write(data->regmap, AF8133J_REG_RANGE, range); pm_runtime_enable(dev); data->range = range; return ret; } static int af8133j_write_raw(struct iio_dev *indio_dev, struct iio_chan_spec const *chan, int val, int val2, long mask) { struct af8133j_data *data = iio_priv(indio_dev); switch (mask) { case IIO_CHAN_INFO_SCALE: return af8133j_set_scale(data, val, val2); default: return -EINVAL; } } static int af8133j_write_raw_get_fmt(struct iio_dev *indio_dev, struct iio_chan_spec const *chan, long mask) { return IIO_VAL_INT_PLUS_NANO; } static const struct iio_info af8133j_info = { .read_raw = af8133j_read_raw, .read_avail = af8133j_read_avail, .write_raw = af8133j_write_raw, .write_raw_get_fmt = af8133j_write_raw_get_fmt, }; static irqreturn_t af8133j_trigger_handler(int irq, void *p) { struct iio_poll_func *pf = p; struct iio_dev *indio_dev = pf->indio_dev; struct af8133j_data *data = iio_priv(indio_dev); s64 timestamp = iio_get_time_ns(indio_dev); struct { __le16 values[3]; s64 timestamp __aligned(8); } sample; int ret; memset(&sample, 0, sizeof(sample)); ret = af8133j_read_measurement(data, sample.values); if (ret) goto out_done; iio_push_to_buffers_with_timestamp(indio_dev, &sample, timestamp); out_done: iio_trigger_notify_done(indio_dev->trig); return IRQ_HANDLED; } static const struct regmap_config af8133j_regmap_config = { .name = "af8133j_regmap", .reg_bits = 8, .val_bits = 8, .max_register = AF8133J_REG_SWR, .cache_type = REGCACHE_NONE, }; static void af8133j_power_down_action(void *ptr) { struct af8133j_data *data = ptr; if (!pm_runtime_status_suspended(&data->client->dev)) af8133j_power_down(data); } static int af8133j_probe(struct i2c_client *client) { struct device *dev = &client->dev; struct af8133j_data *data; struct iio_dev *indio_dev; struct regmap *regmap; int ret, i; indio_dev = devm_iio_device_alloc(dev, sizeof(*data)); if (!indio_dev) return -ENOMEM; regmap = devm_regmap_init_i2c(client, &af8133j_regmap_config); if (IS_ERR(regmap)) return dev_err_probe(dev, PTR_ERR(regmap), "regmap initialization failed\n"); data = iio_priv(indio_dev); i2c_set_clientdata(client, indio_dev); data->client = client; data->regmap = regmap; data->range = AF8133J_REG_RANGE_12G; mutex_init(&data->mutex); data->reset_gpiod = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH); if (IS_ERR(data->reset_gpiod)) return dev_err_probe(dev, PTR_ERR(data->reset_gpiod), "Failed to get reset gpio\n"); for (i = 0; i < ARRAY_SIZE(af8133j_supply_names); i++) data->supplies[i].supply = af8133j_supply_names[i]; ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(data->supplies), data->supplies); if (ret) return ret; ret = iio_read_mount_matrix(dev, &data->orientation); if (ret) return dev_err_probe(dev, ret, "Failed to read mount matrix\n"); ret = af8133j_power_up(data); if (ret) return ret; pm_runtime_set_active(dev); ret = devm_add_action_or_reset(dev, af8133j_power_down_action, data); if (ret) return ret; ret = af8133j_product_check(data); if (ret) return ret; pm_runtime_get_noresume(dev); pm_runtime_use_autosuspend(dev); pm_runtime_set_autosuspend_delay(dev, 500); ret = devm_pm_runtime_enable(dev); if (ret) return ret; pm_runtime_put_autosuspend(dev); indio_dev->info = &af8133j_info; indio_dev->name = "af8133j"; indio_dev->channels = af8133j_channels; indio_dev->num_channels = ARRAY_SIZE(af8133j_channels); indio_dev->modes = INDIO_DIRECT_MODE; ret = devm_iio_triggered_buffer_setup(dev, indio_dev, NULL, &af8133j_trigger_handler, NULL); if (ret) return dev_err_probe(&client->dev, ret, "Failed to setup iio triggered buffer\n"); ret = devm_iio_device_register(dev, indio_dev); if (ret) return dev_err_probe(dev, ret, "Failed to register iio device"); return 0; } static int af8133j_runtime_suspend(struct device *dev) { struct iio_dev *indio_dev = dev_get_drvdata(dev); struct af8133j_data *data = iio_priv(indio_dev); af8133j_power_down(data); return 0; } static int af8133j_runtime_resume(struct device *dev) { struct iio_dev *indio_dev = dev_get_drvdata(dev); struct af8133j_data *data = iio_priv(indio_dev); return af8133j_power_up(data); } static const struct dev_pm_ops af8133j_pm_ops = { SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend, pm_runtime_force_resume) RUNTIME_PM_OPS(af8133j_runtime_suspend, af8133j_runtime_resume, NULL) }; static const struct of_device_id af8133j_of_match[] = { { .compatible = "voltafield,af8133j", }, { } }; MODULE_DEVICE_TABLE(of, af8133j_of_match); static const struct i2c_device_id af8133j_id[] = { { "af8133j", 0 }, { } }; MODULE_DEVICE_TABLE(i2c, af8133j_id); static struct i2c_driver af8133j_driver = { .driver = { .name = "af8133j", .of_match_table = af8133j_of_match, .pm = pm_ptr(&af8133j_pm_ops), }, .probe = af8133j_probe, .id_table = af8133j_id, }; module_i2c_driver(af8133j_driver); MODULE_AUTHOR("Icenowy Zheng "); MODULE_AUTHOR("Ondřej Jirman "); MODULE_DESCRIPTION("Voltafield AF8133J magnetic sensor driver"); MODULE_LICENSE("GPL");