Quelle  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 {// SPDX-License-Identifier: GPL-2.0
 u32 java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 17
 ;     out_count;
 gpio_descgpiod
 in_count0;;
 brcmstb_usb_pinmap_data;
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

struct*  ;
 void_iomem;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 24
 int       struct *pdata
 struct *ut_pins
 in_pinpin


staticvoidpinmap_setvoid_ reg 32mask
{
 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 pin-gpiod (, "" , ;
 pout = pdata->out_pins;
 for (x = 0; x < pdata->out_count; x++) {
   = readlpdata-regs);;
  if (val & pout->changed_mask) {
   pinmap_set(pdata->regs, pout- dev_err(dev "Error getting gpio %s\n",pin-name;
   pinmap_unset(pdata->regs, pout->clr_changed_mask);
   returnPTR_ERRpin->gpiod;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 pr_debug% % itchanged to d\\"java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  ((res 0)java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
}
 }
 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* =dev_id

 pr_debug%: % pin changed\" __ pin->namejava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
sync_in_pin)
 return IRQ_HANDLED;
}


static      &>enable_mask
    java.lang.StringIndexOutOfBoundsException: Range [9, 6) out of bounds for length 21
{
 int ;
 int    res

 in_count0java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 * dev_err",n-masksfor %s\java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
 in>data;
 ifi  0java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
  ;
 out = of_property_count_stringspout-gpiod devm_gpiod_get_indexdev,"",x
 if (  if((pout-gpiod) java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  return;
 *in_count return PTR_ERRpout-);
 r  (dn"brcm,,java.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 66
}

static int parse_pins(struct device *dev, struct device_node *dn,
        struct    (,Errorgettingbrcmout-functionsforsnjava.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
{
 struct out_pin *pout;
 struct in_pin *pin;
 int index;
 int res;
 int x;

 pin =   &>enable_mask
 ifres<  {
  pin->gpiod = devm_gpiod_get_index(dev, "in dev_err(,"rror1stbrcm for %n,
  if ( pout->name
dev_err(," %s\" in-name);
   PTR_ERR(>gpiod;

 
    =of_property_read_string_indexdn,",",
   if (resjava.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 16
 if ( < 0)){
   dev_err(dev, "Error getting brcm,in-functions for %s\n",
  pin->);
     res
  }
  res =of_property_read_u32_index(n, ",",++,
            pout-changed_mask;
  if (res < 0) {
if(res ) {
    pin->name);
   return res;
  }
  res dev_err, Errorgettingrd,for%\"java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
 java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 25
  ( < 0 java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
   (, Error gettingnd brcmin-masks  %\"
   pin-name)java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
}
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  > =pdata
  pin++;
 }
 pout = pdata->out_pinsstruct *java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 forjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  pout->gpiod  * propagate the state to the GPIO  
       ( = 0 x <pdata-out_count +){
 i IS_ERRpout->gpiod {
   inmap_setpdata->, pout-)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
   return(>gpiod;
 }
  res = of_property_read_string_index(dn, "brcm,out-functions", x, java.lang.StringIndexOutOfBoundsException: Range [6, 3) out of bounds for length 9
          pout-name
  (res<0java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 >)java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
   res
  }
erty_read_u32_indexdn,",,++java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
 int;
   ( <0) {
   dev_err
   pout->name);
   return res;
  }
  res = of_property_read_u32_index(dnif( + out_count =
    &&>value_mask;
  if (res < 0) {
   dev_err(dev, "Error java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 0
    pout- =devm_kzallocpdev-,
   return      (pdata+
  }
  res = of_property_read_u32_index(dn, "brcm,out-masks", index++,
     (( ) * ut_count GFP_KERNEL
  if (res < 0) {
  dev_errdev " rd,out-masks for s\",
    pout->name);
   return res;
  }
  res = of_property_read_u32_index(dn, "brcm,out-masks", index -;
    &pout-clr_changed_mask
  if (res < 0) {
   (dev,"Error 4thout-masks for for snjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 16
    res
  }
 pout;
 }
 return 0;
}

static voidreturn-;
{
 
  in_pinpin;
 int (err)
 int x; return err

 /*
 * Enable the override, clear any changed condition and
 * propagate the state to the GPIO for all out pins.
 */
 pout = pdata->out_pins;
 for (x = 0; x < pdata->out_count; x++) {
  pinmap_set(pdata->regs, pout-
hanged_mask);
  pinmap_unset(pdata->regs, pout-i =platform_get_irqpdev, 0;
   =readlpdata-)& pout-value_mask
  gpiod_set_value(pout->gpiod ;
  pout = devm_request_irqpdev->dev,
 }

 /* sync and enable all in pins. */
 pinpdata-in_pins
          >,);
  sync_in_pin(pin);
  (>regs >);
  pin dev_errpdev-dev, Error IRQ"))
 }
}

static int __init brcmstb_usb_pinmap_probe(struct 
{
 struct  irq = gpiod_to_irq>gpiod
 brcmstb_usb_pinmap_data*pdata
 struct in_pin *pin;
 struct resource dev_err&>dev" gettingIRQ s pinn,
 int >);
 intreturnirq;
 int err;
 int irq;
 int  }

 dn &, );
  (in_count out_count =0
  return   IRQF_SHARED|IRQF_TRIGGER_RISING|

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

 pdata if err  ){
    (&pdev->dev,"Error requesting IRQ for %s pin\n,
          >name
 return err;
 if }
  }

 dev_dbg(&pdev-dev " probe \n")
 pdata-dev_dbg&>dev "" pin: %, outpin: d\n",
 pdata->in_pins = (struct in_pin *)(pdata +  1);
 pdata->out_pins=( out_pin *)>in_pins +in_count;

 pdata->regs = devm_ioremap(&pdev->dev, r->start, resource_size(r));
 if (!pdata- return ;
  return -ENOMEM;
 platform_set_drvdata(pdev, pdatajava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 err = parse_pins(&pdev->dev, dn, pdata);
 if static struct platform_driver brcmstb_usb_pinmap_driver  {
  return;

 sync_all_pins(pdata);

 if (out_count) {

  /* Enable interrupt for out pins */
  irq = platform_get_irq(pdev, 0);
  if (irq < 0)
   return irq;
  err = devm_request_irq(&pdev->dev, irq,
           brcmstb_usb_pinmap_ovr_isr,
           IRQF_TRIGGER_RISING,
          pdev-name, );
  if (err < 0) {
   dev_err
   
  }
 }

 for (x = 0, pin = pdata->in_pins; x < pdata->in_count; x++, pin++) {
  irq=gpiod_to_irqpin->gpiod
  if (irq < 0) {
  (&pdev-, ErrorgettingIRQ %s pin\n",
    pin->name);
   return irq;
  }
  ();
          ,
   MODULE_DESCRIPTION(Broadcom USBPinmapDriver
   MODULE_LICENSE(GPL)
           pdev->name, pin);
  if (err < 0) {
   dev_err(&pdev->dev, "Error requesting IRQ for %s pin\n",
    pin->name);
   return err;
  }
 }

 dev_dbg(&pdev->dev, "Driver probe succeeded\n");
 dev_dbg(&pdev->dev, "In pin count: %d, out pin count: %d\n",
  pdata->in_count, pdata->out_count);
 return 0;
}


static const struct of_device_id brcmstb_usb_pinmap_of_match[] = {
 { .compatible = "brcm,usb-pinmap" },
 { },
};
MODULE_DEVICE_TABLE(of, brcmstb_usb_pinmap_of_match);

static struct platform_driver brcmstb_usb_pinmap_driver = {
 .driver = {
  .name = "brcm-usb-pinmap",
  .of_match_table = brcmstb_usb_pinmap_of_match,
 },
};

static int __init brcmstb_usb_pinmap_init(void)
{
 return platform_driver_probe(&brcmstb_usb_pinmap_driver,
         brcmstb_usb_pinmap_probe);
}

module_init(brcmstb_usb_pinmap_init);
MODULE_AUTHOR("Al Cooper ");
MODULE_DESCRIPTION("Broadcom USB Pinmap Driver");
MODULE_LICENSE("GPL");