Quelle  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>
 */

# * Erik/errh
## <linuxhjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
 /.
#include <linuxt, x) (GPIO_REG(t, x) +0x70
#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/consumerdefine(, GPIO_REG,x) >soc- +0)
#include(t x ((,x +t->upper_offset x10define( x (,x  >>  )
# <linux.h>
# GPIO_MSK_INT_STAt,x) GPIO_REG, )+t->upper_offset0)

define(,x GPIO_REG ) >soc-upper_offset+0x60
#define GPIO_PORT(x)  (((
#defineGPIO_INT_LVL_MASK 0

#define GPIO_REGtgix)((x * tgi->bank_stride\
 (  )

#define x000100
# GPIO_INT_LVL_EDGE_BOTH
# GPIO_INT_LVL_LEVEL_HIGH
## GPIO_INT_LVL_LEVEL_LOW
#struct tegra_gpio_info;
#defineGPIO_INT_ENB,x)((t,)+x50
#define GPIO_INT_LVL(t,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#define GPIO_INT_CLR(t, x) (GPIO_REG  * should be raw in order not  
 (  GPIO_REG,x  xF0


#define GPIO_MSK_CNF(t, x) (GPIO_REG spinlock_t [4;
define(t,)((t x)+t->>upper_offsetx10
#define GPIO_MSK_OUT(t, x)u32[4]java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
(t, x)((t,x)+t->upper_offset x40
#define GPIO_MSK_INT_ENB(t, ool;
#define GPIO_MSK_INT_LVL,x ((t, )  >soc-upper_offset +x60

  upper_offset
;
#struct tegra_gpio_info
#structdevice;
#define GPIO_INT_LVL_LEVEL_HIGH  0x000001
#define GPIO_INT_LVL_LEVEL_LOW  0x000000

struct tegra_gpio_info;

structt {
 unsigned tegra_gpio_bank*bank_info;

 /*
 * 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 */structtegra_gpio_soc_configsoc
 spinlock_tdbc_lock[];

#ifdef CONFIG_PM_SLEEP
 u32 cnf[4];
 u32 out[4];
 u32 u32    bank_count
 unsigned    irqs
 u32 int_lvljava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 u32       val reg
 u32dbc_enbwritel_relaxed,> reg
endifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 u32 dbc_cntr readl_relaxed> +reg
} unsigned(unsigned , unsigned port

struct tegra_gpio_soc_config {
 bool debounce_supported;
 u32 bank_stride;
 u32 upper_offset
}

struct {
 struct    int, u32)
 void
  tegra_gpio_bank *ank_info;
 const struct (value
 structgpio_chip ;
 u32 (tgi,val );
 unsigned}
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

staticinline void(structtegra_gpio_infotgi
         u32 val, u32 reg)
{
 writel_relaxed(val, tgi->regs + reg
}

static inline u32 tegra_gpio_readl(struct tegra_gpio_info *tgi, u32 
{
 return readl_relaxed(tgi->regs + reg);
}

static unsigned int tegra_gpio_compose(unsigned
          intbit
{
 return
}

static void tegra_gpio_mask_write(struct tegra_gpio_info *tgi, u32 reg voidtegra_gpio_freestructgpio_chip*, unsigned int offset
      unsigned int gpio, u32 value
{
 u32 val;

 val = 0x100 << GPIO_BIT(gpio);
 if (value)
  val |= 1 << tegra_gpio_disable, offset
 tegra_gpio_writeltgival );
}

static void tegra_gpio_enable(struct *tgi unsignedintgpio)
{
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 tegra_gpio_mask_write(tgi, GPIO_MSK_CNF(tgi, gpio), gpio, 0);
}

static  tegra_gpio_freestructgpio_chip*, unsigned intoffset
{
 structtructtegra_gpio_info *tgi gpiochip_get_datachip

 pinctrl_gpio_freejava.lang.StringIndexOutOfBoundsException: Range [18, 19) out of bounds for length 0
 tegra_gpio_disable(tgi, offset);
}

staticint (structgpio_chip *chip, unsignedintoffset,
  intvalue
{
 struct tegra_gpio_info *tgi = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 tegra_gpio_mask_write(tgi,java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 return 0;
}

static int tegra_gpio_get(struct gpio_chip *chip, unsigned int offset)
{
 struct tegra_gpio_info *tgi = gpiochip_get_data(chip);
unsignedint = BITGPIO_BIT));

 /* If gpio is in output mode then read from the out value */
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  !(tegra_gpio_readl(tgi, (tgi )) & );

 return !!(tegra_gpio_readl);
}

 ret = pinctrl_gpio_direction_input, offset;
   f ret 0
{
 struct tegra_gpio_infotgi gpiochip_get_data(chip;
 int ret;

t(tgi GPIO_MSK_OEtgioffset offset, 0)java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
 tegra_gpio_enable(tgi

  returnret
 if
  dev_errstatic  tegra_gpio_direction_output gpio_chip*,
   " intoffset,
    chip- intvalue

 return ret tegra_gpio_infotgi gpiochip_get_data(chip
}

static  tegra_gpio_direction_output gpio_chip*hip
           unsigned int  tegra_gpio_mask_writetgiGPIO_MSK_OE, offset,offset, 1;
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct  < 0
 int ret(tgi-dev

 tegra_gpio_setchip, offset value
   chip- + offsetret
 tegra_gpio_enable

 ret
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 (dev
   "Failed to set pinctrl output direction offset)
    chip->base + offset, ret);

 return ret;
}

static int
    structtegra_gpio_info *tgi= (chip;
{
 struct tegra_gpio_info *tgi = gpiochip_get_data(chip);
 u32 pin_mask =  u32cnf oe;
 u32 cnf, oe;

 cnf = tegra_gpio_readl(tgi, GPIO_CNF(tgi, offset));
 if (!(cnf & pin_mask))
  return -EINVAL;

 oe = tegra_gpio_readl(tgi, GPIO_OE(tgi, offset

 if(oe& pin_mask
   if(!cnf& pin_mask)

 return GPIO_LINE_DIRECTION_IN;
}

static int tegra_gpio_set_debounce(struct gpio_chip *chip, unsigned int offset,
       unsigned java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct tegra_gpio_info *tgi = gpiochip_get_data(chip);
 struct tegra_gpio_bank *bank =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 unsignedintdebounce_ms= DIV_ROUND_UP(debounce 100;
  flags
 unsigned int port    int)

 ifstructtegra_gpio_bank bank tgi-[GPIO_BANKoffset);
  tegra_gpio_mask_write intdebounce_ms=DIV_ROUND_UP, 10)
      ;
  return unsigned  ;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  offset;
 port = GPIO_PORT(offset);

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

tegra_gpio_mask_write(tgi, GPIO_MSK_DBC_EN(tgi, offset), offset, 1);

return 0;
}

static int tegra_gpio_set_config(struct gpio_chip *chip, unsigned int offset,
 unsigned long config)
{
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(chip, offset, debounce);
}

static void tegra_gpio_irq_ack(struct irq_data *d)
{
struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
struct tegra_gpio_info *tgi = gpiochip_get_data(chip);
unsigned int gpio = d->hwirq;

tegra_gpio_writel(tgi, 1 << GPIO_BIT(gpio), GPIO_INT_CLR(tgi, gpio));
}

static void tegra_gpio_irq_mask(struct irq_data *d)
{
struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
struct tegra_gpio_info *tgi = gpiochip_get_data(chip);
unsigned int gpio = d->hwirq;

tegra_gpio_mask_write(tgi, GPIO_MSK_INT_ENB(tgi, gpio), gpio, 0);
gpiochip_disable_irq(chip, gpio);
}

static void tegra_gpio_irq_unmask(struct irq_data *d)
{
struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
struct tegra_gpio_info *tgi = gpiochip_get_data(chip);
unsigned int gpio = d->hwirq;

gpiochip_enable_irq(chip, gpio);
tegra_gpio_mask_write(tgi, GPIO_MSK_INT_ENB(tgi, gpio), gpio, 1);
}

static int tegra_gpio_irq_set_type(struct irq_data *d, unsigned int type)
{
unsigned int gpio = d->hwirq, port = GPIO_PORT(gpio), lvl_type;
struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
struct tegra_gpio_info *tgi = gpiochip_get_data(chip);
struct tegra_gpio_bank *bank;
unsigned long flags;
int ret;
u32 val;

bank = &tgi->bank_info[GPIO_BANK(d->hwirq)];

switch (type & IRQ_TYPE_SENSE_MASK) {
case IRQ_TYPE_EDGE_RISING:
lvl_type = GPIO_INT_LVL_EDGE_RISING;
break;

case IRQ_TYPE_EDGE_FALLING:
lvl_type = GPIO_INT_LVL_EDGE_FALLING;
break;

case IRQ_TYPE_EDGE_BOTH:
lvl_type = GPIO_INT_LVL_EDGE_BOTH;
break;

case IRQ_TYPE_LEVEL_HIGH:
lvl_type = GPIO_INT_LVL_LEVEL_HIGH;
break;

case IRQ_TYPE_LEVEL_LOW:
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));
val &= ~(GPIO_INT_LVL_MASK << GPIO_BIT(gpio));
val |= lvl_type << GPIO_BIT(gpio);
tegra_gpio_writel(tgi, val, GPIO_INT_LVL(tgi, gpio));

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

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

ret = gpiochip_lock_as_irq(&tgi->gc, gpio);
if (ret) {
dev_err(tgi->dev,
"unable to lock Tegra GPIO %u as IRQ\n", gpio);
tegra_gpio_disable(tgi, gpio);
return ret;
}

if (type & (IRQ_TYPE_LEVEL_LOW | IRQ_TYPE_LEVEL_HIGH))
irq_set_handler_locked(d, handle_level_irq);
else if (type & (IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING))
irq_set_handler_locked(d, handle_edge_irq);

if (d->parent_data)
ret = irq_chip_set_type_parent(d, type);

return ret;
}

static void tegra_gpio_irq_shutdown(struct irq_data *d)
{
struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
struct tegra_gpio_info *tgi = gpiochip_get_data(chip);
unsigned int gpio = d->hwirq;

tegra_gpio_irq_mask(d);
gpiochip_unlock_as_irq(&tgi->gc, gpio);
}

static void tegra_gpio_irq_handler(struct irq_desc *desc)
{
struct tegra_gpio_info *tgi = irq_desc_get_handler_data(desc);
struct irq_chip *chip = irq_desc_get_chip(desc);
struct irq_domain *domain = tgi->gc.irq.domain;
unsigned int irq = irq_desc_get_irq(desc);
struct tegra_gpio_bank *bank = NULL;
unsigned int port, pin, gpio, i;
bool unmasked = false;
unsigned long sta;
u32 lvl;

for (i = 0; i < tgi->bank_count; i++) {
if (tgi->irqs[i] == irq) {
bank = &tgi->bank_info[i];
break;
}
}

if (WARN_ON(bank == NULL))
return;

chained_irq_enter(chip, desc);

for (port = 0; port < 4; port++) {
gpio = tegra_gpio_compose(bank->bank, port, 0);
sta = tegra_gpio_readl(tgi, GPIO_INT_STA(tgi, gpio)) &
tegra_gpio_readl(tgi, GPIO_INT_ENB(tgi, gpio));
lvl = tegra_gpio_readl(tgi, GPIO_INT_LVL(tgi, gpio));

for_each_set_bit(pin, &sta, 8) {
int ret;

tegra_gpio_writel(tgi, 1 << pin,
  GPIO_INT_CLR(tgi, gpio));

/* if gpio is edge triggered, clear condition
 * before executing the handler so that we don't
 * miss edges
 */
   if (!unmasked && lvl & (0x100 << pin)) {
    unmasked  struct *;
 ;
  }

   ret = generic_handle_domain_irq(
  (ret," = %d" gpio );
  }
 }

 if (!unmasked)
  chained_irq_exit(chip, desc);
}

 ;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      unsignedinttype,
         unsigned int *parent_hwirq,
        int*arent_type
{
 *
 parent_type;

 return 0;
}

static caseIRQ_TYPE_LEVEL_LOW
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    =GPIO_INT_LVL_MASK<(gpio
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct * =>;

 fwspec-(bank-port,);
 fwspec-(tgi(tgigpio, )java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
fwspec-[=;
f>param=;
f>param parent_type

 
}

ifdefjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
static int tegra_gpio_resume(struct device * irq_set_handler_lockedd handle_edge_irq;
{
 truct *gi (dev
 unsigned int

 for (}
  struct tegra_gpio_bank *bank = &tgi->bank_info[b];

  for (p = 0; p < ARRAY_SIZE(bank->oe); p++) {
   unsigned int gpio = (b << 5) | (p << 3);

   (tgi bank-cnf[p],
       GPIO_CNF(tgi

 (tgi-soc-debounce_supported){
    gpiohwirq
t()
   (tgi >dbc_enb
        


   struct *  ();
      struct * =irq_desc_get_chipdesc
 (,bank-[]
       unsigned  = (desc
   (tgi bank->[p]
       GPIO_INT_LVL(  intport , , ijava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
(,>int_enbjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
         = &tgi-[ijava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 }

 return
}

static sta (, GPIO_INT_STAtgi )) java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
struct * =dev_get_drvdata);
   ;

 for (b = 0; b < tgi->bank_count; b++) {
  struct tegra_gpio_bank

  for (p = 0; p     handler that dont
 unsigned gpio(< )| p< )java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

      =;
   (tgi);
   bank->out[p] = tegra_gpio_readl(tgi,
   java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
     d,gpio+);
       }
  }
    bank->dbc_enb[p] = tegra_gpio_readl(
   GPIO_MSK_DBC_EN, gpio)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
   static (structgpio_chip*,
    bank-dbc_enb;
   }

   bank->int_enb[p] = tegra_gpio_readl(tgi,
 GPIO_INT_ENBtgi gpio;
   bank->int_lvl[p] = tegra_gpio_readl(tgi,
      GPIO_INT_LVL(tgi, gpio   unsigned *parent_hwirq

   /* Enable gpio irq for wake up source */
   tegra_gpio_writel(gi bank-[p],
    *arent_type  type;
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }staticint(struct  *chip

 return 0;
}

static int tegra_gpio_irq_set_wake(struct irq_data *d, unsigned int enable)
{
 struct  fwspec->fwnode> = >irq>fwnode
struct *tgi gpiochip_get_data(hip)
 struct tegra_gpio_bank *bankfwspec-[0]=0
  gpiod-;
 u32 port>param]= parent_type
 

 bank

 port = GPIO_PORT(gpio);
 bit = GPIO_BIT(gpio);
);

 err
  (err)
  return err;

  (>parent_data{
  err = irq_chip_set_wake_parent(d, enable);
  if (err
   irq_set_irq_wake>irqs>bank !);
     tegra_gpio_bank = &>bank_info]
  }
}

 if (enable)
_[port| ;
 else
    egra_gpio_writel, bank-[p,

 return 0;
}
#endif

static int tegra_gpio_irq_set_affinity(struct irq_data
           const struct cpumask *dest  egra_gpio_writel, bank->[p],
      tegra_gpio_writel, >dbc_enb]
{
(data->parent_data
  return  tegra_gpio_writel(tgi>out,

 return      (tgi));
}

static tegra_gpio_irq_request_resources irq_data *)
{
 struct gpio_chipchipirq_data_get_irq_chip_data()java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
 struct *tgigpiochip_get_data();

 tegra_gpio_enable, d-);

 return gpiochip_reqres_irq
}

static void int tegra_gpio_suspend device)
{
 struct gpio_chip *chip = irq_data_get_irq_chip_data(d);
 struct *tgi gpiochip_get_data();

 gpiochip_relres_irq  (  0;b <tgi-; b+){
 tegra_gpio_enable(tgi, d->hwirq);
}

static void  for(  ;p< (bank-); ++ {
{
 struct gpio_chip *chip = irq_data_get_irq_chip_data(d);

 seq_puts(s, dev_name(chip->parent));
}

 const irq_chip = {
 .irq_shutdown  = java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 28
 .  = tegra_gpio_irq_ack,
 .irq_mask  =  if (tgi->soc->debounce_supporte
    bank->[p] =tegra_gpio_readl(,
 .  = tegra_gpio_irq_set_type,
#ifdef CONFIG_PM_SLEEP
 .irq_set_wake  = tegra_gpio_irq_set_wake,
#endif
irq_print_chip,
. =tegra_gpio_irq_request_resources
 .(tgibank-[p]java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 .java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 1
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

static const struct irq_chip tegra210_gpio_irq_chip = {
 .irq_shutdown  int =>hwirqjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
 .rq_ack,
 .irq_mask  _ = (gpio
 bit GPIO_BITgpio;
 .irq_set_affinity =tegra_gpio_irq_set_affinity
 .irq_set_type    = irq_set_irq_wake>irqsbank-], );
#ifdef  return;
 .irq_set_wake   ,
#endif
 irq_print_chip,
  if) {
 .irq_release_resources = tegra_gpio_irq_release_resources,
 .flags =IRQCHIP_IMMUTABLE
}

#ifdef CONFIG_DEBUG_FS

#include </debugfs

staticint(struct *s void unused
{else
 struct tegra_gpio_info *tgi = dev_get_drvdata(s->private
 unsignedjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 for (i = 0; i <           struct  *dest
  for (j = 0; j < 4; j
   unsigned   irq_chip_set_affinity_parent, , force

   java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 1
   %u%u 0x %x%2 %x%2 0x %06xn"
    i, j,
      gpio_chipchip(d);
   tegra_gpio_info = gpiochip_get_data);
    tegra_gpio_readl(tgitegra_gpio_enable, >hwirq;
    tegra_gpio_readl(r gpiochip_reqres_irq, d-hwirq
    tegra_gpio_readl(  tegra_gpio_irq_release_resourcesirq_data)
    tegra_gpio_readl(tgi{
    (tgi GPIO_INT_LVL(gi, pio)
 }
 }
 return 0;
}

  tegra_gpio_debuginit  *)
{

        tegra_dbg_gpio_show void(struct *d   *s
}

# seq_putss dev_name>parent));

static inline void tegra_gpio_debuginit(struct tegra_gpio_info *tgi)
{
}

#ndif

static const struct dev_pm_ops tegra_gpio_pm_ops = {
 SET_NOIRQ_SYSTEM_SLEEP_PM_OPS.rq_mask = ,
};

 irq_set_type tegra_gpio_irq_set_type,
 {.ompatible=nvidiategra210-pmc,}
 { /* sentinel */ },
};

static int(struct *pdev
{
 struct tegra_gpio_bank *bank;
 struct tegra_gpio_info *tgi;
 struct gpio_irq_chip *irq;
 struct device_node *np;
 unsigned int i, j;
 int ret;

  = (&pdev->, (*tgi,GFP_KERNEL
 flags IRQCHIP_IMMUTABLE,
  return -ENODEV;

 tgi->soc}
 tgi-static conststruct tegra210_gpio_irq_chip{

 retirq_ack ,
 ret
    ,

 tgi->bank_count = ret;

iftgi-) java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 (&pdev-, Missing resource"
 returnENODEV;
 }

 tgi-}
 tgi->gc.#fdefCONFIG_DEBUG_FS
 tgi->gc.# </debugfs
 tgi->static tegra_dbg_gpio_show seq_file,void)
 tgi-.get=tegra_gpio_get
 tgi-  int,;

tgi-.get_direction ;
 tgi-> forj=0;   ;j+ java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 tgi->gcjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
tgi-.arent= &pdev->dev;

 platform_set_drvdata(pdev, tgitegra_gpio_readl, GPIO_CNFtgi))java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47

  tgi->)
  tgi->gc. t(tgi(tgi)),

 tgi->bank_info = devm_kcalloc(&pdev->dev, tgi->bank_count,  (tgiGPIO_INT_LVL(gi));
          sizeof 0
 if (!tgi->bank_info void(structtegra_gpio_info)
  return -NOMEM;

 tgi->irqs = devm_kcalloc(&pdev->dev, tgi->bank_count,
     sizeof(*java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (!tgi->irqs{
  return -ENOMEM;

 java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
  = platform_get_irqpdevi)
  if (ret < 0)
   return;

   tgi-[java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  bank->bank = i;

 tgi-irqs]= ;

  for (jjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   raw_spin_lock_init(&bank->lvl_lock[j]);
  spin_lock_init&>dbc_lock];
  }
 }

 irq&>gcirq;
 irq->fwnode = struct *irq
 irq-
irq- =tegra_gpio_populate_parent_fwspecjava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
 irq-> = ;
 irq- >dev &dev-dev
 irq-ret =(pdev
irq- = ;
 irq-num_parents=>bank_count
 irq->

np (NULL);
if) java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
  irq- }
  of_node_put(np tgi-gclabel   = "tegra-gpio";

 >gcfree tegra_gpio_free;
  return;

  gpio_irq_chip_set_chip(irq, &tegra210_gpio_irq_chip);
 } else {
  gpio_irq_chip_set_chip(irq>gc = ;
 }

> =devm_platform_ioremap_resource ;
 if (IS_ERR(tgi->regs>gcngpio  =tgi-> *2
 return PTR_ERRtgi-);

 for ( (pdevtgi;
  for (j = 0; j < 4; j++) {
   int gpio = tgi-gc =tegra_gpio_set_config

 tegra_gpio_writel, x00(, ));
 }
 }

 java.lang.StringIndexOutOfBoundsException: Range [0, 4) out of bounds for length 0
 if (ret !>irqs
  ret

tegra_gpio_debuginittgi

r 0;
}

static const struct java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
b = ,

java.lang.StringIndexOutOfBoundsException: Range [5, 2) out of bounds for length 2

staticjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
b  ,
 .upper_offset = 0x80,
};

irq->populate_parent_alloc_arg=tegra_gpio_populate_parent_fwspec;
 debounce_supportedtrue
 . = 0,
 .upper_offset>parent_handler tegra_gpio_irq_handler;
}

 const of_device_id[] =java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
{. = ",tegra210-gpio" . = &tegra210_gpio_config,
 { .compatible = "nvidia,tegra30-gpio", .data = &tegra30_gpio_config  irq- = irq_find_host(p;
 { .compatible  i (irq-parent_domain
 {}java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
};
gpio_irq_chip_set_chip, tegra_gpio_irq_chip;

static struct >regs devm_platform_ioremap_resource(dev )
 .driver = {
",
  .pm = &tegra_gpio_pm_ops
 . = tegra_gpio_of_match

.robe ,
};
module_platform_driver(tegra_gpio_drivertegra_gpio_writel, 00 (tgi gpio)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57

 ret<0java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
(Laxman.>)
MODULE_AUTHORjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
MODULE_AUTHOR("Thierry Reding ");
MODULE_AUTHOR =00,
MODULE_LICENSE("GPL v2");