1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * Hardware monitoring driver for ina233
4 *
5 * Copyright (c) 2025 Leo Yang
6 */
7
8 #include <linux/err.h>
9 #include <linux/i2c.h>
10 #include <linux/init.h>
11 #include <linux/kernel.h>
12 #include <linux/module.h>
13 #include "pmbus.h"
14
15 #define MFR_READ_VSHUNT 0xd1
16 #define MFR_CALIBRATION 0xd4
17
18 #define INA233_MAX_CURRENT_DEFAULT 32768000 /* uA */
19 #define INA233_RSHUNT_DEFAULT 2000 /* uOhm */
20
21 #define MAX_M_VAL 32767
22
calculate_coef(int * m,int * R,u32 current_lsb,int power_coef)23 static void calculate_coef(int *m, int *R, u32 current_lsb, int power_coef)
24 {
25 u64 scaled_m;
26 int scale_factor = 0;
27 int scale_coef = 1;
28
29 /*
30 * 1000000 from Current_LSB A->uA .
31 * scale_coef is for scaling up to minimize rounding errors,
32 * If there is no decimal information, no need to scale.
33 */
34 if (1000000 % current_lsb) {
35 /* Scaling to keep integer precision */
36 scale_factor = -3;
37 scale_coef = 1000;
38 }
39
40 /*
41 * Unit Conversion (Current_LSB A->uA) and use scaling(scale_factor)
42 * to keep integer precision.
43 * Formulae referenced from spec.
44 */
45 scaled_m = div64_u64(1000000 * scale_coef, (u64)current_lsb * power_coef);
46
47 /* Maximize while keeping it bounded.*/
48 while (scaled_m > MAX_M_VAL) {
49 scaled_m = div_u64(scaled_m, 10);
50 scale_factor++;
51 }
52 /* Scale up only if fractional part exists. */
53 while (scaled_m * 10 < MAX_M_VAL && scale_coef != 1) {
54 scaled_m *= 10;
55 scale_factor--;
56 }
57
58 *m = scaled_m;
59 *R = scale_factor;
60 }
61
ina233_read_word_data(struct i2c_client * client,int page,int phase,int reg)62 static int ina233_read_word_data(struct i2c_client *client, int page,
63 int phase, int reg)
64 {
65 int ret;
66
67 switch (reg) {
68 case PMBUS_VIRT_READ_VMON:
69 ret = pmbus_read_word_data(client, 0, 0xff, MFR_READ_VSHUNT);
70
71 /* Adjust returned value to match VIN coefficients */
72 /* VIN: 1.25 mV VSHUNT: 2.5 uV LSB */
73 ret = DIV_ROUND_CLOSEST(ret * 25, 12500);
74 break;
75 default:
76 ret = -ENODATA;
77 break;
78 }
79 return ret;
80 }
81
ina233_probe(struct i2c_client * client)82 static int ina233_probe(struct i2c_client *client)
83 {
84 struct device *dev = &client->dev;
85 int ret, m, R;
86 u32 rshunt;
87 u32 max_current;
88 u32 current_lsb;
89 u16 calibration;
90 struct pmbus_driver_info *info;
91
92 info = devm_kzalloc(dev, sizeof(struct pmbus_driver_info),
93 GFP_KERNEL);
94 if (!info)
95 return -ENOMEM;
96
97 info->pages = 1;
98 info->format[PSC_VOLTAGE_IN] = direct;
99 info->format[PSC_VOLTAGE_OUT] = direct;
100 info->format[PSC_CURRENT_OUT] = direct;
101 info->format[PSC_POWER] = direct;
102 info->func[0] = PMBUS_HAVE_VIN | PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_INPUT
103 | PMBUS_HAVE_IOUT | PMBUS_HAVE_STATUS_IOUT
104 | PMBUS_HAVE_POUT
105 | PMBUS_HAVE_VMON | PMBUS_HAVE_STATUS_VMON;
106 info->m[PSC_VOLTAGE_IN] = 8;
107 info->R[PSC_VOLTAGE_IN] = 2;
108 info->m[PSC_VOLTAGE_OUT] = 8;
109 info->R[PSC_VOLTAGE_OUT] = 2;
110 info->read_word_data = ina233_read_word_data;
111
112 /* If INA233 skips current/power, shunt-resistor and current-lsb aren't needed. */
113 /* read rshunt value (uOhm) */
114 ret = device_property_read_u32(dev, "shunt-resistor", &rshunt);
115 if (ret) {
116 if (ret != -EINVAL)
117 return dev_err_probe(dev, ret, "Shunt resistor property read fail.\n");
118 rshunt = INA233_RSHUNT_DEFAULT;
119 }
120 if (!rshunt)
121 return dev_err_probe(dev, -EINVAL,
122 "Shunt resistor cannot be zero.\n");
123
124 /* read Maximum expected current value (uA) */
125 ret = device_property_read_u32(dev, "ti,maximum-expected-current-microamp", &max_current);
126 if (ret) {
127 if (ret != -EINVAL)
128 return dev_err_probe(dev, ret,
129 "Maximum expected current property read fail.\n");
130 max_current = INA233_MAX_CURRENT_DEFAULT;
131 }
132 if (max_current < 32768)
133 return dev_err_probe(dev, -EINVAL,
134 "Maximum expected current cannot less then 32768.\n");
135
136 /* Calculate Current_LSB according to the spec formula */
137 current_lsb = max_current / 32768;
138
139 /* calculate current coefficient */
140 calculate_coef(&m, &R, current_lsb, 1);
141 info->m[PSC_CURRENT_OUT] = m;
142 info->R[PSC_CURRENT_OUT] = R;
143
144 /* calculate power coefficient */
145 calculate_coef(&m, &R, current_lsb, 25);
146 info->m[PSC_POWER] = m;
147 info->R[PSC_POWER] = R;
148
149 /* write MFR_CALIBRATION register, Apply formula from spec with unit scaling. */
150 calibration = div64_u64(5120000000ULL, (u64)rshunt * current_lsb);
151 if (calibration > 0x7FFF)
152 return dev_err_probe(dev, -EINVAL,
153 "Product of Current_LSB %u and shunt resistor %u too small, MFR_CALIBRATION reg exceeds 0x7FFF.\n",
154 current_lsb, rshunt);
155 ret = i2c_smbus_write_word_data(client, MFR_CALIBRATION, calibration);
156 if (ret < 0)
157 return dev_err_probe(dev, ret, "Unable to write calibration.\n");
158
159 dev_dbg(dev, "power monitor %s (Rshunt = %u uOhm, Current_LSB = %u uA/bit)\n",
160 client->name, rshunt, current_lsb);
161
162 return pmbus_do_probe(client, info);
163 }
164
165 static const struct i2c_device_id ina233_id[] = {
166 {"ina233", 0},
167 {}
168 };
169 MODULE_DEVICE_TABLE(i2c, ina233_id);
170
171 static const struct of_device_id __maybe_unused ina233_of_match[] = {
172 { .compatible = "ti,ina233" },
173 {}
174 };
175 MODULE_DEVICE_TABLE(of, ina233_of_match);
176
177 static struct i2c_driver ina233_driver = {
178 .driver = {
179 .name = "ina233",
180 .of_match_table = of_match_ptr(ina233_of_match),
181 },
182 .probe = ina233_probe,
183 .id_table = ina233_id,
184 };
185
186 module_i2c_driver(ina233_driver);
187
188 MODULE_AUTHOR("Leo Yang <leo.yang.sy0@gmail.com>");
189 MODULE_DESCRIPTION("PMBus driver for INA233 and compatible chips");
190 MODULE_LICENSE("GPL");
191 MODULE_IMPORT_NS("PMBUS");
192