1 /* 2 * (C) Copyright 2017 Rockchip Electronics Co., Ltd 3 * 4 * SPDX-License-Identifier: GPL-2.0+ 5 */ 6 7 #include <asm/io.h> 8 #include <irq-generic.h> 9 #include "irq-gpio.h" 10 #include "irq-gpio-switch.h" 11 12 typedef enum GPIOIntType { 13 GPIOLevelLow = 0, 14 GPIOLevelHigh, 15 GPIOEdgelFalling, 16 GPIOEdgelRising 17 } eGPIOIntType_t; 18 19 typedef enum eGPIOPinLevel { 20 GPIO_LOW = 0, 21 GPIO_HIGH 22 } eGPIOPinLevel_t; 23 24 typedef enum eGPIOPinDirection { 25 GPIO_IN = 0, 26 GPIO_OUT 27 } eGPIOPinDirection_t; 28 29 #define GPIO_SWPORT_DR 0x00 30 #define GPIO_SWPORT_DDR 0x04 31 #define GPIO_INTEN 0x30 32 #define GPIO_INTMASK 0x34 33 #define GPIO_INTTYPE_LEVEL 0x38 34 #define GPIO_INT_POLARITY 0x3c 35 #define GPIO_INT_STATUS 0x40 36 #define GPIO_INT_RAWSTATUS 0x44 37 #define GPIO_DEBOUNCE 0x48 38 #define GPIO_PORTS_EOI 0x4c 39 #define GPIO_EXT_PORT 0x50 40 #define GPIO_LS_SYNC 0x60 41 42 static inline unsigned pin_to_bit(unsigned pin) 43 { 44 return (1 << pin); 45 } 46 47 static inline unsigned offset_to_bit(unsigned offset) 48 { 49 return (1 << offset); 50 } 51 52 static void gpio_bit_op(void __iomem *regbase, unsigned int offset, 53 u32 bit, unsigned char flag) 54 { 55 u32 val = readl(regbase + offset); 56 57 if (flag) 58 val |= bit; 59 else 60 val &= ~bit; 61 62 writel(val, regbase + offset); 63 } 64 65 static int gpio_bit_rd(void __iomem *regbase, unsigned int offset, u32 bit) 66 { 67 return readl(regbase + offset) & bit ? 1 : 0; 68 } 69 70 static void gpio_irq_unmask(void __iomem *regbase, unsigned int bit) 71 { 72 gpio_bit_op(regbase, GPIO_INTEN, bit, 1); 73 } 74 75 static void gpio_irq_mask(void __iomem *regbase, unsigned int bit) 76 { 77 gpio_bit_op(regbase, GPIO_INTEN, bit, 0); 78 } 79 80 static void gpio_irq_ack(void __iomem *regbase, unsigned int bit) 81 { 82 gpio_bit_op(regbase, GPIO_PORTS_EOI, bit, 1); 83 } 84 85 static void generic_gpio_handle_irq(int irq, void *data __always_unused) 86 { 87 struct gpio_bank *bank = gpio_id_to_bank(irq - IRQ_GPIO0); 88 unsigned gpio_irq, pin, unmasked = 0; 89 u32 isr, ilr; 90 91 isr = readl(bank->regbase + GPIO_INT_STATUS); 92 ilr = readl(bank->regbase + GPIO_INTTYPE_LEVEL); 93 94 gpio_irq = bank->irq_base; 95 96 while (isr) { 97 pin = fls(isr) - 1; 98 99 /* first mask and ack irq */ 100 gpio_irq_mask(bank->regbase, offset_to_bit(pin)); 101 gpio_irq_ack(bank->regbase, offset_to_bit(pin)); 102 103 /* 104 * if gpio is edge triggered, clear condition before executing 105 * the handler so that we don't miss edges 106 */ 107 if (ilr & (1 << pin)) { 108 unmasked = 1; 109 gpio_irq_unmask(bank->regbase, offset_to_bit(pin)); 110 } 111 112 _generic_gpio_handle_irq(gpio_irq + pin); 113 114 isr &= ~(1 << pin); 115 116 if (!unmasked) 117 gpio_irq_unmask(bank->regbase, offset_to_bit(pin)); 118 } 119 } 120 121 static void gpio_set_intr_type(void __iomem *regbase, 122 unsigned int bit, 123 eGPIOIntType_t type) 124 { 125 switch (type) { 126 case GPIOLevelLow: 127 gpio_bit_op(regbase, GPIO_INT_POLARITY, bit, 0); 128 gpio_bit_op(regbase, GPIO_INTTYPE_LEVEL, bit, 0); 129 break; 130 case GPIOLevelHigh: 131 gpio_bit_op(regbase, GPIO_INTTYPE_LEVEL, bit, 0); 132 gpio_bit_op(regbase, GPIO_INT_POLARITY, bit, 1); 133 break; 134 case GPIOEdgelFalling: 135 gpio_bit_op(regbase, GPIO_INTTYPE_LEVEL, bit, 1); 136 gpio_bit_op(regbase, GPIO_INT_POLARITY, bit, 0); 137 break; 138 case GPIOEdgelRising: 139 gpio_bit_op(regbase, GPIO_INTTYPE_LEVEL, bit, 1); 140 gpio_bit_op(regbase, GPIO_INT_POLARITY, bit, 1); 141 break; 142 } 143 } 144 145 static int gpio_get_intr_type(void __iomem *regbase, 146 unsigned int bit) 147 { 148 u32 polarity, level, magic = 0; 149 int type; 150 151 polarity = gpio_bit_rd(regbase, GPIO_INT_POLARITY, bit); 152 level = gpio_bit_rd(regbase, GPIO_INTTYPE_LEVEL, bit); 153 magic = (polarity << 1) | (level << 0); 154 155 switch (magic) { 156 case 0x00: 157 type = GPIOLevelLow; 158 break; 159 case 0x02: 160 type = GPIOLevelHigh; 161 break; 162 case 0x01: 163 type = GPIOEdgelFalling; 164 break; 165 case 0x03: 166 type = GPIOEdgelRising; 167 break; 168 } 169 170 return type; 171 } 172 173 static int gpio_irq_set_type(int gpio_irq, unsigned int type) 174 { 175 int gpio = irq_to_gpio(gpio_irq); 176 struct gpio_bank *bank = gpio_to_bank(gpio); 177 eGPIOIntType_t int_type = 0; 178 179 if (!bank) 180 return -EINVAL; 181 182 gpio &= GPIO_PIN_MASK; 183 if (gpio >= bank->ngpio) 184 return -EINVAL; 185 186 switch (type) { 187 case IRQ_TYPE_EDGE_RISING: 188 int_type = GPIOEdgelRising; 189 break; 190 case IRQ_TYPE_EDGE_FALLING: 191 int_type = GPIOEdgelFalling; 192 break; 193 case IRQ_TYPE_LEVEL_HIGH: 194 int_type = GPIOLevelHigh; 195 break; 196 case IRQ_TYPE_LEVEL_LOW: 197 int_type = GPIOLevelLow; 198 break; 199 default: 200 return -EINVAL; 201 } 202 203 /* Before set interrupt type, gpio must set input */ 204 gpio_bit_op(bank->regbase, GPIO_SWPORT_DDR, 205 offset_to_bit(gpio), GPIO_IN); 206 gpio_set_intr_type(bank->regbase, offset_to_bit(gpio), int_type); 207 208 return 0; 209 } 210 211 static int gpio_irq_revert_type(int gpio_irq) 212 { 213 int gpio = irq_to_gpio(gpio_irq); 214 struct gpio_bank *bank = gpio_to_bank(gpio); 215 eGPIOIntType_t int_type = 0; 216 int type; 217 218 if (!bank) 219 return -EINVAL; 220 221 gpio &= GPIO_PIN_MASK; 222 if (gpio >= bank->ngpio) 223 return -EINVAL; 224 225 type = gpio_get_intr_type(bank->regbase, offset_to_bit(gpio)); 226 switch (type) { 227 case GPIOEdgelFalling: 228 int_type = GPIOEdgelRising; 229 break; 230 case GPIOEdgelRising: 231 int_type = GPIOEdgelFalling; 232 break; 233 case GPIOLevelHigh: 234 int_type = GPIOLevelLow; 235 break; 236 case GPIOLevelLow: 237 int_type = GPIOLevelHigh; 238 break; 239 default: 240 return -EINVAL; 241 } 242 243 gpio_set_intr_type(bank->regbase, offset_to_bit(gpio), int_type); 244 245 return 0; 246 } 247 248 static int gpio_irq_get_gpio_level(int gpio_irq) 249 { 250 int gpio = irq_to_gpio(gpio_irq); 251 struct gpio_bank *bank = gpio_to_bank(gpio); 252 253 if (!bank) 254 return -EINVAL; 255 256 gpio &= GPIO_PIN_MASK; 257 if (gpio >= bank->ngpio) 258 return -EINVAL; 259 260 return gpio_bit_rd(bank->regbase, GPIO_EXT_PORT, offset_to_bit(gpio)); 261 } 262 263 static int gpio_irq_enable(int gpio_irq) 264 { 265 int gpio = irq_to_gpio(gpio_irq); 266 struct gpio_bank *bank = gpio_to_bank(gpio); 267 268 if (!bank) 269 return -EINVAL; 270 271 gpio &= GPIO_PIN_MASK; 272 if (gpio >= bank->ngpio) 273 return -EINVAL; 274 275 gpio_irq_unmask(bank->regbase, offset_to_bit(gpio)); 276 277 return 0; 278 } 279 280 static int gpio_irq_disable(int irq) 281 { 282 int gpio = irq_to_gpio(irq); 283 struct gpio_bank *bank = gpio_to_bank(gpio); 284 285 if (!bank) 286 return -EINVAL; 287 288 gpio &= GPIO_PIN_MASK; 289 if (gpio >= bank->ngpio) 290 return -EINVAL; 291 292 gpio_irq_mask(bank->regbase, offset_to_bit(gpio)); 293 294 return 0; 295 } 296 297 static int gpio_irq_init(void) 298 { 299 struct gpio_bank *bank = NULL; 300 int i = 0; 301 302 for (i = 0; i < GPIO_BANK_NUM; i++) { 303 bank = gpio_id_to_bank(i); 304 if (bank) { 305 /* disable gpio pin interrupt */ 306 writel(0, bank->regbase + GPIO_INTEN); 307 308 /* register gpio group irq handler */ 309 irq_install_handler(IRQ_GPIO0 + bank->id, 310 (interrupt_handler_t *)generic_gpio_handle_irq, NULL); 311 312 /* default enable all gpio group interrupt */ 313 irq_handler_enable(IRQ_GPIO0 + bank->id); 314 } 315 } 316 317 return 0; 318 } 319 320 static struct irq_chip gpio_irq_chip = { 321 .name = "gpio-irq-chip", 322 .irq_init = gpio_irq_init, 323 .irq_enable = gpio_irq_enable, 324 .irq_disable = gpio_irq_disable, 325 .irq_set_type = gpio_irq_set_type, 326 .irq_revert_type = gpio_irq_revert_type, 327 .irq_get_gpio_level = gpio_irq_get_gpio_level, 328 }; 329 330 struct irq_chip *arch_gpio_irq_init(void) 331 { 332 return &gpio_irq_chip; 333 } 334