1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * XPower AXP288 PMIC operation region driver |
4 | * |
5 | * Copyright (C) 2014 Intel Corporation. All rights reserved. |
6 | */ |
7 | |
8 | #include <linux/acpi.h> |
9 | #include <linux/init.h> |
10 | #include <linux/mfd/axp20x.h> |
11 | #include <linux/regmap.h> |
12 | #include <linux/platform_device.h> |
13 | #include <asm/iosf_mbi.h> |
14 | #include "intel_pmic.h" |
15 | |
16 | #define XPOWER_GPADC_LOW 0x5b |
17 | #define XPOWER_GPI1_CTRL 0x92 |
18 | |
19 | #define GPI1_LDO_MASK GENMASK(2, 0) |
20 | #define GPI1_LDO_ON (3 << 0) |
21 | #define GPI1_LDO_OFF (4 << 0) |
22 | |
23 | #define AXP288_ADC_TS_CURRENT_ON_OFF_MASK GENMASK(1, 0) |
24 | #define AXP288_ADC_TS_CURRENT_OFF (0 << 0) |
25 | #define AXP288_ADC_TS_CURRENT_ON_WHEN_CHARGING (1 << 0) |
26 | #define AXP288_ADC_TS_CURRENT_ON_ONDEMAND (2 << 0) |
27 | #define AXP288_ADC_TS_CURRENT_ON (3 << 0) |
28 | |
29 | static struct pmic_table power_table[] = { |
30 | { |
31 | .address = 0x00, |
32 | .reg = 0x13, |
33 | .bit = 0x05, |
34 | }, /* ALD1 */ |
35 | { |
36 | .address = 0x04, |
37 | .reg = 0x13, |
38 | .bit = 0x06, |
39 | }, /* ALD2 */ |
40 | { |
41 | .address = 0x08, |
42 | .reg = 0x13, |
43 | .bit = 0x07, |
44 | }, /* ALD3 */ |
45 | { |
46 | .address = 0x0c, |
47 | .reg = 0x12, |
48 | .bit = 0x03, |
49 | }, /* DLD1 */ |
50 | { |
51 | .address = 0x10, |
52 | .reg = 0x12, |
53 | .bit = 0x04, |
54 | }, /* DLD2 */ |
55 | { |
56 | .address = 0x14, |
57 | .reg = 0x12, |
58 | .bit = 0x05, |
59 | }, /* DLD3 */ |
60 | { |
61 | .address = 0x18, |
62 | .reg = 0x12, |
63 | .bit = 0x06, |
64 | }, /* DLD4 */ |
65 | { |
66 | .address = 0x1c, |
67 | .reg = 0x12, |
68 | .bit = 0x00, |
69 | }, /* ELD1 */ |
70 | { |
71 | .address = 0x20, |
72 | .reg = 0x12, |
73 | .bit = 0x01, |
74 | }, /* ELD2 */ |
75 | { |
76 | .address = 0x24, |
77 | .reg = 0x12, |
78 | .bit = 0x02, |
79 | }, /* ELD3 */ |
80 | { |
81 | .address = 0x28, |
82 | .reg = 0x13, |
83 | .bit = 0x02, |
84 | }, /* FLD1 */ |
85 | { |
86 | .address = 0x2c, |
87 | .reg = 0x13, |
88 | .bit = 0x03, |
89 | }, /* FLD2 */ |
90 | { |
91 | .address = 0x30, |
92 | .reg = 0x13, |
93 | .bit = 0x04, |
94 | }, /* FLD3 */ |
95 | { |
96 | .address = 0x34, |
97 | .reg = 0x10, |
98 | .bit = 0x03, |
99 | }, /* BUC1 */ |
100 | { |
101 | .address = 0x38, |
102 | .reg = 0x10, |
103 | .bit = 0x06, |
104 | }, /* BUC2 */ |
105 | { |
106 | .address = 0x3c, |
107 | .reg = 0x10, |
108 | .bit = 0x05, |
109 | }, /* BUC3 */ |
110 | { |
111 | .address = 0x40, |
112 | .reg = 0x10, |
113 | .bit = 0x04, |
114 | }, /* BUC4 */ |
115 | { |
116 | .address = 0x44, |
117 | .reg = 0x10, |
118 | .bit = 0x01, |
119 | }, /* BUC5 */ |
120 | { |
121 | .address = 0x48, |
122 | .reg = 0x10, |
123 | .bit = 0x00 |
124 | }, /* BUC6 */ |
125 | { |
126 | .address = 0x4c, |
127 | .reg = 0x92, |
128 | }, /* GPI1 */ |
129 | }; |
130 | |
131 | /* TMP0 - TMP5 are the same, all from GPADC */ |
132 | static struct pmic_table thermal_table[] = { |
133 | { |
134 | .address = 0x00, |
135 | .reg = XPOWER_GPADC_LOW |
136 | }, |
137 | { |
138 | .address = 0x0c, |
139 | .reg = XPOWER_GPADC_LOW |
140 | }, |
141 | { |
142 | .address = 0x18, |
143 | .reg = XPOWER_GPADC_LOW |
144 | }, |
145 | { |
146 | .address = 0x24, |
147 | .reg = XPOWER_GPADC_LOW |
148 | }, |
149 | { |
150 | .address = 0x30, |
151 | .reg = XPOWER_GPADC_LOW |
152 | }, |
153 | { |
154 | .address = 0x3c, |
155 | .reg = XPOWER_GPADC_LOW |
156 | }, |
157 | }; |
158 | |
159 | static int intel_xpower_pmic_get_power(struct regmap *regmap, int reg, |
160 | int bit, u64 *value) |
161 | { |
162 | int data; |
163 | |
164 | if (regmap_read(map: regmap, reg, val: &data)) |
165 | return -EIO; |
166 | |
167 | /* GPIO1 LDO regulator needs special handling */ |
168 | if (reg == XPOWER_GPI1_CTRL) |
169 | *value = ((data & GPI1_LDO_MASK) == GPI1_LDO_ON); |
170 | else |
171 | *value = (data & BIT(bit)) ? 1 : 0; |
172 | |
173 | return 0; |
174 | } |
175 | |
176 | static int intel_xpower_pmic_update_power(struct regmap *regmap, int reg, |
177 | int bit, bool on) |
178 | { |
179 | int data, ret; |
180 | |
181 | ret = iosf_mbi_block_punit_i2c_access(); |
182 | if (ret) |
183 | return ret; |
184 | |
185 | /* GPIO1 LDO regulator needs special handling */ |
186 | if (reg == XPOWER_GPI1_CTRL) { |
187 | ret = regmap_update_bits(map: regmap, reg, GPI1_LDO_MASK, |
188 | val: on ? GPI1_LDO_ON : GPI1_LDO_OFF); |
189 | goto out; |
190 | } |
191 | |
192 | if (regmap_read(map: regmap, reg, val: &data)) { |
193 | ret = -EIO; |
194 | goto out; |
195 | } |
196 | |
197 | if (on) |
198 | data |= BIT(bit); |
199 | else |
200 | data &= ~BIT(bit); |
201 | |
202 | if (regmap_write(map: regmap, reg, val: data)) |
203 | ret = -EIO; |
204 | out: |
205 | iosf_mbi_unblock_punit_i2c_access(); |
206 | |
207 | return ret; |
208 | } |
209 | |
210 | /** |
211 | * intel_xpower_pmic_get_raw_temp(): Get raw temperature reading from the PMIC |
212 | * |
213 | * @regmap: regmap of the PMIC device |
214 | * @reg: register to get the reading |
215 | * |
216 | * Return a positive value on success, errno on failure. |
217 | */ |
218 | static int intel_xpower_pmic_get_raw_temp(struct regmap *regmap, int reg) |
219 | { |
220 | int ret, adc_ts_pin_ctrl; |
221 | u8 buf[2]; |
222 | |
223 | /* |
224 | * The current-source used for the battery temp-sensor (TS) is shared |
225 | * with the GPADC. For proper fuel-gauge and charger operation the TS |
226 | * current-source needs to be permanently on. But to read the GPADC we |
227 | * need to temporary switch the TS current-source to ondemand, so that |
228 | * the GPADC can use it, otherwise we will always read an all 0 value. |
229 | * |
230 | * Note that the switching from on to on-ondemand is not necessary |
231 | * when the TS current-source is off (this happens on devices which |
232 | * do not use the TS-pin). |
233 | */ |
234 | ret = regmap_read(map: regmap, AXP288_ADC_TS_PIN_CTRL, val: &adc_ts_pin_ctrl); |
235 | if (ret) |
236 | return ret; |
237 | |
238 | if (adc_ts_pin_ctrl & AXP288_ADC_TS_CURRENT_ON_OFF_MASK) { |
239 | /* |
240 | * AXP288_ADC_TS_PIN_CTRL reads are cached by the regmap, so |
241 | * this does to a single I2C-transfer, and thus there is no |
242 | * need to explicitly call iosf_mbi_block_punit_i2c_access(). |
243 | */ |
244 | ret = regmap_update_bits(map: regmap, AXP288_ADC_TS_PIN_CTRL, |
245 | AXP288_ADC_TS_CURRENT_ON_OFF_MASK, |
246 | AXP288_ADC_TS_CURRENT_ON_ONDEMAND); |
247 | if (ret) |
248 | return ret; |
249 | |
250 | /* Wait a bit after switching the current-source */ |
251 | usleep_range(min: 6000, max: 10000); |
252 | } |
253 | |
254 | ret = iosf_mbi_block_punit_i2c_access(); |
255 | if (ret) |
256 | return ret; |
257 | |
258 | ret = regmap_bulk_read(map: regmap, AXP288_GP_ADC_H, val: buf, val_count: 2); |
259 | if (ret == 0) |
260 | ret = (buf[0] << 4) + ((buf[1] >> 4) & 0x0f); |
261 | |
262 | if (adc_ts_pin_ctrl & AXP288_ADC_TS_CURRENT_ON_OFF_MASK) { |
263 | regmap_update_bits(map: regmap, AXP288_ADC_TS_PIN_CTRL, |
264 | AXP288_ADC_TS_CURRENT_ON_OFF_MASK, |
265 | AXP288_ADC_TS_CURRENT_ON); |
266 | } |
267 | |
268 | iosf_mbi_unblock_punit_i2c_access(); |
269 | |
270 | return ret; |
271 | } |
272 | |
273 | static int intel_xpower_exec_mipi_pmic_seq_element(struct regmap *regmap, |
274 | u16 i2c_address, u32 reg_address, |
275 | u32 value, u32 mask) |
276 | { |
277 | int ret; |
278 | |
279 | if (i2c_address != 0x34) { |
280 | pr_err("%s: Unexpected i2c-addr: 0x%02x (reg-addr 0x%x value 0x%x mask 0x%x)\n" , |
281 | __func__, i2c_address, reg_address, value, mask); |
282 | return -ENXIO; |
283 | } |
284 | |
285 | ret = iosf_mbi_block_punit_i2c_access(); |
286 | if (ret) |
287 | return ret; |
288 | |
289 | ret = regmap_update_bits(map: regmap, reg: reg_address, mask, val: value); |
290 | |
291 | iosf_mbi_unblock_punit_i2c_access(); |
292 | |
293 | return ret; |
294 | } |
295 | |
296 | static int intel_xpower_lpat_raw_to_temp(struct acpi_lpat_conversion_table *lpat_table, |
297 | int raw) |
298 | { |
299 | struct acpi_lpat first = lpat_table->lpat[0]; |
300 | struct acpi_lpat last = lpat_table->lpat[lpat_table->lpat_count - 1]; |
301 | |
302 | /* |
303 | * Some LPAT tables in the ACPI Device for the AXP288 PMIC for some |
304 | * reason only describe a small temperature range, e.g. 27° - 37° |
305 | * Celcius. Resulting in errors when the tablet is idle in a cool room. |
306 | * |
307 | * To avoid these errors clamp the raw value to be inside the LPAT. |
308 | */ |
309 | if (first.raw < last.raw) |
310 | raw = clamp(raw, first.raw, last.raw); |
311 | else |
312 | raw = clamp(raw, last.raw, first.raw); |
313 | |
314 | return acpi_lpat_raw_to_temp(lpat_table, raw); |
315 | } |
316 | |
317 | static const struct intel_pmic_opregion_data intel_xpower_pmic_opregion_data = { |
318 | .get_power = intel_xpower_pmic_get_power, |
319 | .update_power = intel_xpower_pmic_update_power, |
320 | .get_raw_temp = intel_xpower_pmic_get_raw_temp, |
321 | .exec_mipi_pmic_seq_element = intel_xpower_exec_mipi_pmic_seq_element, |
322 | .lpat_raw_to_temp = intel_xpower_lpat_raw_to_temp, |
323 | .power_table = power_table, |
324 | .power_table_count = ARRAY_SIZE(power_table), |
325 | .thermal_table = thermal_table, |
326 | .thermal_table_count = ARRAY_SIZE(thermal_table), |
327 | .pmic_i2c_address = 0x34, |
328 | }; |
329 | |
330 | static acpi_status intel_xpower_pmic_gpio_handler(u32 function, |
331 | acpi_physical_address address, u32 bit_width, u64 *value, |
332 | void *handler_context, void *region_context) |
333 | { |
334 | return AE_OK; |
335 | } |
336 | |
337 | static int intel_xpower_pmic_opregion_probe(struct platform_device *pdev) |
338 | { |
339 | struct device *parent = pdev->dev.parent; |
340 | struct axp20x_dev *axp20x = dev_get_drvdata(dev: parent); |
341 | acpi_status status; |
342 | int result; |
343 | |
344 | status = acpi_install_address_space_handler(ACPI_HANDLE(parent), |
345 | ACPI_ADR_SPACE_GPIO, handler: intel_xpower_pmic_gpio_handler, |
346 | NULL, NULL); |
347 | if (ACPI_FAILURE(status)) |
348 | return -ENODEV; |
349 | |
350 | result = intel_pmic_install_opregion_handler(dev: &pdev->dev, |
351 | ACPI_HANDLE(parent), regmap: axp20x->regmap, |
352 | d: &intel_xpower_pmic_opregion_data); |
353 | if (result) |
354 | acpi_remove_address_space_handler(ACPI_HANDLE(parent), |
355 | ACPI_ADR_SPACE_GPIO, |
356 | handler: intel_xpower_pmic_gpio_handler); |
357 | |
358 | return result; |
359 | } |
360 | |
361 | static struct platform_driver intel_xpower_pmic_opregion_driver = { |
362 | .probe = intel_xpower_pmic_opregion_probe, |
363 | .driver = { |
364 | .name = "axp288_pmic_acpi" , |
365 | }, |
366 | }; |
367 | builtin_platform_driver(intel_xpower_pmic_opregion_driver); |
368 | |