1/*
  2 * intel_pmic.c - Intel PMIC operation region driver
  3 *
  4 * Copyright (C) 2014 Intel Corporation. All rights reserved.
  5 *
  6 * This program is free software; you can redistribute it and/or
  7 * modify it under the terms of the GNU General Public License version
  8 * 2 as published by the Free Software Foundation.
  9 *
 10 * This program is distributed in the hope that it will be useful,
 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 13 * GNU General Public License for more details.
 14 */
 15
 16#include <linux/module.h>
 17#include <linux/acpi.h>
 18#include <linux/regmap.h>
 19#include <acpi/acpi_lpat.h>
 20#include "intel_pmic.h"
 21
 22#define PMIC_POWER_OPREGION_ID		0x8d
 23#define PMIC_THERMAL_OPREGION_ID	0x8c
 24
 25struct intel_pmic_opregion {
 26	struct mutex lock;
 27	struct acpi_lpat_conversion_table *lpat_table;
 28	struct regmap *regmap;
 29	struct intel_pmic_opregion_data *data;
 30};
 31
 32static int pmic_get_reg_bit(int address, struct pmic_table *table,
 33			    int count, int *reg, int *bit)
 34{
 35	int i;
 36
 37	for (i = 0; i < count; i++) {
 38		if (table[i].address == address) {
 39			*reg = table[i].reg;
 40			if (bit)
 41				*bit = table[i].bit;
 42			return 0;
 43		}
 44	}
 45	return -ENOENT;
 46}
 47
 48static acpi_status intel_pmic_power_handler(u32 function,
 49		acpi_physical_address address, u32 bits, u64 *value64,
 50		void *handler_context, void *region_context)
 51{
 52	struct intel_pmic_opregion *opregion = region_context;
 53	struct regmap *regmap = opregion->regmap;
 54	struct intel_pmic_opregion_data *d = opregion->data;
 55	int reg, bit, result;
 56
 57	if (bits != 32 || !value64)
 58		return AE_BAD_PARAMETER;
 59
 60	if (function == ACPI_WRITE && !(*value64 == 0 || *value64 == 1))
 61		return AE_BAD_PARAMETER;
 62
 63	result = pmic_get_reg_bit(address, d->power_table,
 64				  d->power_table_count, &reg, &bit);
 65	if (result == -ENOENT)
 66		return AE_BAD_PARAMETER;
 67
 68	mutex_lock(&opregion->lock);
 69
 70	result = function == ACPI_READ ?
 71		d->get_power(regmap, reg, bit, value64) :
 72		d->update_power(regmap, reg, bit, *value64 == 1);
 73
 74	mutex_unlock(&opregion->lock);
 75
 76	return result ? AE_ERROR : AE_OK;
 77}
 78
 79static int pmic_read_temp(struct intel_pmic_opregion *opregion,
 80			  int reg, u64 *value)
 81{
 82	int raw_temp, temp;
 83
 84	if (!opregion->data->get_raw_temp)
 85		return -ENXIO;
 86
 87	raw_temp = opregion->data->get_raw_temp(opregion->regmap, reg);
 88	if (raw_temp < 0)
 89		return raw_temp;
 90
 91	if (!opregion->lpat_table) {
 92		*value = raw_temp;
 93		return 0;
 94	}
 95
 96	temp = acpi_lpat_raw_to_temp(opregion->lpat_table, raw_temp);
 97	if (temp < 0)
 98		return temp;
 99
100	*value = temp;
101	return 0;
102}
103
104static int pmic_thermal_temp(struct intel_pmic_opregion *opregion, int reg,
105			     u32 function, u64 *value)
106{
107	return function == ACPI_READ ?
108		pmic_read_temp(opregion, reg, value) : -EINVAL;
109}
110
111static int pmic_thermal_aux(struct intel_pmic_opregion *opregion, int reg,
112			    u32 function, u64 *value)
113{
114	int raw_temp;
115
116	if (function == ACPI_READ)
117		return pmic_read_temp(opregion, reg, value);
118
119	if (!opregion->data->update_aux)
120		return -ENXIO;
121
122	if (opregion->lpat_table) {
123		raw_temp = acpi_lpat_temp_to_raw(opregion->lpat_table, *value);
124		if (raw_temp < 0)
125			return raw_temp;
126	} else {
127		raw_temp = *value;
128	}
129
130	return opregion->data->update_aux(opregion->regmap, reg, raw_temp);
131}
132
133static int pmic_thermal_pen(struct intel_pmic_opregion *opregion, int reg,
134			    u32 function, u64 *value)
135{
136	struct intel_pmic_opregion_data *d = opregion->data;
137	struct regmap *regmap = opregion->regmap;
138
139	if (!d->get_policy || !d->update_policy)
140		return -ENXIO;
141
142	if (function == ACPI_READ)
143		return d->get_policy(regmap, reg, value);
144
145	if (*value != 0 && *value != 1)
146		return -EINVAL;
147
148	return d->update_policy(regmap, reg, *value);
149}
150
151static bool pmic_thermal_is_temp(int address)
152{
153	return (address <= 0x3c) && !(address % 12);
154}
155
156static bool pmic_thermal_is_aux(int address)
157{
158	return (address >= 4 && address <= 0x40 && !((address - 4) % 12)) ||
159	       (address >= 8 && address <= 0x44 && !((address - 8) % 12));
160}
161
162static bool pmic_thermal_is_pen(int address)
163{
164	return address >= 0x48 && address <= 0x5c;
165}
166
167static acpi_status intel_pmic_thermal_handler(u32 function,
168		acpi_physical_address address, u32 bits, u64 *value64,
169		void *handler_context, void *region_context)
170{
171	struct intel_pmic_opregion *opregion = region_context;
172	struct intel_pmic_opregion_data *d = opregion->data;
173	int reg, result;
174
175	if (bits != 32 || !value64)
176		return AE_BAD_PARAMETER;
177
178	result = pmic_get_reg_bit(address, d->thermal_table,
179				  d->thermal_table_count, &reg, NULL);
180	if (result == -ENOENT)
181		return AE_BAD_PARAMETER;
182
183	mutex_lock(&opregion->lock);
184
185	if (pmic_thermal_is_temp(address))
186		result = pmic_thermal_temp(opregion, reg, function, value64);
187	else if (pmic_thermal_is_aux(address))
188		result = pmic_thermal_aux(opregion, reg, function, value64);
189	else if (pmic_thermal_is_pen(address))
190		result = pmic_thermal_pen(opregion, reg, function, value64);
191	else
192		result = -EINVAL;
193
194	mutex_unlock(&opregion->lock);
195
196	if (result < 0) {
197		if (result == -EINVAL)
198			return AE_BAD_PARAMETER;
199		else
200			return AE_ERROR;
201	}
202
203	return AE_OK;
204}
205
206int intel_pmic_install_opregion_handler(struct device *dev, acpi_handle handle,
207					struct regmap *regmap,
208					struct intel_pmic_opregion_data *d)
209{
210	acpi_status status;
211	struct intel_pmic_opregion *opregion;
212	int ret;
213
214	if (!dev || !regmap || !d)
215		return -EINVAL;
216
217	if (!handle)
218		return -ENODEV;
219
220	opregion = devm_kzalloc(dev, sizeof(*opregion), GFP_KERNEL);
221	if (!opregion)
222		return -ENOMEM;
223
224	mutex_init(&opregion->lock);
225	opregion->regmap = regmap;
226	opregion->lpat_table = acpi_lpat_get_conversion_table(handle);
227
228	status = acpi_install_address_space_handler(handle,
229						    PMIC_POWER_OPREGION_ID,
230						    intel_pmic_power_handler,
231						    NULL, opregion);
232	if (ACPI_FAILURE(status)) {
233		ret = -ENODEV;
234		goto out_error;
235	}
236
237	status = acpi_install_address_space_handler(handle,
238						    PMIC_THERMAL_OPREGION_ID,
239						    intel_pmic_thermal_handler,
240						    NULL, opregion);
241	if (ACPI_FAILURE(status)) {
242		acpi_remove_address_space_handler(handle, PMIC_POWER_OPREGION_ID,
243						  intel_pmic_power_handler);
244		ret = -ENODEV;
245		goto out_error;
246	}
247
248	opregion->data = d;
249	return 0;
250
251out_error:
252	acpi_lpat_free_conversion_table(opregion->lpat_table);
253	return ret;
254}
255EXPORT_SYMBOL_GPL(intel_pmic_install_opregion_handler);
256
257MODULE_LICENSE("GPL");