1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * intel_pmic.c - Intel PMIC operation region driver |
4 | * |
5 | * Copyright (C) 2014 Intel Corporation. All rights reserved. |
6 | */ |
7 | |
8 | #include <linux/export.h> |
9 | #include <linux/acpi.h> |
10 | #include <linux/mfd/intel_soc_pmic.h> |
11 | #include <linux/regmap.h> |
12 | #include <acpi/acpi_lpat.h> |
13 | #include "intel_pmic.h" |
14 | |
15 | #define PMIC_POWER_OPREGION_ID 0x8d |
16 | #define PMIC_THERMAL_OPREGION_ID 0x8c |
17 | #define PMIC_REGS_OPREGION_ID 0x8f |
18 | |
19 | struct intel_pmic_regs_handler_ctx { |
20 | unsigned int val; |
21 | u16 addr; |
22 | }; |
23 | |
24 | struct intel_pmic_opregion { |
25 | struct mutex lock; |
26 | struct acpi_lpat_conversion_table *lpat_table; |
27 | struct regmap *regmap; |
28 | const struct intel_pmic_opregion_data *data; |
29 | struct intel_pmic_regs_handler_ctx ctx; |
30 | }; |
31 | |
32 | static struct intel_pmic_opregion *intel_pmic_opregion; |
33 | |
34 | static int pmic_get_reg_bit(int address, struct pmic_table *table, |
35 | int count, int *reg, int *bit) |
36 | { |
37 | int i; |
38 | |
39 | for (i = 0; i < count; i++) { |
40 | if (table[i].address == address) { |
41 | *reg = table[i].reg; |
42 | if (bit) |
43 | *bit = table[i].bit; |
44 | return 0; |
45 | } |
46 | } |
47 | return -ENOENT; |
48 | } |
49 | |
50 | static acpi_status intel_pmic_power_handler(u32 function, |
51 | acpi_physical_address address, u32 bits, u64 *value64, |
52 | void *handler_context, void *region_context) |
53 | { |
54 | struct intel_pmic_opregion *opregion = region_context; |
55 | struct regmap *regmap = opregion->regmap; |
56 | const struct intel_pmic_opregion_data *d = opregion->data; |
57 | int reg, bit, result; |
58 | |
59 | if (bits != 32 || !value64) |
60 | return AE_BAD_PARAMETER; |
61 | |
62 | if (function == ACPI_WRITE && !(*value64 == 0 || *value64 == 1)) |
63 | return AE_BAD_PARAMETER; |
64 | |
65 | result = pmic_get_reg_bit(address, table: d->power_table, |
66 | count: d->power_table_count, reg: ®, bit: &bit); |
67 | if (result == -ENOENT) |
68 | return AE_BAD_PARAMETER; |
69 | |
70 | mutex_lock(&opregion->lock); |
71 | |
72 | result = function == ACPI_READ ? |
73 | d->get_power(regmap, reg, bit, value64) : |
74 | d->update_power(regmap, reg, bit, *value64 == 1); |
75 | |
76 | mutex_unlock(lock: &opregion->lock); |
77 | |
78 | return result ? AE_ERROR : AE_OK; |
79 | } |
80 | |
81 | static int pmic_read_temp(struct intel_pmic_opregion *opregion, |
82 | int reg, u64 *value) |
83 | { |
84 | int raw_temp, temp; |
85 | |
86 | if (!opregion->data->get_raw_temp) |
87 | return -ENXIO; |
88 | |
89 | raw_temp = opregion->data->get_raw_temp(opregion->regmap, reg); |
90 | if (raw_temp < 0) |
91 | return raw_temp; |
92 | |
93 | if (!opregion->lpat_table) { |
94 | *value = raw_temp; |
95 | return 0; |
96 | } |
97 | |
98 | temp = opregion->data->lpat_raw_to_temp(opregion->lpat_table, raw_temp); |
99 | if (temp < 0) |
100 | return temp; |
101 | |
102 | *value = temp; |
103 | return 0; |
104 | } |
105 | |
106 | static int pmic_thermal_temp(struct intel_pmic_opregion *opregion, int reg, |
107 | u32 function, u64 *value) |
108 | { |
109 | return function == ACPI_READ ? |
110 | pmic_read_temp(opregion, reg, value) : -EINVAL; |
111 | } |
112 | |
113 | static int pmic_thermal_aux(struct intel_pmic_opregion *opregion, int reg, |
114 | u32 function, u64 *value) |
115 | { |
116 | int raw_temp; |
117 | |
118 | if (function == ACPI_READ) |
119 | return pmic_read_temp(opregion, reg, value); |
120 | |
121 | if (!opregion->data->update_aux) |
122 | return -ENXIO; |
123 | |
124 | if (opregion->lpat_table) { |
125 | raw_temp = acpi_lpat_temp_to_raw(lpat_table: opregion->lpat_table, temp: *value); |
126 | if (raw_temp < 0) |
127 | return raw_temp; |
128 | } else { |
129 | raw_temp = *value; |
130 | } |
131 | |
132 | return opregion->data->update_aux(opregion->regmap, reg, raw_temp); |
133 | } |
134 | |
135 | static int pmic_thermal_pen(struct intel_pmic_opregion *opregion, int reg, |
136 | int bit, u32 function, u64 *value) |
137 | { |
138 | const struct intel_pmic_opregion_data *d = opregion->data; |
139 | struct regmap *regmap = opregion->regmap; |
140 | |
141 | if (!d->get_policy || !d->update_policy) |
142 | return -ENXIO; |
143 | |
144 | if (function == ACPI_READ) |
145 | return d->get_policy(regmap, reg, bit, value); |
146 | |
147 | if (*value != 0 && *value != 1) |
148 | return -EINVAL; |
149 | |
150 | return d->update_policy(regmap, reg, bit, *value); |
151 | } |
152 | |
153 | static bool pmic_thermal_is_temp(int address) |
154 | { |
155 | return (address <= 0x3c) && !(address % 12); |
156 | } |
157 | |
158 | static bool pmic_thermal_is_aux(int address) |
159 | { |
160 | return (address >= 4 && address <= 0x40 && !((address - 4) % 12)) || |
161 | (address >= 8 && address <= 0x44 && !((address - 8) % 12)); |
162 | } |
163 | |
164 | static bool pmic_thermal_is_pen(int address) |
165 | { |
166 | return address >= 0x48 && address <= 0x5c; |
167 | } |
168 | |
169 | static acpi_status intel_pmic_thermal_handler(u32 function, |
170 | acpi_physical_address address, u32 bits, u64 *value64, |
171 | void *handler_context, void *region_context) |
172 | { |
173 | struct intel_pmic_opregion *opregion = region_context; |
174 | const struct intel_pmic_opregion_data *d = opregion->data; |
175 | int reg, bit, result; |
176 | |
177 | if (bits != 32 || !value64) |
178 | return AE_BAD_PARAMETER; |
179 | |
180 | result = pmic_get_reg_bit(address, table: d->thermal_table, |
181 | count: d->thermal_table_count, reg: ®, bit: &bit); |
182 | if (result == -ENOENT) |
183 | return AE_BAD_PARAMETER; |
184 | |
185 | mutex_lock(&opregion->lock); |
186 | |
187 | if (pmic_thermal_is_temp(address)) |
188 | result = pmic_thermal_temp(opregion, reg, function, value: value64); |
189 | else if (pmic_thermal_is_aux(address)) |
190 | result = pmic_thermal_aux(opregion, reg, function, value: value64); |
191 | else if (pmic_thermal_is_pen(address)) |
192 | result = pmic_thermal_pen(opregion, reg, bit, |
193 | function, value: value64); |
194 | else |
195 | result = -EINVAL; |
196 | |
197 | mutex_unlock(lock: &opregion->lock); |
198 | |
199 | if (result < 0) { |
200 | if (result == -EINVAL) |
201 | return AE_BAD_PARAMETER; |
202 | else |
203 | return AE_ERROR; |
204 | } |
205 | |
206 | return AE_OK; |
207 | } |
208 | |
209 | static acpi_status intel_pmic_regs_handler(u32 function, |
210 | acpi_physical_address address, u32 bits, u64 *value64, |
211 | void *handler_context, void *region_context) |
212 | { |
213 | struct intel_pmic_opregion *opregion = region_context; |
214 | int result = -EINVAL; |
215 | |
216 | if (function == ACPI_WRITE) { |
217 | switch (address) { |
218 | case 0: |
219 | return AE_OK; |
220 | case 1: |
221 | opregion->ctx.addr |= (*value64 & 0xff) << 8; |
222 | return AE_OK; |
223 | case 2: |
224 | opregion->ctx.addr |= *value64 & 0xff; |
225 | return AE_OK; |
226 | case 3: |
227 | opregion->ctx.val = *value64 & 0xff; |
228 | return AE_OK; |
229 | case 4: |
230 | if (*value64) { |
231 | result = regmap_write(map: opregion->regmap, reg: opregion->ctx.addr, |
232 | val: opregion->ctx.val); |
233 | } else { |
234 | result = regmap_read(map: opregion->regmap, reg: opregion->ctx.addr, |
235 | val: &opregion->ctx.val); |
236 | } |
237 | opregion->ctx.addr = 0; |
238 | } |
239 | } |
240 | |
241 | if (function == ACPI_READ && address == 3) { |
242 | *value64 = opregion->ctx.val; |
243 | return AE_OK; |
244 | } |
245 | |
246 | if (result < 0) { |
247 | if (result == -EINVAL) |
248 | return AE_BAD_PARAMETER; |
249 | else |
250 | return AE_ERROR; |
251 | } |
252 | |
253 | return AE_OK; |
254 | } |
255 | |
256 | int intel_pmic_install_opregion_handler(struct device *dev, acpi_handle handle, |
257 | struct regmap *regmap, |
258 | const struct intel_pmic_opregion_data *d) |
259 | { |
260 | acpi_status status = AE_OK; |
261 | struct intel_pmic_opregion *opregion; |
262 | int ret; |
263 | |
264 | if (!dev || !regmap || !d) |
265 | return -EINVAL; |
266 | |
267 | if (!handle) |
268 | return -ENODEV; |
269 | |
270 | opregion = devm_kzalloc(dev, size: sizeof(*opregion), GFP_KERNEL); |
271 | if (!opregion) |
272 | return -ENOMEM; |
273 | |
274 | mutex_init(&opregion->lock); |
275 | opregion->regmap = regmap; |
276 | opregion->lpat_table = acpi_lpat_get_conversion_table(handle); |
277 | |
278 | if (d->power_table_count) |
279 | status = acpi_install_address_space_handler(device: handle, |
280 | PMIC_POWER_OPREGION_ID, |
281 | handler: intel_pmic_power_handler, |
282 | NULL, context: opregion); |
283 | if (ACPI_FAILURE(status)) { |
284 | ret = -ENODEV; |
285 | goto out_error; |
286 | } |
287 | |
288 | if (d->thermal_table_count) |
289 | status = acpi_install_address_space_handler(device: handle, |
290 | PMIC_THERMAL_OPREGION_ID, |
291 | handler: intel_pmic_thermal_handler, |
292 | NULL, context: opregion); |
293 | if (ACPI_FAILURE(status)) { |
294 | ret = -ENODEV; |
295 | goto out_remove_power_handler; |
296 | } |
297 | |
298 | status = acpi_install_address_space_handler(device: handle, |
299 | PMIC_REGS_OPREGION_ID, handler: intel_pmic_regs_handler, NULL, |
300 | context: opregion); |
301 | if (ACPI_FAILURE(status)) { |
302 | ret = -ENODEV; |
303 | goto out_remove_thermal_handler; |
304 | } |
305 | |
306 | opregion->data = d; |
307 | intel_pmic_opregion = opregion; |
308 | return 0; |
309 | |
310 | out_remove_thermal_handler: |
311 | if (d->thermal_table_count) |
312 | acpi_remove_address_space_handler(device: handle, |
313 | PMIC_THERMAL_OPREGION_ID, |
314 | handler: intel_pmic_thermal_handler); |
315 | |
316 | out_remove_power_handler: |
317 | if (d->power_table_count) |
318 | acpi_remove_address_space_handler(device: handle, |
319 | PMIC_POWER_OPREGION_ID, |
320 | handler: intel_pmic_power_handler); |
321 | |
322 | out_error: |
323 | acpi_lpat_free_conversion_table(lpat_table: opregion->lpat_table); |
324 | return ret; |
325 | } |
326 | EXPORT_SYMBOL_GPL(intel_pmic_install_opregion_handler); |
327 | |
328 | /** |
329 | * intel_soc_pmic_exec_mipi_pmic_seq_element - Execute PMIC MIPI sequence |
330 | * @i2c_address: I2C client address for the PMIC |
331 | * @reg_address: PMIC register address |
332 | * @value: New value for the register bits to change |
333 | * @mask: Mask indicating which register bits to change |
334 | * |
335 | * DSI LCD panels describe an initialization sequence in the i915 VBT (Video |
336 | * BIOS Tables) using so called MIPI sequences. One possible element in these |
337 | * sequences is a PMIC specific element of 15 bytes. |
338 | * |
339 | * This function executes these PMIC specific elements sending the embedded |
340 | * commands to the PMIC. |
341 | * |
342 | * Return 0 on success, < 0 on failure. |
343 | */ |
344 | int intel_soc_pmic_exec_mipi_pmic_seq_element(u16 i2c_address, u32 reg_address, |
345 | u32 value, u32 mask) |
346 | { |
347 | const struct intel_pmic_opregion_data *d; |
348 | int ret; |
349 | |
350 | if (!intel_pmic_opregion) { |
351 | pr_warn("%s: No PMIC registered\n" , __func__); |
352 | return -ENXIO; |
353 | } |
354 | |
355 | d = intel_pmic_opregion->data; |
356 | |
357 | mutex_lock(&intel_pmic_opregion->lock); |
358 | |
359 | if (d->exec_mipi_pmic_seq_element) { |
360 | ret = d->exec_mipi_pmic_seq_element(intel_pmic_opregion->regmap, |
361 | i2c_address, reg_address, |
362 | value, mask); |
363 | } else if (d->pmic_i2c_address) { |
364 | if (i2c_address == d->pmic_i2c_address) { |
365 | ret = regmap_update_bits(map: intel_pmic_opregion->regmap, |
366 | reg: reg_address, mask, val: value); |
367 | } else { |
368 | pr_err("%s: Unexpected i2c-addr: 0x%02x (reg-addr 0x%x value 0x%x mask 0x%x)\n" , |
369 | __func__, i2c_address, reg_address, value, mask); |
370 | ret = -ENXIO; |
371 | } |
372 | } else { |
373 | pr_warn("%s: Not implemented\n" , __func__); |
374 | pr_warn("%s: i2c-addr: 0x%x reg-addr 0x%x value 0x%x mask 0x%x\n" , |
375 | __func__, i2c_address, reg_address, value, mask); |
376 | ret = -EOPNOTSUPP; |
377 | } |
378 | |
379 | mutex_unlock(lock: &intel_pmic_opregion->lock); |
380 | |
381 | return ret; |
382 | } |
383 | EXPORT_SYMBOL_GPL(intel_soc_pmic_exec_mipi_pmic_seq_element); |
384 | |