[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / hwmon / ltc4245.c

/*
 * Driver for Linear Technology LTC4245 I2C Multiple Supply Hot Swap Controller
 *
 * Copyright (C) 2008 Ira W. Snyder <iws@ovro.caltech.edu>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; version 2 of the License.
 *
 * This driver is based on the ds1621 and ina209 drivers.
 *
 * Datasheet:
 * http://www.linear.com/pc/downloadDocument.do?navId=H0,C1,C1003,C1006,C1140,P19392,D13517
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/err.h>
#include <linux/slab.h>
#include <linux/i2c.h>
#include <linux/hwmon.h>
#include <linux/hwmon-sysfs.h>
#include <linux/jiffies.h>
#include <linux/i2c/ltc4245.h>

/* Here are names of the chip's registers (a.k.a. commands) */
enum ltc4245_cmd {
	LTC4245_STATUS			= 0x00, /* readonly */
	LTC4245_ALERT			= 0x01,
	LTC4245_CONTROL			= 0x02,
	LTC4245_ON			= 0x03,
	LTC4245_FAULT1			= 0x04,
	LTC4245_FAULT2			= 0x05,
	LTC4245_GPIO			= 0x06,
	LTC4245_ADCADR			= 0x07,

	LTC4245_12VIN			= 0x10,
	LTC4245_12VSENSE		= 0x11,
	LTC4245_12VOUT			= 0x12,
	LTC4245_5VIN			= 0x13,
	LTC4245_5VSENSE			= 0x14,
	LTC4245_5VOUT			= 0x15,
	LTC4245_3VIN			= 0x16,
	LTC4245_3VSENSE			= 0x17,
	LTC4245_3VOUT			= 0x18,
	LTC4245_VEEIN			= 0x19,
	LTC4245_VEESENSE		= 0x1a,
	LTC4245_VEEOUT			= 0x1b,
	LTC4245_GPIOADC			= 0x1c,
};

struct ltc4245_data {
	struct device *hwmon_dev;

	struct mutex update_lock;
	bool valid;
	unsigned long last_updated; /* in jiffies */

	/* Control registers */
	u8 cregs[0x08];

	/* Voltage registers */
	u8 vregs[0x0d];

	/* GPIO ADC registers */
	bool use_extra_gpios;
	int gpios[3];
};

/*
 * Update the readings from the GPIO pins. If the driver has been configured to
 * sample all GPIO's as analog voltages, a round-robin sampling method is used.
 * Otherwise, only the configured GPIO pin is sampled.
 *
 * LOCKING: must hold data->update_lock
 */
static void ltc4245_update_gpios(struct device *dev)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct ltc4245_data *data = i2c_get_clientdata(client);
	u8 gpio_curr, gpio_next, gpio_reg;
	int i;

	/* no extra gpio support, we're basically done */
	if (!data->use_extra_gpios) {
		data->gpios[0] = data->vregs[LTC4245_GPIOADC - 0x10];
		return;
	}

	/*
	 * If the last reading was too long ago, then we mark all old GPIO
	 * readings as stale by setting them to -EAGAIN
	 */
	if (time_after(jiffies, data->last_updated + 5 * HZ)) {
		dev_dbg(&client->dev, "Marking GPIOs invalid\n");
		for (i = 0; i < ARRAY_SIZE(data->gpios); i++)
			data->gpios[i] = -EAGAIN;
	}

	/*
	 * Get the current GPIO pin
	 *
	 * The datasheet calls these GPIO[1-3], but we'll calculate the zero
	 * based array index instead, and call them GPIO[0-2]. This is much
	 * easier to think about.
	 */
	gpio_curr = (data->cregs[LTC4245_GPIO] & 0xc0) >> 6;
	if (gpio_curr > 0)
		gpio_curr -= 1;

	/* Read the GPIO voltage from the GPIOADC register */
	data->gpios[gpio_curr] = data->vregs[LTC4245_GPIOADC - 0x10];

	/* Find the next GPIO pin to read */
	gpio_next = (gpio_curr + 1) % ARRAY_SIZE(data->gpios);

	/*
	 * Calculate the correct setting for the GPIO register so it will
	 * sample the next GPIO pin
	 */
	gpio_reg = (data->cregs[LTC4245_GPIO] & 0x3f) | ((gpio_next + 1) << 6);

	/* Update the GPIO register */
	i2c_smbus_write_byte_data(client, LTC4245_GPIO, gpio_reg);

	/* Update saved data */
	data->cregs[LTC4245_GPIO] = gpio_reg;
}

static struct ltc4245_data *ltc4245_update_device(struct device *dev)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct ltc4245_data *data = i2c_get_clientdata(client);
	s32 val;
	int i;

	mutex_lock(&data->update_lock);

	if (time_after(jiffies, data->last_updated + HZ) || !data->valid) {

		dev_dbg(&client->dev, "Starting ltc4245 update\n");

		/* Read control registers -- 0x00 to 0x07 */
		for (i = 0; i < ARRAY_SIZE(data->cregs); i++) {
			val = i2c_smbus_read_byte_data(client, i);
			if (unlikely(val < 0))
				data->cregs[i] = 0;
			else
				data->cregs[i] = val;
		}

		/* Read voltage registers -- 0x10 to 0x1c */
		for (i = 0; i < ARRAY_SIZE(data->vregs); i++) {
			val = i2c_smbus_read_byte_data(client, i+0x10);
			if (unlikely(val < 0))
				data->vregs[i] = 0;
			else
				data->vregs[i] = val;
		}

		/* Update GPIO readings */
		ltc4245_update_gpios(dev);

		data->last_updated = jiffies;
		data->valid = 1;
	}

	mutex_unlock(&data->update_lock);

	return data;
}

/* Return the voltage from the given register in millivolts */
static int ltc4245_get_voltage(struct device *dev, u8 reg)
{
	struct ltc4245_data *data = ltc4245_update_device(dev);
	const u8 regval = data->vregs[reg - 0x10];
	u32 voltage = 0;

	switch (reg) {
	case LTC4245_12VIN:
	case LTC4245_12VOUT:
		voltage = regval * 55;
		break;
	case LTC4245_5VIN:
	case LTC4245_5VOUT:
		voltage = regval * 22;
		break;
	case LTC4245_3VIN:
	case LTC4245_3VOUT:
		voltage = regval * 15;
		break;
	case LTC4245_VEEIN:
	case LTC4245_VEEOUT:
		voltage = regval * -55;
		break;
	case LTC4245_GPIOADC:
		voltage = regval * 10;
		break;
	default:
		/* If we get here, the developer messed up */
		WARN_ON_ONCE(1);
		break;
	}

	return voltage;
}

/* Return the current in the given sense register in milliAmperes */
static unsigned int ltc4245_get_current(struct device *dev, u8 reg)
{
	struct ltc4245_data *data = ltc4245_update_device(dev);
	const u8 regval = data->vregs[reg - 0x10];
	unsigned int voltage;
	unsigned int curr;

	/*
	 * The strange looking conversions that follow are fixed-point
	 * math, since we cannot do floating point in the kernel.
	 *
	 * Step 1: convert sense register to microVolts
	 * Step 2: convert voltage to milliAmperes
	 *
	 * If you play around with the V=IR equation, you come up with
	 * the following: X uV / Y mOhm == Z mA
	 *
	 * With the resistors that are fractions of a milliOhm, we multiply
	 * the voltage and resistance by 10, to shift the decimal point.
	 * Now we can use the normal division operator again.
	 */

	switch (reg) {
	case LTC4245_12VSENSE:
		voltage = regval * 250; /* voltage in uV */
		curr = voltage / 50; /* sense resistor 50 mOhm */
		break;
	case LTC4245_5VSENSE:
		voltage = regval * 125; /* voltage in uV */
		curr = (voltage * 10) / 35; /* sense resistor 3.5 mOhm */
		break;
	case LTC4245_3VSENSE:
		voltage = regval * 125; /* voltage in uV */
		curr = (voltage * 10) / 25; /* sense resistor 2.5 mOhm */
		break;
	case LTC4245_VEESENSE:
		voltage = regval * 250; /* voltage in uV */
		curr = voltage / 100; /* sense resistor 100 mOhm */
		break;
	default:
		/* If we get here, the developer messed up */
		WARN_ON_ONCE(1);
		curr = 0;
		break;
	}

	return curr;
}

static ssize_t ltc4245_show_voltage(struct device *dev,
				    struct device_attribute *da,
				    char *buf)
{
	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
	const int voltage = ltc4245_get_voltage(dev, attr->index);

	return snprintf(buf, PAGE_SIZE, "%d\n", voltage);
}

static ssize_t ltc4245_show_current(struct device *dev,
				    struct device_attribute *da,
				    char *buf)
{
	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
	const unsigned int curr = ltc4245_get_current(dev, attr->index);

	return snprintf(buf, PAGE_SIZE, "%u\n", curr);
}

static ssize_t ltc4245_show_power(struct device *dev,
				  struct device_attribute *da,
				  char *buf)
{
	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
	const unsigned int curr = ltc4245_get_current(dev, attr->index);
	const int output_voltage = ltc4245_get_voltage(dev, attr->index+1);

	/* current in mA * voltage in mV == power in uW */
	const unsigned int power = abs(output_voltage * curr);

	return snprintf(buf, PAGE_SIZE, "%u\n", power);
}

static ssize_t ltc4245_show_alarm(struct device *dev,
					  struct device_attribute *da,
					  char *buf)
{
	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(da);
	struct ltc4245_data *data = ltc4245_update_device(dev);
	const u8 reg = data->cregs[attr->index];
	const u32 mask = attr->nr;

	return snprintf(buf, PAGE_SIZE, "%u\n", (reg & mask) ? 1 : 0);
}

static ssize_t ltc4245_show_gpio(struct device *dev,
				 struct device_attribute *da,
				 char *buf)
{
	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
	struct ltc4245_data *data = ltc4245_update_device(dev);
	int val = data->gpios[attr->index];

	/* handle stale GPIO's */
	if (val < 0)
		return val;

	/* Convert to millivolts and print */
	return snprintf(buf, PAGE_SIZE, "%u\n", val * 10);
}

/* Construct a sensor_device_attribute structure for each register */

/* Input voltages */
static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, ltc4245_show_voltage, NULL,
			  LTC4245_12VIN);
static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, ltc4245_show_voltage, NULL,
			  LTC4245_5VIN);
static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, ltc4245_show_voltage, NULL,
			  LTC4245_3VIN);
static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, ltc4245_show_voltage, NULL,
			  LTC4245_VEEIN);

/* Input undervoltage alarms */
static SENSOR_DEVICE_ATTR_2(in1_min_alarm, S_IRUGO, ltc4245_show_alarm, NULL,
			    1 << 0, LTC4245_FAULT1);
static SENSOR_DEVICE_ATTR_2(in2_min_alarm, S_IRUGO, ltc4245_show_alarm, NULL,
			    1 << 1, LTC4245_FAULT1);
static SENSOR_DEVICE_ATTR_2(in3_min_alarm, S_IRUGO, ltc4245_show_alarm, NULL,
			    1 << 2, LTC4245_FAULT1);
static SENSOR_DEVICE_ATTR_2(in4_min_alarm, S_IRUGO, ltc4245_show_alarm, NULL,
			    1 << 3, LTC4245_FAULT1);

/* Currents (via sense resistor) */
static SENSOR_DEVICE_ATTR(curr1_input, S_IRUGO, ltc4245_show_current, NULL,
			  LTC4245_12VSENSE);
static SENSOR_DEVICE_ATTR(curr2_input, S_IRUGO, ltc4245_show_current, NULL,
			  LTC4245_5VSENSE);
static SENSOR_DEVICE_ATTR(curr3_input, S_IRUGO, ltc4245_show_current, NULL,
			  LTC4245_3VSENSE);
static SENSOR_DEVICE_ATTR(curr4_input, S_IRUGO, ltc4245_show_current, NULL,
			  LTC4245_VEESENSE);

/* Overcurrent alarms */
static SENSOR_DEVICE_ATTR_2(curr1_max_alarm, S_IRUGO, ltc4245_show_alarm, NULL,
			    1 << 4, LTC4245_FAULT1);
static SENSOR_DEVICE_ATTR_2(curr2_max_alarm, S_IRUGO, ltc4245_show_alarm, NULL,
			    1 << 5, LTC4245_FAULT1);
static SENSOR_DEVICE_ATTR_2(curr3_max_alarm, S_IRUGO, ltc4245_show_alarm, NULL,
			    1 << 6, LTC4245_FAULT1);
static SENSOR_DEVICE_ATTR_2(curr4_max_alarm, S_IRUGO, ltc4245_show_alarm, NULL,
			    1 << 7, LTC4245_FAULT1);

/* Output voltages */
static SENSOR_DEVICE_ATTR(in5_input, S_IRUGO, ltc4245_show_voltage, NULL,
			  LTC4245_12VOUT);
static SENSOR_DEVICE_ATTR(in6_input, S_IRUGO, ltc4245_show_voltage, NULL,
			  LTC4245_5VOUT);
static SENSOR_DEVICE_ATTR(in7_input, S_IRUGO, ltc4245_show_voltage, NULL,
			  LTC4245_3VOUT);
static SENSOR_DEVICE_ATTR(in8_input, S_IRUGO, ltc4245_show_voltage, NULL,
			  LTC4245_VEEOUT);

/* Power Bad alarms */
static SENSOR_DEVICE_ATTR_2(in5_min_alarm, S_IRUGO, ltc4245_show_alarm, NULL,
			    1 << 0, LTC4245_FAULT2);
static SENSOR_DEVICE_ATTR_2(in6_min_alarm, S_IRUGO, ltc4245_show_alarm, NULL,
			    1 << 1, LTC4245_FAULT2);
static SENSOR_DEVICE_ATTR_2(in7_min_alarm, S_IRUGO, ltc4245_show_alarm, NULL,
			    1 << 2, LTC4245_FAULT2);
static SENSOR_DEVICE_ATTR_2(in8_min_alarm, S_IRUGO, ltc4245_show_alarm, NULL,
			    1 << 3, LTC4245_FAULT2);

/* GPIO voltages */
static SENSOR_DEVICE_ATTR(in9_input, S_IRUGO, ltc4245_show_gpio, NULL, 0);
static SENSOR_DEVICE_ATTR(in10_input, S_IRUGO, ltc4245_show_gpio, NULL, 1);
static SENSOR_DEVICE_ATTR(in11_input, S_IRUGO, ltc4245_show_gpio, NULL, 2);

/* Power Consumption (virtual) */
static SENSOR_DEVICE_ATTR(power1_input, S_IRUGO, ltc4245_show_power, NULL,
			  LTC4245_12VSENSE);
static SENSOR_DEVICE_ATTR(power2_input, S_IRUGO, ltc4245_show_power, NULL,
			  LTC4245_5VSENSE);
static SENSOR_DEVICE_ATTR(power3_input, S_IRUGO, ltc4245_show_power, NULL,
			  LTC4245_3VSENSE);
static SENSOR_DEVICE_ATTR(power4_input, S_IRUGO, ltc4245_show_power, NULL,
			  LTC4245_VEESENSE);

/*
 * Finally, construct an array of pointers to members of the above objects,
 * as required for sysfs_create_group()
 */
static struct attribute *ltc4245_std_attributes[] = {
	&sensor_dev_attr_in1_input.dev_attr.attr,
	&sensor_dev_attr_in2_input.dev_attr.attr,
	&sensor_dev_attr_in3_input.dev_attr.attr,
	&sensor_dev_attr_in4_input.dev_attr.attr,

	&sensor_dev_attr_in1_min_alarm.dev_attr.attr,
	&sensor_dev_attr_in2_min_alarm.dev_attr.attr,
	&sensor_dev_attr_in3_min_alarm.dev_attr.attr,
	&sensor_dev_attr_in4_min_alarm.dev_attr.attr,

	&sensor_dev_attr_curr1_input.dev_attr.attr,
	&sensor_dev_attr_curr2_input.dev_attr.attr,
	&sensor_dev_attr_curr3_input.dev_attr.attr,
	&sensor_dev_attr_curr4_input.dev_attr.attr,

	&sensor_dev_attr_curr1_max_alarm.dev_attr.attr,
	&sensor_dev_attr_curr2_max_alarm.dev_attr.attr,
	&sensor_dev_attr_curr3_max_alarm.dev_attr.attr,
	&sensor_dev_attr_curr4_max_alarm.dev_attr.attr,

	&sensor_dev_attr_in5_input.dev_attr.attr,
	&sensor_dev_attr_in6_input.dev_attr.attr,
	&sensor_dev_attr_in7_input.dev_attr.attr,
	&sensor_dev_attr_in8_input.dev_attr.attr,

	&sensor_dev_attr_in5_min_alarm.dev_attr.attr,
	&sensor_dev_attr_in6_min_alarm.dev_attr.attr,
	&sensor_dev_attr_in7_min_alarm.dev_attr.attr,
	&sensor_dev_attr_in8_min_alarm.dev_attr.attr,

	&sensor_dev_attr_in9_input.dev_attr.attr,

	&sensor_dev_attr_power1_input.dev_attr.attr,
	&sensor_dev_attr_power2_input.dev_attr.attr,
	&sensor_dev_attr_power3_input.dev_attr.attr,
	&sensor_dev_attr_power4_input.dev_attr.attr,

	NULL,
};

static struct attribute *ltc4245_gpio_attributes[] = {
	&sensor_dev_attr_in10_input.dev_attr.attr,
	&sensor_dev_attr_in11_input.dev_attr.attr,
	NULL,
};

static const struct attribute_group ltc4245_std_group = {
	.attrs = ltc4245_std_attributes,
};

static const struct attribute_group ltc4245_gpio_group = {
	.attrs = ltc4245_gpio_attributes,
};

static int ltc4245_sysfs_create_groups(struct i2c_client *client)
{
	struct ltc4245_data *data = i2c_get_clientdata(client);
	struct device *dev = &client->dev;
	int ret;

	/* register the standard sysfs attributes */
	ret = sysfs_create_group(&dev->kobj, &ltc4245_std_group);
	if (ret) {
		dev_err(dev, "unable to register standard attributes\n");
		return ret;
	}

	/* if we're using the extra gpio support, register it's attributes */
	if (data->use_extra_gpios) {
		ret = sysfs_create_group(&dev->kobj, &ltc4245_gpio_group);
		if (ret) {
			dev_err(dev, "unable to register gpio attributes\n");
			sysfs_remove_group(&dev->kobj, &ltc4245_std_group);
			return ret;
		}
	}

	return 0;
}

static void ltc4245_sysfs_remove_groups(struct i2c_client *client)
{
	struct ltc4245_data *data = i2c_get_clientdata(client);
	struct device *dev = &client->dev;

	if (data->use_extra_gpios)
		sysfs_remove_group(&dev->kobj, &ltc4245_gpio_group);

	sysfs_remove_group(&dev->kobj, &ltc4245_std_group);
}

static bool ltc4245_use_extra_gpios(struct i2c_client *client)
{
	struct ltc4245_platform_data *pdata = dev_get_platdata(&client->dev);
#ifdef CONFIG_OF
	struct device_node *np = client->dev.of_node;
#endif

	/* prefer platform data */
	if (pdata)
		return pdata->use_extra_gpios;

#ifdef CONFIG_OF
	/* fallback on OF */
	if (of_find_property(np, "ltc4245,use-extra-gpios", NULL))
		return true;
#endif

	return false;
}

static int ltc4245_probe(struct i2c_client *client,
			 const struct i2c_device_id *id)
{
	struct i2c_adapter *adapter = client->adapter;
	struct ltc4245_data *data;
	int ret;

	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
		return -ENODEV;

	data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL);
	if (!data)
		return -ENOMEM;

	i2c_set_clientdata(client, data);
	mutex_init(&data->update_lock);
	data->use_extra_gpios = ltc4245_use_extra_gpios(client);

	/* Initialize the LTC4245 chip */
	i2c_smbus_write_byte_data(client, LTC4245_FAULT1, 0x00);
	i2c_smbus_write_byte_data(client, LTC4245_FAULT2, 0x00);

	/* Register sysfs hooks */
	ret = ltc4245_sysfs_create_groups(client);
	if (ret)
		return ret;

	data->hwmon_dev = hwmon_device_register(&client->dev);
	if (IS_ERR(data->hwmon_dev)) {
		ret = PTR_ERR(data->hwmon_dev);
		goto out_hwmon_device_register;
	}

	return 0;

out_hwmon_device_register:
	ltc4245_sysfs_remove_groups(client);
	return ret;
}

static int ltc4245_remove(struct i2c_client *client)
{
	struct ltc4245_data *data = i2c_get_clientdata(client);

	hwmon_device_unregister(data->hwmon_dev);
	ltc4245_sysfs_remove_groups(client);

	return 0;
}

static const struct i2c_device_id ltc4245_id[] = {
	{ "ltc4245", 0 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, ltc4245_id);

/* This is the driver that will be inserted */
static struct i2c_driver ltc4245_driver = {
	.driver = {
		.name	= "ltc4245",
	},
	.probe		= ltc4245_probe,
	.remove		= ltc4245_remove,
	.id_table	= ltc4245_id,
};

module_i2c_driver(ltc4245_driver);

MODULE_AUTHOR("Ira W. Snyder <iws@ovro.caltech.edu>");
MODULE_DESCRIPTION("LTC4245 driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
6e34b187 IS	1	/*
	2	* Driver for Linear Technology LTC4245 I2C Multiple Supply Hot Swap Controller
	3	*
	4	* Copyright (C) 2008 Ira W. Snyder <iws@ovro.caltech.edu>
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; version 2 of the License.
	9	*
	10	* This driver is based on the ds1621 and ina209 drivers.
	11	*
	12	* Datasheet:
	13	* http://www.linear.com/pc/downloadDocument.do?navId=H0,C1,C1003,C1006,C1140,P19392,D13517
	14	*/
	15
	16	#include <linux/kernel.h>
	17	#include <linux/module.h>
	18	#include <linux/init.h>
	19	#include <linux/err.h>
	20	#include <linux/slab.h>
	21	#include <linux/i2c.h>
	22	#include <linux/hwmon.h>
	23	#include <linux/hwmon-sysfs.h>
dcd8f392	24	#include <linux/jiffies.h>
5950ec8d	25	#include <linux/i2c/ltc4245.h>
6e34b187	26
6e34b187 IS	27	/* Here are names of the chip's registers (a.k.a. commands) */
	28	enum ltc4245_cmd {
	29	LTC4245_STATUS = 0x00, /* readonly */
	30	LTC4245_ALERT = 0x01,
	31	LTC4245_CONTROL = 0x02,
	32	LTC4245_ON = 0x03,
	33	LTC4245_FAULT1 = 0x04,
	34	LTC4245_FAULT2 = 0x05,
	35	LTC4245_GPIO = 0x06,
	36	LTC4245_ADCADR = 0x07,
	37
	38	LTC4245_12VIN = 0x10,
	39	LTC4245_12VSENSE = 0x11,
	40	LTC4245_12VOUT = 0x12,
	41	LTC4245_5VIN = 0x13,
	42	LTC4245_5VSENSE = 0x14,
	43	LTC4245_5VOUT = 0x15,
	44	LTC4245_3VIN = 0x16,
	45	LTC4245_3VSENSE = 0x17,
	46	LTC4245_3VOUT = 0x18,
	47	LTC4245_VEEIN = 0x19,
	48	LTC4245_VEESENSE = 0x1a,
	49	LTC4245_VEEOUT = 0x1b,
df16dd53	50	LTC4245_GPIOADC = 0x1c,
6e34b187 IS	51	};
	52
	53	struct ltc4245_data {
	54	struct device *hwmon_dev;
	55
	56	struct mutex update_lock;
	57	bool valid;
	58	unsigned long last_updated; /* in jiffies */
	59
	60	/* Control registers */
	61	u8 cregs[0x08];
	62
	63	/* Voltage registers */
df16dd53	64	u8 vregs[0x0d];
5950ec8d IS	65
	66	/* GPIO ADC registers */
	67	bool use_extra_gpios;
	68	int gpios[3];
6e34b187 IS	69	};
6e34b187 IS	70
5950ec8d IS	71	/*
	72	* Update the readings from the GPIO pins. If the driver has been configured to
	73	* sample all GPIO's as analog voltages, a round-robin sampling method is used.
	74	* Otherwise, only the configured GPIO pin is sampled.
	75	*
	76	* LOCKING: must hold data->update_lock
	77	*/
	78	static void ltc4245_update_gpios(struct device *dev)
	79	{
	80	struct i2c_client *client = to_i2c_client(dev);
	81	struct ltc4245_data *data = i2c_get_clientdata(client);
	82	u8 gpio_curr, gpio_next, gpio_reg;
	83	int i;
	84
	85	/* no extra gpio support, we're basically done */
	86	if (!data->use_extra_gpios) {
	87	data->gpios[0] = data->vregs[LTC4245_GPIOADC - 0x10];
	88	return;
	89	}
	90
	91	/*
	92	* If the last reading was too long ago, then we mark all old GPIO
	93	* readings as stale by setting them to -EAGAIN
	94	*/
	95	if (time_after(jiffies, data->last_updated + 5 * HZ)) {
	96	dev_dbg(&client->dev, "Marking GPIOs invalid\n");
	97	for (i = 0; i < ARRAY_SIZE(data->gpios); i++)
	98	data->gpios[i] = -EAGAIN;
	99	}
	100
	101	/*
	102	* Get the current GPIO pin
	103	*
	104	* The datasheet calls these GPIO[1-3], but we'll calculate the zero
	105	* based array index instead, and call them GPIO[0-2]. This is much
	106	* easier to think about.
	107	*/
	108	gpio_curr = (data->cregs[LTC4245_GPIO] & 0xc0) >> 6;
	109	if (gpio_curr > 0)
	110	gpio_curr -= 1;
	111
	112	/* Read the GPIO voltage from the GPIOADC register */
	113	data->gpios[gpio_curr] = data->vregs[LTC4245_GPIOADC - 0x10];
	114
	115	/* Find the next GPIO pin to read */
	116	gpio_next = (gpio_curr + 1) % ARRAY_SIZE(data->gpios);
	117
	118	/*
	119	* Calculate the correct setting for the GPIO register so it will
	120	* sample the next GPIO pin
	121	*/
	122	gpio_reg = (data->cregs[LTC4245_GPIO] & 0x3f) \| ((gpio_next + 1) << 6);
	123
	124	/* Update the GPIO register */
	125	i2c_smbus_write_byte_data(client, LTC4245_GPIO, gpio_reg);
	126
	127	/* Update saved data */
	128	data->cregs[LTC4245_GPIO] = gpio_reg;
	129	}
	130
6e34b187 IS	131	static struct ltc4245_data ltc4245_update_device(struct device dev)
	132	{
	133	struct i2c_client *client = to_i2c_client(dev);
	134	struct ltc4245_data *data = i2c_get_clientdata(client);
	135	s32 val;
	136	int i;
	137
	138	mutex_lock(&data->update_lock);
	139
	140	if (time_after(jiffies, data->last_updated + HZ) \|\| !data->valid) {
	141
	142	dev_dbg(&client->dev, "Starting ltc4245 update\n");
	143
	144	/* Read control registers -- 0x00 to 0x07 */
	145	for (i = 0; i < ARRAY_SIZE(data->cregs); i++) {
	146	val = i2c_smbus_read_byte_data(client, i);
	147	if (unlikely(val < 0))
	148	data->cregs[i] = 0;
	149	else
	150	data->cregs[i] = val;
	151	}
	152
df16dd53	153	/* Read voltage registers -- 0x10 to 0x1c */
6e34b187 IS	154	for (i = 0; i < ARRAY_SIZE(data->vregs); i++) {
	155	val = i2c_smbus_read_byte_data(client, i+0x10);
	156	if (unlikely(val < 0))
	157	data->vregs[i] = 0;
	158	else
	159	data->vregs[i] = val;
	160	}
	161
5950ec8d IS	162	/* Update GPIO readings */
	163	ltc4245_update_gpios(dev);
	164
6e34b187 IS	165	data->last_updated = jiffies;
	166	data->valid = 1;
	167	}
	168
	169	mutex_unlock(&data->update_lock);
	170
	171	return data;
	172	}
	173
	174	/* Return the voltage from the given register in millivolts */
	175	static int ltc4245_get_voltage(struct device *dev, u8 reg)
	176	{
	177	struct ltc4245_data *data = ltc4245_update_device(dev);
	178	const u8 regval = data->vregs[reg - 0x10];
	179	u32 voltage = 0;
	180
	181	switch (reg) {
	182	case LTC4245_12VIN:
	183	case LTC4245_12VOUT:
	184	voltage = regval * 55;
	185	break;
	186	case LTC4245_5VIN:
	187	case LTC4245_5VOUT:
	188	voltage = regval * 22;
	189	break;
	190	case LTC4245_3VIN:
	191	case LTC4245_3VOUT:
	192	voltage = regval * 15;
	193	break;
	194	case LTC4245_VEEIN:
	195	case LTC4245_VEEOUT:
	196	voltage = regval * -55;
	197	break;
df16dd53	198	case LTC4245_GPIOADC:
6e34b187 IS	199	voltage = regval * 10;
	200	break;
	201	default:
	202	/* If we get here, the developer messed up */
	203	WARN_ON_ONCE(1);
	204	break;
	205	}
	206
	207	return voltage;
	208	}
	209
	210	/* Return the current in the given sense register in milliAmperes */
	211	static unsigned int ltc4245_get_current(struct device *dev, u8 reg)
	212	{
	213	struct ltc4245_data *data = ltc4245_update_device(dev);
	214	const u8 regval = data->vregs[reg - 0x10];
	215	unsigned int voltage;
	216	unsigned int curr;
	217
430b4fcd GR	218	/*
430b4fcd GR	219	* The strange looking conversions that follow are fixed-point
6e34b187 IS	220	* math, since we cannot do floating point in the kernel.
	221	*
	222	* Step 1: convert sense register to microVolts
	223	* Step 2: convert voltage to milliAmperes
	224	*
	225	* If you play around with the V=IR equation, you come up with
	226	* the following: X uV / Y mOhm == Z mA
	227	*
	228	* With the resistors that are fractions of a milliOhm, we multiply
	229	* the voltage and resistance by 10, to shift the decimal point.
	230	* Now we can use the normal division operator again.
	231	*/
	232
	233	switch (reg) {
	234	case LTC4245_12VSENSE:
	235	voltage = regval * 250; /* voltage in uV */
	236	curr = voltage / 50; /* sense resistor 50 mOhm */
	237	break;
	238	case LTC4245_5VSENSE:
	239	voltage = regval * 125; /* voltage in uV */
	240	curr = (voltage * 10) / 35; /* sense resistor 3.5 mOhm */
	241	break;
	242	case LTC4245_3VSENSE:
	243	voltage = regval * 125; /* voltage in uV */
	244	curr = (voltage * 10) / 25; /* sense resistor 2.5 mOhm */
	245	break;
	246	case LTC4245_VEESENSE:
	247	voltage = regval * 250; /* voltage in uV */
	248	curr = voltage / 100; /* sense resistor 100 mOhm */
	249	break;
	250	default:
	251	/* If we get here, the developer messed up */
	252	WARN_ON_ONCE(1);
	253	curr = 0;
	254	break;
	255	}
	256
	257	return curr;
	258	}
	259
	260	static ssize_t ltc4245_show_voltage(struct device *dev,
	261	struct device_attribute *da,
	262	char *buf)
	263	{
	264	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
	265	const int voltage = ltc4245_get_voltage(dev, attr->index);
	266
	267	return snprintf(buf, PAGE_SIZE, "%d\n", voltage);
	268	}
	269
	270	static ssize_t ltc4245_show_current(struct device *dev,
	271	struct device_attribute *da,
	272	char *buf)
	273	{
	274	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
	275	const unsigned int curr = ltc4245_get_current(dev, attr->index);
	276
	277	return snprintf(buf, PAGE_SIZE, "%u\n", curr);
	278	}
	279
	280	static ssize_t ltc4245_show_power(struct device *dev,
	281	struct device_attribute *da,
	282	char *buf)
	283	{
284	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
285	const unsigned int curr = ltc4245_get_current(dev, attr->index);
286	const int output_voltage = ltc4245_get_voltage(dev, attr->index+1);
287
288	/* current in mA * voltage in mV == power in uW */
289	const unsigned int power = abs(output_voltage * curr);
290
291	return snprintf(buf, PAGE_SIZE, "%u\n", power);
292	}
293
294	static ssize_t ltc4245_show_alarm(struct device *dev,
295	struct device_attribute *da,
296	char *buf)
297	{
298	struct sensor_device_attribute_2 *attr = to_sensor_dev_attr_2(da);
299	struct ltc4245_data *data = ltc4245_update_device(dev);
300	const u8 reg = data->cregs[attr->index];
301	const u32 mask = attr->nr;
302
303	return snprintf(buf, PAGE_SIZE, "%u\n", (reg & mask) ? 1 : 0);
304	}
305
5950ec8d IS	306	static ssize_t ltc4245_show_gpio(struct device *dev,
	307	struct device_attribute *da,
	308	char *buf)
	309	{
	310	struct sensor_device_attribute *attr = to_sensor_dev_attr(da);
	311	struct ltc4245_data *data = ltc4245_update_device(dev);
	312	int val = data->gpios[attr->index];
	313
	314	/* handle stale GPIO's */
	315	if (val < 0)
	316	return val;
	317
	318	/* Convert to millivolts and print */
	319	return snprintf(buf, PAGE_SIZE, "%u\n", val * 10);
	320	}
	321
6e34b187 IS	322	/* Construct a sensor_device_attribute structure for each register */
	323
	324	/* Input voltages */
f539038e GR	325	static SENSOR_DEVICE_ATTR(in1_input, S_IRUGO, ltc4245_show_voltage, NULL,
	326	LTC4245_12VIN);
	327	static SENSOR_DEVICE_ATTR(in2_input, S_IRUGO, ltc4245_show_voltage, NULL,
	328	LTC4245_5VIN);
	329	static SENSOR_DEVICE_ATTR(in3_input, S_IRUGO, ltc4245_show_voltage, NULL,
	330	LTC4245_3VIN);
	331	static SENSOR_DEVICE_ATTR(in4_input, S_IRUGO, ltc4245_show_voltage, NULL,
	332	LTC4245_VEEIN);
6e34b187 IS	333
6e34b187 IS	334	/* Input undervoltage alarms */
f539038e GR	335	static SENSOR_DEVICE_ATTR_2(in1_min_alarm, S_IRUGO, ltc4245_show_alarm, NULL,
	336	1 << 0, LTC4245_FAULT1);
	337	static SENSOR_DEVICE_ATTR_2(in2_min_alarm, S_IRUGO, ltc4245_show_alarm, NULL,
	338	1 << 1, LTC4245_FAULT1);
	339	static SENSOR_DEVICE_ATTR_2(in3_min_alarm, S_IRUGO, ltc4245_show_alarm, NULL,
	340	1 << 2, LTC4245_FAULT1);
	341	static SENSOR_DEVICE_ATTR_2(in4_min_alarm, S_IRUGO, ltc4245_show_alarm, NULL,
	342	1 << 3, LTC4245_FAULT1);
6e34b187 IS	343
6e34b187 IS	344	/* Currents (via sense resistor) */
f539038e GR	345	static SENSOR_DEVICE_ATTR(curr1_input, S_IRUGO, ltc4245_show_current, NULL,
	346	LTC4245_12VSENSE);
	347	static SENSOR_DEVICE_ATTR(curr2_input, S_IRUGO, ltc4245_show_current, NULL,
	348	LTC4245_5VSENSE);
	349	static SENSOR_DEVICE_ATTR(curr3_input, S_IRUGO, ltc4245_show_current, NULL,
	350	LTC4245_3VSENSE);
	351	static SENSOR_DEVICE_ATTR(curr4_input, S_IRUGO, ltc4245_show_current, NULL,
	352	LTC4245_VEESENSE);
6e34b187 IS	353
6e34b187 IS	354	/* Overcurrent alarms */
f539038e GR	355	static SENSOR_DEVICE_ATTR_2(curr1_max_alarm, S_IRUGO, ltc4245_show_alarm, NULL,
	356	1 << 4, LTC4245_FAULT1);
	357	static SENSOR_DEVICE_ATTR_2(curr2_max_alarm, S_IRUGO, ltc4245_show_alarm, NULL,
	358	1 << 5, LTC4245_FAULT1);
	359	static SENSOR_DEVICE_ATTR_2(curr3_max_alarm, S_IRUGO, ltc4245_show_alarm, NULL,
	360	1 << 6, LTC4245_FAULT1);
	361	static SENSOR_DEVICE_ATTR_2(curr4_max_alarm, S_IRUGO, ltc4245_show_alarm, NULL,
	362	1 << 7, LTC4245_FAULT1);
6e34b187 IS	363
6e34b187 IS	364	/* Output voltages */
f539038e GR	365	static SENSOR_DEVICE_ATTR(in5_input, S_IRUGO, ltc4245_show_voltage, NULL,
	366	LTC4245_12VOUT);
	367	static SENSOR_DEVICE_ATTR(in6_input, S_IRUGO, ltc4245_show_voltage, NULL,
	368	LTC4245_5VOUT);
	369	static SENSOR_DEVICE_ATTR(in7_input, S_IRUGO, ltc4245_show_voltage, NULL,
	370	LTC4245_3VOUT);
	371	static SENSOR_DEVICE_ATTR(in8_input, S_IRUGO, ltc4245_show_voltage, NULL,
	372	LTC4245_VEEOUT);
6e34b187 IS	373
6e34b187 IS	374	/* Power Bad alarms */
f539038e GR	375	static SENSOR_DEVICE_ATTR_2(in5_min_alarm, S_IRUGO, ltc4245_show_alarm, NULL,
	376	1 << 0, LTC4245_FAULT2);
	377	static SENSOR_DEVICE_ATTR_2(in6_min_alarm, S_IRUGO, ltc4245_show_alarm, NULL,
	378	1 << 1, LTC4245_FAULT2);
	379	static SENSOR_DEVICE_ATTR_2(in7_min_alarm, S_IRUGO, ltc4245_show_alarm, NULL,
	380	1 << 2, LTC4245_FAULT2);
	381	static SENSOR_DEVICE_ATTR_2(in8_min_alarm, S_IRUGO, ltc4245_show_alarm, NULL,
	382	1 << 3, LTC4245_FAULT2);
6e34b187 IS	383
6e34b187 IS	384	/* GPIO voltages */
f539038e GR	385	static SENSOR_DEVICE_ATTR(in9_input, S_IRUGO, ltc4245_show_gpio, NULL, 0);
	386	static SENSOR_DEVICE_ATTR(in10_input, S_IRUGO, ltc4245_show_gpio, NULL, 1);
	387	static SENSOR_DEVICE_ATTR(in11_input, S_IRUGO, ltc4245_show_gpio, NULL, 2);
6e34b187 IS	388
6e34b187 IS	389	/* Power Consumption (virtual) */
f539038e GR	390	static SENSOR_DEVICE_ATTR(power1_input, S_IRUGO, ltc4245_show_power, NULL,
	391	LTC4245_12VSENSE);
	392	static SENSOR_DEVICE_ATTR(power2_input, S_IRUGO, ltc4245_show_power, NULL,
	393	LTC4245_5VSENSE);
	394	static SENSOR_DEVICE_ATTR(power3_input, S_IRUGO, ltc4245_show_power, NULL,
	395	LTC4245_3VSENSE);
	396	static SENSOR_DEVICE_ATTR(power4_input, S_IRUGO, ltc4245_show_power, NULL,
	397	LTC4245_VEESENSE);
6e34b187	398
430b4fcd GR	399	/*
430b4fcd GR	400	* Finally, construct an array of pointers to members of the above objects,
6e34b187 IS	401	* as required for sysfs_create_group()
6e34b187 IS	402	*/
5950ec8d	403	static struct attribute *ltc4245_std_attributes[] = {
6e34b187 IS	404	&sensor_dev_attr_in1_input.dev_attr.attr,
	405	&sensor_dev_attr_in2_input.dev_attr.attr,
	406	&sensor_dev_attr_in3_input.dev_attr.attr,
	407	&sensor_dev_attr_in4_input.dev_attr.attr,
	408
	409	&sensor_dev_attr_in1_min_alarm.dev_attr.attr,
	410	&sensor_dev_attr_in2_min_alarm.dev_attr.attr,
	411	&sensor_dev_attr_in3_min_alarm.dev_attr.attr,
	412	&sensor_dev_attr_in4_min_alarm.dev_attr.attr,
	413
	414	&sensor_dev_attr_curr1_input.dev_attr.attr,
	415	&sensor_dev_attr_curr2_input.dev_attr.attr,
	416	&sensor_dev_attr_curr3_input.dev_attr.attr,
	417	&sensor_dev_attr_curr4_input.dev_attr.attr,
	418
	419	&sensor_dev_attr_curr1_max_alarm.dev_attr.attr,
	420	&sensor_dev_attr_curr2_max_alarm.dev_attr.attr,
	421	&sensor_dev_attr_curr3_max_alarm.dev_attr.attr,
	422	&sensor_dev_attr_curr4_max_alarm.dev_attr.attr,
	423
	424	&sensor_dev_attr_in5_input.dev_attr.attr,
	425	&sensor_dev_attr_in6_input.dev_attr.attr,
	426	&sensor_dev_attr_in7_input.dev_attr.attr,
	427	&sensor_dev_attr_in8_input.dev_attr.attr,
	428
	429	&sensor_dev_attr_in5_min_alarm.dev_attr.attr,
	430	&sensor_dev_attr_in6_min_alarm.dev_attr.attr,
	431	&sensor_dev_attr_in7_min_alarm.dev_attr.attr,
	432	&sensor_dev_attr_in8_min_alarm.dev_attr.attr,
	433
	434	&sensor_dev_attr_in9_input.dev_attr.attr,
6e34b187 IS	435
	436	&sensor_dev_attr_power1_input.dev_attr.attr,
	437	&sensor_dev_attr_power2_input.dev_attr.attr,
	438	&sensor_dev_attr_power3_input.dev_attr.attr,
	439	&sensor_dev_attr_power4_input.dev_attr.attr,
	440
	441	NULL,
	442	};
	443
5950ec8d IS	444	static struct attribute *ltc4245_gpio_attributes[] = {
	445	&sensor_dev_attr_in10_input.dev_attr.attr,
	446	&sensor_dev_attr_in11_input.dev_attr.attr,
	447	NULL,
	448	};
	449
	450	static const struct attribute_group ltc4245_std_group = {
	451	.attrs = ltc4245_std_attributes,
	452	};
	453
	454	static const struct attribute_group ltc4245_gpio_group = {
	455	.attrs = ltc4245_gpio_attributes,
6e34b187 IS	456	};
6e34b187 IS	457
5950ec8d IS	458	static int ltc4245_sysfs_create_groups(struct i2c_client *client)
	459	{
	460	struct ltc4245_data *data = i2c_get_clientdata(client);
	461	struct device *dev = &client->dev;
	462	int ret;
	463
	464	/* register the standard sysfs attributes */
	465	ret = sysfs_create_group(&dev->kobj, &ltc4245_std_group);
	466	if (ret) {
	467	dev_err(dev, "unable to register standard attributes\n");
	468	return ret;
	469	}
	470
	471	/* if we're using the extra gpio support, register it's attributes */
	472	if (data->use_extra_gpios) {
	473	ret = sysfs_create_group(&dev->kobj, &ltc4245_gpio_group);
	474	if (ret) {
	475	dev_err(dev, "unable to register gpio attributes\n");
	476	sysfs_remove_group(&dev->kobj, &ltc4245_std_group);
	477	return ret;
	478	}
	479	}
	480
	481	return 0;
	482	}
	483
	484	static void ltc4245_sysfs_remove_groups(struct i2c_client *client)
	485	{
	486	struct ltc4245_data *data = i2c_get_clientdata(client);
	487	struct device *dev = &client->dev;
	488
	489	if (data->use_extra_gpios)
	490	sysfs_remove_group(&dev->kobj, &ltc4245_gpio_group);
	491
	492	sysfs_remove_group(&dev->kobj, &ltc4245_std_group);
	493	}
	494
	495	static bool ltc4245_use_extra_gpios(struct i2c_client *client)
	496	{
	497	struct ltc4245_platform_data *pdata = dev_get_platdata(&client->dev);
	498	#ifdef CONFIG_OF
	499	struct device_node *np = client->dev.of_node;
	500	#endif
	501
	502	/* prefer platform data */
	503	if (pdata)
	504	return pdata->use_extra_gpios;
	505
	506	#ifdef CONFIG_OF
	507	/* fallback on OF */
	508	if (of_find_property(np, "ltc4245,use-extra-gpios", NULL))
	509	return true;
	510	#endif
	511
	512	return false;
	513	}
	514
6e34b187 IS	515	static int ltc4245_probe(struct i2c_client *client,
	516	const struct i2c_device_id *id)
	517	{
2d2a7cff	518	struct i2c_adapter *adapter = client->adapter;
6e34b187 IS	519	struct ltc4245_data *data;
	520	int ret;
	521
2d2a7cff JD	522	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA))
	523	return -ENODEV;
	524
effb8ab1 GR	525	data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL);
	526	if (!data)
	527	return -ENOMEM;
6e34b187 IS	528
	529	i2c_set_clientdata(client, data);
	530	mutex_init(&data->update_lock);
5950ec8d	531	data->use_extra_gpios = ltc4245_use_extra_gpios(client);
6e34b187 IS	532
6e34b187 IS	533	/* Initialize the LTC4245 chip */
58f055e5 IS	534	i2c_smbus_write_byte_data(client, LTC4245_FAULT1, 0x00);
58f055e5 IS	535	i2c_smbus_write_byte_data(client, LTC4245_FAULT2, 0x00);
6e34b187 IS	536
6e34b187 IS	537	/* Register sysfs hooks */
5950ec8d	538	ret = ltc4245_sysfs_create_groups(client);
6e34b187	539	if (ret)
effb8ab1	540	return ret;
6e34b187 IS	541
	542	data->hwmon_dev = hwmon_device_register(&client->dev);
	543	if (IS_ERR(data->hwmon_dev)) {
	544	ret = PTR_ERR(data->hwmon_dev);
	545	goto out_hwmon_device_register;
	546	}
	547
	548	return 0;
	549
	550	out_hwmon_device_register:
5950ec8d	551	ltc4245_sysfs_remove_groups(client);
6e34b187 IS	552	return ret;
	553	}
	554
	555	static int ltc4245_remove(struct i2c_client *client)
	556	{
	557	struct ltc4245_data *data = i2c_get_clientdata(client);
	558
	559	hwmon_device_unregister(data->hwmon_dev);
5950ec8d	560	ltc4245_sysfs_remove_groups(client);
6e34b187 IS	561
	562	return 0;
	563	}
	564
6e34b187	565	static const struct i2c_device_id ltc4245_id[] = {
2d2a7cff	566	{ "ltc4245", 0 },
6e34b187 IS	567	{ }
	568	};
	569	MODULE_DEVICE_TABLE(i2c, ltc4245_id);
	570
	571	/* This is the driver that will be inserted */
	572	static struct i2c_driver ltc4245_driver = {
6e34b187 IS	573	.driver = {
	574	.name = "ltc4245",
	575	},
	576	.probe = ltc4245_probe,
	577	.remove = ltc4245_remove,
	578	.id_table = ltc4245_id,
6e34b187 IS	579	};
6e34b187 IS	580
f0967eea	581	module_i2c_driver(ltc4245_driver);
6e34b187 IS	582
	583	MODULE_AUTHOR("Ira W. Snyder <iws@ovro.caltech.edu>");
	584	MODULE_DESCRIPTION("LTC4245 driver");
	585	MODULE_LICENSE("GPL");