1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * Nokia RX-51 battery driver |
4 | * |
5 | * Copyright (C) 2012 Pali Rohár <pali@kernel.org> |
6 | */ |
7 | |
8 | #include <linux/module.h> |
9 | #include <linux/param.h> |
10 | #include <linux/platform_device.h> |
11 | #include <linux/power_supply.h> |
12 | #include <linux/slab.h> |
13 | #include <linux/iio/consumer.h> |
14 | #include <linux/of.h> |
15 | |
16 | struct rx51_device_info { |
17 | struct device *dev; |
18 | struct power_supply *bat; |
19 | struct power_supply_desc bat_desc; |
20 | struct iio_channel *channel_temp; |
21 | struct iio_channel *channel_bsi; |
22 | struct iio_channel *channel_vbat; |
23 | }; |
24 | |
25 | /* |
26 | * Read ADCIN channel value, code copied from maemo kernel |
27 | */ |
28 | static int rx51_battery_read_adc(struct iio_channel *channel) |
29 | { |
30 | int val, err; |
31 | err = iio_read_channel_average_raw(chan: channel, val: &val); |
32 | if (err < 0) |
33 | return err; |
34 | return val; |
35 | } |
36 | |
37 | /* |
38 | * Read ADCIN channel 12 (voltage) and convert RAW value to micro voltage |
39 | * This conversion formula was extracted from maemo program bsi-read |
40 | */ |
41 | static int rx51_battery_read_voltage(struct rx51_device_info *di) |
42 | { |
43 | int voltage = rx51_battery_read_adc(channel: di->channel_vbat); |
44 | |
45 | if (voltage < 0) { |
46 | dev_err(di->dev, "Could not read ADC: %d\n" , voltage); |
47 | return voltage; |
48 | } |
49 | |
50 | return 1000 * (10000 * voltage / 1705); |
51 | } |
52 | |
53 | /* |
54 | * Temperature look-up tables |
55 | * TEMP = (1/(t1 + 1/298) - 273.15) |
56 | * Where t1 = (1/B) * ln((RAW_ADC_U * 2.5)/(R * I * 255)) |
57 | * Formula is based on experimental data, RX-51 CAL data, maemo program bme |
58 | * and formula from da9052 driver with values R = 100, B = 3380, I = 0.00671 |
59 | */ |
60 | |
61 | /* |
62 | * Table1 (temperature for first 25 RAW values) |
63 | * Usage: TEMP = rx51_temp_table1[RAW] |
64 | * RAW is between 1 and 24 |
65 | * TEMP is between 201 C and 55 C |
66 | */ |
67 | static u8 rx51_temp_table1[] = { |
68 | 255, 201, 159, 138, 124, 114, 106, 99, 94, 89, 85, 82, 78, 75, |
69 | 73, 70, 68, 66, 64, 62, 61, 59, 57, 56, 55 |
70 | }; |
71 | |
72 | /* |
73 | * Table2 (lowest RAW value for temperature) |
74 | * Usage: RAW = rx51_temp_table2[TEMP-rx51_temp_table2_first] |
75 | * TEMP is between 53 C and -32 C |
76 | * RAW is between 25 and 993 |
77 | */ |
78 | #define rx51_temp_table2_first 53 |
79 | static u16 rx51_temp_table2[] = { |
80 | 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 39, |
81 | 40, 41, 43, 44, 46, 48, 49, 51, 53, 55, 57, 59, 61, 64, |
82 | 66, 69, 71, 74, 77, 80, 83, 86, 90, 94, 97, 101, 106, 110, |
83 | 115, 119, 125, 130, 136, 141, 148, 154, 161, 168, 176, 184, 202, 211, |
84 | 221, 231, 242, 254, 266, 279, 293, 308, 323, 340, 357, 375, 395, 415, |
85 | 437, 460, 485, 511, 539, 568, 600, 633, 669, 706, 747, 790, 836, 885, |
86 | 937, 993, 1024 |
87 | }; |
88 | |
89 | /* |
90 | * Read ADCIN channel 0 (battery temp) and convert value to tenths of Celsius |
91 | * Use Temperature look-up tables for conversation |
92 | */ |
93 | static int rx51_battery_read_temperature(struct rx51_device_info *di) |
94 | { |
95 | int min = 0; |
96 | int max = ARRAY_SIZE(rx51_temp_table2) - 1; |
97 | int raw = rx51_battery_read_adc(channel: di->channel_temp); |
98 | |
99 | if (raw < 0) |
100 | dev_err(di->dev, "Could not read ADC: %d\n" , raw); |
101 | |
102 | /* Zero and negative values are undefined */ |
103 | if (raw <= 0) |
104 | return INT_MAX; |
105 | |
106 | /* ADC channels are 10 bit, higher value are undefined */ |
107 | if (raw >= (1 << 10)) |
108 | return INT_MIN; |
109 | |
110 | /* First check for temperature in first direct table */ |
111 | if (raw < ARRAY_SIZE(rx51_temp_table1)) |
112 | return rx51_temp_table1[raw] * 10; |
113 | |
114 | /* Binary search RAW value in second inverse table */ |
115 | while (max - min > 1) { |
116 | int mid = (max + min) / 2; |
117 | if (rx51_temp_table2[mid] <= raw) |
118 | min = mid; |
119 | else if (rx51_temp_table2[mid] > raw) |
120 | max = mid; |
121 | if (rx51_temp_table2[mid] == raw) |
122 | break; |
123 | } |
124 | |
125 | return (rx51_temp_table2_first - min) * 10; |
126 | } |
127 | |
128 | /* |
129 | * Read ADCIN channel 4 (BSI) and convert RAW value to micro Ah |
130 | * This conversion formula was extracted from maemo program bsi-read |
131 | */ |
132 | static int rx51_battery_read_capacity(struct rx51_device_info *di) |
133 | { |
134 | int capacity = rx51_battery_read_adc(channel: di->channel_bsi); |
135 | |
136 | if (capacity < 0) { |
137 | dev_err(di->dev, "Could not read ADC: %d\n" , capacity); |
138 | return capacity; |
139 | } |
140 | |
141 | return 1280 * (1200 * capacity)/(1024 - capacity); |
142 | } |
143 | |
144 | /* |
145 | * Return power_supply property |
146 | */ |
147 | static int rx51_battery_get_property(struct power_supply *psy, |
148 | enum power_supply_property psp, |
149 | union power_supply_propval *val) |
150 | { |
151 | struct rx51_device_info *di = power_supply_get_drvdata(psy); |
152 | |
153 | switch (psp) { |
154 | case POWER_SUPPLY_PROP_TECHNOLOGY: |
155 | val->intval = POWER_SUPPLY_TECHNOLOGY_LION; |
156 | break; |
157 | case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN: |
158 | val->intval = 4200000; |
159 | break; |
160 | case POWER_SUPPLY_PROP_PRESENT: |
161 | val->intval = rx51_battery_read_voltage(di) ? 1 : 0; |
162 | break; |
163 | case POWER_SUPPLY_PROP_VOLTAGE_NOW: |
164 | val->intval = rx51_battery_read_voltage(di); |
165 | break; |
166 | case POWER_SUPPLY_PROP_TEMP: |
167 | val->intval = rx51_battery_read_temperature(di); |
168 | break; |
169 | case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN: |
170 | val->intval = rx51_battery_read_capacity(di); |
171 | break; |
172 | default: |
173 | return -EINVAL; |
174 | } |
175 | |
176 | if (val->intval == INT_MAX || val->intval == INT_MIN) |
177 | return -EINVAL; |
178 | |
179 | return 0; |
180 | } |
181 | |
182 | static enum power_supply_property rx51_battery_props[] = { |
183 | POWER_SUPPLY_PROP_TECHNOLOGY, |
184 | POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN, |
185 | POWER_SUPPLY_PROP_PRESENT, |
186 | POWER_SUPPLY_PROP_VOLTAGE_NOW, |
187 | POWER_SUPPLY_PROP_TEMP, |
188 | POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, |
189 | }; |
190 | |
191 | static int rx51_battery_probe(struct platform_device *pdev) |
192 | { |
193 | struct power_supply_config psy_cfg = {}; |
194 | struct rx51_device_info *di; |
195 | int ret; |
196 | |
197 | di = devm_kzalloc(dev: &pdev->dev, size: sizeof(*di), GFP_KERNEL); |
198 | if (!di) |
199 | return -ENOMEM; |
200 | |
201 | platform_set_drvdata(pdev, data: di); |
202 | |
203 | di->dev = &pdev->dev; |
204 | di->bat_desc.name = "rx51-battery" ; |
205 | di->bat_desc.type = POWER_SUPPLY_TYPE_BATTERY; |
206 | di->bat_desc.properties = rx51_battery_props; |
207 | di->bat_desc.num_properties = ARRAY_SIZE(rx51_battery_props); |
208 | di->bat_desc.get_property = rx51_battery_get_property; |
209 | |
210 | psy_cfg.drv_data = di; |
211 | |
212 | di->channel_temp = iio_channel_get(dev: di->dev, consumer_channel: "temp" ); |
213 | if (IS_ERR(ptr: di->channel_temp)) { |
214 | ret = PTR_ERR(ptr: di->channel_temp); |
215 | goto error; |
216 | } |
217 | |
218 | di->channel_bsi = iio_channel_get(dev: di->dev, consumer_channel: "bsi" ); |
219 | if (IS_ERR(ptr: di->channel_bsi)) { |
220 | ret = PTR_ERR(ptr: di->channel_bsi); |
221 | goto error_channel_temp; |
222 | } |
223 | |
224 | di->channel_vbat = iio_channel_get(dev: di->dev, consumer_channel: "vbat" ); |
225 | if (IS_ERR(ptr: di->channel_vbat)) { |
226 | ret = PTR_ERR(ptr: di->channel_vbat); |
227 | goto error_channel_bsi; |
228 | } |
229 | |
230 | di->bat = power_supply_register(parent: di->dev, desc: &di->bat_desc, cfg: &psy_cfg); |
231 | if (IS_ERR(ptr: di->bat)) { |
232 | ret = PTR_ERR(ptr: di->bat); |
233 | goto error_channel_vbat; |
234 | } |
235 | |
236 | return 0; |
237 | |
238 | error_channel_vbat: |
239 | iio_channel_release(chan: di->channel_vbat); |
240 | error_channel_bsi: |
241 | iio_channel_release(chan: di->channel_bsi); |
242 | error_channel_temp: |
243 | iio_channel_release(chan: di->channel_temp); |
244 | error: |
245 | |
246 | return ret; |
247 | } |
248 | |
249 | static void rx51_battery_remove(struct platform_device *pdev) |
250 | { |
251 | struct rx51_device_info *di = platform_get_drvdata(pdev); |
252 | |
253 | power_supply_unregister(psy: di->bat); |
254 | |
255 | iio_channel_release(chan: di->channel_vbat); |
256 | iio_channel_release(chan: di->channel_bsi); |
257 | iio_channel_release(chan: di->channel_temp); |
258 | } |
259 | |
260 | #ifdef CONFIG_OF |
261 | static const struct of_device_id n900_battery_of_match[] = { |
262 | {.compatible = "nokia,n900-battery" , }, |
263 | { }, |
264 | }; |
265 | MODULE_DEVICE_TABLE(of, n900_battery_of_match); |
266 | #endif |
267 | |
268 | static struct platform_driver rx51_battery_driver = { |
269 | .probe = rx51_battery_probe, |
270 | .remove_new = rx51_battery_remove, |
271 | .driver = { |
272 | .name = "rx51-battery" , |
273 | .of_match_table = of_match_ptr(n900_battery_of_match), |
274 | }, |
275 | }; |
276 | module_platform_driver(rx51_battery_driver); |
277 | |
278 | MODULE_ALIAS("platform:rx51-battery" ); |
279 | MODULE_AUTHOR("Pali Rohár <pali@kernel.org>" ); |
280 | MODULE_DESCRIPTION("Nokia RX-51 battery driver" ); |
281 | MODULE_LICENSE("GPL" ); |
282 | |