intel_pmic_gpio.c 8.2 KB
Newer Older
A
Alek Du 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
/* Moorestown PMIC GPIO (access through IPC) driver
 * Copyright (c) 2008 - 2009, Intel Corporation.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

/* Supports:
 * Moorestown platform PMIC chip
 */

22 23
#define pr_fmt(fmt) "%s: " fmt, __func__

A
Alek Du 已提交
24 25 26 27 28 29 30 31 32
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/interrupt.h>
#include <linux/delay.h>
#include <linux/stddef.h>
#include <linux/slab.h>
#include <linux/ioport.h>
#include <linux/init.h>
#include <linux/io.h>
33
#include <linux/gpio/driver.h>
A
Alek Du 已提交
34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64
#include <asm/intel_scu_ipc.h>
#include <linux/device.h>
#include <linux/intel_pmic_gpio.h>
#include <linux/platform_device.h>

#define DRIVER_NAME "pmic_gpio"

/* register offset that IPC driver should use
 * 8 GPIO + 8 GPOSW (6 controllable) + 8GPO
 */
enum pmic_gpio_register {
	GPIO0		= 0xE0,
	GPIO7		= 0xE7,
	GPIOINT		= 0xE8,
	GPOSWCTL0	= 0xEC,
	GPOSWCTL5	= 0xF1,
	GPO		= 0xF4,
};

/* bits definition for GPIO & GPOSW */
#define GPIO_DRV 0x01
#define GPIO_DIR 0x02
#define GPIO_DIN 0x04
#define GPIO_DOU 0x08
#define GPIO_INTCTL 0x30
#define GPIO_DBC 0xc0

#define GPOSW_DRV 0x01
#define GPOSW_DOU 0x08
#define GPOSW_RDRV 0x30

65
#define GPIO_UPDATE_TYPE	0x80000000
A
Alek Du 已提交
66 67 68 69

#define NUM_GPIO 24

struct pmic_gpio {
70
	struct mutex		buslock;
A
Alek Du 已提交
71 72 73 74
	struct gpio_chip	chip;
	void			*gpiointr;
	int			irq;
	unsigned		irq_base;
75 76
	unsigned int		update_type;
	u32			trigger_type;
A
Alek Du 已提交
77 78
};

79 80 81 82 83 84 85 86 87 88 89 90 91
static void pmic_program_irqtype(int gpio, int type)
{
	if (type & IRQ_TYPE_EDGE_RISING)
		intel_scu_ipc_update_register(GPIO0 + gpio, 0x20, 0x20);
	else
		intel_scu_ipc_update_register(GPIO0 + gpio, 0x00, 0x20);

	if (type & IRQ_TYPE_EDGE_FALLING)
		intel_scu_ipc_update_register(GPIO0 + gpio, 0x10, 0x10);
	else
		intel_scu_ipc_update_register(GPIO0 + gpio, 0x00, 0x10);
};

A
Alek Du 已提交
92 93
static int pmic_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
{
94
	if (offset >= 8) {
95
		pr_err("only pin 0-7 support input\n");
A
Alek Du 已提交
96 97 98 99 100 101 102 103 104 105 106 107 108
		return -1;/* we only have 8 GPIO can use as input */
	}
	return intel_scu_ipc_update_register(GPIO0 + offset,
							GPIO_DIR, GPIO_DIR);
}

static int pmic_gpio_direction_output(struct gpio_chip *chip,
			unsigned offset, int value)
{
	int rc = 0;

	if (offset < 8)/* it is GPIO */
		rc = intel_scu_ipc_update_register(GPIO0 + offset,
109 110
				GPIO_DRV | (value ? GPIO_DOU : 0),
				GPIO_DRV | GPIO_DOU | GPIO_DIR);
A
Alek Du 已提交
111 112
	else if (offset < 16)/* it is GPOSW */
		rc = intel_scu_ipc_update_register(GPOSWCTL0 + offset - 8,
113 114
				GPOSW_DRV | (value ? GPOSW_DOU : 0),
				GPOSW_DRV | GPOSW_DOU | GPOSW_RDRV);
A
Alek Du 已提交
115 116
	else if (offset > 15 && offset < 24)/* it is GPO */
		rc = intel_scu_ipc_update_register(GPO,
117 118
				value ? 1 << (offset - 16) : 0,
				1 << (offset - 16));
A
Alek Du 已提交
119
	else {
120
		pr_err("invalid PMIC GPIO pin %d!\n", offset);
A
Alek Du 已提交
121 122 123 124 125 126 127 128 129 130 131 132
		WARN_ON(1);
	}

	return rc;
}

static int pmic_gpio_get(struct gpio_chip *chip, unsigned offset)
{
	u8 r;
	int ret;

	/* we only have 8 GPIO pins we can use as input */
133
	if (offset >= 8)
A
Alek Du 已提交
134 135 136 137 138 139 140 141 142 143 144
		return -EOPNOTSUPP;
	ret = intel_scu_ipc_ioread8(GPIO0 + offset, &r);
	if (ret < 0)
		return ret;
	return r & GPIO_DIN;
}

static void pmic_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
{
	if (offset < 8)/* it is GPIO */
		intel_scu_ipc_update_register(GPIO0 + offset,
145 146
			GPIO_DRV | (value ? GPIO_DOU : 0),
			GPIO_DRV | GPIO_DOU);
A
Alek Du 已提交
147 148
	else if (offset < 16)/* it is GPOSW */
		intel_scu_ipc_update_register(GPOSWCTL0 + offset - 8,
149 150
			GPOSW_DRV | (value ? GPOSW_DOU : 0),
			GPOSW_DRV | GPOSW_DOU | GPOSW_RDRV);
A
Alek Du 已提交
151 152
	else if (offset > 15 && offset < 24) /* it is GPO */
		intel_scu_ipc_update_register(GPO,
153 154
			value ? 1 << (offset - 16) : 0,
			1 << (offset - 16));
A
Alek Du 已提交
155 156
}

157 158 159 160 161
/*
 * This is called from genirq with pg->buslock locked and
 * irq_desc->lock held. We can not access the scu bus here, so we
 * store the change and update in the bus_sync_unlock() function below
 */
162
static int pmic_irq_type(struct irq_data *data, unsigned type)
A
Alek Du 已提交
163
{
164 165
	struct pmic_gpio *pg = irq_data_get_irq_chip_data(data);
	u32 gpio = data->irq - pg->irq_base;
A
Alek Du 已提交
166

167
	if (gpio >= pg->chip.ngpio)
A
Alek Du 已提交
168 169
		return -EINVAL;

170 171
	pg->trigger_type = type;
	pg->update_type = gpio | GPIO_UPDATE_TYPE;
A
Alek Du 已提交
172 173 174 175 176
	return 0;
}

static int pmic_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
{
177
	struct pmic_gpio *pg = gpiochip_get_data(chip);
A
Alek Du 已提交
178 179 180 181

	return pg->irq_base + offset;
}

182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201
static void pmic_bus_lock(struct irq_data *data)
{
	struct pmic_gpio *pg = irq_data_get_irq_chip_data(data);

	mutex_lock(&pg->buslock);
}

static void pmic_bus_sync_unlock(struct irq_data *data)
{
	struct pmic_gpio *pg = irq_data_get_irq_chip_data(data);

	if (pg->update_type) {
		unsigned int gpio = pg->update_type & ~GPIO_UPDATE_TYPE;

		pmic_program_irqtype(gpio, pg->trigger_type);
		pg->update_type = 0;
	}
	mutex_unlock(&pg->buslock);
}

A
Alek Du 已提交
202
/* the gpiointr register is read-clear, so just do nothing. */
203
static void pmic_irq_unmask(struct irq_data *data) { }
A
Alek Du 已提交
204

205
static void pmic_irq_mask(struct irq_data *data) { }
A
Alek Du 已提交
206 207

static struct irq_chip pmic_irqchip = {
208 209 210 211
	.name			= "PMIC-GPIO",
	.irq_mask		= pmic_irq_mask,
	.irq_unmask		= pmic_irq_unmask,
	.irq_set_type		= pmic_irq_type,
212
	.irq_bus_lock		= pmic_bus_lock,
213
	.irq_bus_sync_unlock	= pmic_bus_sync_unlock,
A
Alek Du 已提交
214 215
};

216
static irqreturn_t pmic_irq_handler(int irq, void *data)
A
Alek Du 已提交
217
{
218
	struct pmic_gpio *pg = data;
A
Alek Du 已提交
219 220
	u8 intsts = *((u8 *)pg->gpiointr + 4);
	int gpio;
221
	irqreturn_t ret = IRQ_NONE;
A
Alek Du 已提交
222 223 224 225 226

	for (gpio = 0; gpio < 8; gpio++) {
		if (intsts & (1 << gpio)) {
			pr_debug("pmic pin %d triggered\n", gpio);
			generic_handle_irq(pg->irq_base + gpio);
227
			ret = IRQ_HANDLED;
A
Alek Du 已提交
228 229
		}
	}
230
	return ret;
A
Alek Du 已提交
231 232
}

233
static int platform_pmic_gpio_probe(struct platform_device *pdev)
A
Alek Du 已提交
234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262
{
	struct device *dev = &pdev->dev;
	int irq = platform_get_irq(pdev, 0);
	struct intel_pmic_gpio_platform_data *pdata = dev->platform_data;

	struct pmic_gpio *pg;
	int retval;
	int i;

	if (irq < 0) {
		dev_dbg(dev, "no IRQ line\n");
		return -EINVAL;
	}

	if (!pdata || !pdata->gpio_base || !pdata->irq_base) {
		dev_dbg(dev, "incorrect or missing platform data\n");
		return -EINVAL;
	}

	pg = kzalloc(sizeof(*pg), GFP_KERNEL);
	if (!pg)
		return -ENOMEM;

	dev_set_drvdata(dev, pg);

	pg->irq = irq;
	/* setting up SRAM mapping for GPIOINT register */
	pg->gpiointr = ioremap_nocache(pdata->gpiointr, 8);
	if (!pg->gpiointr) {
263
		pr_err("Can not map GPIOINT\n");
A
Alek Du 已提交
264 265 266 267 268 269 270 271 272 273 274 275 276
		retval = -EINVAL;
		goto err2;
	}
	pg->irq_base = pdata->irq_base;
	pg->chip.label = "intel_pmic";
	pg->chip.direction_input = pmic_gpio_direction_input;
	pg->chip.direction_output = pmic_gpio_direction_output;
	pg->chip.get = pmic_gpio_get;
	pg->chip.set = pmic_gpio_set;
	pg->chip.to_irq = pmic_gpio_to_irq;
	pg->chip.base = pdata->gpio_base;
	pg->chip.ngpio = NUM_GPIO;
	pg->chip.can_sleep = 1;
277
	pg->chip.parent = dev;
A
Alek Du 已提交
278

279
	mutex_init(&pg->buslock);
A
Alek Du 已提交
280

281
	pg->chip.parent = dev;
282
	retval = gpiochip_add_data(&pg->chip, pg);
A
Alek Du 已提交
283
	if (retval) {
284
		pr_err("Can not add pmic gpio chip\n");
A
Alek Du 已提交
285 286
		goto err;
	}
287 288 289

	retval = request_irq(pg->irq, pmic_irq_handler, 0, "pmic", pg);
	if (retval) {
290
		pr_warn("Interrupt request failed\n");
L
Libo Chen 已提交
291
		goto fail_request_irq;
292 293
	}

A
Alek Du 已提交
294
	for (i = 0; i < 8; i++) {
295 296 297 298 299
		irq_set_chip_and_handler_name(i + pg->irq_base,
					      &pmic_irqchip,
					      handle_simple_irq,
					      "demux");
		irq_set_chip_data(i + pg->irq_base, pg);
A
Alek Du 已提交
300 301
	}
	return 0;
L
Libo Chen 已提交
302 303

fail_request_irq:
304
	gpiochip_remove(&pg->chip);
A
Alek Du 已提交
305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330
err:
	iounmap(pg->gpiointr);
err2:
	kfree(pg);
	return retval;
}

/* at the same time, register a platform driver
 * this supports the sfi 0.81 fw */
static struct platform_driver platform_pmic_gpio_driver = {
	.driver = {
		.name		= DRIVER_NAME,
	},
	.probe		= platform_pmic_gpio_probe,
};

static int __init platform_pmic_gpio_init(void)
{
	return platform_driver_register(&platform_pmic_gpio_driver);
}

subsys_initcall(platform_pmic_gpio_init);

MODULE_AUTHOR("Alek Du <alek.du@intel.com>");
MODULE_DESCRIPTION("Intel Moorestown PMIC GPIO driver");
MODULE_LICENSE("GPL v2");