drivers/gpio/gpio-xilinx.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Xilinx gpio driver for xps/axi_gpio IP.
   4  *
   5  * Copyright 2008 - 2013 Xilinx, Inc.
   6  */
   7
   8 #include <linux/bitops.h>
   9 #include <linux/clk.h>
  10 #include <linux/errno.h>
  11 #include <linux/gpio/driver.h>
  12 #include <linux/init.h>
  13 #include <linux/interrupt.h>
  14 #include <linux/io.h>
  15 #include <linux/irq.h>
  16 #include <linux/module.h>
  17 #include <linux/of_device.h>
  18 #include <linux/of_platform.h>
  19 #include <linux/pm_runtime.h>
  20 #include <linux/slab.h>
  21
  22 /* Register Offset Definitions */
  23 #define XGPIO_DATA_OFFSET   (0x0)       /* Data register  */
  24 #define XGPIO_TRI_OFFSET    (0x4)       /* I/O direction register  */
  25
  26 #define XGPIO_CHANNEL_OFFSET    0x8
  27
  28 #define XGPIO_GIER_OFFSET       0x11c /* Global Interrupt Enable */
  29 #define XGPIO_GIER_IE           BIT(31)
  30 #define XGPIO_IPISR_OFFSET      0x120 /* IP Interrupt Status */
  31 #define XGPIO_IPIER_OFFSET      0x128 /* IP Interrupt Enable */
  32
  33 /* Read/Write access to the GPIO registers */
  34 #if defined(CONFIG_ARCH_ZYNQ) || defined(CONFIG_X86)
  35 # define xgpio_readreg(offset)          readl(offset)
  36 # define xgpio_writereg(offset, val)    writel(val, offset)
  37 #else
  38 # define xgpio_readreg(offset)          __raw_readl(offset)
  39 # define xgpio_writereg(offset, val)    __raw_writel(val, offset)
  40 #endif
  41
  42 /**
  43  * struct xgpio_instance - Stores information about GPIO device
  44  * @gc: GPIO chip
  45  * @regs: register block
  46  * @gpio_width: GPIO width for every channel
  47  * @gpio_state: GPIO write state shadow register
  48  * @gpio_last_irq_read: GPIO read state register from last interrupt
  49  * @gpio_dir: GPIO direction shadow register
  50  * @gpio_lock: Lock used for synchronization
  51  * @irq: IRQ used by GPIO device
  52  * @irqchip: IRQ chip
  53  * @irq_enable: GPIO IRQ enable/disable bitfield
  54  * @irq_rising_edge: GPIO IRQ rising edge enable/disable bitfield
  55  * @irq_falling_edge: GPIO IRQ falling edge enable/disable bitfield
  56  * @clk: clock resource for this driver
  57  */
  58 struct xgpio_instance {
  59         struct gpio_chip gc;
  60         void __iomem *regs;
  61         unsigned int gpio_width[2];
  62         u32 gpio_state[2];
  63         u32 gpio_last_irq_read[2];
  64         u32 gpio_dir[2];
  65         spinlock_t gpio_lock;   /* For serializing operations */
  66         int irq;
  67         struct irq_chip irqchip;
  68         u32 irq_enable[2];
  69         u32 irq_rising_edge[2];
  70         u32 irq_falling_edge[2];
  71         struct clk *clk;
  72 };
  73
  74 static inline int xgpio_index(struct xgpio_instance *chip, int gpio)
  75 {
  76         if (gpio >= chip->gpio_width[0])
  77                 return 1;
  78
  79         return 0;
  80 }
  81
  82 static inline int xgpio_regoffset(struct xgpio_instance *chip, int gpio)
  83 {
  84         if (xgpio_index(chip, gpio))
  85                 return XGPIO_CHANNEL_OFFSET;
  86
  87         return 0;
  88 }
  89
  90 static inline int xgpio_offset(struct xgpio_instance *chip, int gpio)
  91 {
  92         if (xgpio_index(chip, gpio))
  93                 return gpio - chip->gpio_width[0];
  94
  95         return gpio;
  96 }
  97
  98 /**
  99  * xgpio_get - Read the specified signal of the GPIO device.
 100  * @gc:     Pointer to gpio_chip device structure.
 101  * @gpio:   GPIO signal number.
 102  *
 103  * This function reads the specified signal of the GPIO device.
 104  *
 105  * Return:
 106  * 0 if direction of GPIO signals is set as input otherwise it
 107  * returns negative error value.
 108  */
 109 static int xgpio_get(struct gpio_chip *gc, unsigned int gpio)
 110 {
 111         struct xgpio_instance *chip = gpiochip_get_data(gc);
 112         u32 val;
 113
 114         val = xgpio_readreg(chip->regs + XGPIO_DATA_OFFSET +
 115                             xgpio_regoffset(chip, gpio));
 116
 117         return !!(val & BIT(xgpio_offset(chip, gpio)));
 118 }
 119
 120 /**
 121  * xgpio_set - Write the specified signal of the GPIO device.
 122  * @gc:     Pointer to gpio_chip device structure.
 123  * @gpio:   GPIO signal number.
 124  * @val:    Value to be written to specified signal.
 125  *
 126  * This function writes the specified value in to the specified signal of the
 127  * GPIO device.
 128  */
 129 static void xgpio_set(struct gpio_chip *gc, unsigned int gpio, int val)
 130 {
 131         unsigned long flags;
 132         struct xgpio_instance *chip = gpiochip_get_data(gc);
 133         int index =  xgpio_index(chip, gpio);
 134         int offset =  xgpio_offset(chip, gpio);
 135
 136         spin_lock_irqsave(&chip->gpio_lock, flags);
 137
 138         /* Write to GPIO signal and set its direction to output */
 139         if (val)
 140                 chip->gpio_state[index] |= BIT(offset);
 141         else
 142                 chip->gpio_state[index] &= ~BIT(offset);
 143
 144         xgpio_writereg(chip->regs + XGPIO_DATA_OFFSET +
 145                        xgpio_regoffset(chip, gpio), chip->gpio_state[index]);
 146
 147         spin_unlock_irqrestore(&chip->gpio_lock, flags);
 148 }
 149
 150 /**
 151  * xgpio_set_multiple - Write the specified signals of the GPIO device.
 152  * @gc:     Pointer to gpio_chip device structure.
 153  * @mask:   Mask of the GPIOS to modify.
 154  * @bits:   Value to be wrote on each GPIO
 155  *
 156  * This function writes the specified values into the specified signals of the
 157  * GPIO devices.
 158  */
 159 static void xgpio_set_multiple(struct gpio_chip *gc, unsigned long *mask,
 160                                unsigned long *bits)
 161 {
 162         unsigned long flags;
 163         struct xgpio_instance *chip = gpiochip_get_data(gc);
 164         int index = xgpio_index(chip, 0);
 165         int offset, i;
 166
 167         spin_lock_irqsave(&chip->gpio_lock, flags);
 168
 169         /* Write to GPIO signals */
 170         for (i = 0; i < gc->ngpio; i++) {
 171                 if (*mask == 0)
 172                         break;
 173                 /* Once finished with an index write it out to the register */
 174                 if (index !=  xgpio_index(chip, i)) {
 175                         xgpio_writereg(chip->regs + XGPIO_DATA_OFFSET +
 176                                        index * XGPIO_CHANNEL_OFFSET,
 177                                        chip->gpio_state[index]);
 178                         spin_unlock_irqrestore(&chip->gpio_lock, flags);
 179                         index =  xgpio_index(chip, i);
 180                         spin_lock_irqsave(&chip->gpio_lock, flags);
 181                 }
 182                 if (__test_and_clear_bit(i, mask)) {
 183                         offset =  xgpio_offset(chip, i);
 184                         if (test_bit(i, bits))
 185                                 chip->gpio_state[index] |= BIT(offset);
 186                         else
 187                                 chip->gpio_state[index] &= ~BIT(offset);
 188                 }
 189         }
 190
 191         xgpio_writereg(chip->regs + XGPIO_DATA_OFFSET +
 192                        index * XGPIO_CHANNEL_OFFSET, chip->gpio_state[index]);
 193
 194         spin_unlock_irqrestore(&chip->gpio_lock, flags);
 195 }
 196
 197 /**
 198  * xgpio_dir_in - Set the direction of the specified GPIO signal as input.
 199  * @gc:     Pointer to gpio_chip device structure.
 200  * @gpio:   GPIO signal number.
 201  *
 202  * Return:
 203  * 0 - if direction of GPIO signals is set as input
 204  * otherwise it returns negative error value.
 205  */
 206 static int xgpio_dir_in(struct gpio_chip *gc, unsigned int gpio)
 207 {
 208         unsigned long flags;
 209         struct xgpio_instance *chip = gpiochip_get_data(gc);
 210         int index =  xgpio_index(chip, gpio);
 211         int offset =  xgpio_offset(chip, gpio);
 212
 213         spin_lock_irqsave(&chip->gpio_lock, flags);
 214
 215         /* Set the GPIO bit in shadow register and set direction as input */
 216         chip->gpio_dir[index] |= BIT(offset);
 217         xgpio_writereg(chip->regs + XGPIO_TRI_OFFSET +
 218                        xgpio_regoffset(chip, gpio), chip->gpio_dir[index]);
 219
 220         spin_unlock_irqrestore(&chip->gpio_lock, flags);
 221
 222         return 0;
 223 }
 224
 225 /**
 226  * xgpio_dir_out - Set the direction of the specified GPIO signal as output.
 227  * @gc:     Pointer to gpio_chip device structure.
 228  * @gpio:   GPIO signal number.
 229  * @val:    Value to be written to specified signal.
 230  *
 231  * This function sets the direction of specified GPIO signal as output.
 232  *
 233  * Return:
 234  * If all GPIO signals of GPIO chip is configured as input then it returns
 235  * error otherwise it returns 0.
 236  */
 237 static int xgpio_dir_out(struct gpio_chip *gc, unsigned int gpio, int val)
 238 {
 239         unsigned long flags;
 240         struct xgpio_instance *chip = gpiochip_get_data(gc);
 241         int index =  xgpio_index(chip, gpio);
 242         int offset =  xgpio_offset(chip, gpio);
 243
 244         spin_lock_irqsave(&chip->gpio_lock, flags);
 245
 246         /* Write state of GPIO signal */
 247         if (val)
 248                 chip->gpio_state[index] |= BIT(offset);
 249         else
 250                 chip->gpio_state[index] &= ~BIT(offset);
 251         xgpio_writereg(chip->regs + XGPIO_DATA_OFFSET +
 252                         xgpio_regoffset(chip, gpio), chip->gpio_state[index]);
 253
 254         /* Clear the GPIO bit in shadow register and set direction as output */
 255         chip->gpio_dir[index] &= ~BIT(offset);
 256         xgpio_writereg(chip->regs + XGPIO_TRI_OFFSET +
 257                         xgpio_regoffset(chip, gpio), chip->gpio_dir[index]);
 258
 259         spin_unlock_irqrestore(&chip->gpio_lock, flags);
 260
 261         return 0;
 262 }
 263
 264 /**
 265  * xgpio_save_regs - Set initial values of GPIO pins
 266  * @chip: Pointer to GPIO instance
 267  */
 268 static void xgpio_save_regs(struct xgpio_instance *chip)
 269 {
 270         xgpio_writereg(chip->regs + XGPIO_DATA_OFFSET,  chip->gpio_state[0]);
 271         xgpio_writereg(chip->regs + XGPIO_TRI_OFFSET, chip->gpio_dir[0]);
 272
 273         if (!chip->gpio_width[1])
 274                 return;
 275
 276         xgpio_writereg(chip->regs + XGPIO_DATA_OFFSET + XGPIO_CHANNEL_OFFSET,
 277                        chip->gpio_state[1]);
 278         xgpio_writereg(chip->regs + XGPIO_TRI_OFFSET + XGPIO_CHANNEL_OFFSET,
 279                        chip->gpio_dir[1]);
 280 }
 281
 282 static int xgpio_request(struct gpio_chip *chip, unsigned int offset)
 283 {
 284         int ret;
 285
 286         ret = pm_runtime_get_sync(chip->parent);
 287         /*
 288          * If the device is already active pm_runtime_get() will return 1 on
 289          * success, but gpio_request still needs to return 0.
 290          */
 291         return ret < 0 ? ret : 0;
 292 }
 293
 294 static void xgpio_free(struct gpio_chip *chip, unsigned int offset)
 295 {
 296         pm_runtime_put(chip->parent);
 297 }
 298
 299 static int __maybe_unused xgpio_suspend(struct device *dev)
 300 {
 301         struct xgpio_instance *gpio = dev_get_drvdata(dev);
 302         struct irq_data *data = irq_get_irq_data(gpio->irq);
 303
 304         if (!data) {
 305                 dev_err(dev, "irq_get_irq_data() failed\n");
 306                 return -EINVAL;
 307         }
 308
 309         if (!irqd_is_wakeup_set(data))
 310                 return pm_runtime_force_suspend(dev);
 311
 312         return 0;
 313 }
 314
 315 /**
 316  * xgpio_remove - Remove method for the GPIO device.
 317  * @pdev: pointer to the platform device
 318  *
 319  * This function remove gpiochips and frees all the allocated resources.
 320  *
 321  * Return: 0 always
 322  */
 323 static int xgpio_remove(struct platform_device *pdev)
 324 {
 325         struct xgpio_instance *gpio = platform_get_drvdata(pdev);
 326
 327         pm_runtime_get_sync(&pdev->dev);
 328         pm_runtime_put_noidle(&pdev->dev);
 329         pm_runtime_disable(&pdev->dev);
 330         clk_disable_unprepare(gpio->clk);
 331
 332         return 0;
 333 }
 334
 335 /**
 336  * xgpio_irq_ack - Acknowledge a child GPIO interrupt.
 337  * @irq_data: per IRQ and chip data passed down to chip functions
 338  * This currently does nothing, but irq_ack is unconditionally called by
 339  * handle_edge_irq and therefore must be defined.
 340  */
 341 static void xgpio_irq_ack(struct irq_data *irq_data)
 342 {
 343 }
 344
 345 static int __maybe_unused xgpio_resume(struct device *dev)
 346 {
 347         struct xgpio_instance *gpio = dev_get_drvdata(dev);
 348         struct irq_data *data = irq_get_irq_data(gpio->irq);
 349
 350         if (!data) {
 351                 dev_err(dev, "irq_get_irq_data() failed\n");
 352                 return -EINVAL;
 353         }
 354
 355         if (!irqd_is_wakeup_set(data))
 356                 return pm_runtime_force_resume(dev);
 357
 358         return 0;
 359 }
 360
 361 static int __maybe_unused xgpio_runtime_suspend(struct device *dev)
 362 {
 363         struct platform_device *pdev = to_platform_device(dev);
 364         struct xgpio_instance *gpio = platform_get_drvdata(pdev);
 365
 366         clk_disable(gpio->clk);
 367
 368         return 0;
 369 }
 370
 371 static int __maybe_unused xgpio_runtime_resume(struct device *dev)
 372 {
 373         struct platform_device *pdev = to_platform_device(dev);
 374         struct xgpio_instance *gpio = platform_get_drvdata(pdev);
 375
 376         return clk_enable(gpio->clk);
 377 }
 378
 379 static const struct dev_pm_ops xgpio_dev_pm_ops = {
 380         SET_SYSTEM_SLEEP_PM_OPS(xgpio_suspend, xgpio_resume)
 381         SET_RUNTIME_PM_OPS(xgpio_runtime_suspend,
 382                            xgpio_runtime_resume, NULL)
 383 };
 384
 385 /**
 386  * xgpio_irq_mask - Write the specified signal of the GPIO device.
 387  * @irq_data: per IRQ and chip data passed down to chip functions
 388  */
 389 static void xgpio_irq_mask(struct irq_data *irq_data)
 390 {
 391         unsigned long flags;
 392         struct xgpio_instance *chip = irq_data_get_irq_chip_data(irq_data);
 393         int irq_offset = irqd_to_hwirq(irq_data);
 394         int index = xgpio_index(chip, irq_offset);
 395         int offset = xgpio_offset(chip, irq_offset);
 396
 397         spin_lock_irqsave(&chip->gpio_lock, flags);
 398
 399         chip->irq_enable[index] &= ~BIT(offset);
 400
 401         if (!chip->irq_enable[index]) {
 402                 /* Disable per channel interrupt */
 403                 u32 temp = xgpio_readreg(chip->regs + XGPIO_IPIER_OFFSET);
 404
 405                 temp &= ~BIT(index);
 406                 xgpio_writereg(chip->regs + XGPIO_IPIER_OFFSET, temp);
 407         }
 408         spin_unlock_irqrestore(&chip->gpio_lock, flags);
 409 }
 410
 411 /**
 412  * xgpio_irq_unmask - Write the specified signal of the GPIO device.
 413  * @irq_data: per IRQ and chip data passed down to chip functions
 414  */
 415 static void xgpio_irq_unmask(struct irq_data *irq_data)
 416 {
 417         unsigned long flags;
 418         struct xgpio_instance *chip = irq_data_get_irq_chip_data(irq_data);
 419         int irq_offset = irqd_to_hwirq(irq_data);
 420         int index = xgpio_index(chip, irq_offset);
 421         int offset = xgpio_offset(chip, irq_offset);
 422         u32 old_enable = chip->irq_enable[index];
 423
 424         spin_lock_irqsave(&chip->gpio_lock, flags);
 425
 426         chip->irq_enable[index] |= BIT(offset);
 427
 428         if (!old_enable) {
 429                 /* Clear any existing per-channel interrupts */
 430                 u32 val = xgpio_readreg(chip->regs + XGPIO_IPISR_OFFSET) &
 431                         BIT(index);
 432
 433                 if (val)
 434                         xgpio_writereg(chip->regs + XGPIO_IPISR_OFFSET, val);
 435
 436                 /* Update GPIO IRQ read data before enabling interrupt*/
 437                 val = xgpio_readreg(chip->regs + XGPIO_DATA_OFFSET +
 438                                     index * XGPIO_CHANNEL_OFFSET);
 439                 chip->gpio_last_irq_read[index] = val;
 440
 441                 /* Enable per channel interrupt */
 442                 val = xgpio_readreg(chip->regs + XGPIO_IPIER_OFFSET);
 443                 val |= BIT(index);
 444                 xgpio_writereg(chip->regs + XGPIO_IPIER_OFFSET, val);
 445         }
 446
 447         spin_unlock_irqrestore(&chip->gpio_lock, flags);
 448 }
 449
 450 /**
 451  * xgpio_set_irq_type - Write the specified signal of the GPIO device.
 452  * @irq_data: Per IRQ and chip data passed down to chip functions
 453  * @type: Interrupt type that is to be set for the gpio pin
 454  *
 455  * Return:
 456  * 0 if interrupt type is supported otherwise -EINVAL
 457  */
 458 static int xgpio_set_irq_type(struct irq_data *irq_data, unsigned int type)
 459 {
 460         struct xgpio_instance *chip = irq_data_get_irq_chip_data(irq_data);
 461         int irq_offset = irqd_to_hwirq(irq_data);
 462         int index = xgpio_index(chip, irq_offset);
 463         int offset = xgpio_offset(chip, irq_offset);
 464
 465         /*
 466          * The Xilinx GPIO hardware provides a single interrupt status
 467          * indication for any state change in a given GPIO channel (bank).
 468          * Therefore, only rising edge or falling edge triggers are
 469          * supported.
 470          */
 471         switch (type & IRQ_TYPE_SENSE_MASK) {
 472         case IRQ_TYPE_EDGE_BOTH:
 473                 chip->irq_rising_edge[index] |= BIT(offset);
 474                 chip->irq_falling_edge[index] |= BIT(offset);
 475                 break;
 476         case IRQ_TYPE_EDGE_RISING:
 477                 chip->irq_rising_edge[index] |= BIT(offset);
 478                 chip->irq_falling_edge[index] &= ~BIT(offset);
 479                 break;
 480         case IRQ_TYPE_EDGE_FALLING:
 481                 chip->irq_rising_edge[index] &= ~BIT(offset);
 482                 chip->irq_falling_edge[index] |= BIT(offset);
 483                 break;
 484         default:
 485                 return -EINVAL;
 486         }
 487
 488         irq_set_handler_locked(irq_data, handle_edge_irq);
 489         return 0;
 490 }
 491
 492 /**
 493  * xgpio_irqhandler - Gpio interrupt service routine
 494  * @desc: Pointer to interrupt description
 495  */
 496 static void xgpio_irqhandler(struct irq_desc *desc)
 497 {
 498         struct xgpio_instance *chip = irq_desc_get_handler_data(desc);
 499         struct irq_chip *irqchip = irq_desc_get_chip(desc);
 500         u32 num_channels = chip->gpio_width[1] ? 2 : 1;
 501         u32 offset = 0, index;
 502         u32 status = xgpio_readreg(chip->regs + XGPIO_IPISR_OFFSET);
 503
 504         xgpio_writereg(chip->regs + XGPIO_IPISR_OFFSET, status);
 505
 506         chained_irq_enter(irqchip, desc);
 507         for (index = 0; index < num_channels; index++) {
 508                 if ((status & BIT(index))) {
 509                         unsigned long rising_events, falling_events, all_events;
 510                         unsigned long flags;
 511                         u32 data, bit;
 512                         unsigned int irq;
 513
 514                         spin_lock_irqsave(&chip->gpio_lock, flags);
 515                         data = xgpio_readreg(chip->regs + XGPIO_DATA_OFFSET +
 516                                              index * XGPIO_CHANNEL_OFFSET);
 517                         rising_events = data &
 518                                         ~chip->gpio_last_irq_read[index] &
 519                                         chip->irq_enable[index] &
 520                                         chip->irq_rising_edge[index];
 521                         falling_events = ~data &
 522                                          chip->gpio_last_irq_read[index] &
 523                                          chip->irq_enable[index] &
 524                                          chip->irq_falling_edge[index];
 525                         dev_dbg(chip->gc.parent,
 526                                 "IRQ chan %u rising 0x%lx falling 0x%lx\n",
 527                                 index, rising_events, falling_events);
 528                         all_events = rising_events | falling_events;
 529                         chip->gpio_last_irq_read[index] = data;
 530                         spin_unlock_irqrestore(&chip->gpio_lock, flags);
 531
 532                         for_each_set_bit(bit, &all_events, 32) {
 533                                 irq = irq_find_mapping(chip->gc.irq.domain,
 534                                                        offset + bit);
 535                                 generic_handle_irq(irq);
 536                         }
 537                 }
 538                 offset += chip->gpio_width[index];
 539         }
 540
 541         chained_irq_exit(irqchip, desc);
 542 }
 543
 544 /**
 545  * xgpio_of_probe - Probe method for the GPIO device.
 546  * @pdev: pointer to the platform device
 547  *
 548  * Return:
 549  * It returns 0, if the driver is bound to the GPIO device, or
 550  * a negative value if there is an error.
 551  */
 552 static int xgpio_probe(struct platform_device *pdev)
 553 {
 554         struct xgpio_instance *chip;
 555         int status = 0;
 556         struct device_node *np = pdev->dev.of_node;
 557         u32 is_dual = 0;
 558         u32 cells = 2;
 559         struct gpio_irq_chip *girq;
 560         u32 temp;
 561
 562         chip = devm_kzalloc(&pdev->dev, sizeof(*chip), GFP_KERNEL);
 563         if (!chip)
 564                 return -ENOMEM;
 565
 566         platform_set_drvdata(pdev, chip);
 567
 568         /* Update GPIO state shadow register with default value */
 569         if (of_property_read_u32(np, "xlnx,dout-default", &chip->gpio_state[0]))
 570                 chip->gpio_state[0] = 0x0;
 571
 572         /* Update GPIO direction shadow register with default value */
 573         if (of_property_read_u32(np, "xlnx,tri-default", &chip->gpio_dir[0]))
 574                 chip->gpio_dir[0] = 0xFFFFFFFF;
 575
 576         /* Update cells with gpio-cells value */
 577         if (of_property_read_u32(np, "#gpio-cells", &cells))
 578                 dev_dbg(&pdev->dev, "Missing gpio-cells property\n");
 579
 580         if (cells != 2) {
 581                 dev_err(&pdev->dev, "#gpio-cells mismatch\n");
 582                 return -EINVAL;
 583         }
 584
 585         /*
 586          * Check device node and parent device node for device width
 587          * and assume default width of 32
 588          */
 589         if (of_property_read_u32(np, "xlnx,gpio-width", &chip->gpio_width[0]))
 590                 chip->gpio_width[0] = 32;
 591
 592         if (chip->gpio_width[0] > 32)
 593                 return -EINVAL;
 594
 595         spin_lock_init(&chip->gpio_lock);
 596
 597         if (of_property_read_u32(np, "xlnx,is-dual", &is_dual))
 598                 is_dual = 0;
 599
 600         if (is_dual) {
 601                 /* Update GPIO state shadow register with default value */
 602                 if (of_property_read_u32(np, "xlnx,dout-default-2",
 603                                          &chip->gpio_state[1]))
 604                         chip->gpio_state[1] = 0x0;
 605
 606                 /* Update GPIO direction shadow register with default value */
 607                 if (of_property_read_u32(np, "xlnx,tri-default-2",
 608                                          &chip->gpio_dir[1]))
 609                         chip->gpio_dir[1] = 0xFFFFFFFF;
 610
 611                 /*
 612                  * Check device node and parent device node for device width
 613                  * and assume default width of 32
 614                  */
 615                 if (of_property_read_u32(np, "xlnx,gpio2-width",
 616                                          &chip->gpio_width[1]))
 617                         chip->gpio_width[1] = 32;
 618
 619                 if (chip->gpio_width[1] > 32)
 620                         return -EINVAL;
 621         }
 622
 623         chip->gc.base = -1;
 624         chip->gc.ngpio = chip->gpio_width[0] + chip->gpio_width[1];
 625         chip->gc.parent = &pdev->dev;
 626         chip->gc.direction_input = xgpio_dir_in;
 627         chip->gc.direction_output = xgpio_dir_out;
 628         chip->gc.of_gpio_n_cells = cells;
 629         chip->gc.get = xgpio_get;
 630         chip->gc.set = xgpio_set;
 631         chip->gc.request = xgpio_request;
 632         chip->gc.free = xgpio_free;
 633         chip->gc.set_multiple = xgpio_set_multiple;
 634
 635         chip->gc.label = dev_name(&pdev->dev);
 636
 637         chip->regs = devm_platform_ioremap_resource(pdev, 0);
 638         if (IS_ERR(chip->regs)) {
 639                 dev_err(&pdev->dev, "failed to ioremap memory resource\n");
 640                 return PTR_ERR(chip->regs);
 641         }
 642
 643         chip->clk = devm_clk_get_optional(&pdev->dev, NULL);
 644         if (IS_ERR(chip->clk))
 645                 return dev_err_probe(&pdev->dev, PTR_ERR(chip->clk), "input clock not found.\n");
 646
 647         status = clk_prepare_enable(chip->clk);
 648         if (status < 0) {
 649                 dev_err(&pdev->dev, "Failed to prepare clk\n");
 650                 return status;
 651         }
 652         pm_runtime_get_noresume(&pdev->dev);
 653         pm_runtime_set_active(&pdev->dev);
 654         pm_runtime_enable(&pdev->dev);
 655
 656         xgpio_save_regs(chip);
 657
 658         chip->irq = platform_get_irq_optional(pdev, 0);
 659         if (chip->irq <= 0)
 660                 goto skip_irq;
 661
 662         chip->irqchip.name = "gpio-xilinx";
 663         chip->irqchip.irq_ack = xgpio_irq_ack;
 664         chip->irqchip.irq_mask = xgpio_irq_mask;
 665         chip->irqchip.irq_unmask = xgpio_irq_unmask;
 666         chip->irqchip.irq_set_type = xgpio_set_irq_type;
 667
 668         /* Disable per-channel interrupts */
 669         xgpio_writereg(chip->regs + XGPIO_IPIER_OFFSET, 0);
 670         /* Clear any existing per-channel interrupts */
 671         temp = xgpio_readreg(chip->regs + XGPIO_IPISR_OFFSET);
 672         xgpio_writereg(chip->regs + XGPIO_IPISR_OFFSET, temp);
 673         /* Enable global interrupts */
 674         xgpio_writereg(chip->regs + XGPIO_GIER_OFFSET, XGPIO_GIER_IE);
 675
 676         girq = &chip->gc.irq;
 677         girq->chip = &chip->irqchip;
 678         girq->parent_handler = xgpio_irqhandler;
 679         girq->num_parents = 1;
 680         girq->parents = devm_kcalloc(&pdev->dev, 1,
 681                                      sizeof(*girq->parents),
 682                                      GFP_KERNEL);
 683         if (!girq->parents) {
 684                 status = -ENOMEM;
 685                 goto err_pm_put;
 686         }
 687         girq->parents[0] = chip->irq;
 688         girq->default_type = IRQ_TYPE_NONE;
 689         girq->handler = handle_bad_irq;
 690
 691 skip_irq:
 692         status = devm_gpiochip_add_data(&pdev->dev, &chip->gc, chip);
 693         if (status) {
 694                 dev_err(&pdev->dev, "failed to add GPIO chip\n");
 695                 goto err_pm_put;
 696         }
 697
 698         pm_runtime_put(&pdev->dev);
 699         return 0;
 700
 701 err_pm_put:
 702         pm_runtime_disable(&pdev->dev);
 703         pm_runtime_put_noidle(&pdev->dev);
 704         clk_disable_unprepare(chip->clk);
 705         return status;
 706 }
 707
 708 static const struct of_device_id xgpio_of_match[] = {
 709         { .compatible = "xlnx,xps-gpio-1.00.a", },
 710         { /* end of list */ },
 711 };
 712
 713 MODULE_DEVICE_TABLE(of, xgpio_of_match);
 714
 715 static struct platform_driver xgpio_plat_driver = {
 716         .probe          = xgpio_probe,
 717         .remove         = xgpio_remove,
 718         .driver         = {
 719                         .name = "gpio-xilinx",
 720                         .of_match_table = xgpio_of_match,
 721                         .pm = &xgpio_dev_pm_ops,
 722         },
 723 };
 724
 725 static int __init xgpio_init(void)
 726 {
 727         return platform_driver_register(&xgpio_plat_driver);
 728 }
 729
 730 subsys_initcall(xgpio_init);
 731
 732 static void __exit xgpio_exit(void)
 733 {
 734         platform_driver_unregister(&xgpio_plat_driver);
 735 }
 736 module_exit(xgpio_exit);
 737
 738 MODULE_AUTHOR("Xilinx, Inc.");
 739 MODULE_DESCRIPTION("Xilinx GPIO driver");
 740 MODULE_LICENSE("GPL");