system/linux
system/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux synced 2024-09-28 07:20:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

basic_mmio_gpio: detect output method at probe time

Browse source 
Rather than detecting the output method each time in the .set()
callback, do it at probe time and set the appropriate callback.

Changes since v2: moved the reg_dat initialization into
bgpio_setup_io().

Signed-off-by: Jamie Iles <jamie@jamieiles.com>
Acked-by: Anton Vorontsov <cbouatmailru@gmail.com>
Signed-off-by: Grant Likely <grant.likely@secretlab.ca>
This commit is contained in:
Jamie Iles 2011-05-20 00:40:16 -06:00 committed by Grant Likely
parent 364b5e8718
commit e027d6f9d5
1 changed files with 59 additions and 31 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

90
drivers/gpio/basic_mmio_gpio.c
View file

@ -161,14 +161,6 @@ static void bgpio_set(struct gpio_chip *gc, unsigned int gpio, int val)
unsigned long mask = bgc->pin2mask(bgc, gpio);
unsigned long flags;
if (bgc->reg_set) {
if (val)
bgc->write_reg(bgc->reg_set, mask);
else
bgc->write_reg(bgc->reg_clr, mask);
return;
}
spin_lock_irqsave(&bgc->lock, flags);
if (val)
@ -181,6 +173,18 @@ static void bgpio_set(struct gpio_chip *gc, unsigned int gpio, int val)
spin_unlock_irqrestore(&bgc->lock, flags);
}
static void bgpio_set_with_clear(struct gpio_chip *gc, unsigned int gpio,
int val)
{
struct bgpio_chip *bgc = to_bgpio_chip(gc);
unsigned long mask = bgc->pin2mask(bgc, gpio);
if (val)
bgc->write_reg(bgc->reg_set, mask);
else
bgc->write_reg(bgc->reg_clr, mask);
}
static int bgpio_dir_in(struct gpio_chip *gc, unsigned int gpio)
{
return 0;
@ -188,7 +192,8 @@ static int bgpio_dir_in(struct gpio_chip *gc, unsigned int gpio)
static int bgpio_dir_out(struct gpio_chip *gc, unsigned int gpio, int val)
{
bgpio_set(gc, gpio, val);
gc->set(gc, gpio, val);
return 0;
}
@ -238,18 +243,25 @@ static int bgpio_setup_accessors(struct platform_device *pdev,
return 0;
}
static int __devinit bgpio_probe(struct platform_device *pdev)
/*
* Create the device and allocate the resources. For setting GPIO's there are
* two supported configurations:
*
* - single output register resource (named "dat").
* - set/clear pair (named "set" and "clr").
*
* 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.
*/
static int bgpio_setup_io(struct platform_device *pdev,
struct bgpio_chip *bgc)
{
struct device *dev = &pdev->dev;
struct bgpio_pdata *pdata = dev_get_platdata(dev);
struct bgpio_chip *bgc;
struct resource *res_dat;
struct resource *res_set;
struct resource *res_clr;
struct resource *res_dat;
resource_size_t dat_sz;
int bits;
int ret;
int ngpio;
res_dat = platform_get_resource_byname(pdev, IORESOURCE_MEM, "dat");
if (!res_dat)
@ -259,16 +271,11 @@ static int __devinit bgpio_probe(struct platform_device *pdev)
if (!is_power_of_2(dat_sz))
return -EINVAL;
bits = dat_sz * 8;
ngpio = bits;
if (bits > BITS_PER_LONG)
bgc->bits = dat_sz * 8;
if (bgc->bits > BITS_PER_LONG)
return -EINVAL;
bgc = devm_kzalloc(dev, sizeof(*bgc), GFP_KERNEL);
if (!bgc)
return -ENOMEM;
bgc->reg_dat = bgpio_request_and_map(dev, res_dat);
bgc->reg_dat = bgpio_request_and_map(&pdev->dev, res_dat);
if (!bgc->reg_dat)
return -ENOMEM;
@ -276,19 +283,41 @@ static int __devinit bgpio_probe(struct platform_device *pdev)
res_clr = platform_get_resource_byname(pdev, IORESOURCE_MEM, "clr");
if (res_set && res_clr) {
if (resource_size(res_set) != resource_size(res_clr) ||
resource_size(res_set) != dat_sz)
resource_size(res_set) != resource_size(res_dat))
return -EINVAL;
bgc->reg_set = bgpio_request_and_map(dev, res_set);
bgc->reg_clr = bgpio_request_and_map(dev, res_clr);
bgc->reg_set = bgpio_request_and_map(&pdev->dev, res_set);
bgc->reg_clr = bgpio_request_and_map(&pdev->dev, res_clr);
if (!bgc->reg_set || !bgc->reg_clr)
return -ENOMEM;
bgc->gc.set = bgpio_set_with_clear;
} else if (res_set || res_clr) {
return -EINVAL;
} else {
bgc->gc.set = bgpio_set;
}
spin_lock_init(&bgc->lock);
return 0;
}
static int __devinit bgpio_probe(struct platform_device *pdev)
{
struct device *dev = &pdev->dev;
struct bgpio_pdata *pdata = dev_get_platdata(dev);
struct bgpio_chip *bgc;
int ret;
int ngpio;
bgc = devm_kzalloc(dev, sizeof(*bgc), GFP_KERNEL);
if (!bgc)
return -ENOMEM;
ret = bgpio_setup_io(pdev, bgc);
if (ret)
return ret;
ngpio = bgc->bits;
if (pdata) {
bgc->gc.base = pdata->base;
if (pdata->ngpio > 0)
@ -297,18 +326,17 @@ static int __devinit bgpio_probe(struct platform_device *pdev)
bgc->gc.base = -1;
}
bgc->bits = bits;
ret = bgpio_setup_accessors(pdev, bgc);
if (ret)
return ret;
spin_lock_init(&bgc->lock);
bgc->data = bgc->read_reg(bgc->reg_dat);
bgc->gc.ngpio = ngpio;
bgc->gc.direction_input = bgpio_dir_in;
bgc->gc.direction_output = bgpio_dir_out;
bgc->gc.get = bgpio_get;
bgc->gc.set = bgpio_set;
bgc->gc.dev = dev;
bgc->gc.label = dev_name(dev);