// SPDX-License-Identifier: GPL-2.0 /* * Author: Ziming Zhu */ #include #include #include #include #include #include #include #include "pmbus.h" #define SQ24860_IIN_CAL_GAIN 0x38 #define SQ24860_READ_VAUX 0xd0 #define SQ24860_READ_VIN_MIN 0xd1 #define SQ24860_READ_VIN_PEAK 0xd2 #define SQ24860_READ_IIN_PEAK 0xd4 #define SQ24860_READ_PIN_PEAK 0xd5 #define SQ24860_READ_TEMP_AVG 0xd6 #define SQ24860_READ_TEMP_PEAK 0xd7 #define SQ24860_READ_VOUT_MIN 0xda #define SQ24860_READ_VIN_AVG 0xdc #define SQ24860_READ_VOUT_AVG 0xdd #define SQ24860_READ_IIN_AVG 0xde #define SQ24860_READ_PIN_AVG 0xdf #define SQ24860_VIREF 0xe0 #define SQ24860_PK_MIN_AVG 0xea #define PK_MIN_AVG_RST_PEAK BIT(7) #define PK_MIN_AVG_RST_AVG BIT(6) #define PK_MIN_AVG_RST_MIN BIT(5) #define PK_MIN_AVG_AVG_CNT GENMASK(2, 0) #define SQ24860_MFR_WRITE_PROTECT 0xf8 #define SQ24860_UNLOCKED BIT(7) #define SQ24860_8B_SHIFT 2 #define SQ24860_IIN_OCF_NUM 1000000 #define SQ24860_IIN_OCF_DIV 129278 #define SQ24860_IIN_OCF_OFF 165 #define PK_MIN_AVG_RST_MASK (PK_MIN_AVG_RST_PEAK | \ PK_MIN_AVG_RST_AVG | \ PK_MIN_AVG_RST_MIN) #define SQ24860_MAX_SAMPLES BIT(FIELD_MAX(PK_MIN_AVG_AVG_CNT)) /* * Arbitrary default Rimon value: 1.6kOhm */ #define SQ24860_DEFAULT_RIMON 1600000000 #define SQ24860_GIMON 18180 #define SQ24860_VAUX_DIV 20 static int sq24860_write_iin_cal_gain(struct i2c_client *client, u32 rimon) { u64 temp = 6400ULL * 1000000000ULL * 1000ULL; u64 denom; u64 word; if (!rimon) return -EINVAL; denom = (u64)rimon * SQ24860_GIMON; word = div64_u64(temp, denom); if (!word || word > U16_MAX) return -EINVAL; return i2c_smbus_write_word_data(client, SQ24860_IIN_CAL_GAIN, (u16)word); } static int sq24860_mfr_write_protect_set(struct i2c_client *client, u8 protect) { u8 val; switch (protect) { case 0: val = 0xa2; break; case PB_WP_ALL: val = 0x0; break; default: return -EINVAL; } return pmbus_write_byte_data(client, -1, SQ24860_MFR_WRITE_PROTECT, val); } static int sq24860_mfr_write_protect_get(struct i2c_client *client) { int ret = pmbus_read_byte_data(client, -1, SQ24860_MFR_WRITE_PROTECT); if (ret < 0) return ret; return (ret & SQ24860_UNLOCKED) ? 0 : PB_WP_ALL; } static int sq24860_read_word_data(struct i2c_client *client, int page, int phase, int reg) { int ret; switch (reg) { case PMBUS_VIRT_READ_VIN_MAX: ret = pmbus_read_word_data(client, page, phase, SQ24860_READ_VIN_PEAK); break; case PMBUS_VIRT_READ_VIN_MIN: ret = pmbus_read_word_data(client, page, phase, SQ24860_READ_VIN_MIN); break; case PMBUS_VIRT_READ_VIN_AVG: ret = pmbus_read_word_data(client, page, phase, SQ24860_READ_VIN_AVG); break; case PMBUS_VIRT_READ_VOUT_MIN: ret = pmbus_read_word_data(client, page, phase, SQ24860_READ_VOUT_MIN); break; case PMBUS_VIRT_READ_VOUT_AVG: ret = pmbus_read_word_data(client, page, phase, SQ24860_READ_VOUT_AVG); break; case PMBUS_VIRT_READ_IIN_AVG: ret = pmbus_read_word_data(client, page, phase, SQ24860_READ_IIN_AVG); break; case PMBUS_VIRT_READ_IIN_MAX: ret = pmbus_read_word_data(client, page, phase, SQ24860_READ_IIN_PEAK); break; case PMBUS_VIRT_READ_TEMP_AVG: ret = pmbus_read_word_data(client, page, phase, SQ24860_READ_TEMP_AVG); break; case PMBUS_VIRT_READ_TEMP_MAX: ret = pmbus_read_word_data(client, page, phase, SQ24860_READ_TEMP_PEAK); break; case PMBUS_VIRT_READ_PIN_AVG: ret = pmbus_read_word_data(client, page, phase, SQ24860_READ_PIN_AVG); break; case PMBUS_VIRT_READ_PIN_MAX: ret = pmbus_read_word_data(client, page, phase, SQ24860_READ_PIN_PEAK); break; case PMBUS_VIRT_READ_VMON: ret = pmbus_read_word_data(client, page, phase, SQ24860_READ_VAUX); if (ret < 0) break; ret = DIV_ROUND_CLOSEST(ret, SQ24860_VAUX_DIV); break; case PMBUS_VIN_UV_WARN_LIMIT: case PMBUS_VIN_UV_FAULT_LIMIT: case PMBUS_VIN_OV_WARN_LIMIT: case PMBUS_VIN_OV_FAULT_LIMIT: case PMBUS_VOUT_UV_WARN_LIMIT: case PMBUS_IIN_OC_WARN_LIMIT: case PMBUS_OT_WARN_LIMIT: case PMBUS_OT_FAULT_LIMIT: case PMBUS_PIN_OP_WARN_LIMIT: /* * These registers provide an 8 bits value instead of a * 10bits one. Just shifting twice the register value is * enough to make the sensor type conversion work, even * if the datasheet provides different m, b and R for * those. */ ret = pmbus_read_word_data(client, page, phase, reg); if (ret < 0) break; ret <<= SQ24860_8B_SHIFT; break; case PMBUS_IIN_OC_FAULT_LIMIT: /* * VIREF directly sets the over-current limit at which the eFuse * will turn the FET off and trigger a fault. Expose it through * this generic property instead of a manufacturer specific one. */ ret = pmbus_read_byte_data(client, page, SQ24860_VIREF); if (ret < 0) break; ret = DIV_ROUND_CLOSEST(ret * SQ24860_IIN_OCF_NUM, SQ24860_IIN_OCF_DIV); ret += SQ24860_IIN_OCF_OFF; break; case PMBUS_VIRT_SAMPLES: ret = pmbus_read_byte_data(client, page, SQ24860_PK_MIN_AVG); if (ret < 0) break; ret = BIT(FIELD_GET(PK_MIN_AVG_AVG_CNT, ret)); break; case PMBUS_VIRT_RESET_TEMP_HISTORY: case PMBUS_VIRT_RESET_VIN_HISTORY: case PMBUS_VIRT_RESET_IIN_HISTORY: case PMBUS_VIRT_RESET_PIN_HISTORY: case PMBUS_VIRT_RESET_VOUT_HISTORY: ret = 0; break; default: ret = -ENODATA; break; } return ret; } static int sq24860_write_word_data(struct i2c_client *client, int page, int reg, u16 value) { int ret; switch (reg) { case PMBUS_VIN_UV_WARN_LIMIT: case PMBUS_VIN_UV_FAULT_LIMIT: case PMBUS_VIN_OV_WARN_LIMIT: case PMBUS_VIN_OV_FAULT_LIMIT: case PMBUS_VOUT_UV_WARN_LIMIT: case PMBUS_IIN_OC_WARN_LIMIT: case PMBUS_OT_WARN_LIMIT: case PMBUS_OT_FAULT_LIMIT: case PMBUS_PIN_OP_WARN_LIMIT: value = max_t(s16, (s16)value, 0); value >>= SQ24860_8B_SHIFT; value = clamp_val(value, 0, 0xff); ret = pmbus_write_word_data(client, page, reg, value); break; case PMBUS_IIN_OC_FAULT_LIMIT: value = max_t(s16, (s16)value, SQ24860_IIN_OCF_OFF); value -= SQ24860_IIN_OCF_OFF; value = DIV_ROUND_CLOSEST(((unsigned int)value) * SQ24860_IIN_OCF_DIV, SQ24860_IIN_OCF_NUM); value = clamp_val(value, 0, 0x3f); ret = pmbus_write_byte_data(client, page, SQ24860_VIREF, value); break; case PMBUS_VIRT_SAMPLES: value = clamp_val(value, 1, SQ24860_MAX_SAMPLES); value = ilog2(value); ret = pmbus_update_byte_data(client, page, SQ24860_PK_MIN_AVG, PK_MIN_AVG_AVG_CNT, FIELD_PREP(PK_MIN_AVG_AVG_CNT, value)); break; case PMBUS_VIRT_RESET_TEMP_HISTORY: case PMBUS_VIRT_RESET_VIN_HISTORY: case PMBUS_VIRT_RESET_IIN_HISTORY: case PMBUS_VIRT_RESET_PIN_HISTORY: case PMBUS_VIRT_RESET_VOUT_HISTORY: /* * SQ24860 has history resets based on MIN/AVG/PEAK instead of per * sensor type. Exposing this quirk in hwmon is not desirable so * reset MIN, AVG and PEAK together. Even is there effectively only * one reset, which resets everything, expose the 5 entries so * userspace is not required map a sensor type to another to trigger * a reset */ ret = pmbus_update_byte_data(client, 0, SQ24860_PK_MIN_AVG, PK_MIN_AVG_RST_MASK, PK_MIN_AVG_RST_MASK); break; default: ret = -ENODATA; break; } return ret; } static int sq24860_read_byte_data(struct i2c_client *client, int page, int reg) { int ret; switch (reg) { case PMBUS_WRITE_PROTECT: ret = sq24860_mfr_write_protect_get(client); break; default: ret = -ENODATA; break; } return ret; } static int sq24860_write_byte_data(struct i2c_client *client, int page, int reg, u8 byte) { int ret; switch (reg) { case PMBUS_WRITE_PROTECT: ret = sq24860_mfr_write_protect_set(client, byte); break; default: ret = -ENODATA; break; } return ret; } #if IS_ENABLED(CONFIG_SENSORS_SQ24860_REGULATOR) static const struct regulator_desc sq24860_reg_desc[] = { PMBUS_REGULATOR_ONE_NODE("vout"), }; #endif static const struct pmbus_driver_info sq24860_base_info = { .pages = 1, .format[PSC_VOLTAGE_IN] = direct, .m[PSC_VOLTAGE_IN] = 64, .b[PSC_VOLTAGE_IN] = 0, .R[PSC_VOLTAGE_IN] = 0, .format[PSC_VOLTAGE_OUT] = direct, .m[PSC_VOLTAGE_OUT] = 64, .b[PSC_VOLTAGE_OUT] = 0, .R[PSC_VOLTAGE_OUT] = 0, .format[PSC_TEMPERATURE] = direct, .m[PSC_TEMPERATURE] = 1, .b[PSC_TEMPERATURE] = 0, .R[PSC_TEMPERATURE] = 0, /* * Current and power measurements depend on the calibration gain * programmed from the board-specific IMON resistor value. */ .format[PSC_CURRENT_IN] = direct, .m[PSC_CURRENT_IN] = 16, .b[PSC_CURRENT_IN] = 0, .R[PSC_CURRENT_IN] = 0, .format[PSC_POWER] = direct, .m[PSC_POWER] = 2, .b[PSC_POWER] = 0, .R[PSC_POWER] = 0, .func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_VOUT | PMBUS_HAVE_VMON | PMBUS_HAVE_IIN | PMBUS_HAVE_PIN | PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_VOUT | PMBUS_HAVE_STATUS_IOUT | PMBUS_HAVE_STATUS_INPUT | PMBUS_HAVE_STATUS_TEMP | PMBUS_HAVE_SAMPLES, .read_word_data = sq24860_read_word_data, .write_word_data = sq24860_write_word_data, .read_byte_data = sq24860_read_byte_data, .write_byte_data = sq24860_write_byte_data, #if IS_ENABLED(CONFIG_SENSORS_SQ24860_REGULATOR) .reg_desc = sq24860_reg_desc, .num_regulators = ARRAY_SIZE(sq24860_reg_desc), #endif }; static const struct i2c_device_id sq24860_i2c_id[] = { { "sq24860" }, {} }; MODULE_DEVICE_TABLE(i2c, sq24860_i2c_id); static const struct of_device_id sq24860_of_match[] = { { .compatible = "silergy,sq24860" }, {} }; MODULE_DEVICE_TABLE(of, sq24860_of_match); static int sq24860_probe(struct i2c_client *client) { struct device *dev = &client->dev; struct pmbus_driver_info *info; u32 rimon; int ret; if (device_property_read_u32(dev, "silergy,rimon-micro-ohms", &rimon)) rimon = SQ24860_DEFAULT_RIMON; ret = sq24860_write_iin_cal_gain(client, rimon); if (ret < 0) return dev_err_probe(&client->dev, ret, "Failed to set gain\n"); info = devm_kmemdup(dev, &sq24860_base_info, sizeof(*info), GFP_KERNEL); if (!info) return -ENOMEM; return pmbus_do_probe(client, info); } static struct i2c_driver sq24860_driver = { .driver = { .name = "sq24860", .of_match_table = sq24860_of_match, }, .probe = sq24860_probe, .id_table = sq24860_i2c_id, }; module_i2c_driver(sq24860_driver); MODULE_AUTHOR("Ziming Zhu "); MODULE_DESCRIPTION("PMBUS driver for SQ24860 eFuse"); MODULE_LICENSE("GPL"); MODULE_IMPORT_NS("PMBUS");