gpio-mmio.c 19.2 KB
Newer Older
1
/*
Grant Likely's avatar
Grant Likely committed
2
 * Generic driver for memory-mapped GPIO controllers.
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47
 *
 * Copyright 2008 MontaVista Software, Inc.
 * Copyright 2008,2010 Anton Vorontsov <cbouatmailru@gmail.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.
 *
 * ....``.```~~~~````.`.`.`.`.```````'',,,.........`````......`.......
 * ...``                                                         ```````..
 * ..The simplest form of a GPIO controller that the driver supports is``
 *  `.just a single "data" register, where GPIO state can be read and/or `
 *    `,..written. ,,..``~~~~ .....``.`.`.~~.```.`.........``````.```````
 *        `````````
                                    ___
_/~~|___/~|   . ```~~~~~~       ___/___\___     ,~.`.`.`.`````.~~...,,,,...
__________|~$@~~~        %~    /o*o*o*o*o*o\   .. Implementing such a GPIO .
o        `                     ~~~~\___/~~~~    ` controller in FPGA is ,.`
                                                 `....trivial..'~`.```.```
 *                                                    ```````
 *  .```````~~~~`..`.``.``.
 * .  The driver supports  `...       ,..```.`~~~```````````````....````.``,,
 * .   big-endian notation, just`.  .. A bit more sophisticated controllers ,
 *  . register the device with -be`. .with a pair of set/clear-bit registers ,
 *   `.. suffix.  ```~~`````....`.`   . affecting the data register and the .`
 *     ``.`.``...```                  ```.. output pins are also supported.`
 *                        ^^             `````.`````````.,``~``~``~~``````
 *                                                   .                  ^^
 *   ,..`.`.`...````````````......`.`.`.`.`.`..`.`.`..
 * .. The expectation is that in at least some cases .    ,-~~~-,
 *  .this will be used with roll-your-own ASIC/FPGA .`     \   /
 *  .logic in Verilog or VHDL. ~~~`````````..`````~~`       \ /
 *  ..````````......```````````                             \o_
 *                                                           |
 *                              ^^                          / \
 *
 *           ...`````~~`.....``.`..........``````.`.``.```........``.
 *            `  8, 16, 32 and 64 bits registers are supported, and``.
 *            . the number of GPIOs is determined by the width of   ~
 *             .. the registers. ,............```.`.`..`.`.~~~.`.`.`~
 *               `.......````.```
 */

#include <linux/init.h>
48
#include <linux/err.h>
49 50 51 52 53 54 55 56 57 58
#include <linux/bug.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/spinlock.h>
#include <linux/compiler.h>
#include <linux/types.h>
#include <linux/errno.h>
#include <linux/log2.h>
#include <linux/ioport.h>
#include <linux/io.h>
59
#include <linux/gpio/driver.h>
60
#include <linux/slab.h>
61
#include <linux/bitops.h>
62 63
#include <linux/platform_device.h>
#include <linux/mod_devicetable.h>
64 65
#include <linux/of.h>
#include <linux/of_device.h>
66

67
static void bgpio_write8(void __iomem *reg, unsigned long data)
68
{
69
	writeb(data, reg);
70 71
}

72
static unsigned long bgpio_read8(void __iomem *reg)
73
{
74
	return readb(reg);
75 76 77 78
}

static void bgpio_write16(void __iomem *reg, unsigned long data)
{
79
	writew(data, reg);
80 81 82 83
}

static unsigned long bgpio_read16(void __iomem *reg)
{
84
	return readw(reg);
85 86 87 88
}

static void bgpio_write32(void __iomem *reg, unsigned long data)
{
89
	writel(data, reg);
90 91 92 93
}

static unsigned long bgpio_read32(void __iomem *reg)
{
94
	return readl(reg);
95 96
}

97
#if BITS_PER_LONG >= 64
98 99
static void bgpio_write64(void __iomem *reg, unsigned long data)
{
100
	writeq(data, reg);
101 102 103 104
}

static unsigned long bgpio_read64(void __iomem *reg)
{
105
	return readq(reg);
106
}
107
#endif /* BITS_PER_LONG >= 64 */
108

109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128
static void bgpio_write16be(void __iomem *reg, unsigned long data)
{
	iowrite16be(data, reg);
}

static unsigned long bgpio_read16be(void __iomem *reg)
{
	return ioread16be(reg);
}

static void bgpio_write32be(void __iomem *reg, unsigned long data)
{
	iowrite32be(data, reg);
}

static unsigned long bgpio_read32be(void __iomem *reg)
{
	return ioread32be(reg);
}

129
static unsigned long bgpio_line2mask(struct gpio_chip *gc, unsigned int line)
130
{
131 132 133
	if (gc->be_bits)
		return BIT(gc->bgpio_bits - 1 - line);
	return BIT(line);
134 135
}

136 137
static int bgpio_get_set(struct gpio_chip *gc, unsigned int gpio)
{
138
	unsigned long pinmask = bgpio_line2mask(gc, gpio);
139

140 141
	if (gc->bgpio_dir & pinmask)
		return !!(gc->read_reg(gc->reg_set) & pinmask);
142
	else
143
		return !!(gc->read_reg(gc->reg_dat) & pinmask);
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
/*
 * This assumes that the bits in the GPIO register are in native endianness.
 * We only assign the function pointer if we have that.
 */
static int bgpio_get_set_multiple(struct gpio_chip *gc, unsigned long *mask,
				  unsigned long *bits)
{
	unsigned long get_mask = 0;
	unsigned long set_mask = 0;
	int bit = 0;

	while ((bit = find_next_bit(mask, gc->ngpio, bit)) != gc->ngpio) {
		if (gc->bgpio_dir & BIT(bit))
			set_mask |= BIT(bit);
		else
			get_mask |= BIT(bit);
	}

	if (set_mask)
		*bits |= gc->read_reg(gc->reg_set) & set_mask;
	if (get_mask)
		*bits |= gc->read_reg(gc->reg_dat) & get_mask;

	return 0;
}

172 173
static int bgpio_get(struct gpio_chip *gc, unsigned int gpio)
{
174
	return !!(gc->read_reg(gc->reg_dat) & bgpio_line2mask(gc, gpio));
175 176
}

177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217
/*
 * This only works if the bits in the GPIO register are in native endianness.
 * It is dirt simple and fast in this case. (Also the most common case.)
 */
static int bgpio_get_multiple(struct gpio_chip *gc, unsigned long *mask,
			      unsigned long *bits)
{

	*bits = gc->read_reg(gc->reg_dat) & *mask;
	return 0;
}

/*
 * With big endian mirrored bit order it becomes more tedious.
 */
static int bgpio_get_multiple_be(struct gpio_chip *gc, unsigned long *mask,
				 unsigned long *bits)
{
	unsigned long readmask = 0;
	unsigned long val;
	int bit;

	/* Create a mirrored mask */
	bit = 0;
	while ((bit = find_next_bit(mask, gc->ngpio, bit)) != gc->ngpio)
		readmask |= bgpio_line2mask(gc, bit);

	/* Read the register */
	val = gc->read_reg(gc->reg_dat) & readmask;

	/*
	 * Mirror the result into the "bits" result, this will give line 0
	 * in bit 0 ... line 31 in bit 31 for a 32bit register.
	 */
	bit = 0;
	while ((bit = find_next_bit(&val, gc->ngpio, bit)) != gc->ngpio)
		*bits |= bgpio_line2mask(gc, bit);

	return 0;
}

218 219 220 221
static void bgpio_set_none(struct gpio_chip *gc, unsigned int gpio, int val)
{
}

222 223
static void bgpio_set(struct gpio_chip *gc, unsigned int gpio, int val)
{
224
	unsigned long mask = bgpio_line2mask(gc, gpio);
225 226
	unsigned long flags;

227
	spin_lock_irqsave(&gc->bgpio_lock, flags);
228 229

	if (val)
230
		gc->bgpio_data |= mask;
231
	else
232
		gc->bgpio_data &= ~mask;
233

234
	gc->write_reg(gc->reg_dat, gc->bgpio_data);
235

236
	spin_unlock_irqrestore(&gc->bgpio_lock, flags);
237 238
}

239 240 241
static void bgpio_set_with_clear(struct gpio_chip *gc, unsigned int gpio,
				 int val)
{
242
	unsigned long mask = bgpio_line2mask(gc, gpio);
243 244

	if (val)
245
		gc->write_reg(gc->reg_set, mask);
246
	else
247
		gc->write_reg(gc->reg_clr, mask);
248 249
}

250 251
static void bgpio_set_set(struct gpio_chip *gc, unsigned int gpio, int val)
{
252
	unsigned long mask = bgpio_line2mask(gc, gpio);
253 254
	unsigned long flags;

255
	spin_lock_irqsave(&gc->bgpio_lock, flags);
256 257

	if (val)
258
		gc->bgpio_data |= mask;
259
	else
260
		gc->bgpio_data &= ~mask;
261

262
	gc->write_reg(gc->reg_set, gc->bgpio_data);
263

264
	spin_unlock_irqrestore(&gc->bgpio_lock, flags);
265 266
}

267
static void bgpio_multiple_get_masks(struct gpio_chip *gc,
268 269 270 271 272 273 274 275 276
				     unsigned long *mask, unsigned long *bits,
				     unsigned long *set_mask,
				     unsigned long *clear_mask)
{
	int i;

	*set_mask = 0;
	*clear_mask = 0;

277
	for (i = 0; i < gc->bgpio_bits; i++) {
278 279 280 281
		if (*mask == 0)
			break;
		if (__test_and_clear_bit(i, mask)) {
			if (test_bit(i, bits))
282
				*set_mask |= bgpio_line2mask(gc, i);
283
			else
284
				*clear_mask |= bgpio_line2mask(gc, i);
285 286 287 288
		}
	}
}

289
static void bgpio_set_multiple_single_reg(struct gpio_chip *gc,
290 291 292 293 294 295 296
					  unsigned long *mask,
					  unsigned long *bits,
					  void __iomem *reg)
{
	unsigned long flags;
	unsigned long set_mask, clear_mask;

297
	spin_lock_irqsave(&gc->bgpio_lock, flags);
298

299
	bgpio_multiple_get_masks(gc, mask, bits, &set_mask, &clear_mask);
300

301 302
	gc->bgpio_data |= set_mask;
	gc->bgpio_data &= ~clear_mask;
303

304
	gc->write_reg(reg, gc->bgpio_data);
305

306
	spin_unlock_irqrestore(&gc->bgpio_lock, flags);
307 308 309 310 311
}

static void bgpio_set_multiple(struct gpio_chip *gc, unsigned long *mask,
			       unsigned long *bits)
{
312
	bgpio_set_multiple_single_reg(gc, mask, bits, gc->reg_dat);
313 314 315 316 317
}

static void bgpio_set_multiple_set(struct gpio_chip *gc, unsigned long *mask,
				   unsigned long *bits)
{
318
	bgpio_set_multiple_single_reg(gc, mask, bits, gc->reg_set);
319 320 321 322 323 324 325 326
}

static void bgpio_set_multiple_with_clear(struct gpio_chip *gc,
					  unsigned long *mask,
					  unsigned long *bits)
{
	unsigned long set_mask, clear_mask;

327
	bgpio_multiple_get_masks(gc, mask, bits, &set_mask, &clear_mask);
328 329

	if (set_mask)
330
		gc->write_reg(gc->reg_set, set_mask);
331
	if (clear_mask)
332
		gc->write_reg(gc->reg_clr, clear_mask);
333 334
}

335 336 337 338 339
static int bgpio_simple_dir_in(struct gpio_chip *gc, unsigned int gpio)
{
	return 0;
}

340 341 342 343 344 345
static int bgpio_dir_out_err(struct gpio_chip *gc, unsigned int gpio,
				int val)
{
	return -EINVAL;
}

346 347 348 349 350 351 352 353
static int bgpio_simple_dir_out(struct gpio_chip *gc, unsigned int gpio,
				int val)
{
	gc->set(gc, gpio, val);

	return 0;
}

354 355
static int bgpio_dir_in(struct gpio_chip *gc, unsigned int gpio)
{
356 357
	unsigned long flags;

358
	spin_lock_irqsave(&gc->bgpio_lock, flags);
359

360
	gc->bgpio_dir &= ~bgpio_line2mask(gc, gpio);
361
	gc->write_reg(gc->reg_dir, gc->bgpio_dir);
362

363
	spin_unlock_irqrestore(&gc->bgpio_lock, flags);
364

365 366 367
	return 0;
}

368 369
static int bgpio_get_dir(struct gpio_chip *gc, unsigned int gpio)
{
370
	/* Return 0 if output, 1 of input */
371
	return !(gc->read_reg(gc->reg_dir) & bgpio_line2mask(gc, gpio));
372 373
}

374 375
static int bgpio_dir_out(struct gpio_chip *gc, unsigned int gpio, int val)
{
376 377 378 379
	unsigned long flags;

	gc->set(gc, gpio, val);

380
	spin_lock_irqsave(&gc->bgpio_lock, flags);
381

382
	gc->bgpio_dir |= bgpio_line2mask(gc, gpio);
383
	gc->write_reg(gc->reg_dir, gc->bgpio_dir);
384

385
	spin_unlock_irqrestore(&gc->bgpio_lock, flags);
386 387 388 389 390 391 392 393

	return 0;
}

static int bgpio_dir_in_inv(struct gpio_chip *gc, unsigned int gpio)
{
	unsigned long flags;

394
	spin_lock_irqsave(&gc->bgpio_lock, flags);
395

396
	gc->bgpio_dir |= bgpio_line2mask(gc, gpio);
397
	gc->write_reg(gc->reg_dir, gc->bgpio_dir);
398

399
	spin_unlock_irqrestore(&gc->bgpio_lock, flags);
400 401 402 403 404 405 406 407

	return 0;
}

static int bgpio_dir_out_inv(struct gpio_chip *gc, unsigned int gpio, int val)
{
	unsigned long flags;

408 409
	gc->set(gc, gpio, val);

410
	spin_lock_irqsave(&gc->bgpio_lock, flags);
411

412
	gc->bgpio_dir &= ~bgpio_line2mask(gc, gpio);
413
	gc->write_reg(gc->reg_dir, gc->bgpio_dir);
414

415
	spin_unlock_irqrestore(&gc->bgpio_lock, flags);
416

417 418 419
	return 0;
}

420 421
static int bgpio_get_dir_inv(struct gpio_chip *gc, unsigned int gpio)
{
422
	/* Return 0 if output, 1 if input */
423
	return !!(gc->read_reg(gc->reg_dir) & bgpio_line2mask(gc, gpio));
424 425
}

426
static int bgpio_setup_accessors(struct device *dev,
427
				 struct gpio_chip *gc,
428
				 bool byte_be)
429
{
430

431
	switch (gc->bgpio_bits) {
432
	case 8:
433 434
		gc->read_reg	= bgpio_read8;
		gc->write_reg	= bgpio_write8;
435 436
		break;
	case 16:
437
		if (byte_be) {
438 439
			gc->read_reg	= bgpio_read16be;
			gc->write_reg	= bgpio_write16be;
440
		} else {
441 442
			gc->read_reg	= bgpio_read16;
			gc->write_reg	= bgpio_write16;
443
		}
444 445
		break;
	case 32:
446
		if (byte_be) {
447 448
			gc->read_reg	= bgpio_read32be;
			gc->write_reg	= bgpio_write32be;
449
		} else {
450 451
			gc->read_reg	= bgpio_read32;
			gc->write_reg	= bgpio_write32;
452
		}
453 454 455
		break;
#if BITS_PER_LONG >= 64
	case 64:
456 457 458 459 460
		if (byte_be) {
			dev_err(dev,
				"64 bit big endian byte order unsupported\n");
			return -EINVAL;
		} else {
461 462
			gc->read_reg	= bgpio_read64;
			gc->write_reg	= bgpio_write64;
463
		}
464 465 466
		break;
#endif /* BITS_PER_LONG >= 64 */
	default:
467
		dev_err(dev, "unsupported data width %u bits\n", gc->bgpio_bits);
468 469 470 471 472 473
		return -EINVAL;
	}

	return 0;
}

474 475
/*
 * Create the device and allocate the resources.  For setting GPIO's there are
476
 * three supported configurations:
477
 *
478
 *	- single input/output register resource (named "dat").
479
 *	- set/clear pair (named "set" and "clr").
480 481
 *	- single output register resource and single input resource ("set" and
 *	dat").
482 483 484 485 486
 *
 * For the single output register, this drives a 1 by setting a bit and a zero
 * by clearing a bit.  For the set clr pair, this drives a 1 by setting a bit
 * in the set register and clears it by setting a bit in the clear register.
 * The configuration is detected by which resources are present.
487 488 489 490 491 492 493 494
 *
 * For setting the GPIO direction, there are three supported configurations:
 *
 *	- simple bidirection GPIO that requires no configuration.
 *	- an output direction register (named "dirout") where a 1 bit
 *	indicates the GPIO is an output.
 *	- an input direction register (named "dirin") where a 1 bit indicates
 *	the GPIO is an input.
495
 */
496
static int bgpio_setup_io(struct gpio_chip *gc,
497 498
			  void __iomem *dat,
			  void __iomem *set,
499 500
			  void __iomem *clr,
			  unsigned long flags)
501
{
502

503 504
	gc->reg_dat = dat;
	if (!gc->reg_dat)
505
		return -EINVAL;
506

507
	if (set && clr) {
508 509 510 511
		gc->reg_set = set;
		gc->reg_clr = clr;
		gc->set = bgpio_set_with_clear;
		gc->set_multiple = bgpio_set_multiple_with_clear;
512
	} else if (set && !clr) {
513 514 515
		gc->reg_set = set;
		gc->set = bgpio_set_set;
		gc->set_multiple = bgpio_set_multiple_set;
516
	} else if (flags & BGPIOF_NO_OUTPUT) {
517 518
		gc->set = bgpio_set_none;
		gc->set_multiple = NULL;
519
	} else {
520 521
		gc->set = bgpio_set;
		gc->set_multiple = bgpio_set_multiple;
522 523
	}

524
	if (!(flags & BGPIOF_UNREADABLE_REG_SET) &&
525
	    (flags & BGPIOF_READ_OUTPUT_REG_SET)) {
526
		gc->get = bgpio_get_set;
527 528 529 530 531 532 533 534 535 536
		if (!gc->be_bits)
			gc->get_multiple = bgpio_get_set_multiple;
		/*
		 * We deliberately avoid assigning the ->get_multiple() call
		 * for big endian mirrored registers which are ALSO reflecting
		 * their value in the set register when used as output. It is
		 * simply too much complexity, let the GPIO core fall back to
		 * reading each line individually in that fringe case.
		 */
	} else {
537
		gc->get = bgpio_get;
538 539 540 541 542
		if (gc->be_bits)
			gc->get_multiple = bgpio_get_multiple_be;
		else
			gc->get_multiple = bgpio_get_multiple;
	}
543

544 545 546
	return 0;
}

547
static int bgpio_setup_direction(struct gpio_chip *gc,
548
				 void __iomem *dirout,
549 550
				 void __iomem *dirin,
				 unsigned long flags)
551
{
552
	if (dirout && dirin) {
553
		return -EINVAL;
554
	} else if (dirout) {
555 556 557 558
		gc->reg_dir = dirout;
		gc->direction_output = bgpio_dir_out;
		gc->direction_input = bgpio_dir_in;
		gc->get_direction = bgpio_get_dir;
559
	} else if (dirin) {
560 561 562 563
		gc->reg_dir = dirin;
		gc->direction_output = bgpio_dir_out_inv;
		gc->direction_input = bgpio_dir_in_inv;
		gc->get_direction = bgpio_get_dir_inv;
564
	} else {
565
		if (flags & BGPIOF_NO_OUTPUT)
566
			gc->direction_output = bgpio_dir_out_err;
567
		else
568 569
			gc->direction_output = bgpio_simple_dir_out;
		gc->direction_input = bgpio_simple_dir_in;
570 571 572 573 574
	}

	return 0;
}

575 576 577 578 579 580 581 582
static int bgpio_request(struct gpio_chip *chip, unsigned gpio_pin)
{
	if (gpio_pin < chip->ngpio)
		return 0;

	return -EINVAL;
}

583
int bgpio_init(struct gpio_chip *gc, struct device *dev,
584 585
	       unsigned long sz, void __iomem *dat, void __iomem *set,
	       void __iomem *clr, void __iomem *dirout, void __iomem *dirin,
586
	       unsigned long flags)
587 588 589
{
	int ret;

590 591
	if (!is_power_of_2(sz))
		return -EINVAL;
592

593 594
	gc->bgpio_bits = sz * 8;
	if (gc->bgpio_bits > BITS_PER_LONG)
595 596
		return -EINVAL;

597 598 599 600 601 602
	spin_lock_init(&gc->bgpio_lock);
	gc->parent = dev;
	gc->label = dev_name(dev);
	gc->base = -1;
	gc->ngpio = gc->bgpio_bits;
	gc->request = bgpio_request;
603
	gc->be_bits = !!(flags & BGPIOF_BIG_ENDIAN);
604

605
	ret = bgpio_setup_io(gc, dat, set, clr, flags);
606 607
	if (ret)
		return ret;
608

609
	ret = bgpio_setup_accessors(dev, gc, flags & BGPIOF_BIG_ENDIAN_BYTE_ORDER);
610 611
	if (ret)
		return ret;
612

613
	ret = bgpio_setup_direction(gc, dirout, dirin, flags);
614 615 616
	if (ret)
		return ret;

617 618
	gc->bgpio_data = gc->read_reg(gc->reg_dat);
	if (gc->set == bgpio_set_set &&
619
			!(flags & BGPIOF_UNREADABLE_REG_SET))
620 621 622
		gc->bgpio_data = gc->read_reg(gc->reg_set);
	if (gc->reg_dir && !(flags & BGPIOF_UNREADABLE_REG_DIR))
		gc->bgpio_dir = gc->read_reg(gc->reg_dir);
623

624 625 626
	return ret;
}
EXPORT_SYMBOL_GPL(bgpio_init);
627

628
#if IS_ENABLED(CONFIG_GPIO_GENERIC_PLATFORM)
629

630 631
static void __iomem *bgpio_map(struct platform_device *pdev,
			       const char *name,
632
			       resource_size_t sane_sz)
633 634 635 636 637
{
	struct resource *r;
	resource_size_t sz;

	r = platform_get_resource_byname(pdev, IORESOURCE_MEM, name);
638
	if (!r)
639
		return NULL;
640 641

	sz = resource_size(r);
642 643
	if (sz != sane_sz)
		return IOMEM_ERR_PTR(-EINVAL);
644

645
	return devm_ioremap_resource(&pdev->dev, r);
646 647
}

648 649
#ifdef CONFIG_OF
static const struct of_device_id bgpio_of_match[] = {
650
	{ .compatible = "brcm,bcm6345-gpio" },
651
	{ .compatible = "wd,mbl-gpio" },
652
	{ .compatible = "ni,169445-nand-gpio" },
653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671
	{ }
};
MODULE_DEVICE_TABLE(of, bgpio_of_match);

static struct bgpio_pdata *bgpio_parse_dt(struct platform_device *pdev,
					  unsigned long *flags)
{
	struct bgpio_pdata *pdata;

	if (!of_match_device(bgpio_of_match, &pdev->dev))
		return NULL;

	pdata = devm_kzalloc(&pdev->dev, sizeof(struct bgpio_pdata),
			     GFP_KERNEL);
	if (!pdata)
		return ERR_PTR(-ENOMEM);

	pdata->base = -1;

672 673 674
	if (of_device_is_big_endian(pdev->dev.of_node))
		*flags |= BGPIOF_BIG_ENDIAN_BYTE_ORDER;

675 676 677
	if (of_property_read_bool(pdev->dev.of_node, "no-output"))
		*flags |= BGPIOF_NO_OUTPUT;

678 679 680 681 682 683 684 685 686 687
	return pdata;
}
#else
static struct bgpio_pdata *bgpio_parse_dt(struct platform_device *pdev,
					  unsigned long *flags)
{
	return NULL;
}
#endif /* CONFIG_OF */

Bill Pemberton's avatar
Bill Pemberton committed
688
static int bgpio_pdev_probe(struct platform_device *pdev)
689 690 691 692 693 694 695 696 697
{
	struct device *dev = &pdev->dev;
	struct resource *r;
	void __iomem *dat;
	void __iomem *set;
	void __iomem *clr;
	void __iomem *dirout;
	void __iomem *dirin;
	unsigned long sz;
698
	unsigned long flags = 0;
699
	int err;
700
	struct gpio_chip *gc;
701 702 703 704 705 706 707 708 709 710
	struct bgpio_pdata *pdata;

	pdata = bgpio_parse_dt(pdev, &flags);
	if (IS_ERR(pdata))
		return PTR_ERR(pdata);

	if (!pdata) {
		pdata = dev_get_platdata(dev);
		flags = pdev->id_entry->driver_data;
	}
711 712 713 714 715 716 717

	r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "dat");
	if (!r)
		return -EINVAL;

	sz = resource_size(r);

718 719 720
	dat = bgpio_map(pdev, "dat", sz);
	if (IS_ERR(dat))
		return PTR_ERR(dat);
721

722 723 724
	set = bgpio_map(pdev, "set", sz);
	if (IS_ERR(set))
		return PTR_ERR(set);
725

726 727 728
	clr = bgpio_map(pdev, "clr", sz);
	if (IS_ERR(clr))
		return PTR_ERR(clr);
729

730 731 732
	dirout = bgpio_map(pdev, "dirout", sz);
	if (IS_ERR(dirout))
		return PTR_ERR(dirout);
733

734 735 736
	dirin = bgpio_map(pdev, "dirin", sz);
	if (IS_ERR(dirin))
		return PTR_ERR(dirin);
737

738 739
	gc = devm_kzalloc(&pdev->dev, sizeof(*gc), GFP_KERNEL);
	if (!gc)
740 741
		return -ENOMEM;

742
	err = bgpio_init(gc, dev, sz, dat, set, clr, dirout, dirin, flags);
743 744 745 746
	if (err)
		return err;

	if (pdata) {
747
		if (pdata->label)
748 749
			gc->label = pdata->label;
		gc->base = pdata->base;
750
		if (pdata->ngpio > 0)
751
			gc->ngpio = pdata->ngpio;
752 753
	}

754
	platform_set_drvdata(pdev, gc);
755

756
	return devm_gpiochip_add_data(&pdev->dev, gc, NULL);
757 758 759
}

static const struct platform_device_id bgpio_id_table[] = {
760 761 762 763 764 765 766 767
	{
		.name		= "basic-mmio-gpio",
		.driver_data	= 0,
	}, {
		.name		= "basic-mmio-gpio-be",
		.driver_data	= BGPIOF_BIG_ENDIAN,
	},
	{ }
768 769 770 771 772 773
};
MODULE_DEVICE_TABLE(platform, bgpio_id_table);

static struct platform_driver bgpio_driver = {
	.driver = {
		.name = "basic-mmio-gpio",
774
		.of_match_table = of_match_ptr(bgpio_of_match),
775 776
	},
	.id_table = bgpio_id_table,
777
	.probe = bgpio_pdev_probe,
778 779
};

780
module_platform_driver(bgpio_driver);
781

Grant Likely's avatar
Grant Likely committed
782
#endif /* CONFIG_GPIO_GENERIC_PLATFORM */
783 784 785 786

MODULE_DESCRIPTION("Driver for basic memory-mapped GPIO controllers");
MODULE_AUTHOR("Anton Vorontsov <cbouatmailru@gmail.com>");
MODULE_LICENSE("GPL");