1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Kontron PLD GPIO driver 4 * 5 * Copyright (c) 2010-2013 Kontron Europe GmbH 6 * Author: Michael Brunner <michael.brunner@kontron.com> 7 */ 8 9 #include <linux/init.h> 10 #include <linux/kernel.h> 11 #include <linux/module.h> 12 #include <linux/bitops.h> 13 #include <linux/errno.h> 14 #include <linux/interrupt.h> 15 #include <linux/platform_device.h> 16 #include <linux/gpio/driver.h> 17 #include <linux/mfd/kempld.h> 18 19 #define KEMPLD_GPIO_MAX_NUM 16 20 #define KEMPLD_GPIO_MASK(x) (BIT((x) % 8)) 21 #define KEMPLD_GPIO_DIR 0x40 22 #define KEMPLD_GPIO_LVL 0x42 23 #define KEMPLD_GPIO_STS 0x44 24 #define KEMPLD_GPIO_EVT_LVL_EDGE 0x46 25 #define KEMPLD_GPIO_EVT_LOW_HIGH 0x48 26 #define KEMPLD_GPIO_IEN 0x4A 27 #define KEMPLD_GPIO_OUT_LVL 0x4E 28 29 /* The IRQ to use if none was configured in the BIOS */ 30 static unsigned int gpio_irq; 31 module_param_hw(gpio_irq, uint, irq, 0444); 32 MODULE_PARM_DESC(gpio_irq, "Set legacy GPIO IRQ (1-15)"); 33 34 struct kempld_gpio_data { 35 struct gpio_chip chip; 36 struct kempld_device_data *pld; 37 u8 out_lvl_reg; 38 39 struct mutex irq_lock; 40 u16 ien; 41 u16 evt_low_high; 42 u16 evt_lvl_edge; 43 }; 44 45 /* 46 * Set or clear GPIO bit 47 * kempld_get_mutex must be called prior to calling this function. 48 */ 49 static void kempld_gpio_bitop(struct kempld_device_data *pld, 50 u8 reg, unsigned int bit, bool val) 51 { 52 u8 status; 53 54 status = kempld_read8(pld, reg + (bit / 8)); 55 if (val) 56 status |= KEMPLD_GPIO_MASK(bit); 57 else 58 status &= ~KEMPLD_GPIO_MASK(bit); 59 kempld_write8(pld, reg + (bit / 8), status); 60 } 61 62 static int kempld_gpio_get_bit(struct kempld_device_data *pld, 63 u8 reg, unsigned int bit) 64 { 65 u8 status; 66 67 kempld_get_mutex(pld); 68 status = kempld_read8(pld, reg + (bit / 8)); 69 kempld_release_mutex(pld); 70 71 return !!(status & KEMPLD_GPIO_MASK(bit)); 72 } 73 74 static int kempld_gpio_get(struct gpio_chip *chip, unsigned offset) 75 { 76 struct kempld_gpio_data *gpio = gpiochip_get_data(chip); 77 struct kempld_device_data *pld = gpio->pld; 78 79 return !!kempld_gpio_get_bit(pld, KEMPLD_GPIO_LVL, offset); 80 } 81 82 static int kempld_gpio_get_multiple(struct gpio_chip *chip, unsigned long *mask, 83 unsigned long *bits) 84 { 85 struct kempld_gpio_data *gpio = gpiochip_get_data(chip); 86 struct kempld_device_data *pld = gpio->pld; 87 u8 reg = KEMPLD_GPIO_LVL; 88 unsigned int shift; 89 90 bits[0] &= ~mask[0]; 91 92 kempld_get_mutex(pld); 93 94 /* Try to reduce to a single 8 bits access if possible */ 95 for (shift = 0; shift < gpio->chip.ngpio; shift += 8, reg++) { 96 unsigned long msk = (mask[0] >> shift) & 0xff; 97 98 if (!msk) 99 continue; 100 101 bits[0] |= (kempld_read8(pld, reg) & msk) << shift; 102 } 103 104 kempld_release_mutex(pld); 105 106 return 0; 107 } 108 109 static int kempld_gpio_set(struct gpio_chip *chip, unsigned int offset, 110 int value) 111 { 112 struct kempld_gpio_data *gpio = gpiochip_get_data(chip); 113 struct kempld_device_data *pld = gpio->pld; 114 115 kempld_get_mutex(pld); 116 kempld_gpio_bitop(pld, gpio->out_lvl_reg, offset, value); 117 kempld_release_mutex(pld); 118 119 return 0; 120 } 121 122 static int kempld_gpio_set_multiple(struct gpio_chip *chip, 123 unsigned long *mask, unsigned long *bits) 124 { 125 struct kempld_gpio_data *gpio = gpiochip_get_data(chip); 126 struct kempld_device_data *pld = gpio->pld; 127 u8 reg = gpio->out_lvl_reg; 128 unsigned int shift; 129 130 kempld_get_mutex(pld); 131 132 /* Try to reduce to a single 8 bits access if possible */ 133 for (shift = 0; shift < gpio->chip.ngpio; shift += 8, reg++) { 134 u8 val, msk = mask[0] >> shift; 135 136 if (!msk) 137 continue; 138 139 if (msk != 0xFF) 140 val = kempld_read8(pld, reg) & ~msk; 141 else 142 val = 0; 143 144 val |= (bits[0] >> shift) & msk; 145 kempld_write8(pld, reg, val); 146 } 147 148 kempld_release_mutex(pld); 149 150 return 0; 151 } 152 153 static int kempld_gpio_direction_input(struct gpio_chip *chip, unsigned offset) 154 { 155 struct kempld_gpio_data *gpio = gpiochip_get_data(chip); 156 struct kempld_device_data *pld = gpio->pld; 157 158 kempld_get_mutex(pld); 159 kempld_gpio_bitop(pld, KEMPLD_GPIO_DIR, offset, 0); 160 kempld_release_mutex(pld); 161 162 return 0; 163 } 164 165 static int kempld_gpio_direction_output(struct gpio_chip *chip, unsigned offset, 166 int value) 167 { 168 struct kempld_gpio_data *gpio = gpiochip_get_data(chip); 169 struct kempld_device_data *pld = gpio->pld; 170 171 kempld_get_mutex(pld); 172 kempld_gpio_bitop(pld, gpio->out_lvl_reg, offset, value); 173 kempld_gpio_bitop(pld, KEMPLD_GPIO_DIR, offset, 1); 174 kempld_release_mutex(pld); 175 176 return 0; 177 } 178 179 static int kempld_gpio_get_direction(struct gpio_chip *chip, unsigned offset) 180 { 181 struct kempld_gpio_data *gpio = gpiochip_get_data(chip); 182 struct kempld_device_data *pld = gpio->pld; 183 184 if (kempld_gpio_get_bit(pld, KEMPLD_GPIO_DIR, offset)) 185 return GPIO_LINE_DIRECTION_OUT; 186 187 return GPIO_LINE_DIRECTION_IN; 188 } 189 190 static int kempld_gpio_pincount(struct kempld_device_data *pld) 191 { 192 u16 evt, evt_back; 193 194 kempld_get_mutex(pld); 195 196 /* Backup event register as it might be already initialized */ 197 evt_back = kempld_read16(pld, KEMPLD_GPIO_EVT_LVL_EDGE); 198 /* Clear event register */ 199 kempld_write16(pld, KEMPLD_GPIO_EVT_LVL_EDGE, 0x0000); 200 /* Read back event register */ 201 evt = kempld_read16(pld, KEMPLD_GPIO_EVT_LVL_EDGE); 202 /* Restore event register */ 203 kempld_write16(pld, KEMPLD_GPIO_EVT_LVL_EDGE, evt_back); 204 205 kempld_release_mutex(pld); 206 207 return evt ? __ffs(evt) : 16; 208 } 209 210 static void kempld_irq_mask(struct irq_data *data) 211 { 212 struct gpio_chip *chip = irq_data_get_irq_chip_data(data); 213 struct kempld_gpio_data *gpio = gpiochip_get_data(chip); 214 215 gpio->ien &= ~BIT(irqd_to_hwirq(data)); 216 gpiochip_disable_irq(chip, irqd_to_hwirq(data)); 217 } 218 219 static void kempld_irq_unmask(struct irq_data *data) 220 { 221 struct gpio_chip *chip = irq_data_get_irq_chip_data(data); 222 struct kempld_gpio_data *gpio = gpiochip_get_data(chip); 223 224 gpiochip_enable_irq(chip, irqd_to_hwirq(data)); 225 gpio->ien |= BIT(irqd_to_hwirq(data)); 226 } 227 228 static int kempld_irq_set_type(struct irq_data *data, unsigned int type) 229 { 230 struct gpio_chip *chip = irq_data_get_irq_chip_data(data); 231 struct kempld_gpio_data *gpio = gpiochip_get_data(chip); 232 233 switch (type) { 234 case IRQ_TYPE_EDGE_RISING: 235 gpio->evt_low_high |= BIT(data->hwirq); 236 gpio->evt_lvl_edge |= BIT(data->hwirq); 237 break; 238 case IRQ_TYPE_EDGE_FALLING: 239 gpio->evt_low_high &= ~BIT(data->hwirq); 240 gpio->evt_lvl_edge |= BIT(data->hwirq); 241 break; 242 case IRQ_TYPE_LEVEL_HIGH: 243 gpio->evt_low_high |= BIT(data->hwirq); 244 gpio->evt_lvl_edge &= ~BIT(data->hwirq); 245 break; 246 case IRQ_TYPE_LEVEL_LOW: 247 gpio->evt_low_high &= ~BIT(data->hwirq); 248 gpio->evt_lvl_edge &= ~BIT(data->hwirq); 249 break; 250 default: 251 return -EINVAL; 252 } 253 254 return 0; 255 } 256 257 static void kempld_irq_bus_lock(struct irq_data *data) 258 { 259 struct gpio_chip *chip = irq_data_get_irq_chip_data(data); 260 struct kempld_gpio_data *gpio = gpiochip_get_data(chip); 261 262 mutex_lock(&gpio->irq_lock); 263 } 264 265 static void kempld_irq_bus_sync_unlock(struct irq_data *data) 266 { 267 struct gpio_chip *chip = irq_data_get_irq_chip_data(data); 268 struct kempld_gpio_data *gpio = gpiochip_get_data(chip); 269 struct kempld_device_data *pld = gpio->pld; 270 271 kempld_get_mutex(pld); 272 kempld_write16(pld, KEMPLD_GPIO_EVT_LVL_EDGE, gpio->evt_lvl_edge); 273 kempld_write16(pld, KEMPLD_GPIO_EVT_LOW_HIGH, gpio->evt_low_high); 274 kempld_write16(pld, KEMPLD_GPIO_IEN, gpio->ien); 275 kempld_release_mutex(pld); 276 277 mutex_unlock(&gpio->irq_lock); 278 } 279 280 static const struct irq_chip kempld_irqchip = { 281 .name = "kempld-gpio", 282 .irq_mask = kempld_irq_mask, 283 .irq_unmask = kempld_irq_unmask, 284 .irq_set_type = kempld_irq_set_type, 285 .irq_bus_lock = kempld_irq_bus_lock, 286 .irq_bus_sync_unlock = kempld_irq_bus_sync_unlock, 287 .flags = IRQCHIP_IMMUTABLE, 288 GPIOCHIP_IRQ_RESOURCE_HELPERS, 289 }; 290 291 static irqreturn_t kempld_gpio_irq_handler(int irq, void *data) 292 { 293 struct kempld_gpio_data *gpio = data; 294 struct gpio_chip *chip = &gpio->chip; 295 unsigned int pin, child_irq; 296 unsigned long status; 297 298 kempld_get_mutex(gpio->pld); 299 300 status = kempld_read16(gpio->pld, KEMPLD_GPIO_STS); 301 if (status) 302 kempld_write16(gpio->pld, KEMPLD_GPIO_STS, status); 303 304 kempld_release_mutex(gpio->pld); 305 306 status &= gpio->ien; 307 if (!status) 308 return IRQ_NONE; 309 310 for_each_set_bit(pin, &status, chip->ngpio) { 311 child_irq = irq_find_mapping(chip->irq.domain, pin); 312 handle_nested_irq(child_irq); 313 } 314 315 return IRQ_HANDLED; 316 } 317 318 static int kempld_gpio_irq_init(struct device *dev, 319 struct kempld_gpio_data *gpio) 320 { 321 struct kempld_device_data *pld = gpio->pld; 322 struct gpio_chip *chip = &gpio->chip; 323 struct gpio_irq_chip *girq; 324 unsigned int irq; 325 int ret; 326 327 /* Get the IRQ configured by the BIOS in the PLD */ 328 kempld_get_mutex(pld); 329 irq = kempld_read8(pld, KEMPLD_IRQ_GPIO); 330 kempld_release_mutex(pld); 331 332 if (irq == 0xff) { 333 dev_info(dev, "GPIO controller has no IRQ support\n"); 334 return 0; 335 } 336 337 /* Allow overriding the IRQ with the module parameter */ 338 if (gpio_irq > 0) { 339 dev_warn(dev, "Forcing IRQ to %d\n", gpio_irq); 340 irq &= ~KEMPLD_IRQ_GPIO_MASK; 341 irq |= gpio_irq & KEMPLD_IRQ_GPIO_MASK; 342 } 343 344 if (!(irq & KEMPLD_IRQ_GPIO_MASK)) { 345 dev_warn(dev, "No IRQ configured\n"); 346 return 0; 347 } 348 349 /* Get the current config, disable all child interrupts, clear them 350 * and set the parent IRQ 351 */ 352 kempld_get_mutex(pld); 353 gpio->evt_low_high = kempld_read16(pld, KEMPLD_GPIO_EVT_LOW_HIGH); 354 gpio->evt_lvl_edge = kempld_read16(pld, KEMPLD_GPIO_EVT_LVL_EDGE); 355 kempld_write16(pld, KEMPLD_GPIO_IEN, 0); 356 kempld_write16(pld, KEMPLD_GPIO_STS, 0xFFFF); 357 kempld_write16(pld, KEMPLD_IRQ_GPIO, irq); 358 kempld_release_mutex(pld); 359 360 girq = &chip->irq; 361 gpio_irq_chip_set_chip(girq, &kempld_irqchip); 362 363 girq->parent_handler = NULL; 364 girq->num_parents = 0; 365 girq->parents = NULL; 366 girq->default_type = IRQ_TYPE_NONE; 367 girq->handler = handle_simple_irq; 368 girq->threaded = true; 369 370 mutex_init(&gpio->irq_lock); 371 372 ret = devm_request_threaded_irq(dev, irq & KEMPLD_IRQ_GPIO_MASK, 373 NULL, kempld_gpio_irq_handler, 374 IRQF_ONESHOT, chip->label, 375 gpio); 376 if (ret) { 377 dev_err(dev, "failed to request irq %d\n", irq); 378 return ret; 379 } 380 381 return 0; 382 } 383 384 static int kempld_gpio_probe(struct platform_device *pdev) 385 { 386 struct device *dev = &pdev->dev; 387 struct kempld_device_data *pld = dev_get_drvdata(dev->parent); 388 struct kempld_platform_data *pdata = dev_get_platdata(pld->dev); 389 struct kempld_gpio_data *gpio; 390 struct gpio_chip *chip; 391 int ret; 392 393 if (pld->info.spec_major < 2) { 394 dev_err(dev, 395 "Driver only supports GPIO devices compatible to PLD spec. rev. 2.0 or higher\n"); 396 return -ENODEV; 397 } 398 399 gpio = devm_kzalloc(dev, sizeof(*gpio), GFP_KERNEL); 400 if (!gpio) 401 return -ENOMEM; 402 403 /* Starting with version 2.8 there is a dedicated register for the 404 * output state, earlier versions share the register used to read 405 * the line level. 406 */ 407 if (pld->info.spec_major > 2 || pld->info.spec_minor >= 8) 408 gpio->out_lvl_reg = KEMPLD_GPIO_OUT_LVL; 409 else 410 gpio->out_lvl_reg = KEMPLD_GPIO_LVL; 411 412 gpio->pld = pld; 413 414 platform_set_drvdata(pdev, gpio); 415 416 chip = &gpio->chip; 417 chip->label = "gpio-kempld"; 418 chip->owner = THIS_MODULE; 419 chip->parent = dev; 420 chip->can_sleep = true; 421 if (pdata && pdata->gpio_base) 422 chip->base = pdata->gpio_base; 423 else 424 chip->base = -1; 425 chip->direction_input = kempld_gpio_direction_input; 426 chip->direction_output = kempld_gpio_direction_output; 427 chip->get_direction = kempld_gpio_get_direction; 428 chip->get = kempld_gpio_get; 429 chip->get_multiple = kempld_gpio_get_multiple; 430 chip->set = kempld_gpio_set; 431 chip->set_multiple = kempld_gpio_set_multiple; 432 chip->ngpio = kempld_gpio_pincount(pld); 433 if (chip->ngpio == 0) { 434 dev_err(dev, "No GPIO pins detected\n"); 435 return -ENODEV; 436 } 437 438 ret = kempld_gpio_irq_init(dev, gpio); 439 if (ret) 440 return ret; 441 442 ret = devm_gpiochip_add_data(dev, chip, gpio); 443 if (ret) { 444 dev_err(dev, "Could not register GPIO chip\n"); 445 return ret; 446 } 447 448 dev_info(dev, "GPIO functionality initialized with %d pins\n", 449 chip->ngpio); 450 451 return 0; 452 } 453 454 static struct platform_driver kempld_gpio_driver = { 455 .driver = { 456 .name = "kempld-gpio", 457 }, 458 .probe = kempld_gpio_probe, 459 }; 460 461 module_platform_driver(kempld_gpio_driver); 462 463 MODULE_DESCRIPTION("KEM PLD GPIO Driver"); 464 MODULE_AUTHOR("Michael Brunner <michael.brunner@kontron.com>"); 465 MODULE_LICENSE("GPL"); 466 MODULE_ALIAS("platform:kempld-gpio"); 467