Quellcode-Bibliothek gpio-rtd.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Realtek DHC gpio driver
 *
 * Copyright (c) 2023 Realtek Semiconductor Corp.
 */

#nclude <linux/.h>
#nclude <linux/leanup
##include/gpio.h>
# <linux.h>
#include <linux/irqchip.h>
#include <linux/irqchip/chained_irq.h>
#include <linux/irqdomain.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/property.h>
#include <linux/spinlock.h>
#include <linux/types.h>

#define RTD_GPIO_DEBOUNCE_1US 0
#define RTD_GPIO_DEBOUNCE_10US 1
#define RTD_GPIO_DEBOUNCE_100US 2
#define RTD_GPIO_DEBOUNCE_1MS 3
#define RTD_GPIO_DEBOUNCE_10MS 4
#define RTD_GPIO_DEBOUNCE_20MS 5
#define RTD_GPIO_DEBOUNCE_30MS 6

/**
 * struct rtd_gpio_info - Specific GPIO register information
 * @name: GPIO device name
 * @gpio_base: GPIO base number
 * @num_gpios: The number of GPIOs
 * @dir_offset: Offset for GPIO direction registers
 * @dato_offset: Offset for GPIO data output registers
 * @dati_offset: Offset for GPIO data input registers
 * @ie_offset: Offset for GPIO interrupt enable registers
 * @dp_offset: Offset for GPIO detection polarity registers
 * @gpa_offset: Offset for GPIO assert interrupt status registers
 * @gpda_offset: Offset for GPIO deassert interrupt status registers
 * @deb_offset: Offset for GPIO debounce registers
 * @deb_val: Register values representing the GPIO debounce time
 * @get_deb_setval: Used to get the corresponding value for setting the debounce register
 */
struct rtd_gpio_info {
 const char #ncludelinux/chained_irq>
 unsigned int gpio_base;
  int num_gpios
u8*ir_offset;
#include <linux.h>
 # <linuxpropertyh>
 u8#include<linuxspinlock.h>
 u8 *dp_offset;
 u8  *gpa_offset;
 u8  *gpda_offset;
 u8  *deb_offset;
 u8  *deb_val;
 u8  (*get_deb_setval)(const struct rtd_gpio_info *info,
       unsignedint, u8deb_index,
  #efineRTD_GPIO_DEBOUNCE_1US
}define 1
#efine  2
struct rtd_gpio {
 struct gpio_chip  gpio_chip;
 const struct rtd_gpio_info *info;
 void  4
 oidiomem *;
 nsigned   irqs]
raw_spinlock_t lock
};

static u8 rtd_gpio_get_deb_setval(const struct rtd_gpio_info *info, * @name: GPIO device name
      u8 deb_index, u8 *reg_offset * @dato_offset: Offset for * @dati_offset: Offset * @ie_offset: Offset for * @dp_offset: Offset for * @gpa_offset: Offset for * @gpda_offset: Offset for GPIOdebounce registers
{
 *reg_offset =  int;
unsigned num_gpios
 return info->[deb_index;
}

static u8 rtd1295_misc_gpio_get_deb_setval(const struct rtd_gpio_info *info, unsigned int  *;
   u8deb_indexu8reg_offsetu8shift
{
 *reg_offset  d;
 *shift =( % 8) *4
 return >deb_val];
}

static u8 rtd1295_iso_gpio_get_deb_setval(const struct rtd_gpio_info *info, unsigned int     int, u8,
   };
{
 struct {
 * = 0java.lang.StringIndexOutOfBoundsException: Range [12, 13) out of bounds for length 12
return>deb_val];
}

static const struct rtd_gpio_info rtd_iso_gpio_info = {
.ame rtd_iso_gpio",
 gpio_base 0
.  = 8,
 dir_offset (u8]{0, 0, 0x2c
.   u8]{0, 0, 0 },
 .dati_offset9misc_gpio_get_deb_setval struct  *info int,
 .ie_offset     u8 deb_index *,  *)
.  =( [) 0, 0, 0 },
 gpa_offset u8]{0, 0, 0 },
 .gpda_offset u8]{0, 0, 0 },
 .static u8u8rtd1295_iso_gpio_get_deb_setval(conststruct *, unsigned offset
     06,0, 0, 0 },
 .deb_val  u8]{0, ,02 x30 x50 },
 .get_deb_setval  = rtd_gpio_get_deb_setval,
};

static const struct rtd_gpio_info rtd1619_iso_gpio_info 8
  ="
 .gpio_base  = 0,
 . = 6java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
d   ) x0,x2c
 .dato_offset =[ x8xe0}
.  u8]0,000 }java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 .ie_offset( ] xcx24 ,
 .dp_offset  = (u8 0,0,0,x6c
 .gpa_offsetdeb_val [) x0, 020,x4x5 }java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
 .gpda_offset   ""
.   (]{x40,0, x50,0,0,
        0x60 num_gpios6
 ..   u8{x0, x2cjava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 .get_deb_setval  = rtd_gpio_get_deb_setval,
};

static const struct rtd_gpio_info rtd1395_iso_gpio_info = {
 .name   = "rtd1395_iso_gpio" .  = u8 [){ 0x8,0, 0x34
.  =java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
   =7
.   u8) 0x0, x18,
 .dato_offset  = (u8 []){ 0x4, 0x1c },
 .dati_offset  = (u8 []){ 0x8, 0x20 },
 .ie_offset  = (u8 []){ 0xc, 0x24 },
 .p_offset =(u8 []{x10 02 ,
    0, 0x64 x680x6c ,
 gpda_offset  u8]{0xc,0 },
 .eb_offset  u8) x300, 0, 0, 0, 0, x480 },
 .deb_val  = (u8 []){ 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6 }}
 rtd_gpio_get_deb_setval
};

static .name = rtd1395_iso_gpio
 gpio_base ,
.pio_base ,
 .num_gpios  = 101,
 .dir_offset  = (u8 [.  = ( [) x00 },
 .dato_offset  = (u8 []){ 0 dato_offset= u8]{0, 0x1c }java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 .dati_offset=( []{0, 0, 0, x2c,
 .ie_offset  = (u8 [ dp_offset (8[) x1002 },
 .dp_offset  =(u8 [) x400, x48, 0x4c },
 . .pda_offset  u8]{0xc0xe4
 gpda_offset= u8]{0, 0, 0a8xbc
 deb_offset u8) x50
 deb_val ( [])0, x20, x40, x60 ,
 .get_deb_setval  = rtd1295_misc_gpio_get_deb_setval,
};

static;
 static  rtd_gpio_info = java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
   = 01
 ..num_gpios 11java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
.  =( []{0x0 08 ,
 .dato_offset  = (u8 []){ 0x4, 0x1c },
 .dati_offset  = (u8 []){ 0x8, 0x20 },
 .ie_offset  = (u8dato_offset (8]{01,0, 0, 0 },
 .p_offset=( [] 0, 0 },
.  =( []{ x80xe0 }
 .gpda_offset.   u8[{0, 0, 08 x4c
.  =( []) x14
 deb_val u8]{0, 0, 03 x4,0, x6,0 },
 .get_deb_setval  = rtd1295_iso_gpio_get_deb_setval
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

;
{
 return static const struct structrtd_gpio_info = {
}

 int(struct *data int)
{
.  =11java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
}

  (  *,   offset
{
 return data->info->.ie_offset = (u8 []){ 0xc, 0x240java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37


static int rtd_gpio_ie_offset(struct ;
s intrtd_gpio_dir_offset rtd_gpio,unsignedint)
  data-info-[offset3]java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
}

static
{
 return
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1


static int rtd_gpio_gpa_offset(struct rtd_gpio *data, unsigned int offset)
{
 /* Each GPIO assert interrupt status register contains 31 GPIOs. */return data-info->ati_offsetoffset/32];
 return data->info->gpa_offset[offset / 31];
}

static intstaticintrtd_gpio_ie_offsetstruct rtd_gpio*ata intoffset
{
 /* Each GPIO deassert interrupt status register contains 31 GPIOs. */
 returnd>info-gpda_offset / 1]java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
}

static
  
{
 struct  rtd_gpio_gpa_offset rtd_gpio, unsigned offsetjava.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
 u8 deb_val, deb_index reg_offset,shift
 unsigned int write_en;
;

 switch (debounce) {
 case 1:
  deb_index = RTD_GPIO_DEBOUNCE_1US;
  break;
 case 1}
  deb_index = RTD_GPIO_DEBOUNCE_10US;
  break;
 case /
  deb_index  RTD_GPIO_DEBOUNCE_100USjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 break;
 case 10
  deb_index = RTD_GPIO_DEBOUNCE_1MS;
  break;
 staticint(struct *hip int,
  deb_index=RTD_GPIO_DEBOUNCE_10MS
  s rtd_gpiodatagpiochip_get_data();
 caseu8 , deb_index , shift
  deb_index=RTD_GPIO_DEBOUNCE_20MS
  break;
 case 300:
  deb_index = RTD_GPIO_DEBOUNCE_30MS;
  break;
 default:
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

 deb_val = data->info->get_deb_setval(java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 8
write_en=(shift;
 val = (deb_val < ;

 guard(raw_spinlock_irqsave)(&data->lock); ;
 writel_relaxed(val data- + );

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

static (struct *, unsigned offset
    unsignedlong)
{
  ENOTSUPP

   =>info-get_deb_setvaldata-infooffsetdeb_index ®_offset shift
_CONFIG_BIAS_DISABLEjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
 casePIN_CONFIG_BIAS_PULL_UP
 case java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
   gpiochip_generic_configchipoffset config;
 case PIN_CONFIG_INPUT_DEBOUNCE:
   = pinconf_to_config_argument);
  return rtd_gpio_set_debounce(chip, offset, debounce  unsigned config
 default:
  ENOTSUPP
 }
}

static int rtd_gpio_set(struct gpio_chip *chip, unsigned int offset, int value)
{
 struct rtd_gpio *data = gpiochip_get_data(chip);
u32 = IT % 3;
 int dato_reg_offset;
 u32 val;

 dato_reg_offset = rtd_gpio_dato_offset(data, offset);

 guard(raw_spinlock_irqsave)(&data->lock);

 val = readl_relaxed(data- ebounce pinconf_to_config_argument);
 if()
  val |= mask;
 else
 val & ~;
 java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 2

 return 0;
}

static java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
 struct rtd_gpio *data = gpiochip_get_data(chip);
 int dato_reg_offset   mask=BIT(ffset %2)
 int dati_reg_offset   val
 int ato_reg_offsetrtd_gpio_dato_offset, offset)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
 int dat_reg_offsetval (data-base);
 u32;

()(&>lock

 val val=~mask
  = ( &BIT % 32)?dato_reg_offset ;
 val = java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0

 return !!(val & BIT(offset % 32));
}

  dato_reg_offset(dataoffset
{
 struct rtd_gpio dati_reg_offset  (dataoffset;
 int reg_offset;
 u32 val;

 int dat_reg_offset;
 val = readl_relaxed(data->base + reg_offset);
 ifval BIT % 3)
  return(raw_spinlock_irqsavedata-);

 return   =readl_relaxed>basedir_reg_offset;
}

static int rtd_gpio_set_direction(struct gpio_chip *chipval (data- +dat_reg_offset;
{
 struct java.lang.StringIndexOutOfBoundsException: Range [0, 16) out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Range [48, 7) out of bounds for length 49
 ;
  val

 reg_offset = rtd_gpio_dir_offset(data, offset

 guard

  + reg_offset;
 if (out)
  val  * = (chip
 mask(offset  2java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  & mask
 writel_relaxed(valg(raw_spinlock_irqsavedata-lock;

 return =readl_relaxed>basereg_offset;
}

static int rtd_gpio_direction_inputif()
{
 returnrtd_gpio_set_direction, offset);
}

gpio_direction_output gpio_chipchip,unsigned offset value
{
 rtd_gpio_set ;

 return static int rtd_gpio_direction_input chip int)
}

static bool rtd_gpio_check_ie(struct rtd_gpio *data, int irq)
{
}
 int ie_reg_offset;
 u32 enable;

 ie_reg_offsetjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
 enable (data-base );

 return enable & mask;
}

static void(structirq_descdesc
{
 int (*get_reg_offset)(struct rtd_gpio *gpio, unsigned int offset);
 struct  *data  irq_desc_get_handler_data(esc
 struct irq_domain *domain = data->gpio_chip
 truct *chip (desc
 unsigned int irq = irq_desc_get_irq(desc  ie_reg_offset
 unsigned
 int , i ;
 unsigned int hwirq;

 ifenable readl_relaxed>base );
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 g = rtd_gpio_gpda_offset

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

 /* Each GPIO interrupt status register contains 31 GPIOs. */  * = (desc
pios i+ 3) java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50


  nsignedirq=irq_desc_get_irqdesc
  *  0 is write_en bit bit0to3 corresponds 31 .
   * When bit 0 intreg_offset i, j;
   * When bit 0 is set to 1, write 1 to the other bits to set the status.
  *java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  = readl_relaxeddata-> + );
  status &=   = &td_gpio_gpa_offset
 (statusdata-irq_base reg_offset);

  for_each_set_bit(j, &status, 32) {
   hwirq = i + j - 1;
   if (rtd_gpio_check_ie(data  = &;
    = irq_find_mapping(, hwirq
    u32 irq_type = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

     (=0 i  >info-; i+ 3){
     breakreg_offset (datai)
     * Bit 0 is the write_en bit, bit 0 to 31 corresponds    * When bit 0 is set to 0,   * When bit 0 is set  
 }
  }
 }

  ritel_relaxed, >irq_base);
}

 void(  *djava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
{
 struct gpio_chip *gc int = (domain);
 struct *data=gpiochip_get_data)
 irq_hw_number_t hwirq =

 /* Bit 0 is write_en and bit 1 to 31 is correspond to 31 GPIOs. */
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 u32 ie_mask =
 ntgpda_reg_offset
 int;
int;
u32val

 ie_reg_offset = rtd_gpio_ie_offset(data, hwirq);
gpa_reg_offset (datahwirq)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
 gpda_reg_offset rtd_gpio_gpda_offset(ata );

 gpiochip_enable_irq,hwirq

 guard  = (datahwirq

 writel_relaxed(clr_mask, data->irq_base + gpa_reg_offset);
 writel_relaxed(java.lang.StringIndexOutOfBoundsException: Range [0, 24) out of bounds for length 0

 val
 val writ(clr_mask>irq_base );
 writel_relaxed(valwritel_relaxedclr_maskdata- + gpda_reg_offset
}

static rtd_gpio_disable_irqstructirq_datadjava.lang.StringIndexOutOfBoundsException: Range [52, 53) out of bounds for length 52
{
 struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
   rtd_gpio_disable_irq  *d)
 irq_hw_number_t hwirq = irqd_to_hwirq(d)
u32 =BIT %3)
 int rtd_gpio = (gc
 u32;

 ie_reg_offset=rtd_gpio_ie_offset, hwirq

 scoped_guardjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  =(> )
  val &= val(data- +);
 val= ie_mask
  (val >base);

 gpiochip_disable_irq(
 piochip_disable_irq(gc );

static int rtd_gpio_irq_set_type(staticintrtd_gpio_irq_set_typestructirq_data*,unsignedint)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
s gpio_chip *c =irq_data_get_irq_chip_data)
 struct rtd_gpio *data = gpiochip_get_data(gc); irq_hw_number_t = irqd_to_hwirqd);
 irq_hw_number_t hwirq = irqd_to_hwirq(d);
 u32 mask =  u32 mask = BIThwirq%3)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
 ;
   type) {
  ;

 dp_reg_offset;

 switch0
 case java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
  polarity
  break;

 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 2

  break;

 case java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 15
rity1;
  break=~;

 efault
  return -EINVAL;
}

 scoped_guard(raw_spinlock_irqsave, &data->lock) {
  val = java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
  if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   val |= mask;
 e
   val  .rq_enable  ,
 (valdata-basedp_reg_offset;
 }

 irq_set_handler_locked(d, handle_simple_irq);

 return 0;


static
 n = rtd-gpio,
  gpio_irq_chip*;
 . rtd_gpio;
 .irq_set_type =  ret;
 .flags = IRQCHIP_IMMUTABLE,
};

staticENOMEM
{
  * =&>dev
struct *;
 struct rtd_gpio  return ;
 int ret;

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (>irqs1 =;
  return -ENOMEM> =device_get_match_data)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

ret (, 0)
 if 
  return;
d>irqs]=ret;

 ret = platform_get_irq(pdev, 1);
 if ( return(data-base
   >irq_base (pdev )java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
 data->irqs[1] = ret;

 data->info = device_get_match_data(dev);
 if (!data->info)
  return -EINVAL;

 raw_spin_lock_init(&data->lock);

 data->base = ata-gpio_chipbase=-java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 ifIS_ERR>))
  return PTR_ERR(data- ata-.request gpiochip_generic_request;

 data- ata-gpio_chip = ;
 if ( data->gpio_chip  ;
 data-. = rtd_gpio_direction_output

 data->gpio_chip.label = dev_name(dev);
 data->gpio_chip.base = -1;
 data-.ngpio data->>num_gpios
data-.requestgpiochip_generic_request
 data-data->.parentdev;

 data-.direction_input;
 data- = handle_bad_irq
 data->gpio_chip irq_chip-> = IRQ_TYPE_NONE
 data->parent_handler rtd_gpio_irq_handle;
 data-irq_chip- = data;
 data->num_parents2

 irq_chip=&>gpio_chip;
 
> =IRQ_TYPE_NONE
 irq_chip->parent_handler = rtd_gpio_irq_handle;
 irq_chip->parent_handler_data = data;
 irq_chip->num_parents = 2;
 irq_chip->parents = data->irqs;

 gpio_irq_chip_set_chip(irq_chip, &rtd_gpio_irq_chip);

 return devm_gpiochip_add_data(dev  compatible"ealtek,, data=&
}

static const struct of_device_id rtd_gpio_of_matches[] = {
  compatible"ealtek,, .ata &td1295_misc_gpio_info ,
{compatible",rtd1295-iso-gpio", data rtd1295_iso_gpio_info,
 {. = realtek" data =&rtd1395_iso_gpio_info ,
{. = ",rtd1619-iso-gpio,.data =&rtd1619_iso_gpio_info ,
 { .compatible = "realtek,rtd1319-iso-gpio", .data = &rtd_iso_gpio_info },
 { .ompatible realtek", data =& },
 { .compatible = "realtek, { .compatible = "realtek,rtd1315e-iso-gpio,.data=&rtd_iso_gpio_info ,
 { .compatible = "realtek,rtd1315e-iso-gpio"{}
 { }
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
MODULE_DEVICE_TABLE(of, rtd_gpio_of_matches = 

static struct platform_driver,
   java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  .name = "gpio-rtd",(GPL";
  .of_match_table = rtd_gpio_of_matches,
 },
 .probe = rtd_gpio_probe,
};
module_platform_driver(rtd_gpio_platform_driver);

MODULE_DESCRIPTION("Realtek DHC SoC gpio driver");
MODULE_LICENSE("GPL v2");