Merge tag 'rdma-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/roland...

[~andy/linux] / drivers / pinctrl / pinctrl-single.c

diff --git a/drivers/pinctrl/pinctrl-single.c b/drivers/pinctrl/pinctrl-single.c
index 726a729a2ec92d5d0ae5e45e94bd458305496219..79642831bba2ecc1524f0b884dde808170ca9e16 100644 (file)
--- a/drivers/pinctrl/pinctrl-single.c
+++ b/drivers/pinctrl/pinctrl-single.c
@@ -30,6 +30,7 @@
 #define PCS_MUX_BITS_NAME              "pinctrl-single,bits"
 #define PCS_REG_NAME_LEN               ((sizeof(unsigned long) * 2) + 1)
 #define PCS_OFF_DISABLED               ~0U
+#define PCS_MAX_GPIO_VALUES            2
 
 /**
  * struct pcs_pingroup - pingroups for a function
@@ -76,6 +77,16 @@ struct pcs_function {
        struct list_head node;
 };
 
+/**
+ * struct pcs_gpio_range - pinctrl gpio range
+ * @range:     subrange of the GPIO number space
+ * @gpio_func: gpio function value in the pinmux register
+ */
+struct pcs_gpio_range {
+       struct pinctrl_gpio_range range;
+       int gpio_func;
+};
+
 /**
  * struct pcs_data - wrapper for data needed by pinctrl framework
  * @pa:                pindesc array
@@ -244,15 +255,15 @@ static int pcs_get_group_pins(struct pinctrl_dev *pctldev,
 
 static void pcs_pin_dbg_show(struct pinctrl_dev *pctldev,
                                        struct seq_file *s,
-                                       unsigned offset)
+                                       unsigned pin)
 {
        struct pcs_device *pcs;
-       unsigned val;
+       unsigned val, mux_bytes;
 
        pcs = pinctrl_dev_get_drvdata(pctldev);
 
-       val = pcs->read(pcs->base + offset);
-       val &= pcs->fmask;
+       mux_bytes = pcs->width / BITS_PER_BYTE;
+       val = pcs->read(pcs->base + pin * mux_bytes);
 
        seq_printf(s, "%08x %s " , val, DRIVER_NAME);
 }
@@ -403,9 +414,26 @@ static void pcs_disable(struct pinctrl_dev *pctldev, unsigned fselector,
 }
 
 static int pcs_request_gpio(struct pinctrl_dev *pctldev,
-                       struct pinctrl_gpio_range *range, unsigned offset)
+                           struct pinctrl_gpio_range *range, unsigned pin)
 {
-       return -ENOTSUPP;
+       struct pcs_device *pcs = pinctrl_dev_get_drvdata(pctldev);
+       struct pcs_gpio_range *gpio = NULL;
+       int end, mux_bytes;
+       unsigned data;
+
+       gpio = container_of(range, struct pcs_gpio_range, range);
+       end = range->pin_base + range->npins - 1;
+       if (pin < range->pin_base || pin > end) {
+               dev_err(pctldev->dev,
+                       "pin %d isn't in the range of %d to %d\n",
+                       pin, range->pin_base, end);
+               return -EINVAL;
+       }
+       mux_bytes = pcs->width / BITS_PER_BYTE;
+       data = pcs->read(pcs->base + pin * mux_bytes) & ~pcs->fmask;
+       data |= gpio->gpio_func;
+       pcs->write(data, pcs->base + pin * mux_bytes);
+       return 0;
 }
 
 static struct pinmux_ops pcs_pinmux_ops = {
@@ -772,7 +800,7 @@ static int pcs_dt_node_to_map(struct pinctrl_dev *pctldev,
        pcs = pinctrl_dev_get_drvdata(pctldev);
 
        *map = devm_kzalloc(pcs->dev, sizeof(**map), GFP_KERNEL);
-       if (!map)
+       if (!*map)
                return -ENOMEM;
 
        *num_maps = 0;
@@ -879,6 +907,50 @@ static void pcs_free_resources(struct pcs_device *pcs)
 
 static struct of_device_id pcs_of_match[];
 
+static int __devinit pcs_add_gpio_range(struct device_node *node,
+                                       struct pcs_device *pcs)
+{
+       struct pcs_gpio_range *gpio;
+       struct device_node *child;
+       struct resource r;
+       const char name[] = "pinctrl-single";
+       u32 gpiores[PCS_MAX_GPIO_VALUES];
+       int ret, i = 0, mux_bytes = 0;
+
+       for_each_child_of_node(node, child) {
+               ret = of_address_to_resource(child, 0, &r);
+               if (ret < 0)
+                       continue;
+               memset(gpiores, 0, sizeof(u32) * PCS_MAX_GPIO_VALUES);
+               ret = of_property_read_u32_array(child, "pinctrl-single,gpio",
+                                                gpiores, PCS_MAX_GPIO_VALUES);
+               if (ret < 0)
+                       continue;
+               gpio = devm_kzalloc(pcs->dev, sizeof(*gpio), GFP_KERNEL);
+               if (!gpio) {
+                       dev_err(pcs->dev, "failed to allocate pcs gpio\n");
+                       return -ENOMEM;
+               }
+               gpio->range.name = devm_kzalloc(pcs->dev, sizeof(name),
+                                               GFP_KERNEL);
+               if (!gpio->range.name) {
+                       dev_err(pcs->dev, "failed to allocate range name\n");
+                       return -ENOMEM;
+               }
+               memcpy((char *)gpio->range.name, name, sizeof(name));
+
+               gpio->range.id = i++;
+               gpio->range.base = gpiores[0];
+               gpio->gpio_func = gpiores[1];
+               mux_bytes = pcs->width / BITS_PER_BYTE;
+               gpio->range.pin_base = (r.start - pcs->res->start) / mux_bytes;
+               gpio->range.npins = (r.end - r.start) / mux_bytes + 1;
+
+               pinctrl_add_gpio_range(pcs->pctl, &gpio->range);
+       }
+       return 0;
+}
+
 static int __devinit pcs_probe(struct platform_device *pdev)
 {
        struct device_node *np = pdev->dev.of_node;
@@ -975,6 +1047,10 @@ static int __devinit pcs_probe(struct platform_device *pdev)
                goto free;
        }
 
+       ret = pcs_add_gpio_range(np, pcs);
+       if (ret < 0)
+               goto free;
+
        dev_info(pcs->dev, "%i pins at pa %p size %u\n",
                 pcs->desc.npins, pcs->base, pcs->size);
 
@@ -986,7 +1062,7 @@ free:
        return ret;
 }
 
-static int __devexit pcs_remove(struct platform_device *pdev)
+static int pcs_remove(struct platform_device *pdev)
 {
        struct pcs_device *pcs = platform_get_drvdata(pdev);
 
@@ -998,7 +1074,7 @@ static int __devexit pcs_remove(struct platform_device *pdev)
        return 0;
 }
 
-static struct of_device_id pcs_of_match[] __devinitdata = {
+static struct of_device_id pcs_of_match[] = {
        { .compatible = DRIVER_NAME, },
        { },
 };
@@ -1006,7 +1082,7 @@ MODULE_DEVICE_TABLE(of, pcs_of_match);
 
 static struct platform_driver pcs_driver = {
        .probe          = pcs_probe,
-       .remove         = __devexit_p(pcs_remove),
+       .remove         = pcs_remove,
        .driver = {
                .owner          = THIS_MODULE,
                .name           = DRIVER_NAME,