gpio-dwapb.c 19.7 KB
Newer Older
1 2 3 4 5 6 7 8 9
/*
 * Copyright (c) 2011 Jamie Iles
 *
 * 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.
 *
 * All enquiries to support@picochip.com
 */
10
#include <linux/acpi.h>
11 12 13
#include <linux/gpio/driver.h>
/* FIXME: for gpio_get_value(), replace this with direct register read */
#include <linux/gpio.h>
14 15 16 17 18 19 20 21 22 23
#include <linux/err.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/ioport.h>
#include <linux/irq.h>
#include <linux/irqdomain.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_address.h>
24
#include <linux/of_device.h>
25 26
#include <linux/of_irq.h>
#include <linux/platform_device.h>
27
#include <linux/property.h>
28
#include <linux/reset.h>
29
#include <linux/spinlock.h>
30 31
#include <linux/platform_data/gpio-dwapb.h>
#include <linux/slab.h>
32

33 34
#include "gpiolib.h"

35 36 37 38 39 40 41 42 43 44 45 46 47
#define GPIO_SWPORTA_DR		0x00
#define GPIO_SWPORTA_DDR	0x04
#define GPIO_SWPORTB_DR		0x0c
#define GPIO_SWPORTB_DDR	0x10
#define GPIO_SWPORTC_DR		0x18
#define GPIO_SWPORTC_DDR	0x1c
#define GPIO_SWPORTD_DR		0x24
#define GPIO_SWPORTD_DDR	0x28
#define GPIO_INTEN		0x30
#define GPIO_INTMASK		0x34
#define GPIO_INTTYPE_LEVEL	0x38
#define GPIO_INT_POLARITY	0x3c
#define GPIO_INTSTATUS		0x40
48
#define GPIO_PORTA_DEBOUNCE	0x48
49 50 51 52 53 54 55 56 57 58 59
#define GPIO_PORTA_EOI		0x4c
#define GPIO_EXT_PORTA		0x50
#define GPIO_EXT_PORTB		0x54
#define GPIO_EXT_PORTC		0x58
#define GPIO_EXT_PORTD		0x5c

#define DWAPB_MAX_PORTS		4
#define GPIO_EXT_PORT_SIZE	(GPIO_EXT_PORTB - GPIO_EXT_PORTA)
#define GPIO_SWPORT_DR_SIZE	(GPIO_SWPORTB_DR - GPIO_SWPORTA_DR)
#define GPIO_SWPORT_DDR_SIZE	(GPIO_SWPORTB_DDR - GPIO_SWPORTA_DDR)

60 61 62 63 64 65 66 67
#define GPIO_REG_OFFSET_V2	1

#define GPIO_INTMASK_V2		0x44
#define GPIO_INTTYPE_LEVEL_V2	0x34
#define GPIO_INT_POLARITY_V2	0x38
#define GPIO_INTSTATUS_V2	0x3c
#define GPIO_PORTA_EOI_V2	0x40

68 69
struct dwapb_gpio;

70 71 72 73 74 75 76 77 78 79 80
#ifdef CONFIG_PM_SLEEP
/* Store GPIO context across system-wide suspend/resume transitions */
struct dwapb_context {
	u32 data;
	u32 dir;
	u32 ext;
	u32 int_en;
	u32 int_mask;
	u32 int_type;
	u32 int_pol;
	u32 int_deb;
81
	u32 wake_en;
82 83 84
};
#endif

85
struct dwapb_gpio_port {
86
	struct gpio_chip	gc;
87 88
	bool			is_registered;
	struct dwapb_gpio	*gpio;
89 90 91 92
#ifdef CONFIG_PM_SLEEP
	struct dwapb_context	*ctx;
#endif
	unsigned int		idx;
93 94 95 96 97 98 99 100
};

struct dwapb_gpio {
	struct	device		*dev;
	void __iomem		*regs;
	struct dwapb_gpio_port	*ports;
	unsigned int		nr_ports;
	struct irq_domain	*domain;
101
	unsigned int		flags;
102
	struct reset_control	*rst;
103 104
};

105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130
static inline u32 gpio_reg_v2_convert(unsigned int offset)
{
	switch (offset) {
	case GPIO_INTMASK:
		return GPIO_INTMASK_V2;
	case GPIO_INTTYPE_LEVEL:
		return GPIO_INTTYPE_LEVEL_V2;
	case GPIO_INT_POLARITY:
		return GPIO_INT_POLARITY_V2;
	case GPIO_INTSTATUS:
		return GPIO_INTSTATUS_V2;
	case GPIO_PORTA_EOI:
		return GPIO_PORTA_EOI_V2;
	}

	return offset;
}

static inline u32 gpio_reg_convert(struct dwapb_gpio *gpio, unsigned int offset)
{
	if (gpio->flags & GPIO_REG_OFFSET_V2)
		return gpio_reg_v2_convert(offset);

	return offset;
}

131 132
static inline u32 dwapb_read(struct dwapb_gpio *gpio, unsigned int offset)
{
133
	struct gpio_chip *gc	= &gpio->ports[0].gc;
134 135
	void __iomem *reg_base	= gpio->regs;

136
	return gc->read_reg(reg_base + gpio_reg_convert(gpio, offset));
137 138 139 140 141
}

static inline void dwapb_write(struct dwapb_gpio *gpio, unsigned int offset,
			       u32 val)
{
142
	struct gpio_chip *gc	= &gpio->ports[0].gc;
143 144
	void __iomem *reg_base	= gpio->regs;

145
	gc->write_reg(reg_base + gpio_reg_convert(gpio, offset), val);
146 147
}

148 149
static int dwapb_gpio_to_irq(struct gpio_chip *gc, unsigned offset)
{
150
	struct dwapb_gpio_port *port = gpiochip_get_data(gc);
151 152 153 154 155 156 157
	struct dwapb_gpio *gpio = port->gpio;

	return irq_find_mapping(gpio->domain, offset);
}

static void dwapb_toggle_trigger(struct dwapb_gpio *gpio, unsigned int offs)
{
158
	u32 v = dwapb_read(gpio, GPIO_INT_POLARITY);
159

160
	if (gpio_get_value(gpio->ports[0].gc.base + offs))
161 162 163 164
		v &= ~BIT(offs);
	else
		v |= BIT(offs);

165
	dwapb_write(gpio, GPIO_INT_POLARITY, v);
166 167
}

168
static u32 dwapb_do_irq(struct dwapb_gpio *gpio)
169
{
170
	u32 irq_status = dwapb_read(gpio, GPIO_INTSTATUS);
171
	u32 ret = irq_status;
172 173 174 175 176 177 178 179 180 181 182 183 184

	while (irq_status) {
		int hwirq = fls(irq_status) - 1;
		int gpio_irq = irq_find_mapping(gpio->domain, hwirq);

		generic_handle_irq(gpio_irq);
		irq_status &= ~BIT(hwirq);

		if ((irq_get_trigger_type(gpio_irq) & IRQ_TYPE_SENSE_MASK)
			== IRQ_TYPE_EDGE_BOTH)
			dwapb_toggle_trigger(gpio, hwirq);
	}

185 186 187
	return ret;
}

188
static void dwapb_irq_handler(struct irq_desc *desc)
189
{
190
	struct dwapb_gpio *gpio = irq_desc_get_handler_data(desc);
191 192 193 194
	struct irq_chip *chip = irq_desc_get_chip(desc);

	dwapb_do_irq(gpio);

195 196 197 198 199 200 201 202
	if (chip->irq_eoi)
		chip->irq_eoi(irq_desc_get_irq_data(desc));
}

static void dwapb_irq_enable(struct irq_data *d)
{
	struct irq_chip_generic *igc = irq_data_get_irq_chip_data(d);
	struct dwapb_gpio *gpio = igc->private;
203
	struct gpio_chip *gc = &gpio->ports[0].gc;
204 205 206
	unsigned long flags;
	u32 val;

207
	spin_lock_irqsave(&gc->bgpio_lock, flags);
208
	val = dwapb_read(gpio, GPIO_INTEN);
209
	val |= BIT(d->hwirq);
210
	dwapb_write(gpio, GPIO_INTEN, val);
211
	spin_unlock_irqrestore(&gc->bgpio_lock, flags);
212 213 214 215 216 217
}

static void dwapb_irq_disable(struct irq_data *d)
{
	struct irq_chip_generic *igc = irq_data_get_irq_chip_data(d);
	struct dwapb_gpio *gpio = igc->private;
218
	struct gpio_chip *gc = &gpio->ports[0].gc;
219 220 221
	unsigned long flags;
	u32 val;

222
	spin_lock_irqsave(&gc->bgpio_lock, flags);
223
	val = dwapb_read(gpio, GPIO_INTEN);
224
	val &= ~BIT(d->hwirq);
225
	dwapb_write(gpio, GPIO_INTEN, val);
226
	spin_unlock_irqrestore(&gc->bgpio_lock, flags);
227 228
}

229
static int dwapb_irq_reqres(struct irq_data *d)
230 231 232
{
	struct irq_chip_generic *igc = irq_data_get_irq_chip_data(d);
	struct dwapb_gpio *gpio = igc->private;
233
	struct gpio_chip *gc = &gpio->ports[0].gc;
234

235
	if (gpiochip_lock_as_irq(gc, irqd_to_hwirq(d))) {
236 237
		dev_err(gpio->dev, "unable to lock HW IRQ %lu for IRQ\n",
			irqd_to_hwirq(d));
238 239
		return -EINVAL;
	}
240 241 242
	return 0;
}

243
static void dwapb_irq_relres(struct irq_data *d)
244 245 246
{
	struct irq_chip_generic *igc = irq_data_get_irq_chip_data(d);
	struct dwapb_gpio *gpio = igc->private;
247
	struct gpio_chip *gc = &gpio->ports[0].gc;
248

249
	gpiochip_unlock_as_irq(gc, irqd_to_hwirq(d));
250 251 252 253 254 255
}

static int dwapb_irq_set_type(struct irq_data *d, u32 type)
{
	struct irq_chip_generic *igc = irq_data_get_irq_chip_data(d);
	struct dwapb_gpio *gpio = igc->private;
256
	struct gpio_chip *gc = &gpio->ports[0].gc;
257 258 259 260 261 262 263
	int bit = d->hwirq;
	unsigned long level, polarity, flags;

	if (type & ~(IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING |
		     IRQ_TYPE_LEVEL_HIGH | IRQ_TYPE_LEVEL_LOW))
		return -EINVAL;

264
	spin_lock_irqsave(&gc->bgpio_lock, flags);
265 266
	level = dwapb_read(gpio, GPIO_INTTYPE_LEVEL);
	polarity = dwapb_read(gpio, GPIO_INT_POLARITY);
267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290

	switch (type) {
	case IRQ_TYPE_EDGE_BOTH:
		level |= BIT(bit);
		dwapb_toggle_trigger(gpio, bit);
		break;
	case IRQ_TYPE_EDGE_RISING:
		level |= BIT(bit);
		polarity |= BIT(bit);
		break;
	case IRQ_TYPE_EDGE_FALLING:
		level |= BIT(bit);
		polarity &= ~BIT(bit);
		break;
	case IRQ_TYPE_LEVEL_HIGH:
		level &= ~BIT(bit);
		polarity |= BIT(bit);
		break;
	case IRQ_TYPE_LEVEL_LOW:
		level &= ~BIT(bit);
		polarity &= ~BIT(bit);
		break;
	}

291 292
	irq_setup_alt_chip(d, type);

293
	dwapb_write(gpio, GPIO_INTTYPE_LEVEL, level);
294 295
	if (type != IRQ_TYPE_EDGE_BOTH)
		dwapb_write(gpio, GPIO_INT_POLARITY, polarity);
296
	spin_unlock_irqrestore(&gc->bgpio_lock, flags);
297 298 299 300

	return 0;
}

301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316
#ifdef CONFIG_PM_SLEEP
static int dwapb_irq_set_wake(struct irq_data *d, unsigned int enable)
{
	struct irq_chip_generic *igc = irq_data_get_irq_chip_data(d);
	struct dwapb_gpio *gpio = igc->private;
	struct dwapb_context *ctx = gpio->ports[0].ctx;

	if (enable)
		ctx->wake_en |= BIT(d->hwirq);
	else
		ctx->wake_en &= ~BIT(d->hwirq);

	return 0;
}
#endif

317 318 319
static int dwapb_gpio_set_debounce(struct gpio_chip *gc,
				   unsigned offset, unsigned debounce)
{
320
	struct dwapb_gpio_port *port = gpiochip_get_data(gc);
321 322
	struct dwapb_gpio *gpio = port->gpio;
	unsigned long flags, val_deb;
323
	unsigned long mask = BIT(offset);
324

325
	spin_lock_irqsave(&gc->bgpio_lock, flags);
326 327 328 329 330 331 332

	val_deb = dwapb_read(gpio, GPIO_PORTA_DEBOUNCE);
	if (debounce)
		dwapb_write(gpio, GPIO_PORTA_DEBOUNCE, val_deb | mask);
	else
		dwapb_write(gpio, GPIO_PORTA_DEBOUNCE, val_deb & ~mask);

333
	spin_unlock_irqrestore(&gc->bgpio_lock, flags);
334 335 336 337

	return 0;
}

338 339 340 341 342 343 344 345 346 347 348 349
static int dwapb_gpio_set_config(struct gpio_chip *gc, unsigned offset,
				 unsigned long config)
{
	u32 debounce;

	if (pinconf_to_config_param(config) != PIN_CONFIG_INPUT_DEBOUNCE)
		return -ENOTSUPP;

	debounce = pinconf_to_config_argument(config);
	return dwapb_gpio_set_debounce(gc, offset, debounce);
}

350 351 352 353 354 355 356 357 358 359
static irqreturn_t dwapb_irq_handler_mfd(int irq, void *dev_id)
{
	u32 worked;
	struct dwapb_gpio *gpio = dev_id;

	worked = dwapb_do_irq(gpio);

	return worked ? IRQ_HANDLED : IRQ_NONE;
}

360
static void dwapb_configure_irqs(struct dwapb_gpio *gpio,
361 362
				 struct dwapb_gpio_port *port,
				 struct dwapb_port_property *pp)
363
{
364
	struct gpio_chip *gc = &port->gc;
365
	struct fwnode_handle  *fwnode = pp->fwnode;
366
	struct irq_chip_generic	*irq_gc = NULL;
367 368
	unsigned int hwirq, ngpio = gc->ngpio;
	struct irq_chip_type *ct;
369
	int err, i;
370

371 372
	gpio->domain = irq_domain_create_linear(fwnode, ngpio,
						 &irq_generic_chip_ops, gpio);
373 374 375
	if (!gpio->domain)
		return;

376
	err = irq_alloc_domain_generic_chips(gpio->domain, ngpio, 2,
377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396
					     "gpio-dwapb", handle_level_irq,
					     IRQ_NOREQUEST, 0,
					     IRQ_GC_INIT_NESTED_LOCK);
	if (err) {
		dev_info(gpio->dev, "irq_alloc_domain_generic_chips failed\n");
		irq_domain_remove(gpio->domain);
		gpio->domain = NULL;
		return;
	}

	irq_gc = irq_get_domain_generic_chip(gpio->domain, 0);
	if (!irq_gc) {
		irq_domain_remove(gpio->domain);
		gpio->domain = NULL;
		return;
	}

	irq_gc->reg_base = gpio->regs;
	irq_gc->private = gpio;

397 398 399 400 401 402 403 404 405 406
	for (i = 0; i < 2; i++) {
		ct = &irq_gc->chip_types[i];
		ct->chip.irq_ack = irq_gc_ack_set_bit;
		ct->chip.irq_mask = irq_gc_mask_set_bit;
		ct->chip.irq_unmask = irq_gc_mask_clr_bit;
		ct->chip.irq_set_type = dwapb_irq_set_type;
		ct->chip.irq_enable = dwapb_irq_enable;
		ct->chip.irq_disable = dwapb_irq_disable;
		ct->chip.irq_request_resources = dwapb_irq_reqres;
		ct->chip.irq_release_resources = dwapb_irq_relres;
407 408 409
#ifdef CONFIG_PM_SLEEP
		ct->chip.irq_set_wake = dwapb_irq_set_wake;
#endif
410 411
		ct->regs.ack = gpio_reg_convert(gpio, GPIO_PORTA_EOI);
		ct->regs.mask = gpio_reg_convert(gpio, GPIO_INTMASK);
412 413 414 415 416 417
		ct->type = IRQ_TYPE_LEVEL_MASK;
	}

	irq_gc->chip_types[0].type = IRQ_TYPE_LEVEL_MASK;
	irq_gc->chip_types[1].type = IRQ_TYPE_EDGE_BOTH;
	irq_gc->chip_types[1].handler = handle_edge_irq;
418

419
	if (!pp->irq_shared) {
420 421
		irq_set_chained_handler_and_data(pp->irq, dwapb_irq_handler,
						 gpio);
422 423 424 425 426 427 428 429 430 431 432 433 434 435 436
	} else {
		/*
		 * Request a shared IRQ since where MFD would have devices
		 * using the same irq pin
		 */
		err = devm_request_irq(gpio->dev, pp->irq,
				       dwapb_irq_handler_mfd,
				       IRQF_SHARED, "gpio-dwapb-mfd", gpio);
		if (err) {
			dev_err(gpio->dev, "error requesting IRQ\n");
			irq_domain_remove(gpio->domain);
			gpio->domain = NULL;
			return;
		}
	}
437 438 439 440

	for (hwirq = 0 ; hwirq < ngpio ; hwirq++)
		irq_create_mapping(gpio->domain, hwirq);

441
	port->gc.to_irq = dwapb_gpio_to_irq;
442 443 444 445 446
}

static void dwapb_irq_teardown(struct dwapb_gpio *gpio)
{
	struct dwapb_gpio_port *port = &gpio->ports[0];
447
	struct gpio_chip *gc = &port->gc;
448 449 450 451 452 453 454 455 456 457 458 459 460 461
	unsigned int ngpio = gc->ngpio;
	irq_hw_number_t hwirq;

	if (!gpio->domain)
		return;

	for (hwirq = 0 ; hwirq < ngpio ; hwirq++)
		irq_dispose_mapping(irq_find_mapping(gpio->domain, hwirq));

	irq_domain_remove(gpio->domain);
	gpio->domain = NULL;
}

static int dwapb_gpio_add_port(struct dwapb_gpio *gpio,
462
			       struct dwapb_port_property *pp,
463 464 465 466 467 468 469 470
			       unsigned int offs)
{
	struct dwapb_gpio_port *port;
	void __iomem *dat, *set, *dirout;
	int err;

	port = &gpio->ports[offs];
	port->gpio = gpio;
471 472 473 474 475 476 477
	port->idx = pp->idx;

#ifdef CONFIG_PM_SLEEP
	port->ctx = devm_kzalloc(gpio->dev, sizeof(*port->ctx), GFP_KERNEL);
	if (!port->ctx)
		return -ENOMEM;
#endif
478

479 480
	dat = gpio->regs + GPIO_EXT_PORTA + (pp->idx * GPIO_EXT_PORT_SIZE);
	set = gpio->regs + GPIO_SWPORTA_DR + (pp->idx * GPIO_SWPORT_DR_SIZE);
481
	dirout = gpio->regs + GPIO_SWPORTA_DDR +
482
		(pp->idx * GPIO_SWPORT_DDR_SIZE);
483

484
	err = bgpio_init(&port->gc, gpio->dev, 4, dat, set, NULL, dirout,
485
			 NULL, 0);
486
	if (err) {
487 488
		dev_err(gpio->dev, "failed to init gpio chip for port%d\n",
			port->idx);
489 490 491
		return err;
	}

492
#ifdef CONFIG_OF_GPIO
493
	port->gc.of_node = to_of_node(pp->fwnode);
494
#endif
495 496
	port->gc.ngpio = pp->ngpio;
	port->gc.base = pp->gpio_base;
497

498 499
	/* Only port A support debounce */
	if (pp->idx == 0)
500
		port->gc.set_config = dwapb_gpio_set_config;
501

502 503
	if (pp->irq)
		dwapb_configure_irqs(gpio, port, pp);
504

505
	err = gpiochip_add_data(&port->gc, port);
506
	if (err)
507 508
		dev_err(gpio->dev, "failed to register gpiochip for port%d\n",
			port->idx);
509 510 511
	else
		port->is_registered = true;

512 513 514 515
	/* Add GPIO-signaled ACPI event support */
	if (pp->irq)
		acpi_gpiochip_request_interrupts(&port->gc);

516 517 518 519 520 521 522 523 524
	return err;
}

static void dwapb_gpio_unregister(struct dwapb_gpio *gpio)
{
	unsigned int m;

	for (m = 0; m < gpio->nr_ports; ++m)
		if (gpio->ports[m].is_registered)
525
			gpiochip_remove(&gpio->ports[m].gc);
526 527
}

528
static struct dwapb_platform_data *
529
dwapb_gpio_get_pdata(struct device *dev)
530
{
531
	struct fwnode_handle *fwnode;
532 533 534 535 536
	struct dwapb_platform_data *pdata;
	struct dwapb_port_property *pp;
	int nports;
	int i;

537
	nports = device_get_child_node_count(dev);
538 539 540
	if (nports == 0)
		return ERR_PTR(-ENODEV);

541
	pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
542 543 544
	if (!pdata)
		return ERR_PTR(-ENOMEM);

545 546
	pdata->properties = devm_kcalloc(dev, nports, sizeof(*pp), GFP_KERNEL);
	if (!pdata->properties)
547 548 549 550 551
		return ERR_PTR(-ENOMEM);

	pdata->nports = nports;

	i = 0;
552
	device_for_each_child_node(dev, fwnode)  {
553
		pp = &pdata->properties[i++];
554
		pp->fwnode = fwnode;
555

556
		if (fwnode_property_read_u32(fwnode, "reg", &pp->idx) ||
557
		    pp->idx >= DWAPB_MAX_PORTS) {
558 559
			dev_err(dev,
				"missing/invalid port index for port%d\n", i);
560
			fwnode_handle_put(fwnode);
561 562 563
			return ERR_PTR(-EINVAL);
		}

564
		if (fwnode_property_read_u32(fwnode, "snps,nr-gpios",
565
					 &pp->ngpio)) {
566 567 568
			dev_info(dev,
				 "failed to get number of gpios for port%d\n",
				 i);
569 570 571 572 573 574 575
			pp->ngpio = 32;
		}

		/*
		 * Only port A can provide interrupts in all configurations of
		 * the IP.
		 */
576 577 578 579
		if (dev->of_node && pp->idx == 0 &&
			fwnode_property_read_bool(fwnode,
						  "interrupt-controller")) {
			pp->irq = irq_of_parse_and_map(to_of_node(fwnode), 0);
580 581
			if (!pp->irq)
				dev_warn(dev, "no irq for port%d\n", pp->idx);
582 583
		}

584 585 586
		if (has_acpi_companion(dev) && pp->idx == 0)
			pp->irq = platform_get_irq(to_platform_device(dev), 0);

587 588 589 590 591 592 593
		pp->irq_shared	= false;
		pp->gpio_base	= -1;
	}

	return pdata;
}

594 595 596 597 598 599 600 601 602 603 604 605 606 607 608
static const struct of_device_id dwapb_of_match[] = {
	{ .compatible = "snps,dw-apb-gpio", .data = (void *)0},
	{ .compatible = "apm,xgene-gpio-v2", .data = (void *)GPIO_REG_OFFSET_V2},
	{ /* Sentinel */ }
};
MODULE_DEVICE_TABLE(of, dwapb_of_match);

static const struct acpi_device_id dwapb_acpi_match[] = {
	{"HISI0181", 0},
	{"APMC0D07", 0},
	{"APMC0D81", GPIO_REG_OFFSET_V2},
	{ }
};
MODULE_DEVICE_TABLE(acpi, dwapb_acpi_match);

609 610
static int dwapb_gpio_probe(struct platform_device *pdev)
{
611
	unsigned int i;
612 613 614
	struct resource *res;
	struct dwapb_gpio *gpio;
	int err;
615 616 617
	struct device *dev = &pdev->dev;
	struct dwapb_platform_data *pdata = dev_get_platdata(dev);

618
	if (!pdata) {
619
		pdata = dwapb_gpio_get_pdata(dev);
620 621 622
		if (IS_ERR(pdata))
			return PTR_ERR(pdata);
	}
623

624 625
	if (!pdata->nports)
		return -ENODEV;
626

627
	gpio = devm_kzalloc(&pdev->dev, sizeof(*gpio), GFP_KERNEL);
628 629 630
	if (!gpio)
		return -ENOMEM;

631 632 633
	gpio->dev = &pdev->dev;
	gpio->nr_ports = pdata->nports;

634 635 636 637 638 639
	gpio->rst = devm_reset_control_get_optional_shared(dev, NULL);
	if (IS_ERR(gpio->rst))
		return PTR_ERR(gpio->rst);

	reset_control_deassert(gpio->rst);

640
	gpio->ports = devm_kcalloc(&pdev->dev, gpio->nr_ports,
641
				   sizeof(*gpio->ports), GFP_KERNEL);
642 643
	if (!gpio->ports)
		return -ENOMEM;
644 645 646

	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	gpio->regs = devm_ioremap_resource(&pdev->dev, res);
647 648
	if (IS_ERR(gpio->regs))
		return PTR_ERR(gpio->regs);
649

650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668
	gpio->flags = 0;
	if (dev->of_node) {
		const struct of_device_id *of_devid;

		of_devid = of_match_device(dwapb_of_match, dev);
		if (of_devid) {
			if (of_devid->data)
				gpio->flags = (uintptr_t)of_devid->data;
		}
	} else if (has_acpi_companion(dev)) {
		const struct acpi_device_id *acpi_id;

		acpi_id = acpi_match_device(dwapb_acpi_match, dev);
		if (acpi_id) {
			if (acpi_id->driver_data)
				gpio->flags = acpi_id->driver_data;
		}
	}

669 670
	for (i = 0; i < gpio->nr_ports; i++) {
		err = dwapb_gpio_add_port(gpio, &pdata->properties[i], i);
671 672 673 674 675
		if (err)
			goto out_unregister;
	}
	platform_set_drvdata(pdev, gpio);

676
	return 0;
677 678 679 680 681 682 683 684 685 686 687 688 689 690

out_unregister:
	dwapb_gpio_unregister(gpio);
	dwapb_irq_teardown(gpio);

	return err;
}

static int dwapb_gpio_remove(struct platform_device *pdev)
{
	struct dwapb_gpio *gpio = platform_get_drvdata(pdev);

	dwapb_gpio_unregister(gpio);
	dwapb_irq_teardown(gpio);
691
	reset_control_assert(gpio->rst);
692 693 694 695

	return 0;
}

696 697 698 699 700
#ifdef CONFIG_PM_SLEEP
static int dwapb_gpio_suspend(struct device *dev)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct dwapb_gpio *gpio = platform_get_drvdata(pdev);
701
	struct gpio_chip *gc	= &gpio->ports[0].gc;
702 703 704
	unsigned long flags;
	int i;

705
	spin_lock_irqsave(&gc->bgpio_lock, flags);
706 707 708 709 710
	for (i = 0; i < gpio->nr_ports; i++) {
		unsigned int offset;
		unsigned int idx = gpio->ports[i].idx;
		struct dwapb_context *ctx = gpio->ports[i].ctx;

711
		BUG_ON(!ctx);
712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730

		offset = GPIO_SWPORTA_DDR + idx * GPIO_SWPORT_DDR_SIZE;
		ctx->dir = dwapb_read(gpio, offset);

		offset = GPIO_SWPORTA_DR + idx * GPIO_SWPORT_DR_SIZE;
		ctx->data = dwapb_read(gpio, offset);

		offset = GPIO_EXT_PORTA + idx * GPIO_EXT_PORT_SIZE;
		ctx->ext = dwapb_read(gpio, offset);

		/* Only port A can provide interrupts */
		if (idx == 0) {
			ctx->int_mask	= dwapb_read(gpio, GPIO_INTMASK);
			ctx->int_en	= dwapb_read(gpio, GPIO_INTEN);
			ctx->int_pol	= dwapb_read(gpio, GPIO_INT_POLARITY);
			ctx->int_type	= dwapb_read(gpio, GPIO_INTTYPE_LEVEL);
			ctx->int_deb	= dwapb_read(gpio, GPIO_PORTA_DEBOUNCE);

			/* Mask out interrupts */
731 732
			dwapb_write(gpio, GPIO_INTMASK,
				    0xffffffff & ~ctx->wake_en);
733 734
		}
	}
735
	spin_unlock_irqrestore(&gc->bgpio_lock, flags);
736 737 738 739 740 741 742 743

	return 0;
}

static int dwapb_gpio_resume(struct device *dev)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct dwapb_gpio *gpio = platform_get_drvdata(pdev);
744
	struct gpio_chip *gc	= &gpio->ports[0].gc;
745 746 747
	unsigned long flags;
	int i;

748
	spin_lock_irqsave(&gc->bgpio_lock, flags);
749 750 751 752 753
	for (i = 0; i < gpio->nr_ports; i++) {
		unsigned int offset;
		unsigned int idx = gpio->ports[i].idx;
		struct dwapb_context *ctx = gpio->ports[i].ctx;

754
		BUG_ON(!ctx);
755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776

		offset = GPIO_SWPORTA_DR + idx * GPIO_SWPORT_DR_SIZE;
		dwapb_write(gpio, offset, ctx->data);

		offset = GPIO_SWPORTA_DDR + idx * GPIO_SWPORT_DDR_SIZE;
		dwapb_write(gpio, offset, ctx->dir);

		offset = GPIO_EXT_PORTA + idx * GPIO_EXT_PORT_SIZE;
		dwapb_write(gpio, offset, ctx->ext);

		/* Only port A can provide interrupts */
		if (idx == 0) {
			dwapb_write(gpio, GPIO_INTTYPE_LEVEL, ctx->int_type);
			dwapb_write(gpio, GPIO_INT_POLARITY, ctx->int_pol);
			dwapb_write(gpio, GPIO_PORTA_DEBOUNCE, ctx->int_deb);
			dwapb_write(gpio, GPIO_INTEN, ctx->int_en);
			dwapb_write(gpio, GPIO_INTMASK, ctx->int_mask);

			/* Clear out spurious interrupts */
			dwapb_write(gpio, GPIO_PORTA_EOI, 0xffffffff);
		}
	}
777
	spin_unlock_irqrestore(&gc->bgpio_lock, flags);
778 779 780 781 782 783 784 785

	return 0;
}
#endif

static SIMPLE_DEV_PM_OPS(dwapb_gpio_pm_ops, dwapb_gpio_suspend,
			 dwapb_gpio_resume);

786 787 788
static struct platform_driver dwapb_gpio_driver = {
	.driver		= {
		.name	= "gpio-dwapb",
789
		.pm	= &dwapb_gpio_pm_ops,
790
		.of_match_table = of_match_ptr(dwapb_of_match),
791
		.acpi_match_table = ACPI_PTR(dwapb_acpi_match),
792 793 794 795 796 797 798 799 800 801
	},
	.probe		= dwapb_gpio_probe,
	.remove		= dwapb_gpio_remove,
};

module_platform_driver(dwapb_gpio_driver);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Jamie Iles");
MODULE_DESCRIPTION("Synopsys DesignWare APB GPIO driver");