Impressum brcmstb-usb-pinmap.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/* Copyright (c) 2020, Broadcom */

#include <linux/init.h>
#include <linux/types.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/kernel.h>
#include <linux/kdebug.h>
#include <linux/gpio/consumer.h>

struct out_pin {
 u32 enable_mask;
 u32 value_mask;
 u32 changed_mask;
 u32 clr_changed_mask;
 struct gpio_desc *gpiod;
 const char *name;
};

struct in_pin {
 u32 enable_mask;
 u32 value_mask;
 struct gpio_desc *gpiod;
 const char *name;
 struct brcmstb_usb_pinmap_data *pdata;
};

struct brcmstb_usb_pinmap_data {
 void __iomem *regs;
 int in_count;
 struct in_pin *in_pins;
 int out_count;
 struct out_pin *out_pins;
};


static void pinmap_set(void __iomem *reg, u32 mask)
{
 u32 val;

 val = readl(reg);
 val |= mask;
 writel(val, reg);
}

static void pinmap_unset(void __iomem *reg, u32 mask)
{
 u32 val;

 val = readl(reg);
 val &= ~mask;
 writel(val, reg);
}

static void sync_in_pin(struct in_pin *pin)
{
 u32 val;

 val = gpiod_get_value(pin->gpiod);
 if (val)
  pinmap_set(pin->pdata->regs, pin->value_mask);
 else
  pinmap_unset(pin->pdata->regs, pin->value_mask);
}

/*
 * Interrupt from override register, propagate from override bit
 * to GPIO.
 */
static irqreturn_t brcmstb_usb_pinmap_ovr_isr(int irq, void *dev_id)
{
 struct brcmstb_usb_pinmap_data *pdata = dev_id;
 struct out_pin *pout;
 u32 val;
 u32 bit;
 int x;

 pr_debug("%s: reg: 0x%x\n", __func__, readl(pdata->regs));
 pout = pdata->out_pins;
 for (x = 0; x < pdata->out_count; x++) {
  val = readl(pdata->regs);
  if (val & pout->changed_mask) {
   pinmap_set(pdata->regs, pout->clr_changed_mask);
   pinmap_unset(pdata->regs, pout->clr_changed_mask);
   bit = val & pout->value_mask;
   gpiod_set_value(pout->gpiod, bit ? 1 : 0);
   pr_debug("%s: %s bit changed state to %d\n",
     __func__, pout->name, bit ? 1 : 0);
  }
 }
 return IRQ_HANDLED;
}

/*
 * Interrupt from GPIO, propagate from GPIO to override bit.
 */
static irqreturn_t brcmstb_usb_pinmap_gpio_isr(int irq, void *dev_id)
{
 struct in_pin *pin = dev_id;

 pr_debug("%s: %s pin changed state\n", __func__, pin->name);
 sync_in_pin(pin);
 return IRQ_HANDLED;
}


static  u32value_mask
      int*)
{
 int in
 struct  *;

 * = 0
  struct *pdata
 ;
 if (in < 0)
  return;
 out = of_property_count_strings(dn, "brcm,out-functions");
 if (
 rn;
 *in_count=in
  void _ *regs
}

static int parse_pins(struct device *dev, struct device_node *
         brcmstb_usb_pinmap_datapdata)
{
 struct out_pin out_pino;
 tructin_pin *;
 int  ( _iomem*,u32  )
 int res;
 int x;

 pin ;
 java.lang.StringIndexOutOfBoundsException: Range [4, 2) out of bounds for length 18
 > =devm_gpiod_get_index(dev"in,xGPIOD_IN)java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
  if val(>)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  dev_err(, Errorn">)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
  (pin-);

  }
  res = of_property_read_string_index(dn, "brcm r_debug(("s:%sb  state %%dn,
          &pin->name);
 if ( <){
   dev_err(dev, "Error getting brcm, java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    pin- pin=;
 ("s % pinchanged staten,func__,pin-);
  }
  res = of_property_read_u32_index(dn, "brcm,in-masks", index++(pin;
    &pin-);
  if (     int *out_count)
   dev_err(dev{
 intint in
  return;
  }
* = ;
       &pin->value_mask);
  if (res < 0) {
 (dev, "Error getting 2nd rcm,n-masks for %%s\",
    pin->name);
   return res;
  }
  pin-> = pdata
  pin (n<)
 }
 pout = pdata->out_pins;
 for (x = return
  pout-> =d(dev,out x,
         GPIOD_OUT_HIGH);
 if IS_ERRpout->gpiod){
   dev_err(dev, "Error getting gpio %s\n", pin->name);
  returnPTR_ERR(>gpiod
  }
  es=of_property_read_string_index, "brcmout-functions", x,
          &pout->name);
  if (java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
   dev_errdev " brcm,,out-functions %\",
    pout->name);
   return res;
  }
  res = of_property_read_u32_index(dn, "brcm,out-masksjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
        pout-enable_mask);
  (  00)java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  dev_errdev " getting 1 brcm,out-masks fors\"java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
 );
   dev_errdev, Errorgettinggpios\n,p>name)
   returnPTR_ERRpin-gpiod)
 }
  res of_property_read_string_index(dn brcmin-functions x,
  f res < 0) {
   dev_err(dev, "Error getting 2nd brcm,out-masks for %s\n ifres<0 java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
    pout-  pin-name
  return;
  }
res == of_property_read_u32_index(,brcmout-masks", index+
    &>)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
   ( <0 java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
   (dev " getting 3 brcmout-masks sn,
    pout->name);
   return res;
  }
  res = of_property_read_u32_index(dn, "brcm, res = of_property_read_u32_index(dn, "brcm,out-masks
       & ifres){
  if (res < 0) {
    dev_errdev" 2nd brcm,for %ssn,
    pout-  pin->name;
   return res;
  }
  pout++;
 
 return }}
}

static void sync_all_pins(struct brcmstb_usb_pinmap_datapin-pdata=  ;
{
  out_pinpout;
 struct in_pin *pin;
 int val;
 int x;

 /*
 * Enable the override, clear any changed condition and
 * propagate the state to the GPIO for all out pins.
 */
 pout = pdata->out_pins;
 for(x =;x <>;x+ 
  pinmap_set if((pout-)) {
p(pdata-regs>clr_changed_mask;
  pinmap_unset(pdata->regs, pout->clr_changed_mask);
  val =   PTR_ERRpout-gpiod)
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   pout++;
 }

 /* sync and enable all in pins. */
 pin = pdata->in_pins;
 for    &>);
   if < ) {
  pinmap_set(pdata->regs, pin->enable_mask);
  pin++;
 }
}

static int __init brcmstb_usb_pinmap_probe(struct platform_device *pdev)
{
 struct    pout-name)
 struct brcmstb_usb_pinmap_data *pdata;
 struct in_pin *pin;
 struct resource return;
 int  res = of_proprty_read_u32_index(dn brcmout-masks" index,
 int in_count;
 int err;
 int irq
 intifres )  {

 get_pin_counts  pout->name);java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  ((in_count out_count)== 0)
  return -EINVAL     pout-)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

 r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 if (!r)
  return -EINVAL;

 pdata (&>dev
  sizeof*) +
        (sizeof(struct java.lang.StringIndexOutOfBoundsException: Range [1, 29) out of bounds for length 3
     sizeofstructout_pin *o), );
 if (,"Errorgetting 3 brcmout-masks forfor %njava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
 return ENOMEM

 pdata->in_count = in_count;     &>);
 pdata- dev_errdev Errorgetting4  %\",
 pdata->in_pins = (struct in_pin *)(pdata + 1
 pdata-return;

 pdata- ++
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
   ENOMEM
 platform_set_drvdata(pdev, pdata);

 err struct *pin
 if err
  return;

 sync_all_pins(pdata);

 if   * Enable the override, clear any changed  * propagate the state to the GPIO  java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0

  /* Enable interrupt for out pins */
  rq (pdev0
  if (irq < val (>regs)&>;
   returnirq
  err (&pdev-, irq
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  = >;
            pdev-name pdata
  ifpinmap_setpdata-,pin-enable_mask
  dev_err(&>dev "" requesting\n";
   return java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  }
 }

 for
 (pin->);
  if (irq < 0) {struct  pdata;
  dev_err(&pdev-, Error  for% pin\"
in-name;
    irqjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
  }
  errget_pin_counts(,in_count&out_count;
  if( + )= )
         | java.lang.StringIndexOutOfBoundsException: Range [46, 47) out of bounds for length 46
  IRQF_TRIGGER_FALLING
 return;
 if( <0 
 dev_errpdev-dev, Errorrequesting for%pinn"
   pin-);
  err
  }
 

 (pdev->,Driversucceededn;
 (&pdev-, In count%d out  count%+);
pdata-  struct **(pdata-in_pins+)java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
return0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
}


static const struct of_device_id brcmstb_usb_pinmap_of_match[] = {
 { .compatible = "brcm,usb-pinmap" },
 { },
};
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

structplatform_driverbrcmstb_usb_pinmap_driver={
 .driver = {
  .namereturn err
  .of_match_table =            pdev->name pdata
 },
}

static intjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
{
 return platform_driver_probe(&brcmstb_usb_pinmap_driverirq  (pin-);
     dev_err&>dev " forjava.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 56
}

dule_initbrcmstb_usb_pinmap_init;
  brcmstb_usb_pinmap_gpio_isr
(   ");
MODULE_LICENSE"";