| // SPDX-License-Identifier: GPL-2.0 | |
| /* | |
| * Silicon Labs Si7210 Hall Effect sensor driver | |
| * | |
| * Copyright (c) 2024 Antoni Pokusinski <apokusinski01@gmail.com> | |
| * | |
| * Datasheet: | |
| * https://www.silabs.com/documents/public/data-sheets/si7210-datasheet.pdf | |
| */ | |
| #include <linux/array_size.h> | |
| #include <linux/bitfield.h> | |
| #include <linux/bits.h> | |
| #include <linux/cleanup.h> | |
| #include <linux/err.h> | |
| #include <linux/i2c.h> | |
| #include <linux/iio/iio.h> | |
| #include <linux/math64.h> | |
| #include <linux/mutex.h> | |
| #include <linux/regmap.h> | |
| #include <linux/regulator/consumer.h> | |
| #include <linux/types.h> | |
| #include <linux/units.h> | |
| #include <asm/byteorder.h> | |
| /* Registers offsets and masks */ | |
| #define SI7210_REG_DSPSIGM 0xC1 | |
| #define SI7210_REG_DSPSIGL 0xC2 | |
| #define SI7210_MASK_DSPSIGSEL GENMASK(2, 0) | |
| #define SI7210_REG_DSPSIGSEL 0xC3 | |
| #define SI7210_MASK_STOP BIT(1) | |
| #define SI7210_MASK_ONEBURST BIT(2) | |
| #define SI7210_REG_POWER_CTRL 0xC4 | |
| #define SI7210_MASK_ARAUTOINC BIT(0) | |
| #define SI7210_REG_ARAUTOINC 0xC5 | |
| #define SI7210_REG_A0 0xCA | |
| #define SI7210_REG_A1 0xCB | |
| #define SI7210_REG_A2 0xCC | |
| #define SI7210_REG_A3 0xCE | |
| #define SI7210_REG_A4 0xCF | |
| #define SI7210_REG_A5 0xD0 | |
| #define SI7210_REG_OTP_ADDR 0xE1 | |
| #define SI7210_REG_OTP_DATA 0xE2 | |
| #define SI7210_MASK_OTP_READ_EN BIT(1) | |
| #define SI7210_REG_OTP_CTRL 0xE3 | |
| /* OTP data registers offsets */ | |
| #define SI7210_OTPREG_TMP_OFF 0x1D | |
| #define SI7210_OTPREG_TMP_GAIN 0x1E | |
| #define SI7210_OTPREG_A0_20 0x21 | |
| #define SI7210_OTPREG_A1_20 0x22 | |
| #define SI7210_OTPREG_A2_20 0x23 | |
| #define SI7210_OTPREG_A3_20 0x24 | |
| #define SI7210_OTPREG_A4_20 0x25 | |
| #define SI7210_OTPREG_A5_20 0x26 | |
| #define SI7210_OTPREG_A0_200 0x27 | |
| #define SI7210_OTPREG_A1_200 0x28 | |
| #define SI7210_OTPREG_A2_200 0x29 | |
| #define SI7210_OTPREG_A3_200 0x2A | |
| #define SI7210_OTPREG_A4_200 0x2B | |
| #define SI7210_OTPREG_A5_200 0x2C | |
| #define A_REGS_COUNT 6 | |
| static const unsigned int a20_otp_regs[A_REGS_COUNT] = { | |
| SI7210_OTPREG_A0_20, SI7210_OTPREG_A1_20, SI7210_OTPREG_A2_20, | |
| SI7210_OTPREG_A3_20, SI7210_OTPREG_A4_20, SI7210_OTPREG_A5_20, | |
| }; | |
| static const unsigned int a200_otp_regs[A_REGS_COUNT] = { | |
| SI7210_OTPREG_A0_200, SI7210_OTPREG_A1_200, SI7210_OTPREG_A2_200, | |
| SI7210_OTPREG_A3_200, SI7210_OTPREG_A4_200, SI7210_OTPREG_A5_200, | |
| }; | |
| static const struct regmap_range si7210_read_reg_ranges[] = { | |
| regmap_reg_range(SI7210_REG_DSPSIGM, SI7210_REG_ARAUTOINC), | |
| regmap_reg_range(SI7210_REG_A0, SI7210_REG_A2), | |
| regmap_reg_range(SI7210_REG_A3, SI7210_REG_A5), | |
| regmap_reg_range(SI7210_REG_OTP_ADDR, SI7210_REG_OTP_CTRL), | |
| }; | |
| static const struct regmap_access_table si7210_readable_regs = { | |
| .yes_ranges = si7210_read_reg_ranges, | |
| .n_yes_ranges = ARRAY_SIZE(si7210_read_reg_ranges), | |
| }; | |
| static const struct regmap_range si7210_write_reg_ranges[] = { | |
| regmap_reg_range(SI7210_REG_DSPSIGSEL, SI7210_REG_ARAUTOINC), | |
| regmap_reg_range(SI7210_REG_A0, SI7210_REG_A2), | |
| regmap_reg_range(SI7210_REG_A3, SI7210_REG_A5), | |
| regmap_reg_range(SI7210_REG_OTP_ADDR, SI7210_REG_OTP_CTRL), | |
| }; | |
| static const struct regmap_access_table si7210_writeable_regs = { | |
| .yes_ranges = si7210_write_reg_ranges, | |
| .n_yes_ranges = ARRAY_SIZE(si7210_write_reg_ranges), | |
| }; | |
| static const struct regmap_range si7210_volatile_reg_ranges[] = { | |
| regmap_reg_range(SI7210_REG_DSPSIGM, SI7210_REG_DSPSIGL), | |
| regmap_reg_range(SI7210_REG_POWER_CTRL, SI7210_REG_POWER_CTRL), | |
| }; | |
| static const struct regmap_access_table si7210_volatile_regs = { | |
| .yes_ranges = si7210_volatile_reg_ranges, | |
| .n_yes_ranges = ARRAY_SIZE(si7210_volatile_reg_ranges), | |
| }; | |
| static const struct regmap_config si7210_regmap_conf = { | |
| .reg_bits = 8, | |
| .val_bits = 8, | |
| .max_register = SI7210_REG_OTP_CTRL, | |
| .rd_table = &si7210_readable_regs, | |
| .wr_table = &si7210_writeable_regs, | |
| .volatile_table = &si7210_volatile_regs, | |
| }; | |
| struct si7210_data { | |
| struct regmap *regmap; | |
| struct i2c_client *client; | |
| struct mutex fetch_lock; /* lock for a single measurement fetch */ | |
| unsigned int vdd_uV; | |
| s8 temp_offset; | |
| s8 temp_gain; | |
| s8 scale_20_a[A_REGS_COUNT]; | |
| s8 scale_200_a[A_REGS_COUNT]; | |
| u8 curr_scale; | |
| }; | |
| static const struct iio_chan_spec si7210_channels[] = { | |
| { | |
| .type = IIO_MAGN, | |
| .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | | |
| BIT(IIO_CHAN_INFO_SCALE) | BIT(IIO_CHAN_INFO_OFFSET), | |
| }, { | |
| .type = IIO_TEMP, | |
| .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED), | |
| }, | |
| }; | |
| static int si7210_fetch_measurement(struct si7210_data *data, | |
| struct iio_chan_spec const *chan, | |
| u16 *buf) | |
| { | |
| u8 dspsigsel = chan->type == IIO_MAGN ? 0 : 1; | |
| int ret; | |
| __be16 result; | |
| guard(mutex)(&data->fetch_lock); | |
| ret = regmap_update_bits(data->regmap, SI7210_REG_DSPSIGSEL, | |
| SI7210_MASK_DSPSIGSEL, dspsigsel); | |
| if (ret) | |
| return ret; | |
| ret = regmap_update_bits(data->regmap, SI7210_REG_POWER_CTRL, | |
| SI7210_MASK_ONEBURST | SI7210_MASK_STOP, | |
| SI7210_MASK_ONEBURST & ~SI7210_MASK_STOP); | |
| if (ret) | |
| return ret; | |
| /* | |
| * Read the contents of the | |
| * registers containing the result: DSPSIGM, DSPSIGL | |
| */ | |
| ret = regmap_bulk_read(data->regmap, SI7210_REG_DSPSIGM, | |
| &result, sizeof(result)); | |
| if (ret) | |
| return ret; | |
| *buf = be16_to_cpu(result); | |
| return 0; | |
| } | |
| static int si7210_read_raw(struct iio_dev *indio_dev, | |
| struct iio_chan_spec const *chan, | |
| int *val, int *val2, long mask) | |
| { | |
| struct si7210_data *data = iio_priv(indio_dev); | |
| long long temp; | |
| u16 dspsig; | |
| int ret; | |
| switch (mask) { | |
| case IIO_CHAN_INFO_RAW: | |
| ret = si7210_fetch_measurement(data, chan, &dspsig); | |
| if (ret) | |
| return ret; | |
| *val = dspsig & GENMASK(14, 0); | |
| return IIO_VAL_INT; | |
| case IIO_CHAN_INFO_SCALE: | |
| *val = 0; | |
| if (data->curr_scale == 20) | |
| *val2 = 12500; | |
| else /* data->curr_scale == 200 */ | |
| *val2 = 125000; | |
| return IIO_VAL_INT_PLUS_MICRO; | |
| case IIO_CHAN_INFO_OFFSET: | |
| *val = -16384; | |
| return IIO_VAL_INT; | |
| case IIO_CHAN_INFO_PROCESSED: | |
| ret = si7210_fetch_measurement(data, chan, &dspsig); | |
| if (ret) | |
| return ret; | |
| /* temp = 32 * Dspsigm[6:0] + (Dspsigl[7:0] >> 3) */ | |
| temp = FIELD_GET(GENMASK(14, 3), dspsig); | |
| temp = div_s64(-383 * temp * temp, 100) + 160940 * temp - 279800000; | |
| temp *= (1 + (data->temp_gain / 2048)); | |
| temp += (int)(MICRO / 16) * data->temp_offset; | |
| /* temp -= 0.222 * VDD */ | |
| temp -= 222 * (data->vdd_uV / MILLI); | |
| *val = div_s64(temp, MILLI); | |
| return IIO_VAL_INT; | |
| default: | |
| return -EINVAL; | |
| } | |
| } | |
| static int si7210_set_scale(struct si7210_data *data, unsigned int scale) | |
| { | |
| s8 *a_otp_values; | |
| int ret; | |
| if (scale == 20) | |
| a_otp_values = data->scale_20_a; | |
| else if (scale == 200) | |
| a_otp_values = data->scale_200_a; | |
| else | |
| return -EINVAL; | |
| guard(mutex)(&data->fetch_lock); | |
| /* Write the registers 0xCA - 0xCC */ | |
| ret = regmap_bulk_write(data->regmap, SI7210_REG_A0, a_otp_values, 3); | |
| if (ret) | |
| return ret; | |
| /* Write the registers 0xCE - 0xD0 */ | |
| ret = regmap_bulk_write(data->regmap, SI7210_REG_A3, &a_otp_values[3], 3); | |
| if (ret) | |
| return ret; | |
| data->curr_scale = scale; | |
| return 0; | |
| } | |
| static int si7210_write_raw(struct iio_dev *indio_dev, | |
| struct iio_chan_spec const *chan, | |
| int val, int val2, long mask) | |
| { | |
| struct si7210_data *data = iio_priv(indio_dev); | |
| unsigned int scale; | |
| switch (mask) { | |
| case IIO_CHAN_INFO_SCALE: | |
| if (val == 0 && val2 == 12500) | |
| scale = 20; | |
| else if (val == 0 && val2 == 125000) | |
| scale = 200; | |
| else | |
| return -EINVAL; | |
| return si7210_set_scale(data, scale); | |
| default: | |
| return -EINVAL; | |
| } | |
| } | |
| static int si7210_read_otpreg_val(struct si7210_data *data, unsigned int otpreg, u8 *val) | |
| { | |
| int ret; | |
| unsigned int otpdata; | |
| ret = regmap_write(data->regmap, SI7210_REG_OTP_ADDR, otpreg); | |
| if (ret) | |
| return ret; | |
| ret = regmap_update_bits(data->regmap, SI7210_REG_OTP_CTRL, | |
| SI7210_MASK_OTP_READ_EN, SI7210_MASK_OTP_READ_EN); | |
| if (ret) | |
| return ret; | |
| ret = regmap_read(data->regmap, SI7210_REG_OTP_DATA, &otpdata); | |
| if (ret) | |
| return ret; | |
| *val = otpdata; | |
| return 0; | |
| } | |
| /* | |
| * According to the datasheet, the primary method to wake up a | |
| * device is to send an empty write. However this is not feasible | |
| * using the current API so we use the other method i.e. read a single | |
| * byte. The device should respond with 0xFF. | |
| */ | |
| static int si7210_device_wake(struct si7210_data *data) | |
| { | |
| int ret; | |
| ret = i2c_smbus_read_byte(data->client); | |
| if (ret < 0) | |
| return ret; | |
| if (ret != 0xFF) | |
| return -EIO; | |
| return 0; | |
| } | |
| static int si7210_device_init(struct si7210_data *data) | |
| { | |
| int ret; | |
| unsigned int i; | |
| ret = si7210_device_wake(data); | |
| if (ret) | |
| return ret; | |
| fsleep(1000); | |
| ret = si7210_read_otpreg_val(data, SI7210_OTPREG_TMP_GAIN, &data->temp_gain); | |
| if (ret) | |
| return ret; | |
| ret = si7210_read_otpreg_val(data, SI7210_OTPREG_TMP_OFF, &data->temp_offset); | |
| if (ret) | |
| return ret; | |
| for (i = 0; i < A_REGS_COUNT; i++) { | |
| ret = si7210_read_otpreg_val(data, a20_otp_regs[i], &data->scale_20_a[i]); | |
| if (ret) | |
| return ret; | |
| } | |
| for (i = 0; i < A_REGS_COUNT; i++) { | |
| ret = si7210_read_otpreg_val(data, a200_otp_regs[i], &data->scale_200_a[i]); | |
| if (ret) | |
| return ret; | |
| } | |
| ret = regmap_update_bits(data->regmap, SI7210_REG_ARAUTOINC, | |
| SI7210_MASK_ARAUTOINC, SI7210_MASK_ARAUTOINC); | |
| if (ret) | |
| return ret; | |
| return si7210_set_scale(data, 20); | |
| } | |
| static const struct iio_info si7210_info = { | |
| .read_raw = si7210_read_raw, | |
| .write_raw = si7210_write_raw, | |
| }; | |
| static int si7210_probe(struct i2c_client *client) | |
| { | |
| struct si7210_data *data; | |
| struct iio_dev *indio_dev; | |
| int ret; | |
| indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); | |
| if (!indio_dev) | |
| return -ENOMEM; | |
| data = iio_priv(indio_dev); | |
| data->client = client; | |
| ret = devm_mutex_init(&client->dev, &data->fetch_lock); | |
| if (ret) | |
| return ret; | |
| data->regmap = devm_regmap_init_i2c(client, &si7210_regmap_conf); | |
| if (IS_ERR(data->regmap)) | |
| return dev_err_probe(&client->dev, PTR_ERR(data->regmap), | |
| "failed to register regmap\n"); | |
| ret = devm_regulator_get_enable_read_voltage(&client->dev, "vdd"); | |
| if (ret < 0) | |
| return dev_err_probe(&client->dev, ret, | |
| "Failed to get vdd regulator\n"); | |
| data->vdd_uV = ret; | |
| indio_dev->name = dev_name(&client->dev); | |
| indio_dev->modes = INDIO_DIRECT_MODE; | |
| indio_dev->info = &si7210_info; | |
| indio_dev->channels = si7210_channels; | |
| indio_dev->num_channels = ARRAY_SIZE(si7210_channels); | |
| ret = si7210_device_init(data); | |
| if (ret) | |
| return dev_err_probe(&client->dev, ret, | |
| "device initialization failed\n"); | |
| return devm_iio_device_register(&client->dev, indio_dev); | |
| } | |
| static const struct i2c_device_id si7210_id[] = { | |
| { .name = "si7210" }, | |
| { } | |
| }; | |
| MODULE_DEVICE_TABLE(i2c, si7210_id); | |
| static const struct of_device_id si7210_dt_ids[] = { | |
| { .compatible = "silabs,si7210" }, | |
| { } | |
| }; | |
| MODULE_DEVICE_TABLE(of, si7210_dt_ids); | |
| static struct i2c_driver si7210_driver = { | |
| .driver = { | |
| .name = "si7210", | |
| .of_match_table = si7210_dt_ids, | |
| }, | |
| .probe = si7210_probe, | |
| .id_table = si7210_id, | |
| }; | |
| module_i2c_driver(si7210_driver); | |
| MODULE_AUTHOR("Antoni Pokusinski <apokusinski01@gmail.com>"); | |
| MODULE_DESCRIPTION("Silicon Labs Si7210 Hall Effect sensor I2C driver"); | |
| MODULE_LICENSE("GPL"); |