drivers/gpio/rk_gpio.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2015 Google, Inc
   4  *
   5  * (C) Copyright 2008-2014 Rockchip Electronics
   6  * Peter, Software Engineering, <superpeter.cai@gmail.com>.
   7  */
   8
   9 #include <common.h>
  10 #include <dm.h>
  11 #include <syscon.h>
  12 #include <linux/errno.h>
  13 #include <asm/gpio.h>
  14 #include <asm/io.h>
  15 #include <asm/arch-rockchip/clock.h>
  16 #include <asm/arch-rockchip/gpio.h>
  17 #include <dm/pinctrl.h>
  18 #include <dt-bindings/clock/rk3288-cru.h>
  19
  20 enum {
  21         ROCKCHIP_GPIOS_PER_BANK         = 32,
  22 };
  23
  24 #define OFFSET_TO_BIT(bit)      (1UL << (bit))
  25
  26 struct rockchip_gpio_priv {
  27         struct rockchip_gpio_regs *regs;
  28         struct udevice *pinctrl;
  29         int bank;
  30         char name[2];
  31 };
  32
  33 static int rockchip_gpio_direction_input(struct udevice *dev, unsigned offset)
  34 {
  35         struct rockchip_gpio_priv *priv = dev_get_priv(dev);
  36         struct rockchip_gpio_regs *regs = priv->regs;
  37
  38         clrbits_le32(&regs->swport_ddr, OFFSET_TO_BIT(offset));
  39
  40         return 0;
  41 }
  42
  43 static int rockchip_gpio_direction_output(struct udevice *dev, unsigned offset,
  44                                           int value)
  45 {
  46         struct rockchip_gpio_priv *priv = dev_get_priv(dev);
  47         struct rockchip_gpio_regs *regs = priv->regs;
  48         int mask = OFFSET_TO_BIT(offset);
  49
  50         clrsetbits_le32(&regs->swport_dr, mask, value ? mask : 0);
  51         setbits_le32(&regs->swport_ddr, mask);
  52
  53         return 0;
  54 }
  55
  56 static int rockchip_gpio_get_value(struct udevice *dev, unsigned offset)
  57 {
  58         struct rockchip_gpio_priv *priv = dev_get_priv(dev);
  59         struct rockchip_gpio_regs *regs = priv->regs;
  60
  61         return readl(&regs->ext_port) & OFFSET_TO_BIT(offset) ? 1 : 0;
  62 }
  63
  64 static int rockchip_gpio_set_value(struct udevice *dev, unsigned offset,
  65                                    int value)
  66 {
  67         struct rockchip_gpio_priv *priv = dev_get_priv(dev);
  68         struct rockchip_gpio_regs *regs = priv->regs;
  69         int mask = OFFSET_TO_BIT(offset);
  70
  71         clrsetbits_le32(&regs->swport_dr, mask, value ? mask : 0);
  72
  73         return 0;
  74 }
  75
  76 static int rockchip_gpio_get_function(struct udevice *dev, unsigned offset)
  77 {
  78 #ifdef CONFIG_SPL_BUILD
  79         return -ENODATA;
  80 #else
  81         struct rockchip_gpio_priv *priv = dev_get_priv(dev);
  82         struct rockchip_gpio_regs *regs = priv->regs;
  83         bool is_output;
  84         int ret;
  85
  86         ret = pinctrl_get_gpio_mux(priv->pinctrl, priv->bank, offset);
  87         if (ret)
  88                 return ret;
  89         is_output = readl(&regs->swport_ddr) & OFFSET_TO_BIT(offset);
  90
  91         return is_output ? GPIOF_OUTPUT : GPIOF_INPUT;
  92 #endif
  93 }
  94
  95 /* Simple SPL interface to GPIOs */
  96 #ifdef CONFIG_SPL_BUILD
  97
  98 enum {
  99         PULL_NONE_1V8 = 0,
 100         PULL_DOWN_1V8 = 1,
 101         PULL_UP_1V8 = 3,
 102 };
 103
 104 int spl_gpio_set_pull(void *vregs, uint gpio, int pull)
 105 {
 106         u32 *regs = vregs;
 107         uint val;
 108
 109         regs += gpio >> GPIO_BANK_SHIFT;
 110         gpio &= GPIO_OFFSET_MASK;
 111         switch (pull) {
 112         case GPIO_PULL_UP:
 113                 val = PULL_UP_1V8;
 114                 break;
 115         case GPIO_PULL_DOWN:
 116                 val = PULL_DOWN_1V8;
 117                 break;
 118         case GPIO_PULL_NORMAL:
 119         default:
 120                 val = PULL_NONE_1V8;
 121                 break;
 122         }
 123         clrsetbits_le32(regs, 3 << (gpio * 2), val << (gpio * 2));
 124
 125         return 0;
 126 }
 127
 128 int spl_gpio_output(void *vregs, uint gpio, int value)
 129 {
 130         struct rockchip_gpio_regs * const regs = vregs;
 131
 132         clrsetbits_le32(&regs->swport_dr, 1 << gpio, value << gpio);
 133
 134         /* Set direction */
 135         clrsetbits_le32(&regs->swport_ddr, 1 << gpio, 1 << gpio);
 136
 137         return 0;
 138 }
 139 #endif /* CONFIG_SPL_BUILD */
 140
 141 static int rockchip_gpio_probe(struct udevice *dev)
 142 {
 143         struct gpio_dev_priv *uc_priv = dev_get_uclass_priv(dev);
 144         struct rockchip_gpio_priv *priv = dev_get_priv(dev);
 145         struct ofnode_phandle_args args;
 146         char *end;
 147         int ret;
 148
 149         priv->regs = dev_read_addr_ptr(dev);
 150         ret = uclass_first_device_err(UCLASS_PINCTRL, &priv->pinctrl);
 151         if (ret)
 152                 return ret;
 153
 154         /*
 155          * If "gpio-ranges" is present in the devicetree use it to parse
 156          * the GPIO bank ID, otherwise use the legacy method.
 157          */
 158         ret = ofnode_parse_phandle_with_args(dev_ofnode(dev),
 159                                              "gpio-ranges", NULL, 3,
 160                                              0, &args);
 161         if (!ret || ret != -ENOENT) {
 162                 uc_priv->gpio_count = args.args[2];
 163                 priv->bank = args.args[1] / ROCKCHIP_GPIOS_PER_BANK;
 164         } else {
 165                 uc_priv->gpio_count = ROCKCHIP_GPIOS_PER_BANK;
 166                 end = strrchr(dev->name, '@');
 167                 priv->bank = trailing_strtoln(dev->name, end);
 168         }
 169
 170         priv->name[0] = 'A' + priv->bank;
 171         uc_priv->bank_name = priv->name;
 172
 173         return 0;
 174 }
 175
 176 static const struct dm_gpio_ops gpio_rockchip_ops = {
 177         .direction_input        = rockchip_gpio_direction_input,
 178         .direction_output       = rockchip_gpio_direction_output,
 179         .get_value              = rockchip_gpio_get_value,
 180         .set_value              = rockchip_gpio_set_value,
 181         .get_function           = rockchip_gpio_get_function,
 182 };
 183
 184 static const struct udevice_id rockchip_gpio_ids[] = {
 185         { .compatible = "rockchip,gpio-bank" },
 186         { }
 187 };
 188
 189 U_BOOT_DRIVER(rockchip_gpio_bank) = {
 190         .name   = "rockchip_gpio_bank",
 191         .id     = UCLASS_GPIO,
 192         .of_match = rockchip_gpio_ids,
 193         .ops    = &gpio_rockchip_ops,
 194         .priv_auto      = sizeof(struct rockchip_gpio_priv),
 195         .probe  = rockchip_gpio_probe,
 196 };