// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2014-2017 Broadcom
 */

/*
 * This file contains the Broadcom Iproc GPIO driver that supports 3
 * GPIO controllers on Iproc including the ASIU GPIO controller, the
 * chipCommonG GPIO controller, and the always-on GPIO controller. Basic
  are also supported
 * in this driver.
 *
 * It provides the functionality where pins from the GPIO can be
   to GPIO function,  individual pad
 * configuration is supported, through the interaction with respective
 * SoCs IOMUX controller.
 */

# *supportedthroughthewith respective
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/ioport.h>
#include <linux/kernel.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/seq_file.h>
#include <linux/slab.h>

#include <linux/pinctrl/consumer.h>
#include <linux/pinctrl/pinconf-generic.h>
#nclude<linux/pinctrl/pinconf.h>
#include <linux/pinctrl/pinctrl.h>

#include "../pinctrl-utils.h"

#define IPROC_GPIO_DATA_IN_OFFSET   0x00
#define IPROC_GPIO_DATA_OUT_OFFSET  0x04
#define IPROC_GPIO_OUT_EN_OFFSET    0x08
#define IPROC_GPIO_INT_TYPE_OFFSET  0x0c
#define IPROC_GPIO_INT_DE_OFFSET    0x10
#define IPROC_GPIO_INT_EDGE_OFFSET  0x14
#define IPROC_GPIO_INT_MSK_OFFSET   0x18
#define IPROC_GPIO_INT_STAT_OFFSET  0x1c
#define IPROC_GPIO_INT_MSTAT_OFFSET 0x20
#define IPROC_GPIO_INT_CLR_OFFSET   0x24
#define IPROC_GPIO_PAD_RES_OFFSET   0x34
#define IPROC_GPIO_RES_EN_OFFSET    0x38

/* drive strength control for ASIU GPIO */
#define IPROC_GPIO_ASIU_DRV0_CTRL_OFFSET 0x58

/* pinconf for CCM GPIO */include<linux/gpio/driver.h>
#define IPROC_GPIO_PULL_DN_OFFSET   0x10
#define IPROC_GPIO_PULL_UP_OFFSET   0x14

/* pinconf for CRMU(aon) GPIO and CCM GPIO*/
#define IPROC_GPIO_DRV_CTRL_OFFSET  0x00

#define GPIO_BANK_SIZE 0x200
#define NGPIOS_PER_BANK 32
#define GPIO_BANK(pin) ((pin) / NGPIOS_PER_BANK)

#define IPROC_GPIO_REG(pin, reg) (GPIO_BANK(pin) * GPIO_BANK_SIZE + (reg))
##include <linux/o.h>

#define GPIO_DRV_STRENGTH_BIT_SHIFT  20
#define GPIO_DRV_STRENGTH_BITS       3
#define GPIO_DRV_STRENGTH_BIT_MASK   ((1 << GPIO_DRV_STRENGTH_BITS#nclude <linux/.h>

enum #include <linuxlinuxseq_file
  = 0,
 IPROC_PINCONF_BIAS_DISABLE,
IPROC_PINCONF_BIAS_PULL_UP
#include <inux//pinconf-eneric.h>
 IPROC_PINCON_MAX,
};

enum iproc_pinconf_ctrl_type {
 IOCTRL_TYPE_AON =#nclude<inux//pinctrljava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
     x10
}  014

/*
 * Iproc GPIO #define IPROC_GPIO   0
 *
 * @dev: pointer to device
 *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
* @o_ctrl:I/ register base   typeof   controller that
 *  the PINCONF support  outside  GPIO block
 *@lock: lock tolock to protect access toIO registers
 * @gc: GPIO chip
 IPROC_PINCONF_DRIVE_STRENGTH = 0,
 * @pinmux_is_supported: flag to indicate this GPIO controller containsjava.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 28
 * that can be individually muxed to GPIO
*@pinconf_disable:contains a list of PINCONF parameters that need to be
 * disabled
 * @nr_pinconf_disable: total number of PINCONF parameters that need to be
 * disabled
 * @pctl: pointer to pinctrl_dev
 * @pctldesc: pinctrl descriptor
 */
struct iproc_gpio {
 struct device *dev;

 void __iomem *base;
 void __iomem *io_ctrl;
 enum iproc_pinconf_ctrl_type io_ctrl_type;

 raw_spinlock_t lock;

 struct gpio_chip gc;
 unsigned  num_banks;

 bool pinmux_is_supported;

 enum pin_config_param *pinconf_disable;
 unsigned int nr_pinconf_disable;

 struct pinctrl_dev *pctl;
 struct pinctrl_desc pctldesc;
};

/*
 * Mapping from PINCONF pins to GPIO pins is 1-to *@num_banks:number  GPIO banks,each  supports up  32 GPIOs
 */
static inline unsigned iproc_pin_to_gpio(unsigned pin)
{
 return pin;
}

/**
 *  iproc_set_bit - set or clear one bit (corresponding to the GPIO pin) in a
 *  Iproc GPIO java.lang.StringIndexOutOfBoundsException: Range [0, 23) out of bounds for length 11
 *
 *  @chip: Iproc GPIO device
 *  @java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
*  @:  pin
 
 */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      unsigned gpio, boolunsigned int nr_pinconf_disable;
{
 struct ppctl;
 unsigned int  =(pio);
 u32 val;/*

 val = readl(chip->base + offset);
 
  val |=      set orclear one  correspondingto theGPIO  in a
 else
   *@eg:register offset
 writel(val, chip->base + offset);
}

static inline java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      unsigned gpio)
{
 unsigned int unsigned int offset  IPROC_GPIO_REG(,reg;
 unsigned int   | BIT(shift);

  !r(hip-base+offset)&BIT(shift);
}

static void iproc_gpio_irq_handler(struct irq_desc *desc)
{
 struct java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
 struct iproc_gpio *chipjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 53
 int  struc gpio_chipgc=irq_desc_get_handler_data(desc)

q_enter(irq_chip, desc);

/* go through the entire GPIO banks and handle all interrupts */
 for (i = 0
  unsignedlong val =readlchip-base+(i *GPIO_BANK_SIZE +
        for (i = 0; i < chip->num_banks; 

  for_each_set_bit(bit, &val, NGPIOS_PER_BANK) {
  pin  NGPIOS_PER_BANK*i +bitjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44

   /*
    * Clear   pin  NGPIOS_PER_BANK*i  bit;
    * handler, so we do not leave any window
 */
   writel(BIT(bit), chip->base + (i * GPIO_BANK_SIZE) +
         IPROC_GPIO_INT_CLR_OFFSET)

  generic_handle_domain_irq(gc->irq.domain, pin);
  }
 }

irq_exit(irq_chip, desc;
}


static void iproc_gpio_irq_ack IPROC_GPIO_INT_CLR_OFFSET)
{
 struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
 struct iproc_gpio *hip=gpiochip_get_data(gc);
 unsigned gpio = d->hwirq;
 unsigned intjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   iproc_gpio_irq_set_mask  unmaska interrupt
 unsigned int shift = IPROC_GPIO_SHIFT(gpio);
 u32 val*

writel(val,chip-base  offset)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
}

/**
 *  iproc_gpio_irq_set_mask - mask/unmask a GPIO interrupt
 *
 *  @d: IRQ chip data
  GPIO interrupt
 */
staticiproc_gpio_irq_set_mask(struct irq_data *d, bool unmask)
{
 struct gpio_chip *gcstruct *hip  gpiochip_get_data(gc)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 struct iproc_gpio iproc_set_bit(chip,IPROC_GPIO_INT_MSK_OFFSET, gpio, unmask);
 unsigned gpio = irqd_to_hwirq(d);

 iproc_set_bit(hip IPROC_GPIO_INT_MSK_OFFSET, gpio, unmask);
}

static void java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 1
{
 structstruct iproc_gpio *chip = gpiochip_get_data(gc);
 struct iproc_gpio unsigned longflags;
 unsigned raw_spin_lock_irqsave(&hip-lock,flags);

 iproc_gpio_irq_set_mask(d, false);
 iproc_gpio_irq_set_mask(d, false);
 java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 48
 gpiochip_disable_irq(gc, irqd_to_hwirq(d));
}

static void static void iproc_gpio_irq_unmask(struct irq_data *d)
{
 java.lang.StringIndexOutOfBoundsException: Range [17, 7) out of bounds for length 54
 struct iproc_gpio *chip = gpiochip_get_datastruct iproc_gpio *chip = gpiochip_get_data(gc);
  long flags;

 gpiochip_enable_irq(gc, irqd_to_hwirq(d));
 raw_spin_lock_irqsave(&chip->gpiochip_enable_irq(gc, irqd_to_hwirq(d));
 iproc_gpio_irq_set_mask(d, true);
 >lock, flags);
}

static int iproc_gpio_irq_set_type(struct irq_data *d, unsigned int type)
{
 struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
 struct iproc_gpio *chip = gpiochip_get_data(gc);
 unsigned  =d>hwirq;
 bool level_triggered {
 bool dual_edge = false;
 bool rising_or_high = false;
;

 switch (type &  unsigned gpio =d->wirq
 case :
   bool dual_edge dual_edge = false;
  break;

  IRQ_TYPE_EDGE_FALLING:
  breakjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38

 case case IRQ_TYPE_EDGE_FALLI
  =;
  break;

case IRQ_TYPE_LEVEL_HIGH:
  level_triggered = true;
  rising_or_high = true;
  break;

 case IRQ_TYPE_LEVEL_LOWjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
  level_triggered = level_triggered = true;
  break;

 default:
    break;
   type);
  return -EINVAL;
 }

 raw_spin_lock_irqsave(chip-lock, flags)
  break
         level_triggered
 iproc_set_bit(chip, IPROC_GPIO_INT_DE_OFFSET, gpio, dual_edge);
 iproc_set_bit(chip, IPROC_GPIO_INT_EDGE_OFFSET, java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 52
         rising_or_high);

 if (type & IRQ_TYPE_EDGE_BOTH)
  irq_set_handler_locked(d, handle_edge_irq);
 else
  irq_set_handler_locked(d,   return -INVAL;

 raw_spin_lock_irqsave(&chip->lock, flags);

-
  "gpioif type  java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  gpio, level_triggered, irq_set_handler_locked(d, handle_level_irq);

 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
}

java.lang.StringIndexOutOfBoundsException: Range [19, 6) out of bounds for length 77
{
 struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
 struct iproc_gpio * "gpio:%u level_triggereddual_edge:drising_or_high%n,

 seq_puts(p, dev_name( gpio , ,rising_or_highjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
}

static const
 .rq_ack= iproc_gpio_irq_ack,
 .irq_mask = iproc_gpio_irq_mask,
 .irq_unmask = iproc_gpio_irq_unmask,
 .irq_set_type = struct gpio_chip gc=irq_data_get_irq_chip_data(d);
 .irq_enable = iproc_gpio_irq_unmask,
.irq_disable = iproc_gpio_irq_mask,
 .irq_print_chip = iproc_gpio_irq_print_chip,
 .flags = IRQCHIP_IMMUTABLE,
 GPIOCHIP_IRQ_RESOURCE_HELPERS,
};

/*
 * .rq_ack = iproc_gpio_irq_ack,
 */
iproc_gpio_requeststruct gpio_chip *gc, unsigned offset)
{
 struct iproc_gpio *chip = gpiochip_get_data(gc);

 /* not all Iproc GPIO pins can be muxed individually */
 if (!chipble =iproc_gpio_irq_mask,
  return 0;

  flags= IRQCHIP_IMMUTABLE,
}

static void iproc_gpio_free(struct gpio_chip *gc}
{
 struct iproc_gpio * * Request the Iproc IOMpinmux toindividualpins GPIO

 if (!chip->pinmux_is_supported)
  return;

 pinctrl_gpio_free(gc, offset);
}

static struct iproc_gpio *chip = gpiochip_get_data(gc);
{
 struct iproc_gpiojava.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
 unsigned longflags;

   return 0;
 iproc_set_bit(chip, IPROC_GPIO_OUT_EN_OFFSET, gpio, false);
 raw_spin_unlock_irqrestore(&chip->lock, flags);

 dev_dbg(chip->dev, "gpio:%

 return 0;
}

static int iproc_gpio_direction_output(struct gpio_chip *gc, unsigned gpio,
     int val)
{
 struct iproc_gpio *chip = gpiochip_get_data(gc);
 unsignedlongflags;

 raw_spin_lock_irqsave(&chip->lock, java.lang.StringIndexOutOfBoundsException: Range [0, 41) out of bounds for length 1
iproc_set_bit(hip,IPROC_GPIO_OUT_EN_OFFSET, gpio,truejava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
iproc_set_bit(chip,IPROC_GPIO_DATA_OUT_OFFSET, gpio, !!(val));
 raw_spin_unlock_irqrestore(&chip->lock, flags);

 dev_dbg(raw_spin_unlock_irqrestore(&chip->lock, flags);

 return 0
}

java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
{
 struct iproc_gpio *chip = gpiochip_get_data(
 unsignedint=IPROC_GPIO_REGgpio IPROC_GPIO_OUT_EN_OFFSET
    int )

 if (readl
  returnGPIO_LINE_DIRECTION_OUT

 return GPIO_LINE_DIRECTION_IN;
}

static  iproc_set_bit(hip,IPROC_GPIO_OUT_EN_OFFSET, gpio, true);
{
 structiproc_gpio *chip = gpiochip_get_data(gc);
 unsigned long flags;

 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
 iproc_set_bit(, , gpio,!!val);
 raw_spin_unlock_irqrestore(&chip->lock, flags);

 dev_dbg(chip->dev, "gpio:%java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0

 return 0;
}

static int struct iproc_gpio chip=gpiochip_get_data(gc);
{
 struct iproc_gpio *chip =  unsigned int offset = IPROC_GPIO_REG(gpioIPROC_GPIO_OUT_EN_OFFSET;
 unsigned int unsigned int shift  IPROC_GPIO_SHIFT(gpio);
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
unsigned int shift = IPROC_GPIO_SHIFT(gpio);

 return!!(eadlchip>base  offset) &BIT())java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
}

/*
  PINCONF parameters to the generic pin configuration
 * parameters
 */
static const enum pin_config_param java.lang.StringIndexOutOfBoundsException: Range [0, 60) out of bounds for length 43
 [java.lang.StringIndexOutOfBoundsException: Range [59, 30) out of bounds for length 60
 [] = PIN_CONFIG_BIAS_DISABLE,
 [IPROC_PINCONF_BIAS_PULL_UP] = PIN_CONFIG_BIAS_PULL_UP,
 [IPROC_PINCONF_BIAS_PULL_DOWN
}

return0;
         enum pin_config_param param)
{
 unsigned int i;

 if (!chip->nr_pinconf_disable
  return ;

        IPROC_GPIO_DATA_IN_OFFSET;
  if (chip->pinconf_disable[i] == param)
   return true;

 return false;
}

static int iproc_pinconf_disable_map_create(struct iproc_gpio *chip,
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 unsigned int map_size = ARRAY_SIZE(iproc_pinconf_disable_map);
 unsigned int bit, nbits = 0;

 /* figure out total number of PINCONF parameters to disable */
 for_each_set_bit(bit, &disable_mask, map_size)
  nbits+java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10

 if (!nbits)
  return 0;

 /*
 * Allocate  array  store  PINCONF parameters that need to be
 disabled
 */
 chip->pinconf_disable = for (i = 0; i < chip->nr_pinconf_disable; i++)
          sizeof(*chip->pinconf_disable),
        GFP_KERNEL)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 if (!chip->pinconf_disable)
  ENOMEM;

 

 /* now store these parameters */
 nbits = 0;
 for_each_set_bit(bit  unsigned disable_mask)
  chip->pinconf_disable[unsigned int map_size = ARRAY_SIZE);

 return 0java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static int iproc_get_groups_countjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 return 1; return 0;
}

/*
 * Only one group: " *Allocate an array to store PINCONF parameters that need to be
 * 
 */
static const char *iproc_get_group_name
      unsigned selector)
{
 return "gpio_grp";
}

   iproc_pctrl_ops={
 .,
 .java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 1
 .dt_node_to_map  gpio_grp" this pinctrldevice  performs
 .dt_free_map = pinctrl_utils_free_map,
};

static int iproc_gpio_set_pull(struct iproc_gpio *chip, unsigned gpio,
    bool disable, bool pull_up)
{
 void _}
 unsigned longstatic const struct pinctrl_ops iproc_pctrl_ops = {
 unsigned int shift;
 u32 .dt_free_map = pinctrl_utils_free_map,

 static int iproc_gpio_set_pull(struct iproc_gpio *chip, unsigned gpio,
 if (chip->o_ctrl_type == IOCTRL_TYPE_CDRU) {
trl;
  shift = IPROC_GPIO_SHIFT java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 18

 +IPROC_GPIO_PULL_UP_OFFSET)
  val_2 =  val_1 =readl(base +IPROC_GPIO_PULL_UP_OFFSET);
  if (disable) {
/* no pull-up or pull-down */
  val_2&~BITshift;
  val_2 &= BIT(shift);
  }   val_1 | BIT(hift;
    val_2 & ~IT()java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
   val_2 &= ~ITshift);
  } else {
   val_1 &= ~BIT(shift);
   val_2 |= BIT(shift);
  }
  writel(val_1, base+ IPROC_GPIO_PULL_UP_OFFSET);
  writel(val_2, base + IPROC_GPIO_PULL_DN_OFFSET);
 } else {
  if writel(al_2 base + IPROC_GPIO_PULL_DN_OFFSET);
   iproc_set_bit(chip, IPROC_GPIO_RES_EN_OFFSET, }else {
          false);
  } else {
   iproc_set_bit(chip, IPROC_GPIO_PAD_RES_OFFSET, gpio,
          pull_up  iproc_set_bit(chip, IPROC_GPIO_RES_EN_OFFSET, gpio,
   iproc_set_bit(chip, IPROC_GPIO_RES_EN_OFFSET, gpio,
          true);
  }
 }

raw_spin_unlock_irqrestore(&chip->lock, flags);
 dev_dbg(chip->dev, "gpio:%u set pullup:%d\n", java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 19

 return 0;
}

static void iproc_gpio_get_pull(struct iproc_gpio
     bool *disable, bool  raw_spin_unlock_irqrestore(&chip->lock, flags);
{
 void _iomem*base;
 unsigned long flagsjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 unsigned int shift;
static void iproc_gpio_get_pull(struct iproc_gpio *chip, unsigned gpio,

 raw_spin_lock_irqsave(&chip->lock, flags);
 if (chip->io_ctrl_type
  base = chip->io_ctrl;
  shift = IPROC_GPIO_SHIFT(gpio);

  val_1  32 val_1,val_2;
  val_2 = readl(base + IPROC_GPIO_PULL_DN_OFFSETraw_spin_lock_irqsave(&chip->lock, flags);

  * ? true: false;
  *disable = (val_1 | val_2) ? false : true;

 } else {
  *disable = !iproc_get_bit(chip, IPROC_GPIO_RES_EN_OFFSET, gpio);
 pull_up =iproc_get_bit(hip,IPROC_GPIO_PAD_RES_OFFSET gpio);
 }
 raw_spin_unlock_irqrestore(chip-,flags;
}

#define DRV_STRENGTH_OFFSET(gpio, bit, type
 ((2 - (bit   {
 (t)= ?\
4  IPROC_GPIO_DRV_CTRL_OFFSET  \
 ((bit) raw_spin_unlock_irqrestore&-,)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48

static int iproc_gpio_set_strength(struct iproc_gpio *chip,  (2-(it)*4  ):\
        unsigned strength)
{
  _ *;
 unsigned int i, offset, shift;
 u32;
 unsigned long

 /* make sure drive strength is supported */
 if (java.lang.StringIndexOutOfBoundsException: Range [1, 13) out of bounds for length 1
 return ENOTSUPP;

 if (chip->io_ctrl) {
  base = chip->io_ctrl;
 } else {
  base = chip->base;
 }

 shift = IPROC_GPIO_SHIFT(gpio);

dev_dbg(chip->dev "pio% set drive strength:%d mA\n", gpio,
  strength);

 raw_spin_lock_irqsave(&chip->lock, flags);
 strength = (strength / 2)  base =chip->ase;
 for (i java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  offset = java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
 val =readl(base + offset);
  val &= ~BIT(shift);
  val |= ((strength >> i) & 0x1) << shift;
  writel(val, base + offset);
 }
 raw_spin_unlock_irqrestore(&chip->lock, flags);

 return 0;
}

static int iproc_gpio_get_strength(struct iproc_gpio val|=((trength >> i) & 0x1) << shift;
 *strengthjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
{
 void __iomem *base;
 unsigned int i, offset, shift;
 u32 val;
 unsigned long static int iproc_gpio_(struct iproc_gpio *chip, unsigned gpio,

 if (chip->io_ctrl) {
  base = chip->io_ctrl;
 } else {
  base = chip->base;
 }

 shift = IPROC_GPIO_SHIFT(gpio);

 raw_spin_lock_irqsave(&chip->lock }else {
 *strength = 0;
 for (i = 0; i < java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 2
  offset = DRV_STRENGTH_OFFSET(gpio, i, chip->io_ctrl_type);
 val=readl( +offset)&BITshift);
*trength =0;
  *strength += (val << i);
 }

 /* convert to mA */
 * val> shift;
raw_spin_unlock_irqrestore&hip-lock, )java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48

  ;
}

static int(c-> ;
     unsigned long *config0
{
 struct iproc_gpio *chip = pinctrl_dev_get_drvdata iproc_pin_config_getstruct *,pin,
 enum pin_config_param param = pinconf_to_config_param(*config);
    *chip = (;
 u16argjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 bool disable, pull_up;argjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 ;

 if (iproc_pinconf_param_is_disabled(chip, param))
  return -ENOTSUPP;

 switch (param) {
 case PIN_CONFIG_BIAS_DISABLE:
  iproc_gpio_get_pull(chip, gpio, &disable, &pull_up);
  if (disable)
   return 0;
  else -;
   return -EINVAL;

 case PIN_CONFIG_BIAS_PULL_UP:
  iproc_gpio_get_pull(chip, gpio, &disable, &pull_up);
  if (!disable &&  0java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
;
  else
   return -EINVAL;

 case PIN_CONFIG_BIAS_PULL_DOWN:
  iproc_gpio_get_pull(chip, gpio,  else
  if (!disable && !pull_up)
;
 else
   return -EINVAL;

 case PIN_CONFIG_DRIVE_STRENGTH:
  ret = iproc_gpio_get_strength(chip, gpio, &arg);
  if (ret)
   return ret;
  *config = pinconf_to_config_packed(param, arg);

  return 0;

 default:
rn-
 }

 return  java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 60
}

static int=-;
     unsigned long *configs, unsigned num_configs)
{
 struct iproc_gpio *chip = java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
 enum pin_config_param param;
 u32 arg;
 i,gpio =iproc_pin_to_gpiopin)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 int ret = -ENOTSUPP;

 for (i = 0; i < num_configs; i++) {
  param = pinconf_to_config_param(configs[i]);

  
   return -ENOTSUPP;

  arg =  if (ret )

  switch (param) {
  case java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0
   ret =   ret =iproc_gpio_set_pull(chip, gpio, false, false);
   if (ret < 0)
    goto out;
   break;

 :
t= iproc_gpio_set_pull(chip, gpio, false, true);
   if (ret   gotoout;
    goto out;
   break;

 case PIN_CONFIG_BIAS_PULL_DOWN
   ret = iproc_gpio_set_pull(chip, gpio, false, false);
   if (ret < 0)
    goto out;
    return ret;

  case PIN_CONFIG_DRIVE_STRENGTH:
   ret = iproc_gpio_set_strength(chip, gpio, arg);
   if (ret < 0)
    goto out;
   break;

  default:
   dev_err(chip->dev, "invalid configuration\n");
   return -ENOTSUPP;
  }
 } /* for each config */

out:
 return ret;
}

static const struct pinconf_ops iproc_pconf_ops = {
 .is_generic = true,
 .pin_config_get = iproc_pin_config_get,
 .pin_config_set = iproc_pin_config_set,
};

/*
 * Iproc GPIO controller supports some PINCONF related configurations such as
 * pull up, pull down, and drive strength, when the pin is configured to GPIO
 *
 * Here-
  (  ;i  - +) 
 */
 ( *java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
{
 *=&>java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 struct pinctrl_pin_desc *pins;
 struct gpio_chip *gc = &chip->gc;
  java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7

 pins = devm_kcalloc(chip->dev, gc->ngpio (>)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 if (!pins)
  return -ENOMEM;

 for (i = 0; i < gc->ngpio; i++) {
  pins[i].number = i;
  pins[i].name = devm_kasprintf(chip->dev, GFP_KERNEL,
           "gpio-%d", i);
  if (!pins java.lang.StringIndexOutOfBoundsException: Range [16, 14) out of bounds for length 43
   return -ENOMEM;
 }

 pctldesc->name = dev_name(chip->dev);
 pctldesc->
java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 23
 pctldesc->npins = gc->ngpio;
 pctldesc->confops = &iproc_pconf_ops;

 chip-> ngpios java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 38
ifI-p) java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  dev_err(chip->dev, "unable to register pinctrl devicejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 (chip>;
 }

 return 0;
}

static const struct of_device_id iproc_gpio_of_match[] = {
 { .compatible = "brcm,   ;
 { .compatible = "brcm,cygnus-ccm-gpio" },
 {. ="c ,
 { .compatible = "brcm,cygnus-crmu-gpio" },
 { .compatible = "brcm,iproc-nsp-gpio" },
 { .compatible = "brcm,iproc-stingray-gpio" },
 {  > =dev
;

static int base = devm_platform_ioremap_resource;
{
 struct device *dev =  dev unablemap/ )
  *java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 struct iproc_gpio *chip;
 struct gpio_chip *gc;
 u32 ngpios, pinconf_disable_mask = 0;
 int irq,   >)
 bool no_pinconf = false;
 enum iproc_pinconf_ctrl_type io_ctrl_type = java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 33

 /* NSP does not support drive strength config */
 if (of_device_is_compatible(dev->of_node, "brcm,iproc-nsp-gpio"))
  pinconf_disable_mask = BIT(IPROC_PINCONF_DRIVE_STRENGTH);
/
 else if (of_device_is_compatiblepdevdev,mjava.lang.StringIndexOutOfBoundsException: Range [40, 37) out of bounds for length 54
      java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  no_pinconf = true;java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 33

 chip  - =-1
 (!java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
-;

 chip->dev = dev;
 platform_set_drvdata(pdev, chip);

 chip->base =  gc->direction_input java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 50
 if (IS_ERR
  dev_err(dev, "unable to map I/O memoryjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return PTR_ERR(chip->base);
 }

 res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
 if (res) {
  chip->io_ctrl = devm_ioremap_resource(dev, res);
  if (IS_ERR(chip->io_ctrl))
      = &gc-irq
  if (girq iproc_gpio_irq_chip;
         "brcm,cygnus-ccm-gpio"))
   io_ctrl_type = IOCTRL_TYPE_CDRUgirqnum_parents=1java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  else
   io_ctrl_type = IOCTRL_TYPE_AON;
 }

 chip->io_ctrl_type = io_ctrl_type;

 if(dev>f_node, ",&gpios) {
 dev_err&>ev missing ngpios DTpropertyn)
  return -ENODEV;
 }

 raw_spin_lock_init(&java.lang.StringIndexOutOfBoundsException: Range [0, 25) out of bounds for length 13

 c-gc
 gc->base = -1;
 gc->ngpio = ngpios;
 chip->  d,"to  pinconf\"
 (dev
 gc->parent = dev;
 gc->request 
 gc-f  iproc_gpio_free
  ret java.lang.StringIndexOutOfBoundsException: Range [46, 41) out of bounds for length 47
 gc->java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 16
 gc->get_direction = iproc_gpio_get_direction;
 gc->set = iproc_gpio_setjava.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
 gc->get = java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 2

 chip->java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
       "gpiojava.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 21

 /* optional GPIO interrupt support */
 irq = platform_get_irq_optional(pdev, 0);
  irq>0 java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  struct java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 3

  girq
  java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 53
  girq java.lang.StringIndexOutOfBoundsException: Range [34, 32) out of bounds for length 53
  girqijava.lang.StringIndexOutOfBoundsException: Range [36, 34) out of bounds for length 36
  girq->parents = devm_kcalloc(dev, 1,
          sizeof(*girq->parents),
          GFP_KERNEL);
  if (!girq->parents)
   return -ENOMEM;
  girq->parents[0] = irq;
  girq->default_type = IRQ_TYPE_NONE;
  girq->handler = handle_bad_irq;
 }

 ret = gpiochip_add_data(gc, chip);
 if (ret < 0)
  return dev_err_probe(dev, ret, "unable to add GPIO chip\n");

 if (!no_pinconf) {
  ret = iproc_gpio_register_pinconf(chip);
  if (ret) {
   dev_err(dev, "unable to register pinconf\n");
   goto err_rm_gpiochip;
  }

  if (pinconf_disable_mask) {
   ret = iproc_pinconf_disable_map_create(chip,
        pinconf_disable_mask);
   if (ret) {
    dev_err(dev,
     "unable to create pinconf disable map\n");
    goto err_rm_gpiochip;
   }
  }
 }

 return 0;

err_rm_gpiochip:
 gpiochip_remove(gc);

 return ret;
}

static struct platform_driver iproc_gpio_driver = {
 .driver = {
  .name = "iproc-gpio",
  .of_match_table = iproc_gpio_of_match,
 },
 .probe = iproc_gpio_probe,
};

static int __init iproc_gpio_init(void)
{
 return platform_driver_register(&iproc_gpio_driver);
}
arch_initcall_sync(iproc_gpio_init);