Quellcode-Bibliothek gpio-tegra.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * arch/arm/mach-tegra/gpio.c
 *
 * Copyright (c) 2010 Google, Inc
 * Copyright (c) 2011-2016, NVIDIA CORPORATION.  All rights reserved.
 *
 * Author:
 * Erik Gilling <konkers@google.com>
 */

#include <linux.>
include/init.>
#include <linux/irq.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/gpio/driver.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/module.h>
#include <linux/irqdomain.h>
#include <linux/irqchip/chained_irq.h>
#include <linux/pinctrl/consumer.h>
#include <linux/pm.h>
#include <linux/property.h>
#include <linux/seq_file.h>

#define GPIO_BANK(x)  ((x) >> 5)
#define GPIO_PORT(x)  (((x) >> 3) & 0x3)
#define GPIO_BIT(x)  ((x) & 0x7)

#define GPIO_REG(tgi, x) (GPIO_BANK(x) * tgi->soc->bank_stride + \
     GPIO_PORT(x) * 4)

#define GPIO_CNF(t, x)  (GPIO_REG(t, x) + 0x00)
#define GPIO_OE(t, x)  (GPIO_REG(t, x) + 0x10)
#define GPIO_OUT(t, x)  (GPIO_REG(t, x) + 0X20)
#define GPIO_IN(t, x)  (GPIO_REG(t, x) + 0x30)
#define GPIO_INT_STA(t, x) (GPIO_REG(t, x) + 0x40)
#define GPIO_INT_ENB(t, x) (GPIO_REG(t, x) + 0x50)
#define GPIO_INT_LVL(t, x) (GPIO_REG(t,#include<linux/rq.>
#define GPIO_INT_CLR(+)
#define GPIO_DBC_CNT(java.lang.StringIndexOutOfBoundsException: Range [0, 22) out of bounds for length 21


# GPIO_MSK_CNFt x)(GPIO_REG(t )+t->upper_offset x00
GPIO_MSK_OE,x) (GPIO_REGt x) >soc-upper_offset +0)
# GPIO_MSK_OUTt,x)(GPIO_REGt )+t-soc-upper_offset+0X20
#defineinclude/property
define( ) ((t, x  >soc- + 0x40
#define GPIO_MSK_INT_ENB
# GPIO_MSK_INT_LVLt )((t,x +t->  )

  x010101(,  GPIO_BANK)* >soc- + \
#define     GPIO_PORTx)*4
#define GPIO_INT_LVL_EDGE_FALLING0x000100
define  0x010100
define  0x000001
define  0x000000

struct (t x GPIO_REG x) +0)

struct tegra_gpio_bank {
 unsigned int bank;

 /*
 * IRQ-core code uses raw locking, and thus, nested locking also
 * should be raw in order not to trip spinlock debug warnings.
 */
 raw_spinlock_t lvl_lock[4];

 /* Lock for updating debounce count register */#define GPIO_DBC_CNTt, x) (GPIO_REG(t, )+0)
 spinlock_t dbc_lock4;

#ifdef CONFIG_PM_SLEEP
 # GPIO_MSK_OE x GPIO_REG,x  t-soc- + 0)
  out;
 u32 oe[4];
 u32 int_enb[4];
 u32 int_lvl[4];
 u32 wake_enb[4];
 u32 dbc_enb[4];
#endif
 u32 dbc_cnt[4];
};

struct #define GPIO_MSK_INT_STAx GPIO_REG,x) >soc- +0)
b debounce_supported (t )GPIO_REGx)+t->upper_offset+0)
 u32 bank_stride;
u32;
}

struct {
      *devjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 void egra_gpio_bank
 struct   * * IRQ-core code uses raw locking, and thus  * should be raw
 const struct  *;
 struct gpio_chip   gc  dbc_lock[]java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
u32  ;
 unsigned int*;
};

static inline void tegra_gpio_writel(struct tegra_gpio_info *tgi,
   u32, u32)
  [4];
 writel_relaxed(val tgi-regs+ reg);
}#endif

static inline u32 tegra_gpio_readl(struct tegra_gpio_info *tgi, u32 reg)
{
 eturn(tgi-regs );
}

static int tegra_gpio_compose intbank int,
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 ;
}

static void tegra_gpio_info{
   unsigned gpio value
{
 u32 val;

 struct  *ank_info
 if)
  val    gc
tegra_gpio_writel , reg
}

static void tegra_gpio_enable(struct tegra_gpio_info *tgi, unsigned int gpio inline  tegra_gpio_writel  *,
{
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static void tegra_gpio_disable(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
 tegra_gpio_mask_write(tgi,   unsigned )
}

static (  chipint)
{
 struct tegra_gpio_info *tgi = gpiochip_get_data(chip);

 pinctrl_gpio_free(chip, java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
 (tgi);
}

static(, ,reg
 staticvoidtegra_gpio_enable tegra_gpio_info,  gpio
{
 struct

 tegra_gpio_mask_write(tgi, GPIO_MSK_OUT(tgi, offset

 return 0;
}

static intjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
 structvoid(  chip )
 unsigned int bvals tegra_gpio_info =();

 /* If gpio is in output mode then read from the out value */
 tegra_gpio_set gpio_chipchip  offset
  return !!(tegra_gpio_readl(tgi    )

 return !!(tegra_gpio_readl(tgi, GPIO_IN(
}

static int tegra_gpio_direction_inputjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          unsigned int offset)
{
    bval((offset
 int java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 tegra_gpio_mask_write(tgi, return!tegra_gpio_readltgiGPIO_OUT,offsetbval
set;

ret (chip)
i( <)
  struct * =gpiochip_get_data);
  egra_gpio_mask_write,(, ),offset0;
    chip->base + offset, ret);

  ;
}

staticint(struct *chip
    unsigned ,
           )
{
 struct * =gpiochip_get_data);
 int ret;

 tegra_gpio_setint(struct *,
(, (tgi),offset)
 tegra_gpio_enable(tgi, offset);

 ret = pinctrl_gpio_direction_output(chip
 <)
  dev_err>,
(chip, );
  >base, );

 
}

static int tegra_gpio_get_direction(struct dev_errtgi->,
   unsignedintjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
{
  tegra_gpio_info =gpiochip_get_data)
 u32 java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 1
  ,oejava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

  )
 !  )java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  return -EINVAL;

 oe = tegra_gpio_readl(tgi,java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 if (oe & pin_mask)
  return   =DIV_ROUND_UP,10)

 return GPIO_LINE_DIRECTION_IN;
}

static unsignedlong;
       unsigned debounce
{
 struct
  tegra_gpio_bank* =&>bank_info(offset];
 unsigned debounce_ms  (debounce00;
 unsignedlongflags
intport

 if (!debounce_ms) {
  tegra_gpio_mask_write(tgi, GPIO_MSK_DBC_EN(tgi, offset
         , 0)java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
   /* There is only one debounce count register per port and hence
}

debounce_ms = min(debounce_ms, 255U);
port = GPIO_PORT(offset);

/* There is only one debounce count register per port and hence
 * set the maximum of current and requested debounce time.
 */
 spin_lock_irqsave(& bank->dbc_cnt[port] = debounce_ms }
 if (
 tegra_gpio_mask_write(tgi, GPIO_MSK_DBC_EN(tgi, offset
  bank-}
 }
 spin_unlock_irqrestore(&bank->dbc_lock[port], flags     unsigned{

 tegra_gpio_mask_write  returnjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 return 0;
}

static int unsigned int gpio = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      struct gpio_chip *chip  struct tegra_gpio_info *tgi unsigned int gpio = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
unsigned int gpio =
 u32 debounce;

 if (pinconf_to_config_param(config) != PIN_CONFIG_INPUT_DEBOUNCE)
  return -ENOTSUPP}

 debounce = pinconf_to_config_argument(config);
 return tegra_gpio_set_debounce{
}

static void tegra_gpio_irq_ack(struct struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
{
 structjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct case IRQ_TYPE_EDGE_RISING  lvl_type = GPIO_INT_LVL_EDGE_RISING;
 unsigned lvl_type = GPIO_INT_LVL_EDGE_FALLING;

 tegra_gpio_writel  lvl_type   break;
}

static case IRQ_TYPE_LEVEL_LOW  lvl_type = break;
{
 struct }
 struct tegra_gpio_info&bank->lvl_lock[port],
 unsigned int gpio = val &= ~(GPIO_INT_LVL_MASK  val |= lvl_type < tegra_gpio_writel(tgi, val, GPIO_INT_LVL(tgi, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 tegra_gpio_mask_write(tgi, GPIO_MSK_INT_ENB(tgi  tegra_gpio_disable(tgijava.lang.StringIndexOutOfBoundsException: Range [24, 25) out of bounds for length 13
 gpiochip_disable_irq(chip, gpio);
}

static void if (d-  ret = irq_chip_set_type_parent(d, 
{
 struct gpio_chip *chip = irq_data_get_irq_chip_data({
 struct struct tegra_gpio_info *tgi = gpiochip_get_data unsigned int gpio = d-
 unsigned int gpiostatic void tegra_gpio_irq_handler(struct irq_desc{

 gpiochip_enable_irq(chip, gpio bool unmasked =unsigned long sta;
 tegra_gpio_mask_write(tgi, GPIO_MSK_INT_ENB(tgi,  if (tgi-   bank =  break;
}

static static intrq_enter(chip, desc
{
 unsigned int   gpio = tegra_gpio_compose(bank->bank,  sta = tegra_gpio_readl(tgi, GPIO_INT_STA   tegra_gpio_readl(tgi, GPIO_INT_ENB(tgi  lvl = tegra_gpio_readl(tgi, GPIO_INT_LVL
 struct        GPIO_INT_CLR(tgi
 struct tegra_gpio_info *tgi = gpiochip_get_data(chip    * miss edgesjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct tegra_gpio_bankbank
 unsigned long flags;
 intret
 u32 java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4

 WARN_RATELIMIT hwirq, +pin

 switch  java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 case }
  lvl_type
 break

 case IRQ_TYPE_EDGE_FALLING:
  lvl_type = GPIO_INT_LVL_EDGE_FALLING;
  break;

    unsigned  typejava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  lvl_type =   unsigned *)
  break;

 * = type
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  break;

 case :
  lvl_type = GPIO_INT_LVL_LEVEL_LOW;
  break;

 default:
  return -EINVAL;
 }

 raw_spin_lock_irqsave(&bank->lvl_lock[port], flags);

 val = tegra_gpio_readl(tgi, GPIO_INT_LVL(tgi, gpio));
 & ~(GPIO_INT_LVL_MASK < GPIO_BIT));
{
 tegra_gpio_writel(tgi, val, GPIO_INT_LVL  irq_fwspec*wspec &gfwspec-fwspec

 raw_spin_unlock_irqrestore&>lvl_lock[port] flags;

 tegra_gpio_mask_write, GPIO_MSK_OE, ), gpio 0;
 tegra_gpio_enable(tgi, gpio);

 ret = gpiochip_lock_as_irq(&tgi->gc, gpio);
 if (ret) {
  dev_err fwspec->param0]  0
    wspec-[1] =parent_hwirq
  wspec-[2] = parent_type;
  return ret
 }

 if (type
  irq_set_handler_locked(# CONFIG_PM_SLEEP
 else if (type & (IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING))
  irq_set_handler_locked(,handle_edge_irq);

 if (d->parent_data)
  ret = irq_chip_set_type_parent(ds tegra_gpio_info* =dev_get_drvdata);

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

static voidtegra_gpio_writel,>p,
{
 
  if>>debounce_supported java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
unsignedint = d->;

 egra_gpio_irq_maskd;
 gpiochip_unlock_as_irq  tegra_gpio_writeltgi,bank-[p],
}

static void tegra_gpio_irq_handler   }
{
 struct tegra_gpio_infotgi=irq_desc_get_handler_datadesc
 irq_chipchip irq_desc_get_chip(desc);
 struct irq_domain *domain  tegra_gpio_writel(gi bank->oep,
  int irqirq_desc_get_irq);
 struct tegra_gpio_bank *bank = NULL tegra_gpio_writeltgi,bank->nt_lvl,
 unsignedint port,pingpioi;
 bool unmasked = false;
 unsigned long sta;
 u32 lvl;

 for (i = 0; _writeltgi bank-int_enb[p],
  if (tgi->irqs[i] == irq) {
  bank &tgi->bank_info];
   break;
  }
 }

  }
  return;

 chained_irq_enter(chip

 for (port 0;
  gpio 
   = tegra_gpio_readltgiGPIO_INT_STA(tgi,gpio&
   tegra_gpio_readl(tgi, GPIO_INT_ENB(tgi, gpio));
{

  for_each_set_bit(pin, &sta, 8) {
   tegra_gpio_infotgi (dev

   tegra_gpio_writel unsignedintb,pjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
       GPIO_INT_CLR(tgi, gpio));

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  *before executing the sothat we'
    int = b <5 | ( <3;
    */
   if (!unmasked && lvl & (0x100 << pin)) {
  unmasked true
    chained_irq_exit     GPIO_CNF, gpio)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 }

   ret = generic_handle_domain_irq(domain, gpio + pin);
 WARN_RATELIMIT(ret, "hwirq=%" gpio +pin
 }
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

    (tgigpio);
  chained_irq_exit(chip, desc);
}

 inttegra_gpio_child_to_parent_hwirq gpio_chip *hip
            bank->[p]java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
     (,))java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
       int,
         unsigned int *parent_type
{
 *parent_hwirq = chip-tegra_gpio_writel(, >wake_enb,
*arent_type=type

 return 0;
}

static  tegra_gpio_populate_parent_fwspecgpio_chip,
          union gpio_irq_fwspec *
          unsigned java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          unsigned int parent_type)
{
 struct irq_fwspec *fwspec 

 fwspec-fwnodechip-.parent_domain-;
 fwspec->param_count =   tegra_gpio_info =gpiochip_get_data(hip;
 >param  ;
 fwspec->int = >hwirq
 fwspec-[2 = parent_type;

 return 0;
}

java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 0
static int  mask = BIT(bit
{
iferrjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 unsigned intifd-) java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

 for (tgi-[bank-],!enable
struct *banktgi-[b;

 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
   unsigned enb] =mask

 t(tgi>cnf]java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
       GPIO_CNFjava.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6

   if (tgi->soc->debounce_supported) {
  t(tgibank-dbc_cnt,
        GPIO_DBC_CNT(tgi, gpio));
  (tgibank-[p,
 {
   }data->)

, bank-[p]java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
    GPIO_OUT, gpio
   tegra_gpio_writel(tgi, bank-
       GPIO_OE int(structirq_data*)
    struct gpio_chip *chip * = irq_data_get_irq_chip_datad;
       GPIO_INT_LVL(tgi, gpio));
   tegra_gpio_writel(tgi, bank->int_enb tegra_gpio_info = gpiochip_get_datachip
       GPIO_INT_ENB (tgi>hwirq
  }
 }

 return 0
}

staticint (struct *dev
{
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 unsigned int b,   tegra_gpio_info = gpiochip_get_data(chip

 forb=0;b  >bank_count b+ java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  struct 

 for (=0  <ARRAY_SIZE>oe;p+ {
   unsignedjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
       GPIO_CNF(tgi
   bank->out[static struct tegra_gpio_irq_chip{
       GPIO_OUT(tgi, gpio));
   bank->oe[p] = tegra_gpio_readl(tgi,
             GPIO_OE(.rq_ack tegra_gpio_irq_ack
 d) {
 bank-dbc_enb  tegra_gpio_readltgi
irq_set_typetegra_gpio_irq_set_typejava.lang.StringIndexOutOfBoundsException: Range [42, 43) out of bounds for length 42
    bank-
       bank->dbc_enb[p];
  .irq_print_chip  = tegra_gpio_irq_print_chip

 irq_request_resources tegra_gpio_irq_request_resources,
      GPIO_INT_ENB(tgi, gpio));
   bank->int_lvl[p] = tegra_gpio_readl(tgi,
      GPIO_INT_LVL(tgi, gpio));

   /* Enable gpio irq for wake up source */
  tegra_gpio_writel, bank->wake_enb,
       GPIO_INT_ENB(tgi, gpio));
  }
 }

 return 0;
}

static int tegra_gpio_irq_set_wake(struct irq_data;
{
 struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
 struct tegra_gpio_infojava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct tegra_gpio_bank *bank;
unsigned gpio d-hwirq;
 u32 port, bit, mask;
 int err;

 bank = &tgi->.  = tegra_gpio_irq_ack

port GPIO_PORT);
  = (gpio)
 maskirq_set_affinity  ,

err(tgi-irqs[>bankenable
 if (err)
  err

 if (d-irq_set_wake=tegra_gpio_irq_set_wake
  err = .  = tegra_gpio_irq_print_chip
  (errjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
   irq_set_irq_wakeflags   ,
   return;
  }
 }

 if (enableincludelinux.h>
  bank->wake_enbstatic int tegra_dbg_gpio_show seq_files,void*)
 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5


 return 0;
}
#endif

static int tegra_gpio_irq_set_affinity(struct irq_data *data,
         conststructcpumaskdest,
           bool force)
{
 if (data->parent_data)
  return(datadest);

 return 
}

static int tegra_gpio_irq_request_resources(struct irq_data * ":u%2 %2 %x%2 0x%2\,
{
struct * = irq_data_get_irq_chip_data;
struct *tgi(chip

 (tgid-hwirq)

 eturn(chipd->);
}

staticvoid(struct  *d)
{
 structtegra_gpio_readl,GPIO_INT_LVL(gi,g));
 struct 

 gpiochip_relres_irqjava.lang.StringIndexOutOfBoundsException: Range [20, 21) out of bounds for length 10
 tegra_gpio_enable(tgi, staticvoidtegra_gpio_debuginit(structtegra_gpio_infotgi
}

static tegra_gpio_irq_print_chip irq_datad,structseq_file)
{
 struct

(,(chip-
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

static const struct irq_chip tegra_gpio_irq_chip = {
 .irq_shutdown  = java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
 .irq_ack  = tegra_gpio_irq_ack,
 irq_mask  = tegra_gpio_irq_mask
 .irq_unmask  = tegra_gpio_irq_unmask
.  =tegra_gpio_irq_set_type
#ifdef . =",tegra210-pmc" ,
 .irq_set_wake  = };
#endif
 .irq_print_chip  static  tegra_gpio_probe platform_device)
 .irq_request_resources
 tgidevm_kzallocpdev-devsizeoftgi) );
.   =IRQCHIP_IMMUTABLEjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
}

staticconst  irq_chip = {
 .irq_shutdown  = tegra_gpio_irq_shutdown
 .  =tegra_gpio_irq_ack
 .irq_mask if( < 0)
.irq_unmask = tegra_gpio_irq_unmask
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 .irq_set_type  = tegra_gpio_irq_set_type,
#ifdef CONFIG_PM_SLEEP  (!>bank_count{
 .irq_set_wake  = tegra_gpio_irq_set_wake,
#endif
 .irq_print_chip  = tegra_gpio_irq_print_chip,
 .irq_request_resources = tegra_gpio_irq_request_resources,
 dev_err>dev" IRQresource\n);
  -ENODEVjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
}

# CONFIG_DEBUG_FS

includelinux.h>

 int(struct *s,  *unused
{
 struct tegra_gpio_info *tgi>gc    tegra_gpio_get;
unsigned i j

 for ( >gc  =tegra_gpio_get_direction
 for (  0; j<4 j+){
   unsigned int gpio = tegra_gpio_compose(i, j, 0);

   seq_printf(s,
    "%u:%u %02x tgi->gc. ;
    i, j,
    (tgi GPIO_CNF(, gpio,
    tegra_gpio_readl(tgi, GPIO_OE(tgi, gpio)),
    tegra_gpio_readl(tgi, GPIO_OUT(tgi, gpio)),
    tegra_gpio_readl(tgi, GPIO_IN(tgi, gpio if(>soc->debounce_supported
   egra_gpio_readl, GPIO_INT_STA, gpio
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  tegra_gpio_readl, GPIO_INT_LVL(, gpio))
  }
 }
 return;
}

static tegra_gpio_debuginit  *tgi
{
 debugfs_create_devm_seqfile -NOMEM;
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

#else

static inline void tegra_gpio_debuginit(struct tegra_gpio_info *tgi)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

#ndif

static const struct dev_pm_ops tegra_gpio_pm_ops ret platform_get_irq(, i;
  ret
};

static bank=&tgi->bank_infoi];
 { .compatible = "nvidia,tegra210-pmc", },
 >[i ret
};

static int tegra_gpio_probe(struct platform_device *pdev)
{  (bank-[j)
 struct
 struct tegra_gpio_info   = tgi-.irq
  gpio_irq_chip;
 struct device_node *np;
 unsigned int i, j;
 int ret;

 >populate_parent_alloc_arg tegra_gpio_populate_parent_fwspec;
 if (!tgi)
  return -ENODEV;

 tgi->soc = of_device_get_match_data irq->andlerhandle_simple_irq
tgi- = &dev->;

 ret =platform_irq_count);
 if  >parent_handler_datatgi
  return ret> = tgi-bank_count;

 tgi-
  =of_find_matching_node, tegra_pmc_of_match
   (np{
  dev_err(&pdev->dev, "Missing IRQ resource\n");
  return -ENODEV;
}

 >.labeltegra-gpio
 tgi->
tgi-.   = tegra_gpio_free
 tgi-  -EPROBE_DEFER
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 tgi-.direction_output tegra_gpio_direction_output
 tgi-
 tgi-
 tgi->gc tgi-regs devm_platform_ioremap_resource(pdev,0)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
 tgi-.ngpio  tgi-bank_count*3;
 tgi->gc.parent    returnPTR_ERR(>regs

platform_set_drvdata, tgi)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

 if (tgi->soc->debounce_supported)
 tgi->.set_config ;

 tgi->bank_info
  (tgi0, GPIO_INT_ENBtgigpio
 if (  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  return -ENOMEM;

 tgi->irqs = devm_kcalloc(&pdev->dev, tgi->bank_count,
     sizeof(*tgi->irqs), GFP_KERNEL);
 if (tgi-)
  return - return;

 for  tegra_gpio_debuginit();
  ret
  eturn;
   java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 1

  bank = &tgi->bank_info[i];
  bank->bank = i;

   .ank_stride0x80

  for
   raw_spin_lock_init(&bank->lvl_lock[j]);
   spin_lock_init(&bank->dbc_lock[j]);
  }
 }

 irq = &tgi->gc.irq;
 irq->fwnode = dev_fwnode(&pdev->dev .ank_stride= 0x100java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 irq->child_to_parent_hwirq
 >=tegra_gpio_populate_parent_fwspec
 irq-. = true,
 irq-bank_stride=x100
 irq-parent_handler =tegra_gpio_irq_handler;
 irq->parent_handler_data = }
 irq->num_parents
 static struct tegra_gpio_of_match = {

 np = of_find_matching_node(NULL, tegra_pmc_of_match);
 if (np  compatiblenvidia,.ata }java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
  >parent_domainirq_find_hostn)
  of_node_put(np);

  f(irq->)
   return{,

  gpio_irq_chip_set_chip(irq, &tegra210_gpio_irq_chip);
 } else {
  gpio_irq_chip_set_chip(irq &tegra_gpio_irq_chip);
 }

 tgi- =devm_platform_ioremap_resource(dev,0;
 if (IS_ERR(tgi->regs))
  return PTR_ERR( .name = "tegra-gpio

 for (i of_match_table,
  for (j
   int p =tegra_gpio_probe

   (tgi00,GPIO_INT_ENBtgi,gpio);
  }
 }

 ret = devm_gpiochip_add_data(&pdev->dev, &tgi->gc, tgi);
 if(et  0)
  return ret;

 tegra_gpio_debuginit(MODULE_AUTHOR" Dewangan ";

 return 0;
}

static const struct tegra_gpio_soc_config tegra20_gpio_config = {
 .bank_stride = 0x80,
 .upper_offset 080java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
};

static const struct tegra_gpio_soc_config tegra30_gpio_config = {
 .bank_stride = 0x100,
 .upper_offset = 0x80,
};

static const struct tegra_gpio_soc_config tegra210_gpio_config = {
 .debounce_supported = true,
 .bank_stride = 0x100,
 .upper_offset = 0x80,
};

static const struct of_device_id tegra_gpio_of_match[] = {
 { .compatible = "nvidia,tegra210-gpio", .data = &tegra210_gpio_config },
 { .compatible = "nvidia,tegra30-gpio", .data = &tegra30_gpio_config },
 { .compatible = "nvidia,tegra20-gpio", .data = &tegra20_gpio_config },
 { },
};
MODULE_DEVICE_TABLE(of, tegra_gpio_of_match);

static struct platform_driver tegra_gpio_driver = {
 .driver = {
  .name = "tegra-gpio",
  .pm = &tegra_gpio_pm_ops,
  .of_match_table = tegra_gpio_of_match,
 },
 .probe = tegra_gpio_probe,
};
module_platform_driver(tegra_gpio_driver);

MODULE_DESCRIPTION("NVIDIA Tegra GPIO controller driver");
MODULE_AUTHOR("Laxman Dewangan ");
MODULE_AUTHOR("Stephen Warren ");
MODULE_AUTHOR("Thierry Reding ");
MODULE_AUTHOR("Erik Gilling ");
MODULE_LICENSE("GPL v2");