Release 4.14 drivers/gpio/gpio-mmio.c

Directory: drivers/gpio
/*
 * Generic driver for memory-mapped GPIO controllers.
 *
 * 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>
#include <linux/err.h>
#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>
#include <linux/gpio/driver.h>
#include <linux/slab.h>
#include <linux/bitops.h>
#include <linux/platform_device.h>
#include <linux/mod_devicetable.h>
#include <linux/of.h>
#include <linux/of_device.h>



static void bgpio_write8(void __iomem *reg, unsigned long data)
{
	writeb(data, reg);
}

Contributors
Person Tokens Prop Commits CommitProp
Jamie Iles 22 100.00% 2 100.00%
Total 22 100.00% 2 100.00%



static unsigned long bgpio_read8(void __iomem *reg)
{
	return readb(reg);
}

Contributors
Person Tokens Prop Commits CommitProp
Anton Vorontsov 12 66.67% 1 33.33%
Jamie Iles 6 33.33% 2 66.67%
Total 18 100.00% 3 100.00%



static void bgpio_write16(void __iomem *reg, unsigned long data)
{
	writew(data, reg);
}

Contributors
Person Tokens Prop Commits CommitProp
Anton Vorontsov 19 86.36% 1 33.33%
Jamie Iles 3 13.64% 2 66.67%
Total 22 100.00% 3 100.00%



static unsigned long bgpio_read16(void __iomem *reg)
{
	return readw(reg);
}

Contributors
Person Tokens Prop Commits CommitProp
Jamie Iles 15 83.33% 2 66.67%
Anton Vorontsov 3 16.67% 1 33.33%
Total 18 100.00% 3 100.00%



static void bgpio_write32(void __iomem *reg, unsigned long data)
{
	writel(data, reg);
}

Contributors
Person Tokens Prop Commits CommitProp
Jamie Iles 16 72.73% 2 66.67%
Anton Vorontsov 6 27.27% 1 33.33%
Total 22 100.00% 3 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
Jamie Iles 18 100.00% 2 100.00%
Total 18 100.00% 2 100.00%

#if BITS_PER_LONG >= 64


static void bgpio_write64(void __iomem *reg, unsigned long data)
{
	writeq(data, reg);
}

Contributors
Person Tokens Prop Commits CommitProp
Jamie Iles 15 68.18% 2 66.67%
Anton Vorontsov 7 31.82% 1 33.33%
Total 22 100.00% 3 100.00%



static unsigned long bgpio_read64(void __iomem *reg)
{
	return readq(reg);
}
Contributors
Person Tokens Prop Commits CommitProp
Jamie Iles 17 94.44% 2 66.67%
Anton Vorontsov 1 5.56% 1 33.33%
Total 18 100.00% 3 100.00%

#endif /* BITS_PER_LONG >= 64 */



static void bgpio_write16be(void __iomem *reg, unsigned long data)
{
	iowrite16be(data, reg);
}

Contributors
Person Tokens Prop Commits CommitProp
Andreas Larsson 22 100.00% 1 100.00%
Total 22 100.00% 1 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
Andreas Larsson 18 100.00% 1 100.00%
Total 18 100.00% 1 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
Andreas Larsson 22 100.00% 1 100.00%
Total 22 100.00% 1 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
Andreas Larsson 18 100.00% 1 100.00%
Total 18 100.00% 1 100.00%



static unsigned long bgpio_pin2mask(struct gpio_chip *gc, unsigned int pin)
{
	return BIT(pin);
}

Contributors
Person Tokens Prop Commits CommitProp
Anton Vorontsov 13 59.09% 1 25.00%
Linus Walleij 5 22.73% 2 50.00%
Jamie Iles 4 18.18% 1 25.00%
Total 22 100.00% 4 100.00%



static unsigned long bgpio_pin2mask_be(struct gpio_chip *gc,
				       unsigned int pin)
{
	return BIT(gc->bgpio_bits - 1 - pin);
}

Contributors
Person Tokens Prop Commits CommitProp
Jamie Iles 13 46.43% 1 25.00%
Anton Vorontsov 8 28.57% 1 25.00%
Linus Walleij 7 25.00% 2 50.00%
Total 28 100.00% 4 100.00%



static int bgpio_get_set(struct gpio_chip *gc, unsigned int gpio)
{
	unsigned long pinmask = gc->pin2mask(gc, gpio);

	if (gc->bgpio_dir & pinmask)
		return !!(gc->read_reg(gc->reg_set) & pinmask);
	else
		return !!(gc->read_reg(gc->reg_dat) & pinmask);
}

Contributors
Person Tokens Prop Commits CommitProp
Vladimir Zapolskiy 53 76.81% 1 33.33%
Linus Walleij 16 23.19% 2 66.67%
Total 69 100.00% 3 100.00%



static int bgpio_get(struct gpio_chip *gc, unsigned int gpio)
{
	return !!(gc->read_reg(gc->reg_dat) & gc->pin2mask(gc, gpio));
}

Contributors
Person Tokens Prop Commits CommitProp
Anton Vorontsov 24 63.16% 1 25.00%
Linus Walleij 8 21.05% 2 50.00%
Jamie Iles 6 15.79% 1 25.00%
Total 38 100.00% 4 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
Rabin Vincent 17 100.00% 1 100.00%
Total 17 100.00% 1 100.00%



static void bgpio_set(struct gpio_chip *gc, unsigned int gpio, int val)
{
	unsigned long mask = gc->pin2mask(gc, gpio);
	unsigned long flags;

	spin_lock_irqsave(&gc->bgpio_lock, flags);

	if (val)
		gc->bgpio_data |= mask;
	else
		gc->bgpio_data &= ~mask;

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

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

Contributors
Person Tokens Prop Commits CommitProp
Anton Vorontsov 67 77.91% 1 33.33%
Linus Walleij 14 16.28% 1 33.33%
Jamie Iles 5 5.81% 1 33.33%
Total 86 100.00% 3 100.00%



static void bgpio_set_with_clear(struct gpio_chip *gc, unsigned int gpio,
				 int val)
{
	unsigned long mask = gc->pin2mask(gc, gpio);

	if (val)
		gc->write_reg(gc->reg_set, mask);
	else
		gc->write_reg(gc->reg_clr, mask);
}

Contributors
Person Tokens Prop Commits CommitProp
Jamie Iles 52 89.66% 1 50.00%
Linus Walleij 6 10.34% 1 50.00%
Total 58 100.00% 2 100.00%



static void bgpio_set_set(struct gpio_chip *gc, unsigned int gpio, int val)
{
	unsigned long mask = gc->pin2mask(gc, gpio);
	unsigned long flags;

	spin_lock_irqsave(&gc->bgpio_lock, flags);

	if (val)
		gc->bgpio_data |= mask;
	else
		gc->bgpio_data &= ~mask;

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

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

Contributors
Person Tokens Prop Commits CommitProp
Jamie Iles 72 83.72% 1 50.00%
Linus Walleij 14 16.28% 1 50.00%
Total 86 100.00% 2 100.00%



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

	*set_mask = 0;
	*clear_mask = 0;

	for (i = 0; i < gc->bgpio_bits; i++) {
		if (*mask == 0)
			break;
		if (__test_and_clear_bit(i, mask)) {
			if (test_bit(i, bits))
				*set_mask |= gc->pin2mask(gc, i);
			else
				*clear_mask |= gc->pin2mask(gc, i);
		}
	}
}

Contributors
Person Tokens Prop Commits CommitProp
Rojhalat Ibrahim 106 92.98% 1 50.00%
Linus Walleij 8 7.02% 1 50.00%
Total 114 100.00% 2 100.00%



static void bgpio_set_multiple_single_reg(struct gpio_chip *gc,
					  unsigned long *mask,
					  unsigned long *bits,
					  void __iomem *reg)
{
	unsigned long flags;
	unsigned long set_mask, clear_mask;

	spin_lock_irqsave(&gc->bgpio_lock, flags);

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

	gc->bgpio_data |= set_mask;
	gc->bgpio_data &= ~clear_mask;

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

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

Contributors
Person Tokens Prop Commits CommitProp
Rojhalat Ibrahim 81 85.26% 1 50.00%
Linus Walleij 14 14.74% 1 50.00%
Total 95 100.00% 2 100.00%



static void bgpio_set_multiple(struct gpio_chip *gc, unsigned long *mask,
			       unsigned long *bits)
{
	bgpio_set_multiple_single_reg(gc, mask, bits, gc->reg_dat);
}

Contributors
Person Tokens Prop Commits CommitProp
Rojhalat Ibrahim 32 94.12% 1 50.00%
Linus Walleij 2 5.88% 1 50.00%
Total 34 100.00% 2 100.00%



static void bgpio_set_multiple_set(struct gpio_chip *gc, unsigned long *mask,
				   unsigned long *bits)
{
	bgpio_set_multiple_single_reg(gc, mask, bits, gc->reg_set);
}

Contributors
Person Tokens Prop Commits CommitProp
Rojhalat Ibrahim 32 94.12% 1 50.00%
Linus Walleij 2 5.88% 1 50.00%
Total 34 100.00% 2 100.00%



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

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

	if (set_mask)
		gc->write_reg(gc->reg_set, set_mask);
	if (clear_mask)
		gc->write_reg(gc->reg_clr, clear_mask);
}

Contributors
Person Tokens Prop Commits CommitProp
Rojhalat Ibrahim 67 93.06% 1 50.00%
Linus Walleij 5 6.94% 1 50.00%
Total 72 100.00% 2 100.00%



static int bgpio_simple_dir_in(struct gpio_chip *gc, unsigned int gpio)
{
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Anton Vorontsov 17 94.44% 1 50.00%
Jamie Iles 1 5.56% 1 50.00%
Total 18 100.00% 2 100.00%



static int bgpio_dir_out_err(struct gpio_chip *gc, unsigned int gpio,
				int val)
{
	return -EINVAL;
}

Contributors
Person Tokens Prop Commits CommitProp
Rabin Vincent 22 100.00% 1 100.00%
Total 22 100.00% 1 100.00%



static int bgpio_simple_dir_out(struct gpio_chip *gc, unsigned int gpio,
				int val)
{
	gc->set(gc, gpio, val);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Anton Vorontsov 28 87.50% 1 33.33%
Jamie Iles 4 12.50% 2 66.67%
Total 32 100.00% 3 100.00%



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

	spin_lock_irqsave(&gc->bgpio_lock, flags);

	gc->bgpio_dir &= ~gc->pin2mask(gc, gpio);
	gc->write_reg(gc->reg_dir, gc->bgpio_dir);

	spin_unlock_irqrestore(&gc->bgpio_lock, flags);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Jamie Iles 57 82.61% 2 66.67%
Linus Walleij 12 17.39% 1 33.33%
Total 69 100.00% 3 100.00%



static int bgpio_get_dir(struct gpio_chip *gc, unsigned int gpio)
{
	/* Return 0 if output, 1 of input */
	return !(gc->read_reg(gc->reg_dir) & gc->pin2mask(gc, gpio));
}

Contributors
Person Tokens Prop Commits CommitProp
Philipp Zabel 32 84.21% 1 50.00%
Linus Walleij 6 15.79% 1 50.00%
Total 38 100.00% 2 100.00%



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

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

	spin_lock_irqsave(&gc->bgpio_lock, flags);

	gc->bgpio_dir |= gc->pin2mask(gc, gpio);
	gc->write_reg(gc->reg_dir, gc->bgpio_dir);

	spin_unlock_irqrestore(&gc->bgpio_lock, flags);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Jamie Iles 63 76.83% 2 50.00%
Linus Walleij 12 14.63% 1 25.00%
Anton Vorontsov 7 8.54% 1 25.00%
Total 82 100.00% 4 100.00%



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

	spin_lock_irqsave(&gc->bgpio_lock, flags);

	gc->bgpio_dir |= gc->pin2mask(gc, gpio);
	gc->write_reg(gc->reg_dir, gc->bgpio_dir);

	spin_unlock_irqrestore(&gc->bgpio_lock, flags);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Jamie Iles 56 82.35% 1 50.00%
Linus Walleij 12 17.65% 1 50.00%
Total 68 100.00% 2 100.00%



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

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

	spin_lock_irqsave(&gc->bgpio_lock, flags);

	gc->bgpio_dir &= ~gc->pin2mask(gc, gpio);
	gc->write_reg(gc->reg_dir, gc->bgpio_dir);

	spin_unlock_irqrestore(&gc->bgpio_lock, flags);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Jamie Iles 71 85.54% 1 50.00%
Linus Walleij 12 14.46% 1 50.00%
Total 83 100.00% 2 100.00%



static int bgpio_get_dir_inv(struct gpio_chip *gc, unsigned int gpio)
{
	/* Return 0 if output, 1 if input */
	return !!(gc->read_reg(gc->reg_dir) & gc->pin2mask(gc, gpio));
}

Contributors
Person Tokens Prop Commits CommitProp
Philipp Zabel 32 82.05% 1 50.00%
Linus Walleij 7 17.95% 1 50.00%
Total 39 100.00% 2 100.00%



static int bgpio_setup_accessors(struct device *dev,
				 struct gpio_chip *gc,
				 bool bit_be,
				 bool byte_be)
{

	switch (gc->bgpio_bits) {
	case 8:
		gc->read_reg	= bgpio_read8;
		gc->write_reg	= bgpio_write8;
		break;
	case 16:
		if (byte_be) {
			gc->read_reg	= bgpio_read16be;
			gc->write_reg	= bgpio_write16be;
		} else {
			gc->read_reg	= bgpio_read16;
			gc->write_reg	= bgpio_write16;
		}
		break;
	case 32:
		if (byte_be) {
			gc->read_reg	= bgpio_read32be;
			gc->write_reg	= bgpio_write32be;
		} else {
			gc->read_reg	= bgpio_read32;
			gc->write_reg	= bgpio_write32;
		}
		break;
#if BITS_PER_LONG >= 64
	case 64:
		if (byte_be) {
			dev_err(dev,
				"64 bit big endian byte order unsupported\n");
			return -EINVAL;
		} else {
			gc->read_reg	= bgpio_read64;
			gc->write_reg	= bgpio_write64;
		}
		break;
#endif /* BITS_PER_LONG >= 64 */
	default:
		dev_err(dev, "unsupported data width %u bits\n", gc->bgpio_bits);
		return -EINVAL;
	}

	gc->pin2mask = bit_be ? bgpio_pin2mask_be : bgpio_pin2mask;

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Jamie Iles 111 57.51% 3 60.00%
Andreas Larsson 63 32.64% 1 20.00%
Linus Walleij 19 9.84% 1 20.00%
Total 193 100.00% 5 100.00%

/*
 * Create the device and allocate the resources.  For setting GPIO's there are
 * three supported configurations:
 *
 *      - single input/output register resource (named "dat").
 *      - set/clear pair (named "set" and "clr").
 *      - single output register resource and single input resource ("set" and
 *      dat").
 *
 * 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.
 *
 * 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.
 */


static int bgpio_setup_io(struct gpio_chip *gc,
			  void __iomem *dat,
			  void __iomem *set,
			  void __iomem *clr,
			  unsigned long flags)
{

	gc->reg_dat = dat;
	if (!gc->reg_dat)
		return -EINVAL;

	if (set && clr) {
		gc->reg_set = set;
		gc->reg_clr = clr;
		gc->set = bgpio_set_with_clear;
		gc->set_multiple = bgpio_set_multiple_with_clear;
	} else if (set && !clr) {
		gc->reg_set = set;
		gc->set = bgpio_set_set;
		gc->set_multiple = bgpio_set_multiple_set;
	} else if (flags & BGPIOF_NO_OUTPUT) {
		gc->set = bgpio_set_none;
		gc->set_multiple = NULL;
	} else {
		gc->set = bgpio_set;
		gc->set_multiple = bgpio_set_multiple;
	}

	if (!(flags & BGPIOF_UNREADABLE_REG_SET) &&
	    (flags & BGPIOF_READ_OUTPUT_REG_SET))
		gc->get = bgpio_get_set;
	else
		gc->get = bgpio_get;

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Jamie Iles 68 39.08% 4 44.44%
Anton Vorontsov 30 17.24% 1 11.11%
Vladimir Zapolskiy 25 14.37% 1 11.11%
Rabin Vincent 19 10.92% 1 11.11%
Linus Walleij 17 9.77% 1 11.11%
Rojhalat Ibrahim 15 8.62% 1 11.11%
Total 174 100.00% 9 100.00%



static int bgpio_setup_direction(struct gpio_chip *gc,
				 void __iomem *dirout,
				 void __iomem *dirin,
				 unsigned long flags)
{
	if (dirout && dirin) {
		return -EINVAL;
	} else if (dirout) {
		gc->reg_dir = dirout;
		gc->direction_output = bgpio_dir_out;
		gc->direction_input = bgpio_dir_in;
		gc->get_direction = bgpio_get_dir;
	} else if (dirin) {
		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;
	} else {
		if (flags & BGPIOF_NO_OUTPUT)
			gc->direction_output = bgpio_dir_out_err;
		else
			gc->direction_output = bgpio_simple_dir_out;
		gc->direction_input = bgpio_simple_dir_in;
	}

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
Jamie Iles 91 70.00% 2 40.00%
Rabin Vincent 16 12.31% 1 20.00%
Linus Walleij 13 10.00% 1 20.00%
Philipp Zabel 10 7.69% 1 20.00%
Total 130 100.00% 5 100.00%



static int bgpio_request(struct gpio_chip *chip, unsigned gpio_pin)
{
	if (gpio_pin < chip->ngpio)
		return 0;

	return -EINVAL;
}

Contributors
Person Tokens Prop Commits CommitProp
Anthony Fee 29 100.00% 1 100.00%
Total 29 100.00% 1 100.00%



int bgpio_init(struct gpio_chip *gc, struct device *dev,
	       unsigned long sz, void __iomem *dat, void __iomem *set,
	       void __iomem *clr, void __iomem *dirout, void __iomem *dirin,
	       unsigned long flags)
{
	int ret;

	if (!is_power_of_2(sz))
		return -EINVAL;

	gc->bgpio_bits = sz * 8;
	if (gc->bgpio_bits > BITS_PER_LONG)
		return -EINVAL;

	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;

	ret = bgpio_setup_io(gc, dat, set, clr, flags);
	if (ret)
		return ret;

	ret = bgpio_setup_accessors(dev, gc, flags & BGPIOF_BIG_ENDIAN,
				    flags & BGPIOF_BIG_ENDIAN_BYTE_ORDER);
	if (ret)
		return ret;

	ret = bgpio_setup_direction(gc, dirout, dirin, flags);
	if (ret)
		return ret;

	gc->bgpio_data = gc->read_reg(gc->reg_dat);
	if (gc->set == bgpio_set_set &&
			!(flags & BGPIOF_UNREADABLE_REG_SET))
		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);

	return ret;
}
Contributors
Person Tokens Prop Commits CommitProp
Jamie Iles 167 63.50% 1 12.50%
Shawn Guo 50 19.01% 1 12.50%
Linus Walleij 33 12.55% 2 25.00%
Anthony Fee 5 1.90% 1 12.50%
Andreas Larsson 4 1.52% 1 12.50%
Vladimir Zapolskiy 2 0.76% 1 12.50%
Rabin Vincent 2 0.76% 1 12.50%
Total 263 100.00% 8 100.00%


EXPORT_SYMBOL_GPL(bgpio_init);

#if IS_ENABLED(CONFIG_GPIO_GENERIC_PLATFORM)



static void __iomem *bgpio_map(struct platform_device *pdev,
			       const char *name,
			       resource_size_t sane_sz)
{
	struct resource *r;
	resource_size_t sz;

	r = platform_get_resource_byname(pdev, IORESOURCE_MEM, name);
	if (!r)
		return NULL;

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

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

Contributors
Person Tokens Prop Commits CommitProp
Jamie Iles 67 84.81% 1 25.00%
Heiner Kallweit 11 13.92% 2 50.00%
Guenter Roeck 1 1.27% 1 25.00%
Total 79 100.00% 4 100.00%

#ifdef CONFIG_OF

static const struct of_device_id bgpio_of_match[] = {
	{ .compatible = "brcm,bcm6345-gpio" },
	{ .compatible = "wd,mbl-gpio" },
	{ .compatible = "ni,169445-nand-gpio" },
	{ }
};
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;

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

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

	return pdata;
}
Contributors
Person Tokens Prop Commits CommitProp
Álvaro Fernández Rojas 79 69.91% 1 33.33%
Christian Lamparter 34 30.09% 2 66.67%
Total 113 100.00% 3 100.00%

#else


static struct bgpio_pdata *bgpio_parse_dt(struct platform_device *pdev,
					  unsigned long *flags)
{
	return NULL;
}
Contributors
Person Tokens Prop Commits CommitProp
Álvaro Fernández Rojas 21 100.00% 1 100.00%
Total 21 100.00% 1 100.00%

#endif /* CONFIG_OF */



static int bgpio_pdev_probe(struct platform_device *pdev)
{
	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;
	unsigned long flags = 0;
	int err;
	struct gpio_chip *gc;
	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;
	}

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

	sz = resource_size(r);

	dat = bgpio_map(pdev, "dat", sz);
	if (IS_ERR(dat))
		return PTR_ERR(dat);

	set = bgpio_map(pdev, "set", sz);
	if (IS_ERR(set))
		return PTR_ERR(set);

	clr = bgpio_map(pdev, "clr", sz);
	if (IS_ERR(clr))
		return PTR_ERR(clr);

	dirout = bgpio_map(pdev, "dirout", sz);
	if (IS_ERR(dirout))
		return PTR_ERR(dirout);

	dirin = bgpio_map(pdev, "dirin", sz);
	if (IS_ERR(dirin))
		return PTR_ERR(dirin);

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

	err = bgpio_init(gc, dev, sz, dat, set, clr, dirout, dirin, flags);
	if (err)
		return err;

	if (pdata) {
		if (pdata->label)
			gc->label = pdata->label;
		gc->base = pdata->base;
		if (pdata->ngpio > 0)
			gc->ngpio = pdata->ngpio;
	}

	platform_set_drvdata(pdev, gc);

	return devm_gpiochip_add_data(&pdev->dev, gc, NULL);
}

Contributors
Person Tokens Prop Commits CommitProp
Jamie Iles 241 62.27% 6 46.15%
Álvaro Fernández Rojas 43 11.11% 1 7.69%
Heiner Kallweit 40 10.34% 1 7.69%
Anton Vorontsov 27 6.98% 1 7.69%
Pawel Moll 13 3.36% 1 7.69%
Linus Walleij 12 3.10% 1 7.69%
Laxman Dewangan 6 1.55% 1 7.69%
Shawn Guo 5 1.29% 1 7.69%
Total 387 100.00% 13 100.00%


static const struct platform_device_id bgpio_id_table[] = {
	{
		.name		= "basic-mmio-gpio",
		.driver_data	= 0,
        }, {
		.name		= "basic-mmio-gpio-be",
		.driver_data	= BGPIOF_BIG_ENDIAN,
        },
	{ }
};
MODULE_DEVICE_TABLE(platform, bgpio_id_table);


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


module_platform_driver(bgpio_driver);

#endif /* CONFIG_GPIO_GENERIC_PLATFORM */

MODULE_DESCRIPTION("Driver for basic memory-mapped GPIO controllers");
MODULE_AUTHOR("Anton Vorontsov <cbouatmailru@gmail.com>");
MODULE_LICENSE("GPL");
Overall Contributors
Person Tokens Prop Commits CommitProp
Jamie Iles 1276 41.73% 9 25.71%
Anton Vorontsov 385 12.59% 1 2.86%
Rojhalat Ibrahim 333 10.89% 1 2.86%
Linus Walleij 260 8.50% 5 14.29%
Álvaro Fernández Rojas 183 5.98% 1 2.86%
Andreas Larsson 147 4.81% 1 2.86%
Vladimir Zapolskiy 80 2.62% 1 2.86%
Rabin Vincent 76 2.49% 1 2.86%
Philipp Zabel 74 2.42% 1 2.86%
Shawn Guo 55 1.80% 1 2.86%
Christian Lamparter 53 1.73% 3 8.57%
Heiner Kallweit 51 1.67% 2 5.71%
Anthony Fee 34 1.11% 1 2.86%
Alexander Shiyan 20 0.65% 1 2.86%
Pawel Moll 13 0.43% 1 2.86%
Nathan Sullivan 7 0.23% 1 2.86%
Laxman Dewangan 6 0.20% 1 2.86%
Grant C. Likely 3 0.10% 1 2.86%
Mark Brown 1 0.03% 1 2.86%
Guenter Roeck 1 0.03% 1 2.86%
Total 3058 100.00% 35 100.00%
Directory: drivers/gpio

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
Created with cregit.
Person	Tokens	Prop	Commits	CommitProp
Jamie Iles	22	100.00%	2	100.00%
Total	22	100.00%	2	100.00%
cregit-Linux how code gets into the kernel

Release 4.14 drivers/gpio/gpio-mmio.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
