gpio-tegra.c 13.6 KB
Newer Older
Erik Gilling's avatar
Erik Gilling committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
/*
 * arch/arm/mach-tegra/gpio.c
 *
 * Copyright (c) 2010 Google, Inc
 *
 * Author:
 *	Erik Gilling <konkers@google.com>
 *
 * 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/init.h>
#include <linux/irq.h>
22
#include <linux/interrupt.h>
Erik Gilling's avatar
Erik Gilling committed
23 24
#include <linux/io.h>
#include <linux/gpio.h>
25
#include <linux/of_device.h>
26 27
#include <linux/platform_device.h>
#include <linux/module.h>
28
#include <linux/irqdomain.h>
29
#include <linux/pinctrl/consumer.h>
30
#include <linux/pm.h>
Erik Gilling's avatar
Erik Gilling committed
31

32 33
#include <asm/mach/irq.h>

Erik Gilling's avatar
Erik Gilling committed
34 35 36 37
#define GPIO_BANK(x)		((x) >> 5)
#define GPIO_PORT(x)		(((x) >> 3) & 0x3)
#define GPIO_BIT(x)		((x) & 0x7)

38 39
#define GPIO_REG(x)		(GPIO_BANK(x) * tegra_gpio_bank_stride + \
					GPIO_PORT(x) * 4)
Erik Gilling's avatar
Erik Gilling committed
40 41 42 43 44 45 46 47 48 49

#define GPIO_CNF(x)		(GPIO_REG(x) + 0x00)
#define GPIO_OE(x)		(GPIO_REG(x) + 0x10)
#define GPIO_OUT(x)		(GPIO_REG(x) + 0X20)
#define GPIO_IN(x)		(GPIO_REG(x) + 0x30)
#define GPIO_INT_STA(x)		(GPIO_REG(x) + 0x40)
#define GPIO_INT_ENB(x)		(GPIO_REG(x) + 0x50)
#define GPIO_INT_LVL(x)		(GPIO_REG(x) + 0x60)
#define GPIO_INT_CLR(x)		(GPIO_REG(x) + 0x70)

50 51 52 53 54 55
#define GPIO_MSK_CNF(x)		(GPIO_REG(x) + tegra_gpio_upper_offset + 0x00)
#define GPIO_MSK_OE(x)		(GPIO_REG(x) + tegra_gpio_upper_offset + 0x10)
#define GPIO_MSK_OUT(x)		(GPIO_REG(x) + tegra_gpio_upper_offset + 0X20)
#define GPIO_MSK_INT_STA(x)	(GPIO_REG(x) + tegra_gpio_upper_offset + 0x40)
#define GPIO_MSK_INT_ENB(x)	(GPIO_REG(x) + tegra_gpio_upper_offset + 0x50)
#define GPIO_MSK_INT_LVL(x)	(GPIO_REG(x) + tegra_gpio_upper_offset + 0x60)
Erik Gilling's avatar
Erik Gilling committed
56 57 58 59 60 61 62 63 64 65 66 67

#define GPIO_INT_LVL_MASK		0x010101
#define GPIO_INT_LVL_EDGE_RISING	0x000101
#define GPIO_INT_LVL_EDGE_FALLING	0x000100
#define GPIO_INT_LVL_EDGE_BOTH		0x010100
#define GPIO_INT_LVL_LEVEL_HIGH		0x000001
#define GPIO_INT_LVL_LEVEL_LOW		0x000000

struct tegra_gpio_bank {
	int bank;
	int irq;
	spinlock_t lvl_lock[4];
68
#ifdef CONFIG_PM_SLEEP
69 70 71 72 73 74
	u32 cnf[4];
	u32 out[4];
	u32 oe[4];
	u32 int_enb[4];
	u32 int_lvl[4];
#endif
Erik Gilling's avatar
Erik Gilling committed
75 76
};

77
static struct irq_domain *irq_domain;
78
static void __iomem *regs;
79
static u32 tegra_gpio_bank_count;
80 81
static u32 tegra_gpio_bank_stride;
static u32 tegra_gpio_upper_offset;
82
static struct tegra_gpio_bank *tegra_gpio_banks;
83 84 85 86 87 88 89 90 91 92

static inline void tegra_gpio_writel(u32 val, u32 reg)
{
	__raw_writel(val, regs + reg);
}

static inline u32 tegra_gpio_readl(u32 reg)
{
	return __raw_readl(regs + reg);
}
Erik Gilling's avatar
Erik Gilling committed
93 94 95 96 97 98 99 100 101 102 103 104 105

static int tegra_gpio_compose(int bank, int port, int bit)
{
	return (bank << 5) | ((port & 0x3) << 3) | (bit & 0x7);
}

static void tegra_gpio_mask_write(u32 reg, int gpio, int value)
{
	u32 val;

	val = 0x100 << GPIO_BIT(gpio);
	if (value)
		val |= 1 << GPIO_BIT(gpio);
106
	tegra_gpio_writel(val, reg);
Erik Gilling's avatar
Erik Gilling committed
107 108
}

109
static void tegra_gpio_enable(int gpio)
Erik Gilling's avatar
Erik Gilling committed
110 111 112 113
{
	tegra_gpio_mask_write(GPIO_MSK_CNF(gpio), gpio, 1);
}

114
static void tegra_gpio_disable(int gpio)
Erik Gilling's avatar
Erik Gilling committed
115 116 117 118
{
	tegra_gpio_mask_write(GPIO_MSK_CNF(gpio), gpio, 0);
}

119
static int tegra_gpio_request(struct gpio_chip *chip, unsigned offset)
120 121 122 123
{
	return pinctrl_request_gpio(offset);
}

124
static void tegra_gpio_free(struct gpio_chip *chip, unsigned offset)
125 126 127 128 129
{
	pinctrl_free_gpio(offset);
	tegra_gpio_disable(offset);
}

Erik Gilling's avatar
Erik Gilling committed
130 131 132 133 134 135 136
static void tegra_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
{
	tegra_gpio_mask_write(GPIO_MSK_OUT(offset), offset, value);
}

static int tegra_gpio_get(struct gpio_chip *chip, unsigned offset)
{
137
	return (tegra_gpio_readl(GPIO_IN(offset)) >> GPIO_BIT(offset)) & 0x1;
Erik Gilling's avatar
Erik Gilling committed
138 139 140 141 142
}

static int tegra_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
{
	tegra_gpio_mask_write(GPIO_MSK_OE(offset), offset, 0);
143
	tegra_gpio_enable(offset);
Erik Gilling's avatar
Erik Gilling committed
144 145 146 147 148 149 150 151
	return 0;
}

static int tegra_gpio_direction_output(struct gpio_chip *chip, unsigned offset,
					int value)
{
	tegra_gpio_set(chip, offset, value);
	tegra_gpio_mask_write(GPIO_MSK_OE(offset), offset, 1);
152
	tegra_gpio_enable(offset);
Erik Gilling's avatar
Erik Gilling committed
153 154 155
	return 0;
}

156 157
static int tegra_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
{
158
	return irq_find_mapping(irq_domain, offset);
159
}
Erik Gilling's avatar
Erik Gilling committed
160 161 162

static struct gpio_chip tegra_gpio_chip = {
	.label			= "tegra-gpio",
163 164
	.request		= tegra_gpio_request,
	.free			= tegra_gpio_free,
Erik Gilling's avatar
Erik Gilling committed
165 166 167 168
	.direction_input	= tegra_gpio_direction_input,
	.get			= tegra_gpio_get,
	.direction_output	= tegra_gpio_direction_output,
	.set			= tegra_gpio_set,
169
	.to_irq			= tegra_gpio_to_irq,
Erik Gilling's avatar
Erik Gilling committed
170 171 172
	.base			= 0,
};

173
static void tegra_gpio_irq_ack(struct irq_data *d)
Erik Gilling's avatar
Erik Gilling committed
174
{
175
	int gpio = d->hwirq;
Erik Gilling's avatar
Erik Gilling committed
176

177
	tegra_gpio_writel(1 << GPIO_BIT(gpio), GPIO_INT_CLR(gpio));
Erik Gilling's avatar
Erik Gilling committed
178 179
}

180
static void tegra_gpio_irq_mask(struct irq_data *d)
Erik Gilling's avatar
Erik Gilling committed
181
{
182
	int gpio = d->hwirq;
Erik Gilling's avatar
Erik Gilling committed
183 184 185 186

	tegra_gpio_mask_write(GPIO_MSK_INT_ENB(gpio), gpio, 0);
}

187
static void tegra_gpio_irq_unmask(struct irq_data *d)
Erik Gilling's avatar
Erik Gilling committed
188
{
189
	int gpio = d->hwirq;
Erik Gilling's avatar
Erik Gilling committed
190 191 192 193

	tegra_gpio_mask_write(GPIO_MSK_INT_ENB(gpio), gpio, 1);
}

194
static int tegra_gpio_irq_set_type(struct irq_data *d, unsigned int type)
Erik Gilling's avatar
Erik Gilling committed
195
{
196
	int gpio = d->hwirq;
197
	struct tegra_gpio_bank *bank = irq_data_get_irq_chip_data(d);
Erik Gilling's avatar
Erik Gilling committed
198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229
	int port = GPIO_PORT(gpio);
	int lvl_type;
	int val;
	unsigned long flags;

	switch (type & IRQ_TYPE_SENSE_MASK) {
	case IRQ_TYPE_EDGE_RISING:
		lvl_type = GPIO_INT_LVL_EDGE_RISING;
		break;

	case IRQ_TYPE_EDGE_FALLING:
		lvl_type = GPIO_INT_LVL_EDGE_FALLING;
		break;

	case IRQ_TYPE_EDGE_BOTH:
		lvl_type = GPIO_INT_LVL_EDGE_BOTH;
		break;

	case IRQ_TYPE_LEVEL_HIGH:
		lvl_type = GPIO_INT_LVL_LEVEL_HIGH;
		break;

	case IRQ_TYPE_LEVEL_LOW:
		lvl_type = GPIO_INT_LVL_LEVEL_LOW;
		break;

	default:
		return -EINVAL;
	}

	spin_lock_irqsave(&bank->lvl_lock[port], flags);

230
	val = tegra_gpio_readl(GPIO_INT_LVL(gpio));
Erik Gilling's avatar
Erik Gilling committed
231 232
	val &= ~(GPIO_INT_LVL_MASK << GPIO_BIT(gpio));
	val |= lvl_type << GPIO_BIT(gpio);
233
	tegra_gpio_writel(val, GPIO_INT_LVL(gpio));
Erik Gilling's avatar
Erik Gilling committed
234 235 236

	spin_unlock_irqrestore(&bank->lvl_lock[port], flags);

237 238 239
	tegra_gpio_mask_write(GPIO_MSK_OE(gpio), gpio, 0);
	tegra_gpio_enable(gpio);

Erik Gilling's avatar
Erik Gilling committed
240
	if (type & (IRQ_TYPE_LEVEL_LOW | IRQ_TYPE_LEVEL_HIGH))
241
		__irq_set_handler_locked(d->irq, handle_level_irq);
Erik Gilling's avatar
Erik Gilling committed
242
	else if (type & (IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING))
243
		__irq_set_handler_locked(d->irq, handle_edge_irq);
Erik Gilling's avatar
Erik Gilling committed
244 245 246 247 248 249 250 251 252 253

	return 0;
}

static void tegra_gpio_irq_handler(unsigned int irq, struct irq_desc *desc)
{
	struct tegra_gpio_bank *bank;
	int port;
	int pin;
	int unmasked = 0;
254
	struct irq_chip *chip = irq_desc_get_chip(desc);
Erik Gilling's avatar
Erik Gilling committed
255

256
	chained_irq_enter(chip, desc);
Erik Gilling's avatar
Erik Gilling committed
257

258
	bank = irq_get_handler_data(irq);
Erik Gilling's avatar
Erik Gilling committed
259 260 261

	for (port = 0; port < 4; port++) {
		int gpio = tegra_gpio_compose(bank->bank, port, 0);
262 263 264
		unsigned long sta = tegra_gpio_readl(GPIO_INT_STA(gpio)) &
			tegra_gpio_readl(GPIO_INT_ENB(gpio));
		u32 lvl = tegra_gpio_readl(GPIO_INT_LVL(gpio));
Erik Gilling's avatar
Erik Gilling committed
265 266

		for_each_set_bit(pin, &sta, 8) {
267
			tegra_gpio_writel(1 << pin, GPIO_INT_CLR(gpio));
Erik Gilling's avatar
Erik Gilling committed
268 269 270 271 272 273 274

			/* if gpio is edge triggered, clear condition
			 * before executing the hander so that we don't
			 * miss edges
			 */
			if (lvl & (0x100 << pin)) {
				unmasked = 1;
275
				chained_irq_exit(chip, desc);
Erik Gilling's avatar
Erik Gilling committed
276 277 278 279 280 281 282
			}

			generic_handle_irq(gpio_to_irq(gpio + pin));
		}
	}

	if (!unmasked)
283
		chained_irq_exit(chip, desc);
Erik Gilling's avatar
Erik Gilling committed
284 285 286

}

287 288
#ifdef CONFIG_PM_SLEEP
static int tegra_gpio_resume(struct device *dev)
289 290
{
	unsigned long flags;
291 292
	int b;
	int p;
293 294 295

	local_irq_save(flags);

296
	for (b = 0; b < tegra_gpio_bank_count; b++) {
297 298 299 300
		struct tegra_gpio_bank *bank = &tegra_gpio_banks[b];

		for (p = 0; p < ARRAY_SIZE(bank->oe); p++) {
			unsigned int gpio = (b<<5) | (p<<3);
301 302 303 304 305
			tegra_gpio_writel(bank->cnf[p], GPIO_CNF(gpio));
			tegra_gpio_writel(bank->out[p], GPIO_OUT(gpio));
			tegra_gpio_writel(bank->oe[p], GPIO_OE(gpio));
			tegra_gpio_writel(bank->int_lvl[p], GPIO_INT_LVL(gpio));
			tegra_gpio_writel(bank->int_enb[p], GPIO_INT_ENB(gpio));
306 307 308 309
		}
	}

	local_irq_restore(flags);
310
	return 0;
311 312
}

313
static int tegra_gpio_suspend(struct device *dev)
314 315
{
	unsigned long flags;
316 317
	int b;
	int p;
318 319

	local_irq_save(flags);
320
	for (b = 0; b < tegra_gpio_bank_count; b++) {
321 322 323 324
		struct tegra_gpio_bank *bank = &tegra_gpio_banks[b];

		for (p = 0; p < ARRAY_SIZE(bank->oe); p++) {
			unsigned int gpio = (b<<5) | (p<<3);
325 326 327 328 329
			bank->cnf[p] = tegra_gpio_readl(GPIO_CNF(gpio));
			bank->out[p] = tegra_gpio_readl(GPIO_OUT(gpio));
			bank->oe[p] = tegra_gpio_readl(GPIO_OE(gpio));
			bank->int_enb[p] = tegra_gpio_readl(GPIO_INT_ENB(gpio));
			bank->int_lvl[p] = tegra_gpio_readl(GPIO_INT_LVL(gpio));
330 331 332
		}
	}
	local_irq_restore(flags);
333
	return 0;
334 335
}

336
static int tegra_gpio_wake_enable(struct irq_data *d, unsigned int enable)
337
{
338
	struct tegra_gpio_bank *bank = irq_data_get_irq_chip_data(d);
339
	return irq_set_irq_wake(bank->irq, enable);
340 341
}
#endif
Erik Gilling's avatar
Erik Gilling committed
342 343 344

static struct irq_chip tegra_gpio_irq_chip = {
	.name		= "GPIO",
345 346 347 348
	.irq_ack	= tegra_gpio_irq_ack,
	.irq_mask	= tegra_gpio_irq_mask,
	.irq_unmask	= tegra_gpio_irq_unmask,
	.irq_set_type	= tegra_gpio_irq_set_type,
349
#ifdef CONFIG_PM_SLEEP
350
	.irq_set_wake	= tegra_gpio_wake_enable,
351
#endif
Erik Gilling's avatar
Erik Gilling committed
352 353
};

354 355 356 357
static const struct dev_pm_ops tegra_gpio_pm_ops = {
	SET_SYSTEM_SLEEP_PM_OPS(tegra_gpio_suspend, tegra_gpio_resume)
};

358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377
struct tegra_gpio_soc_config {
	u32 bank_stride;
	u32 upper_offset;
};

static struct tegra_gpio_soc_config tegra20_gpio_config = {
	.bank_stride = 0x80,
	.upper_offset = 0x800,
};

static struct tegra_gpio_soc_config tegra30_gpio_config = {
	.bank_stride = 0x100,
	.upper_offset = 0x80,
};

static struct of_device_id tegra_gpio_of_match[] __devinitdata = {
	{ .compatible = "nvidia,tegra30-gpio", .data = &tegra30_gpio_config },
	{ .compatible = "nvidia,tegra20-gpio", .data = &tegra20_gpio_config },
	{ },
};
Erik Gilling's avatar
Erik Gilling committed
378 379 380 381 382 383

/* This lock class tells lockdep that GPIO irqs are in a different
 * category than their parents, so it won't report false recursion.
 */
static struct lock_class_key gpio_lock_class;

384
static int __devinit tegra_gpio_probe(struct platform_device *pdev)
Erik Gilling's avatar
Erik Gilling committed
385
{
386 387
	const struct of_device_id *match;
	struct tegra_gpio_soc_config *config;
388
	struct resource *res;
Erik Gilling's avatar
Erik Gilling committed
389
	struct tegra_gpio_bank *bank;
390
	int gpio;
Erik Gilling's avatar
Erik Gilling committed
391 392 393
	int i;
	int j;

394 395 396 397 398 399 400 401 402
	match = of_match_device(tegra_gpio_of_match, &pdev->dev);
	if (match)
		config = (struct tegra_gpio_soc_config *)match->data;
	else
		config = &tegra20_gpio_config;

	tegra_gpio_bank_stride = config->bank_stride;
	tegra_gpio_upper_offset = config->upper_offset;

403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423
	for (;;) {
		res = platform_get_resource(pdev, IORESOURCE_IRQ, tegra_gpio_bank_count);
		if (!res)
			break;
		tegra_gpio_bank_count++;
	}
	if (!tegra_gpio_bank_count) {
		dev_err(&pdev->dev, "Missing IRQ resource\n");
		return -ENODEV;
	}

	tegra_gpio_chip.ngpio = tegra_gpio_bank_count * 32;

	tegra_gpio_banks = devm_kzalloc(&pdev->dev,
			tegra_gpio_bank_count * sizeof(*tegra_gpio_banks),
			GFP_KERNEL);
	if (!tegra_gpio_banks) {
		dev_err(&pdev->dev, "Couldn't allocate bank structure\n");
		return -ENODEV;
	}

424 425
	irq_domain = irq_domain_add_linear(pdev->dev.of_node,
					   tegra_gpio_chip.ngpio,
426
					   &irq_domain_simple_ops, NULL);
427 428
	if (!irq_domain)
		return -ENODEV;
429

430
	for (i = 0; i < tegra_gpio_bank_count; i++) {
431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447
		res = platform_get_resource(pdev, IORESOURCE_IRQ, i);
		if (!res) {
			dev_err(&pdev->dev, "Missing IRQ resource\n");
			return -ENODEV;
		}

		bank = &tegra_gpio_banks[i];
		bank->bank = i;
		bank->irq = res->start;
	}

	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (!res) {
		dev_err(&pdev->dev, "Missing MEM resource\n");
		return -ENODEV;
	}

448
	regs = devm_request_and_ioremap(&pdev->dev, res);
449 450 451 452 453
	if (!regs) {
		dev_err(&pdev->dev, "Couldn't ioremap regs\n");
		return -ENODEV;
	}

454
	for (i = 0; i < tegra_gpio_bank_count; i++) {
Erik Gilling's avatar
Erik Gilling committed
455 456
		for (j = 0; j < 4; j++) {
			int gpio = tegra_gpio_compose(i, j, 0);
457
			tegra_gpio_writel(0x00, GPIO_INT_ENB(gpio));
Erik Gilling's avatar
Erik Gilling committed
458 459 460
		}
	}

461
#ifdef CONFIG_OF_GPIO
462 463
	tegra_gpio_chip.of_node = pdev->dev.of_node;
#endif
464

Erik Gilling's avatar
Erik Gilling committed
465 466
	gpiochip_add(&tegra_gpio_chip);

467
	for (gpio = 0; gpio < tegra_gpio_chip.ngpio; gpio++) {
468
		int irq = irq_create_mapping(irq_domain, gpio);
469
		/* No validity check; all Tegra GPIOs are valid IRQs */
Erik Gilling's avatar
Erik Gilling committed
470

471
		bank = &tegra_gpio_banks[GPIO_BANK(gpio)];
Erik Gilling's avatar
Erik Gilling committed
472

473 474 475
		irq_set_lockdep_class(irq, &gpio_lock_class);
		irq_set_chip_data(irq, bank);
		irq_set_chip_and_handler(irq, &tegra_gpio_irq_chip,
476
					 handle_simple_irq);
477
		set_irq_flags(irq, IRQF_VALID);
Erik Gilling's avatar
Erik Gilling committed
478 479
	}

480
	for (i = 0; i < tegra_gpio_bank_count; i++) {
Erik Gilling's avatar
Erik Gilling committed
481 482
		bank = &tegra_gpio_banks[i];

483 484
		irq_set_chained_handler(bank->irq, tegra_gpio_irq_handler);
		irq_set_handler_data(bank->irq, bank);
Erik Gilling's avatar
Erik Gilling committed
485 486 487 488 489 490 491 492

		for (j = 0; j < 4; j++)
			spin_lock_init(&bank->lvl_lock[j]);
	}

	return 0;
}

493 494 495 496
static struct platform_driver tegra_gpio_driver = {
	.driver		= {
		.name	= "tegra-gpio",
		.owner	= THIS_MODULE,
497
		.pm	= &tegra_gpio_pm_ops,
498 499 500 501 502 503 504 505 506
		.of_match_table = tegra_gpio_of_match,
	},
	.probe		= tegra_gpio_probe,
};

static int __init tegra_gpio_init(void)
{
	return platform_driver_register(&tegra_gpio_driver);
}
Erik Gilling's avatar
Erik Gilling committed
507 508 509 510 511 512 513 514 515 516 517 518
postcore_initcall(tegra_gpio_init);

#ifdef	CONFIG_DEBUG_FS

#include <linux/debugfs.h>
#include <linux/seq_file.h>

static int dbg_gpio_show(struct seq_file *s, void *unused)
{
	int i;
	int j;

519
	for (i = 0; i < tegra_gpio_bank_count; i++) {
Erik Gilling's avatar
Erik Gilling committed
520 521
		for (j = 0; j < 4; j++) {
			int gpio = tegra_gpio_compose(i, j, 0);
522 523 524
			seq_printf(s,
				"%d:%d %02x %02x %02x %02x %02x %02x %06x\n",
				i, j,
525 526 527 528 529 530 531
				tegra_gpio_readl(GPIO_CNF(gpio)),
				tegra_gpio_readl(GPIO_OE(gpio)),
				tegra_gpio_readl(GPIO_OUT(gpio)),
				tegra_gpio_readl(GPIO_IN(gpio)),
				tegra_gpio_readl(GPIO_INT_STA(gpio)),
				tegra_gpio_readl(GPIO_INT_ENB(gpio)),
				tegra_gpio_readl(GPIO_INT_LVL(gpio)));
Erik Gilling's avatar
Erik Gilling committed
532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556
		}
	}
	return 0;
}

static int dbg_gpio_open(struct inode *inode, struct file *file)
{
	return single_open(file, dbg_gpio_show, &inode->i_private);
}

static const struct file_operations debug_fops = {
	.open		= dbg_gpio_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
};

static int __init tegra_gpio_debuginit(void)
{
	(void) debugfs_create_file("tegra_gpio", S_IRUGO,
					NULL, NULL, &debug_fops);
	return 0;
}
late_initcall(tegra_gpio_debuginit);
#endif