drivers/pinctrl/pinctrl-adi2.c

   1 /*
   2  * Pinctrl Driver for ADI GPIO2 controller
   3  *
   4  * Copyright 2007-2013 Analog Devices Inc.
   5  *
   6  * Licensed under the GPLv2 or later
   7  */
   8
   9 #include <linux/bitops.h>
  10 #include <linux/delay.h>
  11 #include <linux/module.h>
  12 #include <linux/err.h>
  13 #include <linux/debugfs.h>
  14 #include <linux/seq_file.h>
  15 #include <linux/irq.h>
  16 #include <linux/platform_data/pinctrl-adi2.h>
  17 #include <linux/irqdomain.h>
  18 #include <linux/irqchip/chained_irq.h>
  19 #include <linux/pinctrl/pinctrl.h>
  20 #include <linux/pinctrl/pinmux.h>
  21 #include <linux/pinctrl/consumer.h>
  22 #include <linux/pinctrl/machine.h>
  23 #include <linux/syscore_ops.h>
  24 #include <linux/gpio.h>
  25 #include <asm/portmux.h>
  26 #include "pinctrl-adi2.h"
  27 #include "core.h"
  28
  29 /*
  30 According to the BF54x HRM, pint means "pin interrupt".
  31 http://www.analog.com/static/imported-files/processor_manuals/ADSP-BF54x_hwr_rev1.2.pdf
  32
  33 ADSP-BF54x processor Blackfin processors have four SIC interrupt chan-
  34 nels dedicated to pin interrupt purposes. These channels are managed by
  35 four hardware blocks, called PINT0, PINT1, PINT2, and PINT3. Every PINTx
  36 block can sense to up to 32 pins. While PINT0 and PINT1 can sense the
  37 pins of port A and port B, PINT2 and PINT3 manage all the pins from port
  38 C to port J as shown in Figure 9-2.
  39
  40 n BF54x HRM:
  41 The ten GPIO ports are subdivided into 8-bit half ports, resulting in lower and
  42 upper half 8-bit units. The PINTx_ASSIGN registers control the 8-bit multi-
  43 plexers shown in Figure 9-3. Lower half units of eight pins can be
  44 forwarded to either byte 0 or byte 2 of either associated PINTx block.
  45 Upper half units can be forwarded to either byte 1 or byte 3 of the pin
  46 interrupt blocks, without further restrictions.
  47
  48 All MMR registers in the pin interrupt module are 32 bits wide. To simply the
  49 mapping logic, this driver only maps a 16-bit gpio port to the upper or lower
  50 16 bits of a PINTx block. You can find the Figure 9-3 on page 583.
  51
  52 Each IRQ domain is binding to a GPIO bank device. 2 GPIO bank devices can map
  53 to one PINT device. Two in "struct gpio_pint" are used to ease the PINT
  54 interrupt handler.
  55
  56 The GPIO bank mapping to the lower 16 bits of the PINT device set its IRQ
  57 domain pointer in domain[0]. The IRQ domain pointer of the other bank is set
  58 to domain[1]. PINT interrupt handler adi_gpio_handle_pint_irq() finds out
  59 the current domain pointer according to whether the interrupt request mask
  60 is in lower 16 bits (domain[0]) or upper 16bits (domain[1]).
  61
  62 A PINT device is not part of a GPIO port device in Blackfin. Multiple GPIO
  63 port devices can be mapped to the same PINT device.
  64
  65 */
  66
  67 static LIST_HEAD(adi_pint_list);
  68 static LIST_HEAD(adi_gpio_port_list);
  69
  70 #define DRIVER_NAME "pinctrl-adi2"
  71
  72 #define PINT_HI_OFFSET          16
  73
  74 /**
  75  * struct gpio_port_saved - GPIO port registers that should be saved between
  76  * power suspend and resume operations.
  77  *
  78  * @fer: PORTx_FER register
  79  * @data: PORTx_DATA register
  80  * @dir: PORTx_DIR register
  81  * @inen: PORTx_INEN register
  82  * @mux: PORTx_MUX register
  83  */
  84 struct gpio_port_saved {
  85         u16 fer;
  86         u16 data;
  87         u16 dir;
  88         u16 inen;
  89         u32 mux;
  90 };
  91
  92 /*
  93  * struct gpio_pint_saved - PINT registers saved in PM operations
  94  *
  95  * @assign: ASSIGN register
  96  * @edge_set: EDGE_SET register
  97  * @invert_set: INVERT_SET register
  98  */
  99 struct gpio_pint_saved {
 100         u32 assign;
 101         u32 edge_set;
 102         u32 invert_set;
 103 };
 104
 105 /**
 106  * struct gpio_pint - Pin interrupt controller device. Multiple ADI GPIO
 107  * banks can be mapped into one Pin interrupt controller.
 108  *
 109  * @node: All gpio_pint instances are added to a global list.
 110  * @base: PINT device register base address
 111  * @irq: IRQ of the PINT device, it is the parent IRQ of all
 112  *       GPIO IRQs mapping to this device.
 113  * @domain: [0] irq domain of the gpio port, whose hardware interrupts are
 114  *              mapping to the low 16-bit of the pint registers.
 115  *          [1] irq domain of the gpio port, whose hardware interrupts are
 116  *              mapping to the high 16-bit of the pint registers.
 117  * @regs: address pointer to the PINT device
 118  * @map_count: No more than 2 GPIO banks can be mapped to this PINT device.
 119  * @lock: This lock make sure the irq_chip operations to one PINT device
 120  *        for different GPIO interrrupts are atomic.
 121  * @pint_map_port: Set up the mapping between one PINT device and
 122  *                 multiple GPIO banks.
 123  */
 124 struct gpio_pint {
 125         struct list_head node;
 126         void __iomem *base;
 127         int irq;
 128         struct irq_domain *domain[2];
 129         struct gpio_pint_regs *regs;
 130         struct gpio_pint_saved saved_data;
 131         int map_count;
 132         spinlock_t lock;
 133
 134         int (*pint_map_port)(struct gpio_pint *pint, bool assign,
 135                                 u8 map, struct irq_domain *domain);
 136 };
 137
 138 /**
 139  * ADI pin controller
 140  *
 141  * @dev: a pointer back to containing device
 142  * @pctl: the pinctrl device
 143  * @soc: SoC data for this specific chip
 144  */
 145 struct adi_pinctrl {
 146         struct device *dev;
 147         struct pinctrl_dev *pctl;
 148         const struct adi_pinctrl_soc_data *soc;
 149 };
 150
 151 /**
 152  * struct gpio_port - GPIO bank device. Multiple ADI GPIO banks can be mapped
 153  * into one pin interrupt controller.
 154  *
 155  * @node: All gpio_port instances are added to a list.
 156  * @base: GPIO bank device register base address
 157  * @irq_base: base IRQ of the GPIO bank device
 158  * @width: PIN number of the GPIO bank device
 159  * @regs: address pointer to the GPIO bank device
 160  * @saved_data: registers that should be saved between PM operations.
 161  * @dev: device structure of this GPIO bank
 162  * @pint: GPIO PINT device that this GPIO bank mapped to
 163  * @pint_map: GIOP bank mapping code in PINT device
 164  * @pint_assign: The 32-bit PINT registers can be divided into 2 parts. A
 165  *               GPIO bank can be mapped into either low 16 bits[0] or high 16
 166  *               bits[1] of each PINT register.
 167  * @lock: This lock make sure the irq_chip operations to one PINT device
 168  *        for different GPIO interrrupts are atomic.
 169  * @chip: abstract a GPIO controller
 170  * @domain: The irq domain owned by the GPIO port.
 171  * @rsvmap: Reservation map array for each pin in the GPIO bank
 172  */
 173 struct gpio_port {
 174         struct list_head node;
 175         void __iomem *base;
 176         int irq_base;
 177         unsigned int width;
 178         struct gpio_port_t *regs;
 179         struct gpio_port_saved saved_data;
 180         struct device *dev;
 181
 182         struct gpio_pint *pint;
 183         u8 pint_map;
 184         bool pint_assign;
 185
 186         spinlock_t lock;
 187         struct gpio_chip chip;
 188         struct irq_domain *domain;
 189 };
 190
 191 static inline u8 pin_to_offset(struct pinctrl_gpio_range *range, unsigned pin)
 192 {
 193         return pin - range->pin_base;
 194 }
 195
 196 static inline u32 hwirq_to_pintbit(struct gpio_port *port, int hwirq)
 197 {
 198         return port->pint_assign ? BIT(hwirq) << PINT_HI_OFFSET : BIT(hwirq);
 199 }
 200
 201 static struct gpio_pint *find_gpio_pint(unsigned id)
 202 {
 203         struct gpio_pint *pint;
 204         int i = 0;
 205
 206         list_for_each_entry(pint, &adi_pint_list, node) {
 207                 if (id == i)
 208                         return pint;
 209                 i++;
 210         }
 211
 212         return NULL;
 213 }
 214
 215 static inline void port_setup(struct gpio_port *port, unsigned offset,
 216         bool use_for_gpio)
 217 {
 218         struct gpio_port_t *regs = port->regs;
 219
 220         if (use_for_gpio)
 221                 writew(readw(&regs->port_fer) & ~BIT(offset),
 222                         &regs->port_fer);
 223         else
 224                 writew(readw(&regs->port_fer) | BIT(offset), &regs->port_fer);
 225 }
 226
 227 static inline void portmux_setup(struct gpio_port *port, unsigned offset,
 228         unsigned short function)
 229 {
 230         struct gpio_port_t *regs = port->regs;
 231         u32 pmux;
 232
 233         pmux = readl(&regs->port_mux);
 234
 235         /* The function field of each pin has 2 consecutive bits in
 236          * the mux register.
 237          */
 238         pmux &= ~(0x3 << (2 * offset));
 239         pmux |= (function & 0x3) << (2 * offset);
 240
 241         writel(pmux, &regs->port_mux);
 242 }
 243
 244 static inline u16 get_portmux(struct gpio_port *port, unsigned offset)
 245 {
 246         struct gpio_port_t *regs = port->regs;
 247         u32 pmux = readl(&regs->port_mux);
 248
 249         /* The function field of each pin has 2 consecutive bits in
 250          * the mux register.
 251          */
 252         return pmux >> (2 * offset) & 0x3;
 253 }
 254
 255 static void adi_gpio_ack_irq(struct irq_data *d)
 256 {
 257         unsigned long flags;
 258         struct gpio_port *port = irq_data_get_irq_chip_data(d);
 259         struct gpio_pint_regs *regs = port->pint->regs;
 260         unsigned pintbit = hwirq_to_pintbit(port, d->hwirq);
 261
 262         spin_lock_irqsave(&port->lock, flags);
 263         spin_lock(&port->pint->lock);
 264
 265         if (irqd_get_trigger_type(d) == IRQ_TYPE_EDGE_BOTH) {
 266                 if (readl(&regs->invert_set) & pintbit)
 267                         writel(pintbit, &regs->invert_clear);
 268                 else
 269                         writel(pintbit, &regs->invert_set);
 270         }
 271
 272         writel(pintbit, &regs->request);
 273
 274         spin_unlock(&port->pint->lock);
 275         spin_unlock_irqrestore(&port->lock, flags);
 276 }
 277
 278 static void adi_gpio_mask_ack_irq(struct irq_data *d)
 279 {
 280         unsigned long flags;
 281         struct gpio_port *port = irq_data_get_irq_chip_data(d);
 282         struct gpio_pint_regs *regs = port->pint->regs;
 283         unsigned pintbit = hwirq_to_pintbit(port, d->hwirq);
 284
 285         spin_lock_irqsave(&port->lock, flags);
 286         spin_lock(&port->pint->lock);
 287
 288         if (irqd_get_trigger_type(d) == IRQ_TYPE_EDGE_BOTH) {
 289                 if (readl(&regs->invert_set) & pintbit)
 290                         writel(pintbit, &regs->invert_clear);
 291                 else
 292                         writel(pintbit, &regs->invert_set);
 293         }
 294
 295         writel(pintbit, &regs->request);
 296         writel(pintbit, &regs->mask_clear);
 297
 298         spin_unlock(&port->pint->lock);
 299         spin_unlock_irqrestore(&port->lock, flags);
 300 }
 301
 302 static void adi_gpio_mask_irq(struct irq_data *d)
 303 {
 304         unsigned long flags;
 305         struct gpio_port *port = irq_data_get_irq_chip_data(d);
 306         struct gpio_pint_regs *regs = port->pint->regs;
 307
 308         spin_lock_irqsave(&port->lock, flags);
 309         spin_lock(&port->pint->lock);
 310
 311         writel(hwirq_to_pintbit(port, d->hwirq), &regs->mask_clear);
 312
 313         spin_unlock(&port->pint->lock);
 314         spin_unlock_irqrestore(&port->lock, flags);
 315 }
 316
 317 static void adi_gpio_unmask_irq(struct irq_data *d)
 318 {
 319         unsigned long flags;
 320         struct gpio_port *port = irq_data_get_irq_chip_data(d);
 321         struct gpio_pint_regs *regs = port->pint->regs;
 322
 323         spin_lock_irqsave(&port->lock, flags);
 324         spin_lock(&port->pint->lock);
 325
 326         writel(hwirq_to_pintbit(port, d->hwirq), &regs->mask_set);
 327
 328         spin_unlock(&port->pint->lock);
 329         spin_unlock_irqrestore(&port->lock, flags);
 330 }
 331
 332 static unsigned int adi_gpio_irq_startup(struct irq_data *d)
 333 {
 334         unsigned long flags;
 335         struct gpio_port *port = irq_data_get_irq_chip_data(d);
 336         struct gpio_pint_regs *regs;
 337
 338         if (!port) {
 339                 pr_err("GPIO IRQ %d :Not exist\n", d->irq);
 340                 /* FIXME: negative return code will be ignored */
 341                 return -ENODEV;
 342         }
 343
 344         regs = port->pint->regs;
 345
 346         spin_lock_irqsave(&port->lock, flags);
 347         spin_lock(&port->pint->lock);
 348
 349         port_setup(port, d->hwirq, true);
 350         writew(BIT(d->hwirq), &port->regs->dir_clear);
 351         writew(readw(&port->regs->inen) | BIT(d->hwirq), &port->regs->inen);
 352
 353         writel(hwirq_to_pintbit(port, d->hwirq), &regs->mask_set);
 354
 355         spin_unlock(&port->pint->lock);
 356         spin_unlock_irqrestore(&port->lock, flags);
 357
 358         return 0;
 359 }
 360
 361 static void adi_gpio_irq_shutdown(struct irq_data *d)
 362 {
 363         unsigned long flags;
 364         struct gpio_port *port = irq_data_get_irq_chip_data(d);
 365         struct gpio_pint_regs *regs = port->pint->regs;
 366
 367         spin_lock_irqsave(&port->lock, flags);
 368         spin_lock(&port->pint->lock);
 369
 370         writel(hwirq_to_pintbit(port, d->hwirq), &regs->mask_clear);
 371
 372         spin_unlock(&port->pint->lock);
 373         spin_unlock_irqrestore(&port->lock, flags);
 374 }
 375
 376 static int adi_gpio_irq_type(struct irq_data *d, unsigned int type)
 377 {
 378         unsigned long flags;
 379         struct gpio_port *port = irq_data_get_irq_chip_data(d);
 380         struct gpio_pint_regs *pint_regs;
 381         unsigned pintmask;
 382         unsigned int irq = d->irq;
 383         int ret = 0;
 384         char buf[16];
 385
 386         if (!port) {
 387                 pr_err("GPIO IRQ %d :Not exist\n", d->irq);
 388                 return -ENODEV;
 389         }
 390
 391         pint_regs = port->pint->regs;
 392
 393         pintmask = hwirq_to_pintbit(port, d->hwirq);
 394
 395         spin_lock_irqsave(&port->lock, flags);
 396         spin_lock(&port->pint->lock);
 397
 398         /* In case of interrupt autodetect, set irq type to edge sensitive. */
 399         if (type == IRQ_TYPE_PROBE)
 400                 type = IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING;
 401
 402         if (type & (IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING |
 403                     IRQ_TYPE_LEVEL_HIGH | IRQ_TYPE_LEVEL_LOW)) {
 404                 snprintf(buf, 16, "gpio-irq%u", irq);
 405                 port_setup(port, d->hwirq, true);
 406         } else
 407                 goto out;
 408
 409         /* The GPIO interrupt is triggered only when its input value
 410          * transfer from 0 to 1. So, invert the input value if the
 411          * irq type is low or falling
 412          */
 413         if ((type & (IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_LEVEL_LOW)))
 414                 writel(pintmask, &pint_regs->invert_set);
 415         else
 416                 writel(pintmask, &pint_regs->invert_clear);
 417
 418         /* In edge sensitive case, if the input value of the requested irq
 419          * is already 1, invert it.
 420          */
 421         if ((type & IRQ_TYPE_EDGE_BOTH) == IRQ_TYPE_EDGE_BOTH) {
 422                 if (gpio_get_value(port->chip.base + d->hwirq))
 423                         writel(pintmask, &pint_regs->invert_set);
 424                 else
 425                         writel(pintmask, &pint_regs->invert_clear);
 426         }
 427
 428         if (type & (IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING)) {
 429                 writel(pintmask, &pint_regs->edge_set);
 430                 irq_set_handler_locked(d, handle_edge_irq);
 431         } else {
 432                 writel(pintmask, &pint_regs->edge_clear);
 433                 irq_set_handler_locked(d, handle_level_irq);
 434         }
 435
 436 out:
 437         spin_unlock(&port->pint->lock);
 438         spin_unlock_irqrestore(&port->lock, flags);
 439
 440         return ret;
 441 }
 442
 443 #ifdef CONFIG_PM
 444 static int adi_gpio_set_wake(struct irq_data *d, unsigned int state)
 445 {
 446         struct gpio_port *port = irq_data_get_irq_chip_data(d);
 447
 448         if (!port || !port->pint || port->pint->irq != d->irq)
 449                 return -EINVAL;
 450
 451 #ifndef SEC_GCTL
 452         adi_internal_set_wake(port->pint->irq, state);
 453 #endif
 454
 455         return 0;
 456 }
 457
 458 static int adi_pint_suspend(void)
 459 {
 460         struct gpio_pint *pint;
 461
 462         list_for_each_entry(pint, &adi_pint_list, node) {
 463                 writel(0xffffffff, &pint->regs->mask_clear);
 464                 pint->saved_data.assign = readl(&pint->regs->assign);
 465                 pint->saved_data.edge_set = readl(&pint->regs->edge_set);
 466                 pint->saved_data.invert_set = readl(&pint->regs->invert_set);
 467         }
 468
 469         return 0;
 470 }
 471
 472 static void adi_pint_resume(void)
 473 {
 474         struct gpio_pint *pint;
 475
 476         list_for_each_entry(pint, &adi_pint_list, node) {
 477                 writel(pint->saved_data.assign, &pint->regs->assign);
 478                 writel(pint->saved_data.edge_set, &pint->regs->edge_set);
 479                 writel(pint->saved_data.invert_set, &pint->regs->invert_set);
 480         }
 481 }
 482
 483 static int adi_gpio_suspend(void)
 484 {
 485         struct gpio_port *port;
 486
 487         list_for_each_entry(port, &adi_gpio_port_list, node) {
 488                 port->saved_data.fer = readw(&port->regs->port_fer);
 489                 port->saved_data.mux = readl(&port->regs->port_mux);
 490                 port->saved_data.data = readw(&port->regs->data);
 491                 port->saved_data.inen = readw(&port->regs->inen);
 492                 port->saved_data.dir = readw(&port->regs->dir_set);
 493         }
 494
 495         return adi_pint_suspend();
 496 }
 497
 498 static void adi_gpio_resume(void)
 499 {
 500         struct gpio_port *port;
 501
 502         adi_pint_resume();
 503
 504         list_for_each_entry(port, &adi_gpio_port_list, node) {
 505                 writel(port->saved_data.mux, &port->regs->port_mux);
 506                 writew(port->saved_data.fer, &port->regs->port_fer);
 507                 writew(port->saved_data.inen, &port->regs->inen);
 508                 writew(port->saved_data.data & port->saved_data.dir,
 509                                         &port->regs->data_set);
 510                 writew(port->saved_data.dir, &port->regs->dir_set);
 511         }
 512
 513 }
 514
 515 static struct syscore_ops gpio_pm_syscore_ops = {
 516         .suspend = adi_gpio_suspend,
 517         .resume = adi_gpio_resume,
 518 };
 519 #else /* CONFIG_PM */
 520 #define adi_gpio_set_wake NULL
 521 #endif /* CONFIG_PM */
 522
 523 #ifdef CONFIG_IRQ_PREFLOW_FASTEOI
 524 static inline void preflow_handler(struct irq_desc *desc)
 525 {
 526         if (desc->preflow_handler)
 527                 desc->preflow_handler(&desc->irq_data);
 528 }
 529 #else
 530 static inline void preflow_handler(struct irq_desc *desc) { }
 531 #endif
 532
 533 static void adi_gpio_handle_pint_irq(unsigned int inta_irq,
 534                         struct irq_desc *desc)
 535 {
 536         u32 request;
 537         u32 level_mask, hwirq;
 538         bool umask = false;
 539         struct gpio_pint *pint = irq_desc_get_handler_data(desc);
 540         struct irq_chip *chip = irq_desc_get_chip(desc);
 541         struct gpio_pint_regs *regs = pint->regs;
 542         struct irq_domain *domain;
 543
 544         preflow_handler(desc);
 545         chained_irq_enter(chip, desc);
 546
 547         request = readl(&regs->request);
 548         level_mask = readl(&regs->edge_set) & request;
 549
 550         hwirq = 0;
 551         domain = pint->domain[0];
 552         while (request) {
 553                 /* domain pointer need to be changed only once at IRQ 16 when
 554                  * we go through IRQ requests from bit 0 to bit 31.
 555                  */
 556                 if (hwirq == PINT_HI_OFFSET)
 557                         domain = pint->domain[1];
 558
 559                 if (request & 1) {
 560                         if (level_mask & BIT(hwirq)) {
 561                                 umask = true;
 562                                 chained_irq_exit(chip, desc);
 563                         }
 564                         generic_handle_irq(irq_find_mapping(domain,
 565                                         hwirq % PINT_HI_OFFSET));
 566                 }
 567
 568                 hwirq++;
 569                 request >>= 1;
 570         }
 571
 572         if (!umask)
 573                 chained_irq_exit(chip, desc);
 574 }
 575
 576 static struct irq_chip adi_gpio_irqchip = {
 577         .name = "GPIO",
 578         .irq_ack = adi_gpio_ack_irq,
 579         .irq_mask = adi_gpio_mask_irq,
 580         .irq_mask_ack = adi_gpio_mask_ack_irq,
 581         .irq_unmask = adi_gpio_unmask_irq,
 582         .irq_disable = adi_gpio_mask_irq,
 583         .irq_enable = adi_gpio_unmask_irq,
 584         .irq_set_type = adi_gpio_irq_type,
 585         .irq_startup = adi_gpio_irq_startup,
 586         .irq_shutdown = adi_gpio_irq_shutdown,
 587         .irq_set_wake = adi_gpio_set_wake,
 588 };
 589
 590 static int adi_get_groups_count(struct pinctrl_dev *pctldev)
 591 {
 592         struct adi_pinctrl *pinctrl = pinctrl_dev_get_drvdata(pctldev);
 593
 594         return pinctrl->soc->ngroups;
 595 }
 596
 597 static const char *adi_get_group_name(struct pinctrl_dev *pctldev,
 598                                        unsigned selector)
 599 {
 600         struct adi_pinctrl *pinctrl = pinctrl_dev_get_drvdata(pctldev);
 601
 602         return pinctrl->soc->groups[selector].name;
 603 }
 604
 605 static int adi_get_group_pins(struct pinctrl_dev *pctldev, unsigned selector,
 606                                const unsigned **pins,
 607                                unsigned *num_pins)
 608 {
 609         struct adi_pinctrl *pinctrl = pinctrl_dev_get_drvdata(pctldev);
 610
 611         *pins = pinctrl->soc->groups[selector].pins;
 612         *num_pins = pinctrl->soc->groups[selector].num;
 613         return 0;
 614 }
 615
 616 static struct pinctrl_ops adi_pctrl_ops = {
 617         .get_groups_count = adi_get_groups_count,
 618         .get_group_name = adi_get_group_name,
 619         .get_group_pins = adi_get_group_pins,
 620 };
 621
 622 static int adi_pinmux_set(struct pinctrl_dev *pctldev, unsigned func_id,
 623                           unsigned group_id)
 624 {
 625         struct adi_pinctrl *pinctrl = pinctrl_dev_get_drvdata(pctldev);
 626         struct gpio_port *port;
 627         struct pinctrl_gpio_range *range;
 628         unsigned long flags;
 629         unsigned short *mux, pin;
 630
 631         mux = (unsigned short *)pinctrl->soc->groups[group_id].mux;
 632
 633         while (*mux) {
 634                 pin = P_IDENT(*mux);
 635
 636                 range = pinctrl_find_gpio_range_from_pin(pctldev, pin);
 637                 if (range == NULL) /* should not happen */
 638                         return -ENODEV;
 639
 640                 port = container_of(range->gc, struct gpio_port, chip);
 641
 642                 spin_lock_irqsave(&port->lock, flags);
 643
 644                 portmux_setup(port, pin_to_offset(range, pin),
 645                                 P_FUNCT2MUX(*mux));
 646                 port_setup(port, pin_to_offset(range, pin), false);
 647                 mux++;
 648
 649                 spin_unlock_irqrestore(&port->lock, flags);
 650         }
 651
 652         return 0;
 653 }
 654
 655 static int adi_pinmux_get_funcs_count(struct pinctrl_dev *pctldev)
 656 {
 657         struct adi_pinctrl *pinctrl = pinctrl_dev_get_drvdata(pctldev);
 658
 659         return pinctrl->soc->nfunctions;
 660 }
 661
 662 static const char *adi_pinmux_get_func_name(struct pinctrl_dev *pctldev,
 663                                           unsigned selector)
 664 {
 665         struct adi_pinctrl *pinctrl = pinctrl_dev_get_drvdata(pctldev);
 666
 667         return pinctrl->soc->functions[selector].name;
 668 }
 669
 670 static int adi_pinmux_get_groups(struct pinctrl_dev *pctldev, unsigned selector,
 671                                const char * const **groups,
 672                                unsigned * const num_groups)
 673 {
 674         struct adi_pinctrl *pinctrl = pinctrl_dev_get_drvdata(pctldev);
 675
 676         *groups = pinctrl->soc->functions[selector].groups;
 677         *num_groups = pinctrl->soc->functions[selector].num_groups;
 678         return 0;
 679 }
 680
 681 static int adi_pinmux_request_gpio(struct pinctrl_dev *pctldev,
 682         struct pinctrl_gpio_range *range, unsigned pin)
 683 {
 684         struct gpio_port *port;
 685         unsigned long flags;
 686         u8 offset;
 687
 688         port = container_of(range->gc, struct gpio_port, chip);
 689         offset = pin_to_offset(range, pin);
 690
 691         spin_lock_irqsave(&port->lock, flags);
 692
 693         port_setup(port, offset, true);
 694
 695         spin_unlock_irqrestore(&port->lock, flags);
 696
 697         return 0;
 698 }
 699
 700 static struct pinmux_ops adi_pinmux_ops = {
 701         .set_mux = adi_pinmux_set,
 702         .get_functions_count = adi_pinmux_get_funcs_count,
 703         .get_function_name = adi_pinmux_get_func_name,
 704         .get_function_groups = adi_pinmux_get_groups,
 705         .gpio_request_enable = adi_pinmux_request_gpio,
 706         .strict = true,
 707 };
 708
 709
 710 static struct pinctrl_desc adi_pinmux_desc = {
 711         .name = DRIVER_NAME,
 712         .pctlops = &adi_pctrl_ops,
 713         .pmxops = &adi_pinmux_ops,
 714         .owner = THIS_MODULE,
 715 };
 716
 717 static int adi_gpio_request(struct gpio_chip *chip, unsigned offset)
 718 {
 719         return pinctrl_request_gpio(chip->base + offset);
 720 }
 721
 722 static void adi_gpio_free(struct gpio_chip *chip, unsigned offset)
 723 {
 724         pinctrl_free_gpio(chip->base + offset);
 725 }
 726
 727 static int adi_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
 728 {
 729         struct gpio_port *port;
 730         unsigned long flags;
 731
 732         port = container_of(chip, struct gpio_port, chip);
 733
 734         spin_lock_irqsave(&port->lock, flags);
 735
 736         writew(BIT(offset), &port->regs->dir_clear);
 737         writew(readw(&port->regs->inen) | BIT(offset), &port->regs->inen);
 738
 739         spin_unlock_irqrestore(&port->lock, flags);
 740
 741         return 0;
 742 }
 743
 744 static void adi_gpio_set_value(struct gpio_chip *chip, unsigned offset,
 745         int value)
 746 {
 747         struct gpio_port *port = container_of(chip, struct gpio_port, chip);
 748         struct gpio_port_t *regs = port->regs;
 749         unsigned long flags;
 750
 751         spin_lock_irqsave(&port->lock, flags);
 752
 753         if (value)
 754                 writew(BIT(offset), &regs->data_set);
 755         else
 756                 writew(BIT(offset), &regs->data_clear);
 757
 758         spin_unlock_irqrestore(&port->lock, flags);
 759 }
 760
 761 static int adi_gpio_direction_output(struct gpio_chip *chip, unsigned offset,
 762         int value)
 763 {
 764         struct gpio_port *port = container_of(chip, struct gpio_port, chip);
 765         struct gpio_port_t *regs = port->regs;
 766         unsigned long flags;
 767
 768         spin_lock_irqsave(&port->lock, flags);
 769
 770         writew(readw(&regs->inen) & ~BIT(offset), &regs->inen);
 771         if (value)
 772                 writew(BIT(offset), &regs->data_set);
 773         else
 774                 writew(BIT(offset), &regs->data_clear);
 775         writew(BIT(offset), &regs->dir_set);
 776
 777         spin_unlock_irqrestore(&port->lock, flags);
 778
 779         return 0;
 780 }
 781
 782 static int adi_gpio_get_value(struct gpio_chip *chip, unsigned offset)
 783 {
 784         struct gpio_port *port = container_of(chip, struct gpio_port, chip);
 785         struct gpio_port_t *regs = port->regs;
 786         unsigned long flags;
 787         int ret;
 788
 789         spin_lock_irqsave(&port->lock, flags);
 790
 791         ret = !!(readw(&regs->data) & BIT(offset));
 792
 793         spin_unlock_irqrestore(&port->lock, flags);
 794
 795         return ret;
 796 }
 797
 798 static int adi_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
 799 {
 800         struct gpio_port *port = container_of(chip, struct gpio_port, chip);
 801
 802         if (port->irq_base >= 0)
 803                 return irq_find_mapping(port->domain, offset);
 804         else
 805                 return irq_create_mapping(port->domain, offset);
 806 }
 807
 808 static int adi_pint_map_port(struct gpio_pint *pint, bool assign, u8 map,
 809         struct irq_domain *domain)
 810 {
 811         struct gpio_pint_regs *regs = pint->regs;
 812         u32 map_mask;
 813
 814         if (pint->map_count > 1)
 815                 return -EINVAL;
 816
 817         pint->map_count++;
 818
 819         /* The map_mask of each gpio port is a 16-bit duplicate
 820          * of the 8-bit map. It can be set to either high 16 bits or low
 821          * 16 bits of the pint assignment register.
 822          */
 823         map_mask = (map << 8) | map;
 824         if (assign) {
 825                 map_mask <<= PINT_HI_OFFSET;
 826                 writel((readl(&regs->assign) & 0xFFFF) | map_mask,
 827                         &regs->assign);
 828         } else
 829                 writel((readl(&regs->assign) & 0xFFFF0000) | map_mask,
 830                         &regs->assign);
 831
 832         pint->domain[assign] = domain;
 833
 834         return 0;
 835 }
 836
 837 static int adi_gpio_pint_probe(struct platform_device *pdev)
 838 {
 839         struct device *dev = &pdev->dev;
 840         struct resource *res;
 841         struct gpio_pint *pint;
 842
 843         pint = devm_kzalloc(dev, sizeof(struct gpio_pint), GFP_KERNEL);
 844         if (!pint) {
 845                 dev_err(dev, "Memory alloc failed\n");
 846                 return -ENOMEM;
 847         }
 848
 849         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 850         pint->base = devm_ioremap_resource(dev, res);
 851         if (IS_ERR(pint->base))
 852                 return PTR_ERR(pint->base);
 853
 854         pint->regs = (struct gpio_pint_regs *)pint->base;
 855
 856         res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
 857         if (!res) {
 858                 dev_err(dev, "Invalid IRQ resource\n");
 859                 return -ENODEV;
 860         }
 861
 862         spin_lock_init(&pint->lock);
 863
 864         pint->irq = res->start;
 865         pint->pint_map_port = adi_pint_map_port;
 866         platform_set_drvdata(pdev, pint);
 867
 868         irq_set_chained_handler_and_data(pint->irq, adi_gpio_handle_pint_irq,
 869                                          pint);
 870
 871         list_add_tail(&pint->node, &adi_pint_list);
 872
 873         return 0;
 874 }
 875
 876 static int adi_gpio_pint_remove(struct platform_device *pdev)
 877 {
 878         struct gpio_pint *pint = platform_get_drvdata(pdev);
 879
 880         list_del(&pint->node);
 881         irq_set_handler(pint->irq, handle_simple_irq);
 882
 883         return 0;
 884 }
 885
 886 static int adi_gpio_irq_map(struct irq_domain *d, unsigned int irq,
 887                                 irq_hw_number_t hwirq)
 888 {
 889         struct gpio_port *port = d->host_data;
 890
 891         if (!port)
 892                 return -EINVAL;
 893
 894         irq_set_chip_data(irq, port);
 895         irq_set_chip_and_handler(irq, &adi_gpio_irqchip,
 896                                 handle_level_irq);
 897
 898         return 0;
 899 }
 900
 901 static const struct irq_domain_ops adi_gpio_irq_domain_ops = {
 902         .map = adi_gpio_irq_map,
 903         .xlate = irq_domain_xlate_onecell,
 904 };
 905
 906 static int adi_gpio_init_int(struct gpio_port *port)
 907 {
 908         struct device_node *node = port->dev->of_node;
 909         struct gpio_pint *pint = port->pint;
 910         int ret;
 911
 912         port->domain = irq_domain_add_linear(node, port->width,
 913                                 &adi_gpio_irq_domain_ops, port);
 914         if (!port->domain) {
 915                 dev_err(port->dev, "Failed to create irqdomain\n");
 916                 return -ENOSYS;
 917         }
 918
 919         /* According to BF54x and BF60x HRM, pin interrupt devices are not
 920          * part of the GPIO port device. in GPIO interrupt mode, the GPIO
 921          * pins of multiple port devices can be routed into one pin interrupt
 922          * device. The mapping can be configured by setting pint assignment
 923          * register with the mapping value of different GPIO port. This is
 924          * done via function pint_map_port().
 925          */
 926         ret = pint->pint_map_port(port->pint, port->pint_assign,
 927                         port->pint_map, port->domain);
 928         if (ret)
 929                 return ret;
 930
 931         if (port->irq_base >= 0) {
 932                 ret = irq_create_strict_mappings(port->domain, port->irq_base,
 933                                         0, port->width);
 934                 if (ret) {
 935                         dev_err(port->dev, "Couldn't associate to domain\n");
 936                         return ret;
 937                 }
 938         }
 939
 940         return 0;
 941 }
 942
 943 #define DEVNAME_SIZE 16
 944
 945 static int adi_gpio_probe(struct platform_device *pdev)
 946 {
 947         struct device *dev = &pdev->dev;
 948         const struct adi_pinctrl_gpio_platform_data *pdata;
 949         struct resource *res;
 950         struct gpio_port *port;
 951         char pinctrl_devname[DEVNAME_SIZE];
 952         static int gpio;
 953         int ret = 0;
 954
 955         pdata = dev->platform_data;
 956         if (!pdata)
 957                 return -EINVAL;
 958
 959         port = devm_kzalloc(dev, sizeof(struct gpio_port), GFP_KERNEL);
 960         if (!port) {
 961                 dev_err(dev, "Memory alloc failed\n");
 962                 return -ENOMEM;
 963         }
 964
 965         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 966         port->base = devm_ioremap_resource(dev, res);
 967         if (IS_ERR(port->base))
 968                 return PTR_ERR(port->base);
 969
 970         res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
 971         if (!res)
 972                 port->irq_base = -1;
 973         else
 974                 port->irq_base = res->start;
 975
 976         port->width = pdata->port_width;
 977         port->dev = dev;
 978         port->regs = (struct gpio_port_t *)port->base;
 979         port->pint_assign = pdata->pint_assign;
 980         port->pint_map = pdata->pint_map;
 981
 982         port->pint = find_gpio_pint(pdata->pint_id);
 983         if (port->pint) {
 984                 ret = adi_gpio_init_int(port);
 985                 if (ret)
 986                         return ret;
 987         }
 988
 989         spin_lock_init(&port->lock);
 990
 991         platform_set_drvdata(pdev, port);
 992
 993         port->chip.label                = "adi-gpio";
 994         port->chip.direction_input      = adi_gpio_direction_input;
 995         port->chip.get                  = adi_gpio_get_value;
 996         port->chip.direction_output     = adi_gpio_direction_output;
 997         port->chip.set                  = adi_gpio_set_value;
 998         port->chip.request              = adi_gpio_request;
 999         port->chip.free                 = adi_gpio_free;
1000         port->chip.to_irq               = adi_gpio_to_irq;
1001         if (pdata->port_gpio_base > 0)
1002                 port->chip.base         = pdata->port_gpio_base;
1003         else
1004                 port->chip.base         = gpio;
1005         port->chip.ngpio                = port->width;
1006         gpio = port->chip.base + port->width;
1007
1008         ret = gpiochip_add(&port->chip);
1009         if (ret) {
1010                 dev_err(&pdev->dev, "Fail to add GPIO chip.\n");
1011                 goto out_remove_domain;
1012         }
1013
1014         /* Add gpio pin range */
1015         snprintf(pinctrl_devname, DEVNAME_SIZE, "pinctrl-adi2.%d",
1016                 pdata->pinctrl_id);
1017         pinctrl_devname[DEVNAME_SIZE - 1] = 0;
1018         ret = gpiochip_add_pin_range(&port->chip, pinctrl_devname,
1019                 0, pdata->port_pin_base, port->width);
1020         if (ret) {
1021                 dev_err(&pdev->dev, "Fail to add pin range to %s.\n",
1022                                 pinctrl_devname);
1023                 goto out_remove_gpiochip;
1024         }
1025
1026         list_add_tail(&port->node, &adi_gpio_port_list);
1027
1028         return 0;
1029
1030 out_remove_gpiochip:
1031         gpiochip_remove(&port->chip);
1032 out_remove_domain:
1033         if (port->pint)
1034                 irq_domain_remove(port->domain);
1035
1036         return ret;
1037 }
1038
1039 static int adi_gpio_remove(struct platform_device *pdev)
1040 {
1041         struct gpio_port *port = platform_get_drvdata(pdev);
1042         u8 offset;
1043
1044         list_del(&port->node);
1045         gpiochip_remove(&port->chip);
1046         if (port->pint) {
1047                 for (offset = 0; offset < port->width; offset++)
1048                         irq_dispose_mapping(irq_find_mapping(port->domain,
1049                                 offset));
1050                 irq_domain_remove(port->domain);
1051         }
1052
1053         return 0;
1054 }
1055
1056 static int adi_pinctrl_probe(struct platform_device *pdev)
1057 {
1058         struct adi_pinctrl *pinctrl;
1059
1060         pinctrl = devm_kzalloc(&pdev->dev, sizeof(*pinctrl), GFP_KERNEL);
1061         if (!pinctrl)
1062                 return -ENOMEM;
1063
1064         pinctrl->dev = &pdev->dev;
1065
1066         adi_pinctrl_soc_init(&pinctrl->soc);
1067
1068         adi_pinmux_desc.pins = pinctrl->soc->pins;
1069         adi_pinmux_desc.npins = pinctrl->soc->npins;
1070
1071         /* Now register the pin controller and all pins it handles */
1072         pinctrl->pctl = pinctrl_register(&adi_pinmux_desc, &pdev->dev, pinctrl);
1073         if (IS_ERR(pinctrl->pctl)) {
1074                 dev_err(&pdev->dev, "could not register pinctrl ADI2 driver\n");
1075                 return PTR_ERR(pinctrl->pctl);
1076         }
1077
1078         platform_set_drvdata(pdev, pinctrl);
1079
1080         return 0;
1081 }
1082
1083 static int adi_pinctrl_remove(struct platform_device *pdev)
1084 {
1085         struct adi_pinctrl *pinctrl = platform_get_drvdata(pdev);
1086
1087         pinctrl_unregister(pinctrl->pctl);
1088
1089         return 0;
1090 }
1091
1092 static struct platform_driver adi_pinctrl_driver = {
1093         .probe          = adi_pinctrl_probe,
1094         .remove         = adi_pinctrl_remove,
1095         .driver         = {
1096                 .name   = DRIVER_NAME,
1097         },
1098 };
1099
1100 static struct platform_driver adi_gpio_pint_driver = {
1101         .probe          = adi_gpio_pint_probe,
1102         .remove         = adi_gpio_pint_remove,
1103         .driver         = {
1104                 .name   = "adi-gpio-pint",
1105         },
1106 };
1107
1108 static struct platform_driver adi_gpio_driver = {
1109         .probe          = adi_gpio_probe,
1110         .remove         = adi_gpio_remove,
1111         .driver         = {
1112                 .name   = "adi-gpio",
1113         },
1114 };
1115
1116 static int __init adi_pinctrl_setup(void)
1117 {
1118         int ret;
1119
1120         ret = platform_driver_register(&adi_pinctrl_driver);
1121         if (ret)
1122                 return ret;
1123
1124         ret = platform_driver_register(&adi_gpio_pint_driver);
1125         if (ret)
1126                 goto pint_error;
1127
1128         ret = platform_driver_register(&adi_gpio_driver);
1129         if (ret)
1130                 goto gpio_error;
1131
1132 #ifdef CONFIG_PM
1133         register_syscore_ops(&gpio_pm_syscore_ops);
1134 #endif
1135         return ret;
1136 gpio_error:
1137         platform_driver_unregister(&adi_gpio_pint_driver);
1138 pint_error:
1139         platform_driver_unregister(&adi_pinctrl_driver);
1140
1141         return ret;
1142 }
1143 arch_initcall(adi_pinctrl_setup);
1144
1145 MODULE_AUTHOR("Sonic Zhang <sonic.zhang@analog.com>");
1146 MODULE_DESCRIPTION("ADI gpio2 pin control driver");
1147 MODULE_LICENSE("GPL");