target/linux/realtek/files-5.10/drivers/gpio/gpio-rtl8231.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2
   3 #include <linux/gpio/driver.h>
   4 #include <linux/module.h>
   5 #include <linux/platform_device.h>
   6 #include <linux/delay.h>
   7 #include <asm/mach-rtl838x/mach-rtl83xx.h>
   8
   9 /* RTL8231 registers for LED control */
  10 #define RTL8231_LED_FUNC0                       0x0000
  11 #define RTL8231_GPIO_PIN_SEL(gpio)              ((0x0002) + ((gpio) >> 4))
  12 #define RTL8231_GPIO_DIR(gpio)                  ((0x0005) + ((gpio) >> 4))
  13 #define RTL8231_GPIO_DATA(gpio)                 ((0x001C) + ((gpio) >> 4))
  14
  15 #define USEC_TIMEOUT 5000
  16
  17 #define RTL8231_SMI_BUS_ID_MAX                  0x1F
  18
  19 struct rtl8231_gpios {
  20         struct gpio_chip gc;
  21         struct device *dev;
  22         u32 id;
  23         u32 smi_bus_id;
  24         u16 reg_shadow[0x20];
  25         u32 reg_cached;
  26         int ext_gpio_indrt_access;
  27 };
  28
  29 extern struct mutex smi_lock;
  30 extern struct rtl83xx_soc_info soc_info;
  31
  32 static u32 rtl8231_read(struct rtl8231_gpios *gpios, u32 reg)
  33 {
  34         u32 t = 0, n = 0;
  35
  36         reg &= 0x1f;
  37
  38         /* Calculate read register address */
  39         t = (gpios->smi_bus_id << 2) | (reg << 7);
  40
  41         /* Set execution bit: cleared when operation completed */
  42         t |= 1;
  43
  44         // Start execution
  45         sw_w32(t, gpios->ext_gpio_indrt_access);
  46         do {
  47                 udelay(1);
  48                 t = sw_r32(gpios->ext_gpio_indrt_access);
  49                 n++;
  50         } while ((t & 1) && (n < USEC_TIMEOUT));
  51
  52         if (n >= USEC_TIMEOUT)
  53                 return 0x80000000;
  54
  55         pr_debug("%s: %x, %x, %x\n", __func__, gpios->smi_bus_id,
  56                 reg, (t & 0xffff0000) >> 16);
  57
  58         return (t & 0xffff0000) >> 16;
  59 }
  60
  61 static int rtl8231_write(struct rtl8231_gpios *gpios, u32 reg, u32 data)
  62 {
  63         u32 t = 0, n = 0;
  64
  65         pr_debug("%s: %x, %x, %x\n", __func__, gpios->smi_bus_id, reg, data);
  66         reg &= 0x1f;
  67
  68         t = (gpios->smi_bus_id << 2) | (reg << 7) | (data << 16);
  69         /* Set write bit */
  70         t |= 2;
  71
  72         /* Set execution bit: cleared when operation completed */
  73         t |= 1;
  74
  75         // Start execution
  76         sw_w32(t, gpios->ext_gpio_indrt_access);
  77         do {
  78                 udelay(1);
  79                 t = sw_r32(gpios->ext_gpio_indrt_access);
  80         } while ((t & 1) && (n < USEC_TIMEOUT));
  81
  82         if (n >= USEC_TIMEOUT)
  83                 return -1;
  84
  85         return 0;
  86 }
  87
  88 static u32 rtl8231_read_cached(struct rtl8231_gpios *gpios, u32 reg)
  89 {
  90         if (reg > 0x1f)
  91                 return 0;
  92
  93         if (gpios->reg_cached & (1 << reg))
  94                 return gpios->reg_shadow[reg];
  95
  96         return rtl8231_read(gpios, reg);
  97 }
  98
  99 /* Set Direction of the RTL8231 pin:
 100  * dir 1: input
 101  * dir 0: output
 102  */
 103 static int rtl8231_pin_dir(struct rtl8231_gpios *gpios, u32 gpio, u32 dir)
 104 {
 105         u32 v;
 106         int pin_sel_addr = RTL8231_GPIO_PIN_SEL(gpio);
 107         int pin_dir_addr = RTL8231_GPIO_DIR(gpio);
 108         int dpin = gpio % 16;
 109
 110         if (gpio > 31) {
 111                 pr_debug("WARNING: HIGH pin\n");
 112                 dpin += 5;
 113                 pin_dir_addr = pin_sel_addr;
 114         }
 115
 116         v = rtl8231_read_cached(gpios, pin_dir_addr);
 117         if (v & 0x80000000) {
 118                 pr_err("Error reading RTL8231\n");
 119                 return -1;
 120         }
 121
 122         v = (v & ~(1 << dpin)) | (dir << dpin);
 123         rtl8231_write(gpios, pin_dir_addr, v);
 124         gpios->reg_shadow[pin_dir_addr] = v;
 125         gpios->reg_cached |= 1 << pin_dir_addr;
 126         return 0;
 127 }
 128
 129 static int rtl8231_pin_dir_get(struct rtl8231_gpios *gpios, u32 gpio, u32 *dir)
 130 {
 131         /* dir 1: input
 132          * dir 0: output
 133          */
 134
 135         u32  v;
 136         int pin_dir_addr = RTL8231_GPIO_DIR(gpio);
 137         int pin = gpio % 16;
 138
 139         if (gpio > 31) {
 140                 pin_dir_addr = RTL8231_GPIO_PIN_SEL(gpio);
 141                 pin += 5;
 142         }
 143
 144         v = rtl8231_read(gpios, pin_dir_addr);
 145         if (v & (1 << pin))
 146                 *dir = 1;
 147         else
 148                 *dir = 0;
 149         return 0;
 150 }
 151
 152 static int rtl8231_pin_set(struct rtl8231_gpios *gpios, u32 gpio, u32 data)
 153 {
 154         u32 v = rtl8231_read(gpios, RTL8231_GPIO_DATA(gpio));
 155
 156         pr_debug("%s: %d to %d\n", __func__, gpio, data);
 157         if (v & 0x80000000) {
 158                 pr_err("Error reading RTL8231\n");
 159                 return -1;
 160         }
 161         v = (v & ~(1 << (gpio % 16))) | (data << (gpio % 16));
 162         rtl8231_write(gpios, RTL8231_GPIO_DATA(gpio), v);
 163         gpios->reg_shadow[RTL8231_GPIO_DATA(gpio)] = v;
 164         gpios->reg_cached |= 1 << RTL8231_GPIO_DATA(gpio);
 165         return 0;
 166 }
 167
 168 static int rtl8231_pin_get(struct rtl8231_gpios *gpios, u32 gpio, u16 *state)
 169 {
 170         u32 v = rtl8231_read(gpios, RTL8231_GPIO_DATA(gpio));
 171
 172         if (v & 0x80000000) {
 173                 pr_err("Error reading RTL8231\n");
 174                 return -1;
 175         }
 176
 177         *state = v & 0xffff;
 178         return 0;
 179 }
 180
 181 static int rtl8231_direction_input(struct gpio_chip *gc, unsigned int offset)
 182 {
 183         int err;
 184         struct rtl8231_gpios *gpios = gpiochip_get_data(gc);
 185
 186         pr_debug("%s: %d\n", __func__, offset);
 187         mutex_lock(&smi_lock);
 188         err = rtl8231_pin_dir(gpios, offset, 1);
 189         mutex_unlock(&smi_lock);
 190         return err;
 191 }
 192
 193 static int rtl8231_direction_output(struct gpio_chip *gc, unsigned int offset, int value)
 194 {
 195         int err;
 196         struct rtl8231_gpios *gpios = gpiochip_get_data(gc);
 197
 198         pr_debug("%s: %d\n", __func__, offset);
 199         mutex_lock(&smi_lock);
 200         err = rtl8231_pin_dir(gpios, offset, 0);
 201         mutex_unlock(&smi_lock);
 202         if (!err)
 203                 err = rtl8231_pin_set(gpios, offset, value);
 204         return err;
 205 }
 206
 207 static int rtl8231_get_direction(struct gpio_chip *gc, unsigned int offset)
 208 {
 209         u32 v = 0;
 210         struct rtl8231_gpios *gpios = gpiochip_get_data(gc);
 211
 212         pr_debug("%s: %d\n", __func__, offset);
 213         mutex_lock(&smi_lock);
 214         rtl8231_pin_dir_get(gpios, offset, &v);
 215         mutex_unlock(&smi_lock);
 216         return v;
 217 }
 218
 219 static int rtl8231_gpio_get(struct gpio_chip *gc, unsigned int offset)
 220 {
 221         u16 state = 0;
 222         struct rtl8231_gpios *gpios = gpiochip_get_data(gc);
 223
 224         mutex_lock(&smi_lock);
 225         rtl8231_pin_get(gpios, offset, &state);
 226         mutex_unlock(&smi_lock);
 227         if (state & (1 << (offset % 16)))
 228                 return 1;
 229         return 0;
 230 }
 231
 232 void rtl8231_gpio_set(struct gpio_chip *gc, unsigned int offset, int value)
 233 {
 234         struct rtl8231_gpios *gpios = gpiochip_get_data(gc);
 235
 236         rtl8231_pin_set(gpios, offset, value);
 237 }
 238
 239 int rtl8231_init(struct rtl8231_gpios *gpios)
 240 {
 241         pr_info("%s called, MDIO bus ID: %d\n", __func__, gpios->smi_bus_id);
 242
 243         gpios->reg_cached = 0;
 244
 245         if (soc_info.family == RTL8390_FAMILY_ID) {
 246                 // RTL8390: Enable external gpio in global led control register
 247                 sw_w32_mask(0x7 << 18, 0x4 << 18, RTL839X_LED_GLB_CTRL);
 248         } else if (soc_info.family == RTL8380_FAMILY_ID) {
 249                 // RTL8380: Enable RTL8231 indirect access mode
 250                 sw_w32_mask(0, 1, RTL838X_EXTRA_GPIO_CTRL);
 251                 sw_w32_mask(3, 1, RTL838X_DMY_REG5);
 252         }
 253
 254         /* Select GPIO functionality and force input direction for pins 0-36 */
 255         rtl8231_write(gpios, RTL8231_GPIO_PIN_SEL(0), 0xffff);
 256         rtl8231_write(gpios, RTL8231_GPIO_DIR(0), 0xffff);
 257         rtl8231_write(gpios, RTL8231_GPIO_PIN_SEL(16), 0xffff);
 258         rtl8231_write(gpios, RTL8231_GPIO_DIR(16), 0xffff);
 259         rtl8231_write(gpios, RTL8231_GPIO_PIN_SEL(32), 0x03ff);
 260
 261         /* Set LED_Start to enable drivers for output mode */
 262         rtl8231_write(gpios, RTL8231_LED_FUNC0, 1 << 1);
 263
 264         return 0;
 265 }
 266
 267 static const struct of_device_id rtl8231_gpio_of_match[] = {
 268         { .compatible = "realtek,rtl8231-gpio" },
 269         {},
 270 };
 271
 272 MODULE_DEVICE_TABLE(of, rtl8231_gpio_of_match);
 273
 274 static int rtl8231_gpio_probe(struct platform_device *pdev)
 275 {
 276         struct device *dev = &pdev->dev;
 277         struct device_node *np = dev->of_node;
 278         struct rtl8231_gpios *gpios;
 279         int err;
 280
 281         pr_info("Probing RTL8231 GPIOs\n");
 282
 283         if (!np) {
 284                 dev_err(&pdev->dev, "No DT found\n");
 285                 return -EINVAL;
 286         }
 287
 288         gpios = devm_kzalloc(dev, sizeof(*gpios), GFP_KERNEL);
 289         if (!gpios)
 290                 return -ENOMEM;
 291
 292         gpios->id = soc_info.id;
 293         if (soc_info.family == RTL8380_FAMILY_ID) {
 294                 gpios->ext_gpio_indrt_access = RTL838X_EXT_GPIO_INDRT_ACCESS;
 295         }
 296
 297         if (soc_info.family == RTL8390_FAMILY_ID) {
 298                 gpios->ext_gpio_indrt_access = RTL839X_EXT_GPIO_INDRT_ACCESS;
 299         }
 300
 301         err = of_property_read_u32(np, "indirect-access-bus-id", &gpios->smi_bus_id);
 302         if (!err && gpios->smi_bus_id > RTL8231_SMI_BUS_ID_MAX)
 303                 err = -EINVAL;
 304
 305         if (err) {
 306                 dev_err(dev, "invalid or missing indirect-access-bus-id\n");
 307                 return err;
 308         }
 309
 310         rtl8231_init(gpios);
 311
 312         gpios->dev = dev;
 313         gpios->gc.base = -1;
 314         gpios->gc.ngpio = 37;
 315         gpios->gc.label = "rtl8231";
 316         gpios->gc.parent = dev;
 317         gpios->gc.owner = THIS_MODULE;
 318         gpios->gc.can_sleep = true;
 319
 320         gpios->gc.direction_input = rtl8231_direction_input;
 321         gpios->gc.direction_output = rtl8231_direction_output;
 322         gpios->gc.set = rtl8231_gpio_set;
 323         gpios->gc.get = rtl8231_gpio_get;
 324         gpios->gc.get_direction = rtl8231_get_direction;
 325
 326         err = devm_gpiochip_add_data(dev, &gpios->gc, gpios);
 327         return err;
 328 }
 329
 330 static struct platform_driver rtl8231_gpio_driver = {
 331         .driver = {
 332                 .name = "rtl8231-gpio",
 333                 .of_match_table = rtl8231_gpio_of_match,
 334         },
 335         .probe = rtl8231_gpio_probe,
 336 };
 337
 338 module_platform_driver(rtl8231_gpio_driver);
 339
 340 MODULE_DESCRIPTION("Realtek RTL8231 GPIO expansion chip support");
 341 MODULE_LICENSE("GPL v2");