[linux.git] / drivers / power / goldfish_battery.c

/*
 * Power supply driver for the goldfish emulator
 *
 * Copyright (C) 2008 Google, Inc.
 * Copyright (C) 2012 Intel, Inc.
 * Copyright (C) 2013 Intel, Inc.
 * Author: Mike Lockwood <[email protected]>
 *
 * This software is licensed under the terms of the GNU General Public
 * License version 2, as published by the Free Software Foundation, and
 * may be copied, distributed, and modified under those terms.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

#include <linux/module.h>
#include <linux/err.h>
#include <linux/platform_device.h>
#include <linux/power_supply.h>
#include <linux/types.h>
#include <linux/pci.h>
#include <linux/interrupt.h>
#include <linux/io.h>

struct goldfish_battery_data {
	void __iomem *reg_base;
	int irq;
	spinlock_t lock;

	struct power_supply battery;
	struct power_supply ac;
};

#define GOLDFISH_BATTERY_READ(data, addr) \
	(readl(data->reg_base + addr))
#define GOLDFISH_BATTERY_WRITE(data, addr, x) \
	(writel(x, data->reg_base + addr))

/*
 * Temporary variable used between goldfish_battery_probe() and
 * goldfish_battery_open().
 */
static struct goldfish_battery_data *battery_data;

enum {
	/* status register */
	BATTERY_INT_STATUS	    = 0x00,
	/* set this to enable IRQ */
	BATTERY_INT_ENABLE	    = 0x04,

	BATTERY_AC_ONLINE       = 0x08,
	BATTERY_STATUS          = 0x0C,
	BATTERY_HEALTH          = 0x10,
	BATTERY_PRESENT         = 0x14,
	BATTERY_CAPACITY        = 0x18,

	BATTERY_STATUS_CHANGED	= 1U << 0,
	AC_STATUS_CHANGED	= 1U << 1,
	BATTERY_INT_MASK        = BATTERY_STATUS_CHANGED | AC_STATUS_CHANGED,
};


static int goldfish_ac_get_property(struct power_supply *psy,
			enum power_supply_property psp,
			union power_supply_propval *val)
{
	struct goldfish_battery_data *data = container_of(psy,
		struct goldfish_battery_data, ac);
	int ret = 0;

	switch (psp) {
	case POWER_SUPPLY_PROP_ONLINE:
		val->intval = GOLDFISH_BATTERY_READ(data, BATTERY_AC_ONLINE);
		break;
	default:
		ret = -EINVAL;
		break;
	}
	return ret;
}

static int goldfish_battery_get_property(struct power_supply *psy,
				 enum power_supply_property psp,
				 union power_supply_propval *val)
{
	struct goldfish_battery_data *data = container_of(psy,
		struct goldfish_battery_data, battery);
	int ret = 0;

	switch (psp) {
	case POWER_SUPPLY_PROP_STATUS:
		val->intval = GOLDFISH_BATTERY_READ(data, BATTERY_STATUS);
		break;
	case POWER_SUPPLY_PROP_HEALTH:
		val->intval = GOLDFISH_BATTERY_READ(data, BATTERY_HEALTH);
		break;
	case POWER_SUPPLY_PROP_PRESENT:
		val->intval = GOLDFISH_BATTERY_READ(data, BATTERY_PRESENT);
		break;
	case POWER_SUPPLY_PROP_TECHNOLOGY:
		val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
		break;
	case POWER_SUPPLY_PROP_CAPACITY:
		val->intval = GOLDFISH_BATTERY_READ(data, BATTERY_CAPACITY);
		break;
	default:
		ret = -EINVAL;
		break;
	}

	return ret;
}

static enum power_supply_property goldfish_battery_props[] = {
	POWER_SUPPLY_PROP_STATUS,
	POWER_SUPPLY_PROP_HEALTH,
	POWER_SUPPLY_PROP_PRESENT,
	POWER_SUPPLY_PROP_TECHNOLOGY,
	POWER_SUPPLY_PROP_CAPACITY,
};

static enum power_supply_property goldfish_ac_props[] = {
	POWER_SUPPLY_PROP_ONLINE,
};

static irqreturn_t goldfish_battery_interrupt(int irq, void *dev_id)
{
	unsigned long irq_flags;
	struct goldfish_battery_data *data = dev_id;
	uint32_t status;

	spin_lock_irqsave(&data->lock, irq_flags);

	/* read status flags, which will clear the interrupt */
	status = GOLDFISH_BATTERY_READ(data, BATTERY_INT_STATUS);
	status &= BATTERY_INT_MASK;

	if (status & BATTERY_STATUS_CHANGED)
		power_supply_changed(&data->battery);
	if (status & AC_STATUS_CHANGED)
		power_supply_changed(&data->ac);

	spin_unlock_irqrestore(&data->lock, irq_flags);
	return status ? IRQ_HANDLED : IRQ_NONE;
}


static int goldfish_battery_probe(struct platform_device *pdev)
{
	int ret;
	struct resource *r;
	struct goldfish_battery_data *data;

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

	spin_lock_init(&data->lock);

	data->battery.properties = goldfish_battery_props;
	data->battery.num_properties = ARRAY_SIZE(goldfish_battery_props);
	data->battery.get_property = goldfish_battery_get_property;
	data->battery.name = "battery";
	data->battery.type = POWER_SUPPLY_TYPE_BATTERY;

	data->ac.properties = goldfish_ac_props;
	data->ac.num_properties = ARRAY_SIZE(goldfish_ac_props);
	data->ac.get_property = goldfish_ac_get_property;
	data->ac.name = "ac";
	data->ac.type = POWER_SUPPLY_TYPE_MAINS;

	r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (r == NULL) {
		dev_err(&pdev->dev, "platform_get_resource failed\n");
		return -ENODEV;
	}

	data->reg_base = devm_ioremap(&pdev->dev, r->start, resource_size(r));
	if (data->reg_base == NULL) {
		dev_err(&pdev->dev, "unable to remap MMIO\n");
		return -ENOMEM;
	}

	data->irq = platform_get_irq(pdev, 0);
	if (data->irq < 0) {
		dev_err(&pdev->dev, "platform_get_irq failed\n");
		return -ENODEV;
	}

	ret = devm_request_irq(&pdev->dev, data->irq, goldfish_battery_interrupt,
						IRQF_SHARED, pdev->name, data);
	if (ret)
		return ret;

	ret = power_supply_register(&pdev->dev, &data->ac);
	if (ret)
		return ret;

	ret = power_supply_register(&pdev->dev, &data->battery);
	if (ret) {
		power_supply_unregister(&data->ac);
		return ret;
	}

	platform_set_drvdata(pdev, data);
	battery_data = data;

	GOLDFISH_BATTERY_WRITE(data, BATTERY_INT_ENABLE, BATTERY_INT_MASK);
	return 0;
}

static int goldfish_battery_remove(struct platform_device *pdev)
{
	struct goldfish_battery_data *data = platform_get_drvdata(pdev);

	power_supply_unregister(&data->battery);
	power_supply_unregister(&data->ac);
	battery_data = NULL;
	return 0;
}

static struct platform_driver goldfish_battery_device = {
	.probe		= goldfish_battery_probe,
	.remove		= goldfish_battery_remove,
	.driver = {
		.name = "goldfish-battery"
	}
};
module_platform_driver(goldfish_battery_device);

MODULE_AUTHOR("Mike Lockwood [email protected]");
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Battery driver for the Goldfish emulator");
Commit	Line	Data
84d7b768 ML	1	/*
	2	* Power supply driver for the goldfish emulator
	3	*
	4	* Copyright (C) 2008 Google, Inc.
	5	* Copyright (C) 2012 Intel, Inc.
	6	* Copyright (C) 2013 Intel, Inc.
	7	* Author: Mike Lockwood <[email protected]>
	8	*
	9	* This software is licensed under the terms of the GNU General Public
	10	* License version 2, as published by the Free Software Foundation, and
	11	* may be copied, distributed, and modified under those terms.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*/
	18
	19	#include <linux/module.h>
	20	#include <linux/err.h>
	21	#include <linux/platform_device.h>
	22	#include <linux/power_supply.h>
	23	#include <linux/types.h>
	24	#include <linux/pci.h>
	25	#include <linux/interrupt.h>
	26	#include <linux/io.h>
	27
	28	struct goldfish_battery_data {
	29	void __iomem *reg_base;
	30	int irq;
	31	spinlock_t lock;
	32
	33	struct power_supply battery;
	34	struct power_supply ac;
	35	};
	36
	37	#define GOLDFISH_BATTERY_READ(data, addr) \
	38	(readl(data->reg_base + addr))
	39	#define GOLDFISH_BATTERY_WRITE(data, addr, x) \
	40	(writel(x, data->reg_base + addr))
	41
	42	/*
	43	* Temporary variable used between goldfish_battery_probe() and
	44	* goldfish_battery_open().
	45	*/
	46	static struct goldfish_battery_data *battery_data;
	47
	48	enum {
	49	/* status register */
	50	BATTERY_INT_STATUS = 0x00,
	51	/* set this to enable IRQ */
	52	BATTERY_INT_ENABLE = 0x04,
	53
	54	BATTERY_AC_ONLINE = 0x08,
	55	BATTERY_STATUS = 0x0C,
	56	BATTERY_HEALTH = 0x10,
	57	BATTERY_PRESENT = 0x14,
	58	BATTERY_CAPACITY = 0x18,
	59
	60	BATTERY_STATUS_CHANGED = 1U << 0,
	61	AC_STATUS_CHANGED = 1U << 1,
	62	BATTERY_INT_MASK = BATTERY_STATUS_CHANGED \| AC_STATUS_CHANGED,
	63	};
	64
65
66	static int goldfish_ac_get_property(struct power_supply *psy,
67	enum power_supply_property psp,
68	union power_supply_propval *val)
69	{
70	struct goldfish_battery_data *data = container_of(psy,
71	struct goldfish_battery_data, ac);
72	int ret = 0;
73
74	switch (psp) {
75	case POWER_SUPPLY_PROP_ONLINE:
76	val->intval = GOLDFISH_BATTERY_READ(data, BATTERY_AC_ONLINE);
77	break;
78	default:
79	ret = -EINVAL;
80	break;
81	}
82	return ret;
83	}
84
85	static int goldfish_battery_get_property(struct power_supply *psy,
86	enum power_supply_property psp,
87	union power_supply_propval *val)
88	{
89	struct goldfish_battery_data *data = container_of(psy,
90	struct goldfish_battery_data, battery);
91	int ret = 0;
92
93	switch (psp) {
94	case POWER_SUPPLY_PROP_STATUS:
95	val->intval = GOLDFISH_BATTERY_READ(data, BATTERY_STATUS);
96	break;
97	case POWER_SUPPLY_PROP_HEALTH:
98	val->intval = GOLDFISH_BATTERY_READ(data, BATTERY_HEALTH);
99	break;
100	case POWER_SUPPLY_PROP_PRESENT:
101	val->intval = GOLDFISH_BATTERY_READ(data, BATTERY_PRESENT);
102	break;
103	case POWER_SUPPLY_PROP_TECHNOLOGY:
104	val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
105	break;
106	case POWER_SUPPLY_PROP_CAPACITY:
107	val->intval = GOLDFISH_BATTERY_READ(data, BATTERY_CAPACITY);
108	break;
109	default:
110	ret = -EINVAL;
111	break;
112	}
113
114	return ret;
115	}
116
117	static enum power_supply_property goldfish_battery_props[] = {
118	POWER_SUPPLY_PROP_STATUS,
119	POWER_SUPPLY_PROP_HEALTH,
120	POWER_SUPPLY_PROP_PRESENT,
121	POWER_SUPPLY_PROP_TECHNOLOGY,
122	POWER_SUPPLY_PROP_CAPACITY,
123	};
124
125	static enum power_supply_property goldfish_ac_props[] = {
126	POWER_SUPPLY_PROP_ONLINE,
127	};
128
129	static irqreturn_t goldfish_battery_interrupt(int irq, void *dev_id)
130	{
131	unsigned long irq_flags;
132	struct goldfish_battery_data *data = dev_id;
133	uint32_t status;
134
135	spin_lock_irqsave(&data->lock, irq_flags);
136
137	/* read status flags, which will clear the interrupt */
138	status = GOLDFISH_BATTERY_READ(data, BATTERY_INT_STATUS);
139	status &= BATTERY_INT_MASK;
140
141	if (status & BATTERY_STATUS_CHANGED)
142	power_supply_changed(&data->battery);
143	if (status & AC_STATUS_CHANGED)
144	power_supply_changed(&data->ac);
145
146	spin_unlock_irqrestore(&data->lock, irq_flags);
147	return status ? IRQ_HANDLED : IRQ_NONE;
148	}
149
150
151	static int goldfish_battery_probe(struct platform_device *pdev)
152	{
153	int ret;
154	struct resource *r;
155	struct goldfish_battery_data *data;
156
157	data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
158	if (data == NULL)
159	return -ENOMEM;
160
161	spin_lock_init(&data->lock);
162
163	data->battery.properties = goldfish_battery_props;
164	data->battery.num_properties = ARRAY_SIZE(goldfish_battery_props);
165	data->battery.get_property = goldfish_battery_get_property;
166	data->battery.name = "battery";
167	data->battery.type = POWER_SUPPLY_TYPE_BATTERY;
168
169	data->ac.properties = goldfish_ac_props;
170	data->ac.num_properties = ARRAY_SIZE(goldfish_ac_props);
171	data->ac.get_property = goldfish_ac_get_property;
172	data->ac.name = "ac";
173	data->ac.type = POWER_SUPPLY_TYPE_MAINS;
174
175	r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
176	if (r == NULL) {
177	dev_err(&pdev->dev, "platform_get_resource failed\n");
178	return -ENODEV;
179	}
180
a92d4c7d	181	data->reg_base = devm_ioremap(&pdev->dev, r->start, resource_size(r));
84d7b768 ML	182	if (data->reg_base == NULL) {
	183	dev_err(&pdev->dev, "unable to remap MMIO\n");
	184	return -ENOMEM;
	185	}
	186
	187	data->irq = platform_get_irq(pdev, 0);
	188	if (data->irq < 0) {
	189	dev_err(&pdev->dev, "platform_get_irq failed\n");
	190	return -ENODEV;
	191	}
	192
	193	ret = devm_request_irq(&pdev->dev, data->irq, goldfish_battery_interrupt,
	194	IRQF_SHARED, pdev->name, data);
	195	if (ret)
	196	return ret;
	197
	198	ret = power_supply_register(&pdev->dev, &data->ac);
	199	if (ret)
	200	return ret;
	201
	202	ret = power_supply_register(&pdev->dev, &data->battery);
	203	if (ret) {
	204	power_supply_unregister(&data->ac);
	205	return ret;
	206	}
	207
	208	platform_set_drvdata(pdev, data);
	209	battery_data = data;
	210
	211	GOLDFISH_BATTERY_WRITE(data, BATTERY_INT_ENABLE, BATTERY_INT_MASK);
	212	return 0;
	213	}
	214
	215	static int goldfish_battery_remove(struct platform_device *pdev)
	216	{
	217	struct goldfish_battery_data *data = platform_get_drvdata(pdev);
	218
	219	power_supply_unregister(&data->battery);
	220	power_supply_unregister(&data->ac);
	221	battery_data = NULL;
	222	return 0;
	223	}
	224
	225	static struct platform_driver goldfish_battery_device = {
	226	.probe = goldfish_battery_probe,
	227	.remove = goldfish_battery_remove,
	228	.driver = {
	229	.name = "goldfish-battery"
	230	}
	231	};
	232	module_platform_driver(goldfish_battery_device);
	233
	234	MODULE_AUTHOR("Mike Lockwood [email protected]");
	235	MODULE_LICENSE("GPL");
	236	MODULE_DESCRIPTION("Battery driver for the Goldfish emulator");