drivers/gpio/gpio-realtek-otto.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2
   3 #include <linux/gpio/driver.h>
   4 #include <linux/irq.h>
   5 #include <linux/minmax.h>
   6 #include <linux/mod_devicetable.h>
   7 #include <linux/module.h>
   8 #include <linux/platform_device.h>
   9 #include <linux/property.h>
  10
  11 /*
  12  * Total register block size is 0x1C for one bank of four ports (A, B, C, D).
  13  * An optional second bank, with ports E, F, G, and H, may be present, starting
  14  * at register offset 0x1C.
  15  */
  16
  17 /*
  18  * Pin select: (0) "normal", (1) "dedicate peripheral"
  19  * Not used on RTL8380/RTL8390, peripheral selection is managed by control bits
  20  * in the peripheral registers.
  21  */
  22 #define REALTEK_GPIO_REG_CNR            0x00
  23 /* Clear bit (0) for input, set bit (1) for output */
  24 #define REALTEK_GPIO_REG_DIR            0x08
  25 #define REALTEK_GPIO_REG_DATA           0x0C
  26 /* Read bit for IRQ status, write 1 to clear IRQ */
  27 #define REALTEK_GPIO_REG_ISR            0x10
  28 /* Two bits per GPIO in IMR registers */
  29 #define REALTEK_GPIO_REG_IMR            0x14
  30 #define REALTEK_GPIO_REG_IMR_AB         0x14
  31 #define REALTEK_GPIO_REG_IMR_CD         0x18
  32 #define REALTEK_GPIO_IMR_LINE_MASK      GENMASK(1, 0)
  33 #define REALTEK_GPIO_IRQ_EDGE_FALLING   1
  34 #define REALTEK_GPIO_IRQ_EDGE_RISING    2
  35 #define REALTEK_GPIO_IRQ_EDGE_BOTH      3
  36
  37 #define REALTEK_GPIO_MAX                32
  38 #define REALTEK_GPIO_PORTS_PER_BANK     4
  39
  40 /**
  41  * realtek_gpio_ctrl - Realtek Otto GPIO driver data
  42  *
  43  * @gc: Associated gpio_chip instance
  44  * @base: Base address of the register block for a GPIO bank
  45  * @lock: Lock for accessing the IRQ registers and values
  46  * @intr_mask: Mask for interrupts lines
  47  * @intr_type: Interrupt type selection
  48  *
  49  * Because the interrupt mask register (IMR) combines the function of IRQ type
  50  * selection and masking, two extra values are stored. @intr_mask is used to
  51  * mask/unmask the interrupts for a GPIO port, and @intr_type is used to store
  52  * the selected interrupt types. The logical AND of these values is written to
  53  * IMR on changes.
  54  */
  55 struct realtek_gpio_ctrl {
  56         struct gpio_chip gc;
  57         void __iomem *base;
  58         raw_spinlock_t lock;
  59         u16 intr_mask[REALTEK_GPIO_PORTS_PER_BANK];
  60         u16 intr_type[REALTEK_GPIO_PORTS_PER_BANK];
  61 };
  62
  63 /* Expand with more flags as devices with other quirks are added */
  64 enum realtek_gpio_flags {
  65         /*
  66          * Allow disabling interrupts, for cases where the port order is
  67          * unknown. This may result in a port mismatch between ISR and IMR.
  68          * An interrupt would appear to come from a different line than the
  69          * line the IRQ handler was assigned to, causing uncaught interrupts.
  70          */
  71         GPIO_INTERRUPTS_DISABLED = BIT(0),
  72 };
  73
  74 static struct realtek_gpio_ctrl *irq_data_to_ctrl(struct irq_data *data)
  75 {
  76         struct gpio_chip *gc = irq_data_get_irq_chip_data(data);
  77
  78         return container_of(gc, struct realtek_gpio_ctrl, gc);
  79 }
  80
  81 /*
  82  * Normal port order register access
  83  *
  84  * Port information is stored with the first port at offset 0, followed by the
  85  * second, etc. Most registers store one bit per GPIO and use a u8 value per
  86  * port. The two interrupt mask registers store two bits per GPIO, so use u16
  87  * values.
  88  */
  89 static void realtek_gpio_write_imr(struct realtek_gpio_ctrl *ctrl,
  90         unsigned int port, u16 irq_type, u16 irq_mask)
  91 {
  92         iowrite16(irq_type & irq_mask, ctrl->base + REALTEK_GPIO_REG_IMR + 2 * port);
  93 }
  94
  95 static void realtek_gpio_clear_isr(struct realtek_gpio_ctrl *ctrl,
  96         unsigned int port, u8 mask)
  97 {
  98         iowrite8(mask, ctrl->base + REALTEK_GPIO_REG_ISR + port);
  99 }
 100
 101 static u8 realtek_gpio_read_isr(struct realtek_gpio_ctrl *ctrl, unsigned int port)
 102 {
 103         return ioread8(ctrl->base + REALTEK_GPIO_REG_ISR + port);
 104 }
 105
 106 /* Set the rising and falling edge mask bits for a GPIO port pin */
 107 static u16 realtek_gpio_imr_bits(unsigned int pin, u16 value)
 108 {
 109         return (value & REALTEK_GPIO_IMR_LINE_MASK) << 2 * pin;
 110 }
 111
 112 static void realtek_gpio_irq_ack(struct irq_data *data)
 113 {
 114         struct realtek_gpio_ctrl *ctrl = irq_data_to_ctrl(data);
 115         irq_hw_number_t line = irqd_to_hwirq(data);
 116         unsigned int port = line / 8;
 117         unsigned int port_pin = line % 8;
 118
 119         realtek_gpio_clear_isr(ctrl, port, BIT(port_pin));
 120 }
 121
 122 static void realtek_gpio_irq_unmask(struct irq_data *data)
 123 {
 124         struct realtek_gpio_ctrl *ctrl = irq_data_to_ctrl(data);
 125         unsigned int line = irqd_to_hwirq(data);
 126         unsigned int port = line / 8;
 127         unsigned int port_pin = line % 8;
 128         unsigned long flags;
 129         u16 m;
 130
 131         raw_spin_lock_irqsave(&ctrl->lock, flags);
 132         m = ctrl->intr_mask[port];
 133         m |= realtek_gpio_imr_bits(port_pin, REALTEK_GPIO_IMR_LINE_MASK);
 134         ctrl->intr_mask[port] = m;
 135         realtek_gpio_write_imr(ctrl, port, ctrl->intr_type[port], m);
 136         raw_spin_unlock_irqrestore(&ctrl->lock, flags);
 137 }
 138
 139 static void realtek_gpio_irq_mask(struct irq_data *data)
 140 {
 141         struct realtek_gpio_ctrl *ctrl = irq_data_to_ctrl(data);
 142         unsigned int line = irqd_to_hwirq(data);
 143         unsigned int port = line / 8;
 144         unsigned int port_pin = line % 8;
 145         unsigned long flags;
 146         u16 m;
 147
 148         raw_spin_lock_irqsave(&ctrl->lock, flags);
 149         m = ctrl->intr_mask[port];
 150         m &= ~realtek_gpio_imr_bits(port_pin, REALTEK_GPIO_IMR_LINE_MASK);
 151         ctrl->intr_mask[port] = m;
 152         realtek_gpio_write_imr(ctrl, port, ctrl->intr_type[port], m);
 153         raw_spin_unlock_irqrestore(&ctrl->lock, flags);
 154 }
 155
 156 static int realtek_gpio_irq_set_type(struct irq_data *data, unsigned int flow_type)
 157 {
 158         struct realtek_gpio_ctrl *ctrl = irq_data_to_ctrl(data);
 159         unsigned int line = irqd_to_hwirq(data);
 160         unsigned int port = line / 8;
 161         unsigned int port_pin = line % 8;
 162         unsigned long flags;
 163         u16 type, t;
 164
 165         switch (flow_type & IRQ_TYPE_SENSE_MASK) {
 166         case IRQ_TYPE_EDGE_FALLING:
 167                 type = REALTEK_GPIO_IRQ_EDGE_FALLING;
 168                 break;
 169         case IRQ_TYPE_EDGE_RISING:
 170                 type = REALTEK_GPIO_IRQ_EDGE_RISING;
 171                 break;
 172         case IRQ_TYPE_EDGE_BOTH:
 173                 type = REALTEK_GPIO_IRQ_EDGE_BOTH;
 174                 break;
 175         default:
 176                 return -EINVAL;
 177         }
 178
 179         irq_set_handler_locked(data, handle_edge_irq);
 180
 181         raw_spin_lock_irqsave(&ctrl->lock, flags);
 182         t = ctrl->intr_type[port];
 183         t &= ~realtek_gpio_imr_bits(port_pin, REALTEK_GPIO_IMR_LINE_MASK);
 184         t |= realtek_gpio_imr_bits(port_pin, type);
 185         ctrl->intr_type[port] = t;
 186         realtek_gpio_write_imr(ctrl, port, t, ctrl->intr_mask[port]);
 187         raw_spin_unlock_irqrestore(&ctrl->lock, flags);
 188
 189         return 0;
 190 }
 191
 192 static void realtek_gpio_irq_handler(struct irq_desc *desc)
 193 {
 194         struct gpio_chip *gc = irq_desc_get_handler_data(desc);
 195         struct realtek_gpio_ctrl *ctrl = gpiochip_get_data(gc);
 196         struct irq_chip *irq_chip = irq_desc_get_chip(desc);
 197         unsigned int lines_done;
 198         unsigned int port_pin_count;
 199         unsigned long status;
 200         int offset;
 201
 202         chained_irq_enter(irq_chip, desc);
 203
 204         for (lines_done = 0; lines_done < gc->ngpio; lines_done += 8) {
 205                 status = realtek_gpio_read_isr(ctrl, lines_done / 8);
 206                 port_pin_count = min(gc->ngpio - lines_done, 8U);
 207                 for_each_set_bit(offset, &status, port_pin_count)
 208                         generic_handle_domain_irq(gc->irq.domain, offset);
 209         }
 210
 211         chained_irq_exit(irq_chip, desc);
 212 }
 213
 214 static int realtek_gpio_irq_init(struct gpio_chip *gc)
 215 {
 216         struct realtek_gpio_ctrl *ctrl = gpiochip_get_data(gc);
 217         unsigned int port;
 218
 219         for (port = 0; (port * 8) < gc->ngpio; port++) {
 220                 realtek_gpio_write_imr(ctrl, port, 0, 0);
 221                 realtek_gpio_clear_isr(ctrl, port, GENMASK(7, 0));
 222         }
 223
 224         return 0;
 225 }
 226
 227 static struct irq_chip realtek_gpio_irq_chip = {
 228         .name = "realtek-otto-gpio",
 229         .irq_ack = realtek_gpio_irq_ack,
 230         .irq_mask = realtek_gpio_irq_mask,
 231         .irq_unmask = realtek_gpio_irq_unmask,
 232         .irq_set_type = realtek_gpio_irq_set_type,
 233 };
 234
 235 static const struct of_device_id realtek_gpio_of_match[] = {
 236         {
 237                 .compatible = "realtek,otto-gpio",
 238                 .data = (void *)GPIO_INTERRUPTS_DISABLED,
 239         },
 240         {
 241                 .compatible = "realtek,rtl8380-gpio",
 242         },
 243         {
 244                 .compatible = "realtek,rtl8390-gpio",
 245         },
 246         {}
 247 };
 248 MODULE_DEVICE_TABLE(of, realtek_gpio_of_match);
 249
 250 static int realtek_gpio_probe(struct platform_device *pdev)
 251 {
 252         struct device *dev = &pdev->dev;
 253         unsigned int dev_flags;
 254         struct gpio_irq_chip *girq;
 255         struct realtek_gpio_ctrl *ctrl;
 256         u32 ngpios;
 257         int err, irq;
 258
 259         ctrl = devm_kzalloc(dev, sizeof(*ctrl), GFP_KERNEL);
 260         if (!ctrl)
 261                 return -ENOMEM;
 262
 263         dev_flags = (unsigned int) device_get_match_data(dev);
 264
 265         ngpios = REALTEK_GPIO_MAX;
 266         device_property_read_u32(dev, "ngpios", &ngpios);
 267
 268         if (ngpios > REALTEK_GPIO_MAX) {
 269                 dev_err(&pdev->dev, "invalid ngpios (max. %d)\n",
 270                         REALTEK_GPIO_MAX);
 271                 return -EINVAL;
 272         }
 273
 274         ctrl->base = devm_platform_ioremap_resource(pdev, 0);
 275         if (IS_ERR(ctrl->base))
 276                 return PTR_ERR(ctrl->base);
 277
 278         raw_spin_lock_init(&ctrl->lock);
 279
 280         err = bgpio_init(&ctrl->gc, dev, 4,
 281                 ctrl->base + REALTEK_GPIO_REG_DATA, NULL, NULL,
 282                 ctrl->base + REALTEK_GPIO_REG_DIR, NULL,
 283                 BGPIOF_BIG_ENDIAN_BYTE_ORDER);
 284         if (err) {
 285                 dev_err(dev, "unable to init generic GPIO");
 286                 return err;
 287         }
 288
 289         ctrl->gc.ngpio = ngpios;
 290         ctrl->gc.owner = THIS_MODULE;
 291
 292         irq = platform_get_irq_optional(pdev, 0);
 293         if (!(dev_flags & GPIO_INTERRUPTS_DISABLED) && irq > 0) {
 294                 girq = &ctrl->gc.irq;
 295                 girq->chip = &realtek_gpio_irq_chip;
 296                 girq->default_type = IRQ_TYPE_NONE;
 297                 girq->handler = handle_bad_irq;
 298                 girq->parent_handler = realtek_gpio_irq_handler;
 299                 girq->num_parents = 1;
 300                 girq->parents = devm_kcalloc(dev, girq->num_parents,
 301                                         sizeof(*girq->parents), GFP_KERNEL);
 302                 if (!girq->parents)
 303                         return -ENOMEM;
 304                 girq->parents[0] = irq;
 305                 girq->init_hw = realtek_gpio_irq_init;
 306         }
 307
 308         return devm_gpiochip_add_data(dev, &ctrl->gc, ctrl);
 309 }
 310
 311 static struct platform_driver realtek_gpio_driver = {
 312         .driver = {
 313                 .name = "realtek-otto-gpio",
 314                 .of_match_table = realtek_gpio_of_match,
 315         },
 316         .probe = realtek_gpio_probe,
 317 };
 318 module_platform_driver(realtek_gpio_driver);
 319
 320 MODULE_DESCRIPTION("Realtek Otto GPIO support");
 321 MODULE_AUTHOR("Sander Vanheule <sander@svanheule.net>");
 322 MODULE_LICENSE("GPL v2");