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