]>
Commit | Line | Data |
---|---|---|
d2912cb1 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
dbc4deda KHS |
2 | /* |
3 | * Driver for SBS compliant Smart Battery System Managers | |
4 | * | |
5 | * The device communicates via i2c at address 0x0a and multiplexes access to up | |
6 | * to four smart batteries at address 0x0b. | |
7 | * | |
8 | * Via sysfs interface the online state and charge type are presented. | |
9 | * | |
10 | * Datasheet SBSM: http://sbs-forum.org/specs/sbsm100b.pdf | |
11 | * Datasheet LTC1760: http://cds.linear.com/docs/en/datasheet/1760fb.pdf | |
12 | * | |
13 | * Karl-Heinz Schneider <karl-heinz@schneider-inet.de> | |
dbc4deda KHS |
14 | */ |
15 | ||
a0b8839e | 16 | #include <linux/gpio.h> |
dbc4deda KHS |
17 | #include <linux/module.h> |
18 | #include <linux/i2c.h> | |
19 | #include <linux/i2c-mux.h> | |
20 | #include <linux/power_supply.h> | |
a0b8839e | 21 | #include <linux/property.h> |
dbc4deda KHS |
22 | |
23 | #define SBSM_MAX_BATS 4 | |
24 | #define SBSM_RETRY_CNT 3 | |
25 | ||
26 | /* registers addresses */ | |
27 | #define SBSM_CMD_BATSYSSTATE 0x01 | |
28 | #define SBSM_CMD_BATSYSSTATECONT 0x02 | |
29 | #define SBSM_CMD_BATSYSINFO 0x04 | |
30 | #define SBSM_CMD_LTC 0x3c | |
31 | ||
32 | #define SBSM_MASK_BAT_SUPPORTED GENMASK(3, 0) | |
33 | #define SBSM_MASK_CHARGE_BAT GENMASK(7, 4) | |
34 | #define SBSM_BIT_AC_PRESENT BIT(0) | |
35 | #define SBSM_BIT_TURBO BIT(7) | |
36 | ||
37 | #define SBSM_SMB_BAT_OFFSET 11 | |
38 | struct sbsm_data { | |
39 | struct i2c_client *client; | |
40 | struct i2c_mux_core *muxc; | |
41 | ||
42 | struct power_supply *psy; | |
43 | ||
44 | u8 cur_chan; /* currently selected channel */ | |
a0b8839e | 45 | struct gpio_chip chip; |
dbc4deda | 46 | bool is_ltc1760; /* special capabilities */ |
a0b8839e PR |
47 | |
48 | unsigned int supported_bats; | |
49 | unsigned int last_state; | |
50 | unsigned int last_state_cont; | |
dbc4deda KHS |
51 | }; |
52 | ||
53 | static enum power_supply_property sbsm_props[] = { | |
54 | POWER_SUPPLY_PROP_ONLINE, | |
55 | POWER_SUPPLY_PROP_CHARGE_TYPE, | |
56 | }; | |
57 | ||
58 | static int sbsm_read_word(struct i2c_client *client, u8 address) | |
59 | { | |
60 | int reg, retries; | |
61 | ||
62 | for (retries = SBSM_RETRY_CNT; retries > 0; retries--) { | |
63 | reg = i2c_smbus_read_word_data(client, address); | |
64 | if (reg >= 0) | |
65 | break; | |
66 | } | |
67 | ||
68 | if (reg < 0) { | |
69 | dev_err(&client->dev, "failed to read register 0x%02x\n", | |
70 | address); | |
71 | } | |
72 | ||
73 | return reg; | |
74 | } | |
75 | ||
76 | static int sbsm_write_word(struct i2c_client *client, u8 address, u16 word) | |
77 | { | |
78 | int ret, retries; | |
79 | ||
80 | for (retries = SBSM_RETRY_CNT; retries > 0; retries--) { | |
81 | ret = i2c_smbus_write_word_data(client, address, word); | |
82 | if (ret >= 0) | |
83 | break; | |
84 | } | |
85 | if (ret < 0) | |
86 | dev_err(&client->dev, "failed to write to register 0x%02x\n", | |
87 | address); | |
88 | ||
89 | return ret; | |
90 | } | |
91 | ||
92 | static int sbsm_get_property(struct power_supply *psy, | |
93 | enum power_supply_property psp, | |
94 | union power_supply_propval *val) | |
95 | { | |
96 | struct sbsm_data *data = power_supply_get_drvdata(psy); | |
97 | int regval = 0; | |
98 | ||
99 | switch (psp) { | |
100 | case POWER_SUPPLY_PROP_ONLINE: | |
101 | regval = sbsm_read_word(data->client, SBSM_CMD_BATSYSSTATECONT); | |
102 | if (regval < 0) | |
103 | return regval; | |
104 | val->intval = !!(regval & SBSM_BIT_AC_PRESENT); | |
105 | break; | |
106 | ||
107 | case POWER_SUPPLY_PROP_CHARGE_TYPE: | |
108 | regval = sbsm_read_word(data->client, SBSM_CMD_BATSYSSTATE); | |
109 | if (regval < 0) | |
110 | return regval; | |
111 | ||
112 | if ((regval & SBSM_MASK_CHARGE_BAT) == 0) { | |
113 | val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE; | |
114 | return 0; | |
115 | } | |
116 | val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE; | |
117 | ||
118 | if (data->is_ltc1760) { | |
119 | /* charge mode fast if turbo is active */ | |
120 | regval = sbsm_read_word(data->client, SBSM_CMD_LTC); | |
121 | if (regval < 0) | |
122 | return regval; | |
123 | else if (regval & SBSM_BIT_TURBO) | |
124 | val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST; | |
125 | } | |
126 | break; | |
127 | ||
128 | default: | |
129 | return -EINVAL; | |
130 | } | |
131 | ||
132 | return 0; | |
133 | } | |
134 | ||
135 | static int sbsm_prop_is_writeable(struct power_supply *psy, | |
136 | enum power_supply_property psp) | |
137 | { | |
138 | struct sbsm_data *data = power_supply_get_drvdata(psy); | |
139 | ||
140 | return (psp == POWER_SUPPLY_PROP_CHARGE_TYPE) && data->is_ltc1760; | |
141 | } | |
142 | ||
143 | static int sbsm_set_property(struct power_supply *psy, | |
144 | enum power_supply_property psp, | |
145 | const union power_supply_propval *val) | |
146 | { | |
147 | struct sbsm_data *data = power_supply_get_drvdata(psy); | |
148 | int ret = -EINVAL; | |
149 | u16 regval; | |
150 | ||
151 | switch (psp) { | |
152 | case POWER_SUPPLY_PROP_CHARGE_TYPE: | |
153 | /* write 1 to TURBO if type fast is given */ | |
154 | if (!data->is_ltc1760) | |
155 | break; | |
156 | regval = val->intval == | |
157 | POWER_SUPPLY_CHARGE_TYPE_FAST ? SBSM_BIT_TURBO : 0; | |
158 | ret = sbsm_write_word(data->client, SBSM_CMD_LTC, regval); | |
159 | break; | |
160 | ||
161 | default: | |
162 | break; | |
163 | } | |
164 | ||
165 | return ret; | |
166 | } | |
167 | ||
168 | /* | |
169 | * Switch to battery | |
170 | * Parameter chan is directly the content of SMB_BAT* nibble | |
171 | */ | |
172 | static int sbsm_select(struct i2c_mux_core *muxc, u32 chan) | |
173 | { | |
174 | struct sbsm_data *data = i2c_mux_priv(muxc); | |
175 | struct device *dev = &data->client->dev; | |
176 | int ret = 0; | |
177 | u16 reg; | |
178 | ||
179 | if (data->cur_chan == chan) | |
180 | return ret; | |
181 | ||
182 | /* chan goes from 1 ... 4 */ | |
7d54d0d3 | 183 | reg = BIT(SBSM_SMB_BAT_OFFSET + chan); |
dbc4deda KHS |
184 | ret = sbsm_write_word(data->client, SBSM_CMD_BATSYSSTATE, reg); |
185 | if (ret) | |
186 | dev_err(dev, "Failed to select channel %i\n", chan); | |
187 | else | |
188 | data->cur_chan = chan; | |
189 | ||
190 | return ret; | |
191 | } | |
192 | ||
4cf419a2 | 193 | static int sbsm_gpio_get_value(struct gpio_chip *gc, unsigned int off) |
a0b8839e PR |
194 | { |
195 | struct sbsm_data *data = gpiochip_get_data(gc); | |
196 | int ret; | |
197 | ||
198 | ret = sbsm_read_word(data->client, SBSM_CMD_BATSYSSTATE); | |
199 | if (ret < 0) | |
200 | return ret; | |
201 | ||
202 | return ret & BIT(off); | |
203 | } | |
204 | ||
205 | /* | |
206 | * This needs to be defined or the GPIO lib fails to register the pin. | |
207 | * But the 'gpio' is always an input. | |
208 | */ | |
4cf419a2 | 209 | static int sbsm_gpio_direction_input(struct gpio_chip *gc, unsigned int off) |
a0b8839e PR |
210 | { |
211 | return 0; | |
212 | } | |
213 | ||
214 | static int sbsm_do_alert(struct device *dev, void *d) | |
215 | { | |
216 | struct i2c_client *client = i2c_verify_client(dev); | |
217 | struct i2c_driver *driver; | |
218 | ||
219 | if (!client || client->addr != 0x0b) | |
220 | return 0; | |
221 | ||
222 | device_lock(dev); | |
223 | if (client->dev.driver) { | |
224 | driver = to_i2c_driver(client->dev.driver); | |
225 | if (driver->alert) | |
226 | driver->alert(client, I2C_PROTOCOL_SMBUS_ALERT, 0); | |
227 | else | |
228 | dev_warn(&client->dev, "no driver alert()!\n"); | |
4cf419a2 | 229 | } else { |
a0b8839e | 230 | dev_dbg(&client->dev, "alert with no driver\n"); |
4cf419a2 | 231 | } |
a0b8839e PR |
232 | device_unlock(dev); |
233 | ||
234 | return -EBUSY; | |
235 | } | |
236 | ||
237 | static void sbsm_alert(struct i2c_client *client, enum i2c_alert_protocol prot, | |
238 | unsigned int d) | |
239 | { | |
240 | struct sbsm_data *sbsm = i2c_get_clientdata(client); | |
241 | ||
242 | int ret, i, irq_bat = 0, state = 0; | |
243 | ||
244 | ret = sbsm_read_word(sbsm->client, SBSM_CMD_BATSYSSTATE); | |
245 | if (ret >= 0) { | |
246 | irq_bat = ret ^ sbsm->last_state; | |
247 | sbsm->last_state = ret; | |
248 | state = ret; | |
249 | } | |
250 | ||
251 | ret = sbsm_read_word(sbsm->client, SBSM_CMD_BATSYSSTATECONT); | |
252 | if ((ret >= 0) && | |
253 | ((ret ^ sbsm->last_state_cont) & SBSM_BIT_AC_PRESENT)) { | |
254 | irq_bat |= sbsm->supported_bats & state; | |
255 | power_supply_changed(sbsm->psy); | |
256 | } | |
257 | sbsm->last_state_cont = ret; | |
258 | ||
259 | for (i = 0; i < SBSM_MAX_BATS; i++) { | |
260 | if (irq_bat & BIT(i)) { | |
261 | device_for_each_child(&sbsm->muxc->adapter[i]->dev, | |
262 | NULL, sbsm_do_alert); | |
263 | } | |
264 | } | |
265 | } | |
266 | ||
267 | static int sbsm_gpio_setup(struct sbsm_data *data) | |
268 | { | |
269 | struct gpio_chip *gc = &data->chip; | |
270 | struct i2c_client *client = data->client; | |
271 | struct device *dev = &client->dev; | |
272 | int ret; | |
273 | ||
274 | if (!device_property_present(dev, "gpio-controller")) | |
275 | return 0; | |
276 | ||
277 | ret = sbsm_read_word(client, SBSM_CMD_BATSYSSTATE); | |
278 | if (ret < 0) | |
279 | return ret; | |
280 | data->last_state = ret; | |
281 | ||
282 | ret = sbsm_read_word(client, SBSM_CMD_BATSYSSTATECONT); | |
283 | if (ret < 0) | |
284 | return ret; | |
285 | data->last_state_cont = ret; | |
286 | ||
287 | gc->get = sbsm_gpio_get_value; | |
288 | gc->direction_input = sbsm_gpio_direction_input; | |
289 | gc->can_sleep = true; | |
290 | gc->base = -1; | |
291 | gc->ngpio = SBSM_MAX_BATS; | |
292 | gc->label = client->name; | |
293 | gc->parent = dev; | |
294 | gc->owner = THIS_MODULE; | |
295 | ||
296 | ret = devm_gpiochip_add_data(dev, gc, data); | |
297 | if (ret) { | |
298 | dev_err(dev, "devm_gpiochip_add_data failed: %d\n", ret); | |
299 | return ret; | |
300 | } | |
301 | ||
302 | return ret; | |
303 | } | |
304 | ||
dbc4deda KHS |
305 | static const struct power_supply_desc sbsm_default_psy_desc = { |
306 | .type = POWER_SUPPLY_TYPE_MAINS, | |
307 | .properties = sbsm_props, | |
308 | .num_properties = ARRAY_SIZE(sbsm_props), | |
309 | .get_property = &sbsm_get_property, | |
310 | .set_property = &sbsm_set_property, | |
311 | .property_is_writeable = &sbsm_prop_is_writeable, | |
312 | }; | |
313 | ||
314 | static int sbsm_probe(struct i2c_client *client, | |
315 | const struct i2c_device_id *id) | |
316 | { | |
317 | struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent); | |
318 | struct sbsm_data *data; | |
319 | struct device *dev = &client->dev; | |
320 | struct power_supply_desc *psy_desc; | |
321 | struct power_supply_config psy_cfg = {}; | |
a0b8839e | 322 | int ret = 0, i; |
dbc4deda KHS |
323 | |
324 | /* Device listens only at address 0x0a */ | |
325 | if (client->addr != 0x0a) | |
326 | return -EINVAL; | |
327 | ||
328 | if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA)) | |
329 | return -EPFNOSUPPORT; | |
330 | ||
331 | data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); | |
332 | if (!data) | |
333 | return -ENOMEM; | |
334 | ||
335 | i2c_set_clientdata(client, data); | |
336 | ||
337 | data->client = client; | |
338 | data->is_ltc1760 = !!strstr(id->name, "ltc1760"); | |
339 | ||
340 | ret = sbsm_read_word(client, SBSM_CMD_BATSYSINFO); | |
341 | if (ret < 0) | |
342 | return ret; | |
a0b8839e | 343 | data->supported_bats = ret & SBSM_MASK_BAT_SUPPORTED; |
dbc4deda KHS |
344 | data->muxc = i2c_mux_alloc(adapter, dev, SBSM_MAX_BATS, 0, |
345 | I2C_MUX_LOCKED, &sbsm_select, NULL); | |
346 | if (!data->muxc) { | |
347 | dev_err(dev, "failed to alloc i2c mux\n"); | |
348 | ret = -ENOMEM; | |
349 | goto err_mux_alloc; | |
350 | } | |
351 | data->muxc->priv = data; | |
352 | ||
353 | /* register muxed i2c channels. One for each supported battery */ | |
354 | for (i = 0; i < SBSM_MAX_BATS; ++i) { | |
a0b8839e | 355 | if (data->supported_bats & BIT(i)) { |
dbc4deda KHS |
356 | ret = i2c_mux_add_adapter(data->muxc, 0, i + 1, 0); |
357 | if (ret) | |
358 | break; | |
359 | } | |
360 | } | |
361 | if (ret) { | |
362 | dev_err(dev, "failed to register i2c mux channel %d\n", i + 1); | |
363 | goto err_mux_register; | |
364 | } | |
365 | ||
366 | psy_desc = devm_kmemdup(dev, &sbsm_default_psy_desc, | |
367 | sizeof(struct power_supply_desc), | |
368 | GFP_KERNEL); | |
369 | if (!psy_desc) { | |
370 | ret = -ENOMEM; | |
371 | goto err_psy; | |
372 | } | |
373 | ||
374 | psy_desc->name = devm_kasprintf(dev, GFP_KERNEL, "sbsm-%s", | |
375 | dev_name(&client->dev)); | |
376 | if (!psy_desc->name) { | |
377 | ret = -ENOMEM; | |
378 | goto err_psy; | |
379 | } | |
a0b8839e PR |
380 | ret = sbsm_gpio_setup(data); |
381 | if (ret < 0) | |
382 | goto err_psy; | |
dbc4deda KHS |
383 | |
384 | psy_cfg.drv_data = data; | |
385 | psy_cfg.of_node = dev->of_node; | |
386 | data->psy = devm_power_supply_register(dev, psy_desc, &psy_cfg); | |
387 | if (IS_ERR(data->psy)) { | |
388 | ret = PTR_ERR(data->psy); | |
389 | dev_err(dev, "failed to register power supply %s\n", | |
390 | psy_desc->name); | |
391 | goto err_psy; | |
392 | } | |
393 | ||
394 | return 0; | |
395 | ||
396 | err_psy: | |
397 | err_mux_register: | |
398 | i2c_mux_del_adapters(data->muxc); | |
399 | ||
400 | err_mux_alloc: | |
401 | return ret; | |
402 | } | |
403 | ||
404 | static int sbsm_remove(struct i2c_client *client) | |
405 | { | |
406 | struct sbsm_data *data = i2c_get_clientdata(client); | |
407 | ||
408 | i2c_mux_del_adapters(data->muxc); | |
409 | return 0; | |
410 | } | |
411 | ||
412 | static const struct i2c_device_id sbsm_ids[] = { | |
413 | { "sbs-manager", 0 }, | |
414 | { "ltc1760", 0 }, | |
415 | { } | |
416 | }; | |
417 | MODULE_DEVICE_TABLE(i2c, sbsm_ids); | |
418 | ||
419 | #ifdef CONFIG_OF | |
420 | static const struct of_device_id sbsm_dt_ids[] = { | |
421 | { .compatible = "sbs,sbs-manager" }, | |
422 | { .compatible = "lltc,ltc1760" }, | |
423 | { } | |
424 | }; | |
425 | MODULE_DEVICE_TABLE(of, sbsm_dt_ids); | |
426 | #endif | |
427 | ||
428 | static struct i2c_driver sbsm_driver = { | |
429 | .driver = { | |
430 | .name = "sbsm", | |
431 | .of_match_table = of_match_ptr(sbsm_dt_ids), | |
432 | }, | |
433 | .probe = sbsm_probe, | |
434 | .remove = sbsm_remove, | |
a0b8839e | 435 | .alert = sbsm_alert, |
dbc4deda KHS |
436 | .id_table = sbsm_ids |
437 | }; | |
438 | module_i2c_driver(sbsm_driver); | |
439 | ||
440 | MODULE_LICENSE("GPL"); | |
441 | MODULE_AUTHOR("Karl-Heinz Schneider <karl-heinz@schneider-inet.de>"); | |
442 | MODULE_DESCRIPTION("SBSM Smart Battery System Manager"); |