gpio-davinci.c 14.9 KB
Newer Older
1 2 3
/*
 * TI DaVinci GPIO Support
 *
4
 * Copyright (c) 2006-2007 David Brownell
5 6 7 8 9 10 11
 * Copyright (c) 2007, MontaVista Software, Inc. <source@mvista.com>
 *
 * 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; either version 2 of the License, or
 * (at your option) any later version.
 */
12
#include <linux/gpio.h>
13 14 15 16 17
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/clk.h>
#include <linux/err.h>
#include <linux/io.h>
18
#include <linux/irq.h>
19
#include <linux/irqdomain.h>
K
KV Sujith 已提交
20 21 22
#include <linux/module.h>
#include <linux/of.h>
#include <linux/of_device.h>
23 24
#include <linux/platform_device.h>
#include <linux/platform_data/gpio-davinci.h>
25
#include <linux/irqchip/chained_irq.h>
26

27 28 29 30 31 32 33 34 35 36 37 38 39
struct davinci_gpio_regs {
	u32	dir;
	u32	out_data;
	u32	set_data;
	u32	clr_data;
	u32	in_data;
	u32	set_rising;
	u32	clr_rising;
	u32	set_falling;
	u32	clr_falling;
	u32	intstat;
};

40 41
#define BINTEN	0x8 /* GPIO Interrupt Per-Bank Enable Register */

42
#define chip2controller(chip)	\
43
	container_of(chip, struct davinci_gpio_controller, chip)
44

45
static void __iomem *gpio_base;
46

47
static struct davinci_gpio_regs __iomem *gpio2regs(unsigned gpio)
48
{
49 50 51
	void __iomem *ptr;

	if (gpio < 32 * 1)
52
		ptr = gpio_base + 0x10;
53
	else if (gpio < 32 * 2)
54
		ptr = gpio_base + 0x38;
55
	else if (gpio < 32 * 3)
56
		ptr = gpio_base + 0x60;
57
	else if (gpio < 32 * 4)
58
		ptr = gpio_base + 0x88;
59
	else if (gpio < 32 * 5)
60
		ptr = gpio_base + 0xb0;
61 62 63
	else
		ptr = NULL;
	return ptr;
64 65
}

66
static inline struct davinci_gpio_regs __iomem *irq2regs(int irq)
67
{
68
	struct davinci_gpio_regs __iomem *g;
69

T
Thomas Gleixner 已提交
70
	g = (__force struct davinci_gpio_regs __iomem *)irq_get_chip_data(irq);
71 72 73 74

	return g;
}

75
static int davinci_gpio_irq_setup(struct platform_device *pdev);
76 77 78

/*--------------------------------------------------------------------------*/

79
/* board setup code *MUST* setup pinmux and enable the GPIO clock. */
80 81
static inline int __davinci_direction(struct gpio_chip *chip,
			unsigned offset, bool out, int value)
82
{
83 84
	struct davinci_gpio_controller *d = chip2controller(chip);
	struct davinci_gpio_regs __iomem *g = d->regs;
85
	unsigned long flags;
86
	u32 temp;
87
	u32 mask = 1 << offset;
88

89
	spin_lock_irqsave(&d->lock, flags);
90
	temp = readl_relaxed(&g->dir);
91 92
	if (out) {
		temp &= ~mask;
93
		writel_relaxed(mask, value ? &g->set_data : &g->clr_data);
94 95 96
	} else {
		temp |= mask;
	}
97
	writel_relaxed(temp, &g->dir);
98
	spin_unlock_irqrestore(&d->lock, flags);
99

100 101
	return 0;
}
102

103 104 105 106 107 108 109 110 111 112 113
static int davinci_direction_in(struct gpio_chip *chip, unsigned offset)
{
	return __davinci_direction(chip, offset, false, 0);
}

static int
davinci_direction_out(struct gpio_chip *chip, unsigned offset, int value)
{
	return __davinci_direction(chip, offset, true, value);
}

114 115 116 117 118 119 120
/*
 * Read the pin's value (works even if it's set up as output);
 * returns zero/nonzero.
 *
 * Note that changes are synched to the GPIO clock, so reading values back
 * right after you've set them may give old values.
 */
121
static int davinci_gpio_get(struct gpio_chip *chip, unsigned offset)
122
{
123 124
	struct davinci_gpio_controller *d = chip2controller(chip);
	struct davinci_gpio_regs __iomem *g = d->regs;
125

126
	return (1 << offset) & readl_relaxed(&g->in_data);
127 128
}

129 130 131 132 133
/*
 * Assuming the pin is muxed as a gpio output, set its output value.
 */
static void
davinci_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
134
{
135 136
	struct davinci_gpio_controller *d = chip2controller(chip);
	struct davinci_gpio_regs __iomem *g = d->regs;
137

138
	writel_relaxed((1 << offset), value ? &g->set_data : &g->clr_data);
139 140
}

K
KV Sujith 已提交
141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174
static struct davinci_gpio_platform_data *
davinci_gpio_get_pdata(struct platform_device *pdev)
{
	struct device_node *dn = pdev->dev.of_node;
	struct davinci_gpio_platform_data *pdata;
	int ret;
	u32 val;

	if (!IS_ENABLED(CONFIG_OF) || !pdev->dev.of_node)
		return pdev->dev.platform_data;

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

	ret = of_property_read_u32(dn, "ti,ngpio", &val);
	if (ret)
		goto of_err;

	pdata->ngpio = val;

	ret = of_property_read_u32(dn, "ti,davinci-gpio-unbanked", &val);
	if (ret)
		goto of_err;

	pdata->gpio_unbanked = val;

	return pdata;

of_err:
	dev_err(&pdev->dev, "Populating pdata from DT failed: err %d\n", ret);
	return NULL;
}

175
static int davinci_gpio_probe(struct platform_device *pdev)
176 177
{
	int i, base;
178
	unsigned ngpio;
179 180 181 182 183 184
	struct davinci_gpio_controller *chips;
	struct davinci_gpio_platform_data *pdata;
	struct davinci_gpio_regs __iomem *regs;
	struct device *dev = &pdev->dev;
	struct resource *res;

K
KV Sujith 已提交
185
	pdata = davinci_gpio_get_pdata(pdev);
186 187 188 189
	if (!pdata) {
		dev_err(dev, "No platform data found\n");
		return -EINVAL;
	}
190

K
KV Sujith 已提交
191 192
	dev->platform_data = pdata;

193 194
	/*
	 * The gpio banks conceptually expose a segmented bitmap,
D
David Brownell 已提交
195 196 197
	 * and "ngpio" is one more than the largest zero-based
	 * bit index that's valid.
	 */
198
	ngpio = pdata->ngpio;
199
	if (ngpio == 0) {
200
		dev_err(dev, "How many GPIOs?\n");
D
David Brownell 已提交
201 202 203
		return -EINVAL;
	}

204 205
	if (WARN_ON(ARCH_NR_GPIOS < ngpio))
		ngpio = ARCH_NR_GPIOS;
D
David Brownell 已提交
206

207 208 209 210 211
	chips = devm_kzalloc(dev,
			     ngpio * sizeof(struct davinci_gpio_controller),
			     GFP_KERNEL);
	if (!chips) {
		dev_err(dev, "Memory allocation failed\n");
212
		return -ENOMEM;
213 214 215 216 217 218 219 220 221 222 223
	}

	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (!res) {
		dev_err(dev, "Invalid memory resource\n");
		return -EBUSY;
	}

	gpio_base = devm_ioremap_resource(dev, res);
	if (IS_ERR(gpio_base))
		return PTR_ERR(gpio_base);
224

D
David Brownell 已提交
225
	for (i = 0, base = 0; base < ngpio; i++, base += 32) {
226 227 228 229 230 231 232 233
		chips[i].chip.label = "DaVinci";

		chips[i].chip.direction_input = davinci_direction_in;
		chips[i].chip.get = davinci_gpio_get;
		chips[i].chip.direction_output = davinci_direction_out;
		chips[i].chip.set = davinci_gpio_set;

		chips[i].chip.base = base;
D
David Brownell 已提交
234
		chips[i].chip.ngpio = ngpio - base;
235 236 237
		if (chips[i].chip.ngpio > 32)
			chips[i].chip.ngpio = 32;

K
KV Sujith 已提交
238 239 240
#ifdef CONFIG_OF_GPIO
		chips[i].chip.of_node = dev->of_node;
#endif
241 242
		spin_lock_init(&chips[i].lock);

243 244 245 246 247
		regs = gpio2regs(base);
		chips[i].regs = regs;
		chips[i].set_data = &regs->set_data;
		chips[i].clr_data = &regs->clr_data;
		chips[i].in_data = &regs->in_data;
248 249 250

		gpiochip_add(&chips[i].chip);
	}
251

252 253
	platform_set_drvdata(pdev, chips);
	davinci_gpio_irq_setup(pdev);
254 255 256
	return 0;
}

257
/*--------------------------------------------------------------------------*/
258 259 260 261
/*
 * We expect irqs will normally be set up as input pins, but they can also be
 * used as output pins ... which is convenient for testing.
 *
D
David Brownell 已提交
262
 * NOTE:  The first few GPIOs also have direct INTC hookups in addition
D
David Brownell 已提交
263
 * to their GPIOBNK0 irq, with a bit less overhead.
264
 *
D
David Brownell 已提交
265
 * All those INTC hookups (direct, plus several IRQ banks) can also
266 267 268
 * serve as EDMA event triggers.
 */

269
static void gpio_irq_disable(struct irq_data *d)
270
{
271
	struct davinci_gpio_regs __iomem *g = irq2regs(d->irq);
T
Thomas Gleixner 已提交
272
	u32 mask = (u32) irq_data_get_irq_handler_data(d);
273

274 275
	writel_relaxed(mask, &g->clr_falling);
	writel_relaxed(mask, &g->clr_rising);
276 277
}

278
static void gpio_irq_enable(struct irq_data *d)
279
{
280
	struct davinci_gpio_regs __iomem *g = irq2regs(d->irq);
T
Thomas Gleixner 已提交
281
	u32 mask = (u32) irq_data_get_irq_handler_data(d);
282
	unsigned status = irqd_get_trigger_type(d);
283

D
David Brownell 已提交
284 285 286 287 288
	status &= IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING;
	if (!status)
		status = IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING;

	if (status & IRQ_TYPE_EDGE_FALLING)
289
		writel_relaxed(mask, &g->set_falling);
D
David Brownell 已提交
290
	if (status & IRQ_TYPE_EDGE_RISING)
291
		writel_relaxed(mask, &g->set_rising);
292 293
}

294
static int gpio_irq_type(struct irq_data *d, unsigned trigger)
295 296 297 298 299 300 301 302 303
{
	if (trigger & ~(IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING))
		return -EINVAL;

	return 0;
}

static struct irq_chip gpio_irqchip = {
	.name		= "GPIO",
304 305 306
	.irq_enable	= gpio_irq_enable,
	.irq_disable	= gpio_irq_disable,
	.irq_set_type	= gpio_irq_type,
307
	.flags		= IRQCHIP_SET_TYPE_MASKED,
308 309 310 311 312
};

static void
gpio_irq_handler(unsigned irq, struct irq_desc *desc)
{
313
	struct davinci_gpio_regs __iomem *g;
314
	u32 mask = 0xffff;
315
	struct davinci_gpio_controller *d;
316

317 318
	d = (struct davinci_gpio_controller *)irq_desc_get_handler_data(desc);
	g = (struct davinci_gpio_regs __iomem *)d->regs;
319

320 321 322 323 324
	/* we only care about one bank */
	if (irq & 1)
		mask <<= 16;

	/* temporarily mask (level sensitive) parent IRQ */
325
	chained_irq_enter(irq_desc_get_chip(desc), desc);
326 327
	while (1) {
		u32		status;
328
		int		bit;
329 330

		/* ack any irqs */
331
		status = readl_relaxed(&g->intstat) & mask;
332 333
		if (!status)
			break;
334
		writel_relaxed(status, &g->intstat);
335 336

		/* now demux them to the right lowlevel handler */
337

338
		while (status) {
339 340 341 342 343
			bit = __ffs(status);
			status &= ~BIT(bit);
			generic_handle_irq(
				irq_find_mapping(d->irq_domain,
						 d->chip.base + bit));
344 345
		}
	}
346
	chained_irq_exit(irq_desc_get_chip(desc), desc);
347 348 349
	/* now it may re-trigger */
}

D
David Brownell 已提交
350 351
static int gpio_to_irq_banked(struct gpio_chip *chip, unsigned offset)
{
352
	struct davinci_gpio_controller *d = chip2controller(chip);
D
David Brownell 已提交
353

354 355 356 357
	if (d->irq_domain)
		return irq_create_mapping(d->irq_domain, d->chip.base + offset);
	else
		return -ENXIO;
D
David Brownell 已提交
358 359 360 361
}

static int gpio_to_irq_unbanked(struct gpio_chip *chip, unsigned offset)
{
362
	struct davinci_gpio_controller *d = chip2controller(chip);
D
David Brownell 已提交
363

364 365
	/*
	 * NOTE:  we assume for now that only irqs in the first gpio_chip
D
David Brownell 已提交
366 367
	 * can provide direct-mapped IRQs to AINTC (up to 32 GPIOs).
	 */
368
	if (offset < d->gpio_unbanked)
369
		return d->gpio_irq + offset;
D
David Brownell 已提交
370 371 372 373
	else
		return -ENODEV;
}

374
static int gpio_irq_type_unbanked(struct irq_data *data, unsigned trigger)
D
David Brownell 已提交
375
{
376 377 378 379 380 381
	struct davinci_gpio_controller *d;
	struct davinci_gpio_regs __iomem *g;
	u32 mask;

	d = (struct davinci_gpio_controller *)data->handler_data;
	g = (struct davinci_gpio_regs __iomem *)d->regs;
382
	mask = __gpio_mask(data->irq - d->gpio_irq);
D
David Brownell 已提交
383 384 385 386

	if (trigger & ~(IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING))
		return -EINVAL;

387
	writel_relaxed(mask, (trigger & IRQ_TYPE_EDGE_FALLING)
D
David Brownell 已提交
388
		     ? &g->set_falling : &g->clr_falling);
389
	writel_relaxed(mask, (trigger & IRQ_TYPE_EDGE_RISING)
D
David Brownell 已提交
390 391 392 393 394
		     ? &g->set_rising : &g->clr_rising);

	return 0;
}

395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415
static int
davinci_gpio_irq_map(struct irq_domain *d, unsigned int irq,
		     irq_hw_number_t hw)
{
	struct davinci_gpio_regs __iomem *g = gpio2regs(hw);

	irq_set_chip_and_handler_name(irq, &gpio_irqchip, handle_simple_irq,
				"davinci_gpio");
	irq_set_irq_type(irq, IRQ_TYPE_NONE);
	irq_set_chip_data(irq, (__force void *)g);
	irq_set_handler_data(irq, (void *)__gpio_mask(hw));
	set_irq_flags(irq, IRQF_VALID);

	return 0;
}

static const struct irq_domain_ops davinci_gpio_irq_ops = {
	.map = davinci_gpio_irq_map,
	.xlate = irq_domain_xlate_onetwocell,
};

416
/*
D
David Brownell 已提交
417 418
 * NOTE:  for suspend/resume, probably best to make a platform_device with
 * suspend_late/resume_resume calls hooking into results of the set_wake()
419 420
 * calls ... so if no gpios are wakeup events the clock can be disabled,
 * with outputs left at previously set levels, and so that VDD3P3V.IOPWDN0
D
David Brownell 已提交
421
 * (dm6446) can be set appropriately for GPIOV33 pins.
422 423
 */

424
static int davinci_gpio_irq_setup(struct platform_device *pdev)
425
{
426 427
	unsigned	gpio, bank;
	int		irq;
428
	struct clk	*clk;
D
David Brownell 已提交
429
	u32		binten = 0;
430
	unsigned	ngpio, bank_irq;
431 432 433 434 435
	struct device *dev = &pdev->dev;
	struct resource	*res;
	struct davinci_gpio_controller *chips = platform_get_drvdata(pdev);
	struct davinci_gpio_platform_data *pdata = dev->platform_data;
	struct davinci_gpio_regs __iomem *g;
436
	struct irq_domain	*irq_domain = NULL;
437

438 439 440 441 442 443
	ngpio = pdata->ngpio;
	res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
	if (!res) {
		dev_err(dev, "Invalid IRQ resource\n");
		return -EBUSY;
	}
D
David Brownell 已提交
444

445 446 447 448 449
	bank_irq = res->start;

	if (!bank_irq) {
		dev_err(dev, "Invalid IRQ resource\n");
		return -ENODEV;
D
David Brownell 已提交
450
	}
451

452
	clk = devm_clk_get(dev, "gpio");
453 454 455
	if (IS_ERR(clk)) {
		printk(KERN_ERR "Error %ld getting gpio clock?\n",
		       PTR_ERR(clk));
D
David Brownell 已提交
456
		return PTR_ERR(clk);
457
	}
458
	clk_prepare_enable(clk);
459

460 461 462 463 464 465
	if (!pdata->gpio_unbanked) {
		irq = irq_alloc_descs(-1, 0, ngpio, 0);
		if (irq < 0) {
			dev_err(dev, "Couldn't allocate IRQ numbers\n");
			return irq;
		}
466

467 468 469 470 471 472 473
		irq_domain = irq_domain_add_legacy(NULL, ngpio, irq, 0,
							&davinci_gpio_irq_ops,
							chips);
		if (!irq_domain) {
			dev_err(dev, "Couldn't register an IRQ domain\n");
			return -ENODEV;
		}
474 475
	}

476 477
	/*
	 * Arrange gpio_to_irq() support, handling either direct IRQs or
D
David Brownell 已提交
478 479 480 481 482 483
	 * banked IRQs.  Having GPIOs in the first GPIO bank use direct
	 * IRQs, while the others use banked IRQs, would need some setup
	 * tweaks to recognize hardware which can do that.
	 */
	for (gpio = 0, bank = 0; gpio < ngpio; bank++, gpio += 32) {
		chips[bank].chip.to_irq = gpio_to_irq_banked;
484
		chips[bank].irq_domain = irq_domain;
D
David Brownell 已提交
485 486 487 488 489 490 491
	}

	/*
	 * AINTC can handle direct/unbanked IRQs for GPIOs, with the GPIO
	 * controller only handling trigger modes.  We currently assume no
	 * IRQ mux conflicts; gpio_irq_type_unbanked() is only for GPIOs.
	 */
492
	if (pdata->gpio_unbanked) {
493
		static struct irq_chip_type gpio_unbanked;
D
David Brownell 已提交
494 495 496

		/* pass "bank 0" GPIO IRQs to AINTC */
		chips[0].chip.to_irq = gpio_to_irq_unbanked;
497 498
		chips[0].gpio_irq = bank_irq;
		chips[0].gpio_unbanked = pdata->gpio_unbanked;
D
David Brownell 已提交
499 500 501 502
		binten = BIT(0);

		/* AINTC handles mask/unmask; GPIO handles triggering */
		irq = bank_irq;
503 504 505 506
		gpio_unbanked = *container_of(irq_get_chip(irq),
					      struct irq_chip_type, chip);
		gpio_unbanked.chip.name = "GPIO-AINTC";
		gpio_unbanked.chip.irq_set_type = gpio_irq_type_unbanked;
D
David Brownell 已提交
507 508

		/* default trigger: both edges */
509
		g = gpio2regs(0);
510 511
		writel_relaxed(~0, &g->set_falling);
		writel_relaxed(~0, &g->set_rising);
D
David Brownell 已提交
512 513

		/* set the direct IRQs up to use that irqchip */
514
		for (gpio = 0; gpio < pdata->gpio_unbanked; gpio++, irq++) {
515
			irq_set_chip(irq, &gpio_unbanked.chip);
516
			irq_set_handler_data(irq, &chips[gpio / 32]);
517
			irq_set_status_flags(irq, IRQ_TYPE_EDGE_BOTH);
D
David Brownell 已提交
518 519 520 521 522 523 524 525 526
		}

		goto done;
	}

	/*
	 * Or, AINTC can handle IRQs for banks of 16 GPIO IRQs, which we
	 * then chain through our own handler.
	 */
527
	for (gpio = 0, bank = 0; gpio < ngpio; bank++, bank_irq++, gpio += 16) {
D
David Brownell 已提交
528
		/* disabled by default, enabled only as needed */
529
		g = gpio2regs(gpio);
530 531
		writel_relaxed(~0, &g->clr_falling);
		writel_relaxed(~0, &g->clr_rising);
532 533

		/* set up all irqs in this bank */
T
Thomas Gleixner 已提交
534
		irq_set_chained_handler(bank_irq, gpio_irq_handler);
535 536 537 538 539 540 541

		/*
		 * Each chip handles 32 gpios, and each irq bank consists of 16
		 * gpio irqs. Pass the irq bank's corresponding controller to
		 * the chained irq handler.
		 */
		irq_set_handler_data(bank_irq, &chips[gpio / 32]);
542

D
David Brownell 已提交
543
		binten |= BIT(bank);
544 545
	}

D
David Brownell 已提交
546
done:
547 548
	/*
	 * BINTEN -- per-bank interrupt enable. genirq would also let these
549 550
	 * bits be set/cleared dynamically.
	 */
551
	writel_relaxed(binten, gpio_base + BINTEN);
552 553 554

	return 0;
}
555

K
KV Sujith 已提交
556 557 558 559 560 561 562 563
#if IS_ENABLED(CONFIG_OF)
static const struct of_device_id davinci_gpio_ids[] = {
	{ .compatible = "ti,dm6441-gpio", },
	{ /* sentinel */ },
};
MODULE_DEVICE_TABLE(of, davinci_gpio_ids);
#endif

564 565 566
static struct platform_driver davinci_gpio_driver = {
	.probe		= davinci_gpio_probe,
	.driver		= {
K
KV Sujith 已提交
567 568 569
		.name		= "davinci_gpio",
		.owner		= THIS_MODULE,
		.of_match_table	= of_match_ptr(davinci_gpio_ids),
570 571 572 573 574 575 576 577 578 579 580 581
	},
};

/**
 * GPIO driver registration needs to be done before machine_init functions
 * access GPIO. Hence davinci_gpio_drv_reg() is a postcore_initcall.
 */
static int __init davinci_gpio_drv_reg(void)
{
	return platform_driver_register(&davinci_gpio_driver);
}
postcore_initcall(davinci_gpio_drv_reg);