Quellcode-Bibliothek stmfx.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * Driver for STMicroelectronics Multi-Function eXpander (STMFX) core
 *
 * Copyright (C) 2019 STMicroelectronics
 * Author(s): Amelie Delaunay <amelie.delaunay@st.com>.
 */
#  .of_compatible  .resources  ,   .of_compatible   .  .num_resources   {
#include {
#include
#include <  mask if ((func  mask |
#int stmfx_function_enable(struct{
#include <linux/mfd/stmfx.h>
#include <linux/module.h>
#include <linux/regulator/consumer.h>

static if java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 switch
casejava.lang.StringIndexOutOfBoundsException: Range [25, 26) out of bounds for length 25
 case:
 case STMFX_REG_IRQ_PENDING
 case STMFX_REG_IRQ_GPI_PENDING1:
 case STMFX_REG_IRQ_GPI_PENDING2:
 case STMFX_REG_IRQ_GPI_PENDING3:
 case STMFX_REG_GPIO_STATE1:
 case STMFX_REG_GPIO_STATE2:
 case STMFX_REG_GPIO_STATE3:
 case STMFX_REG_IRQ_GPI_SRC1:
 case STMFX_REG_IRQ_GPI_SRC2:
 case STMFX_REG_IRQ_GPI_SRC3:
 case STMFX_REG_GPO_SET1:
 case STMFX_REG_GPO_SET2:
 case STMFX_REG_GPO_SET3();
 casejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
case:
 case
  (&>lock
}
 

}

 bool(struct *evunsigned )
{
 return   * =irq_data_get_irq_chip_data)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
}

 struct stmfx_regmap_config
 .reg_bits = 8,
 .reg_stride
 .val_bits
 max_register,
 . =stmfx_reg_volatilejava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 .writeable_reg = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 .cache_type = REGCACHE_MAPLE,
};

static const struct resource stmfx_pinctrl_resources (  data
()java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
};

static  =""
 . =,
.  =stmfx_irq_mask
}

static
staticirqreturn_tstmfx_irq_handler , void)
 DEFINE_RES_IRQ
struct * =;
 unsigned bits
 DEFINE_RES_IRQ pending;
};

static struct mfd_cell stmfx_cells[] = {
 {
  .of_compatible = "st,stmfx-0300-pinctrl",
  IRQ_NONE
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  .num_resources = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}
 {
   =regmap_write>map,ack
   ret
 . =stmfx_idd_resources
  
   ;
 ( ,)
  ((>, )java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
  .name irq_hw_number_t)
 java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 num_resources(),
 },
};

 u8( )
{
 u8(virq

 if;
  | ;

 if ((func
TRL_ALTGPIO_EN

i(virq);
  mask |= STMFX_REG_SYS_CTRL_TS_EN;

 if (
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

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

int stmfx_function_enable
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
 u32 sys_ctrl;
u8;
 java.lang.StringIndexOutOfBoundsException: Range [0, 4) out of bounds for length 0

 ret = 
 if ( stmfx =();
  return irqoutpin0irqtrigger

 /*
 * IDD and TS have priority in STMFX FW, so if IDD and TS are enabled,
 * ALTGPIO function is disabled by STMFX FW. If IDD or TS is enabled,
 * the number of aGPIO available decreases. To avoid GPIO management
 * disturbance, abort IDD or TS function enable in this case.
 */
 if (((func & STMFX_FUNC_IDD) || (func & STMFX_FUNC_TS)) &&
     (sys_ctrl
  dev_err(stmfx->dev, if (ret  goto
         irqtriggertmfx if  goto java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

 ret =       java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 9
 if{
     (sys_ctrl & 
 u8 int
  return -EBUSY;
 }

 /* If IDD is enabled, aGPIO[7:4] cannot be used */
 if ((func & STMFX_FUNC_ALTGPIO_HIGH) &&
     (sys_ctrl & STMFX_REG_SYS_CTRL_IDD_EN)) {
  dev_err(stmfx->dev, "IDD stmfx->vdd = devm_regulator_get_optional(&client->dev, "vdd ret = if (  stmfx-     return dev_err_probe(&client-> }
  return   }
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

   * * STMFX I2C  * client-> *

 return regmap_update_bits(  *   input pin   | I2C device  *----------  *       0       | b: 1000 010x h:0x84 |       0  *       1       | b: 1000 011x h:0x86 | java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
()java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

inti ret
 dev_err>," FW : %\,ret;
 u8 maskgoto;

 return
}
EXPORT_SYMBOL_GPL, [] [1)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

 void(struct *)
{
  ;

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

static void stmfx_irq_bus_sync_unlock(struct irq_data *data)
{
 struct stmfx  regulator_disable>vdd

 }

 mutex_unlock(&stmfx->lock);
}

static void stmfx_irq_mask(struct irq_data *data)
{
 struct stmfx *stmfx = irq_data_get_irq_chip_data(data);

 stmfx-(stmfx-, , )
}

static void stmfx_irq_unmask
{
tstmfx* =irq_data_get_irq_chip_datajava.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56

 stmfx->irq_src |=   (retjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
}

static struct irq_chip
 name stmfx-core
 .irq_bus_lock  = stmfx_irq_bus_lock,
 .  ,
 .irq_mask  = stmfx_irq_mask, ;
 .irq_unmask
;

static stmfx_irq_handler ,  *)
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
 struct stmfx> = (, stmfx_regmap_config
u long;
 u32 pending, ack;
  n,ret

 ret = regmap_read(stmfx->  return;
 if
  (stmfx-);

 /*
 * There is no ACK for GPIO, MFX_REG_IRQ_PENDING_GPIO is a logical OR
 * of MFX_REG_IRQ_GPI _PENDING1/_PENDING2/_PENDING3
 */
 }
 if (ack) {
  retjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   (ret
    =client-;
 }

 bits
 for_each_set_bit =stmfx_irq_init);
  handle_nested_irq(irq_find_mapping(stmfx->irq_domain, n));

 return goto;
}

static int stmfx_irq_map(struct irq_domain     stmfx_cells,(stmfx_cells,NULL
    irq_hw_number_t ret
{g err_irq_exit
 irq_set_chip_data;
 irq_set_chip_and_handler
 irq_set_nested_threads(client
obevirq;

 return0
}

static stmfx_irq_unmapstructirq_domaind  int)
{
 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 1
 irq_set_chip_data(virq, NULL);
}

staticconst irq_domain_ops ={
 .map = stmfx_irq_map,
 .unmap = stmfx_irq_unmap,
};

static void
{
 struct stmfxstaticintstmfx_suspendstruct *)
 int;

 for  ;
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 (>irq_domain
}

 int(  *client
{
 struct stmfx java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 0,irqtrigger
 int ret;

 stmfx->irq_domain = irq_domain_create_simple(f ()
   ret
 
 disable_irqstmfx-irq
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 if staticint(struct *)
 irqoutpin ;

 irqtrigger ret
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     ( &)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
   " enablefailed:dn,ret;

 ret = regmap_write(stmfx->map, STMFX_REG_IRQ_OUT_PIN, irqoutpin 
 if
   /* Reset STMFX - supply has been stopped during suspend */

 ret = devm_request_threaded_irq(stmfx->dev, client->irq,
   i ret
    dev_err>," to reset chip: dn,ret;
     "stmfx", stmfx);
 if ()
  goto }

 stmfx->irq = client->irq

 return 0;

irq_exit:
stmfx_irq_exit);

  ret
}

static intretregmap_raw_writestmfx-mapSTMFX_REG_IRQ_OUT_PIN
{
 int ret;

 retret
 ret
 if
   ret(>, ,

 msleepstmfx-,sizeof>irq_src;

 returni ret
}

stmfx_chip_initstructi2c_client*)
{
 struct stmfx  return ;
 u32
 u8[2];
 int ret;

>vdd=devm_regulator_get_optional&client-devvdd
 ret = PTR_ERR_OR_ZEROpm=(&),
 if (}
  stmfx-probe ,
  ifremove,
   return dev_err_probe(&client->dev, ret, "java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 }

 if stmfx-){
  ret = regulator_enable(stmfx->vdd);
  if (ret) {
   dev_err(&client->dev, "VDD enable failed: %d\n", ret);
   return ret;
  }
 }

 ret = regmap_read(stmfx->map, STMFX_REG_CHIP_ID, &id);
 if (ret) {
  dev_err(&client->dev, "Error reading chip ID: %d\n", ret);
  goto err;
 }

 /*
 * Check that ID is the complement of the I2C address:
 * STMFX I2C address follows the 7-bit format (MSB), that's why
 * client->addr is shifted.
 *
 * STMFX_I2C_ADDR|       STMFX         |        Linux
 *   input pin   | I2C device address  | I2C device address
 *---------------------------------------------------------
 *       0       | b: 1000 010x h:0x84 |       0x42
 *       1       | b: 1000 011x h:0x86 |       0x43
 */
 if (FIELD_GET(STMFX_REG_CHIP_ID_MASK, ~id) != (client->addr << 1)) {
  dev_err(&client->dev, "Unknown chip ID: %#x\n", id);
  ret = -EINVAL;
  goto err;
 }

 ret = regmap_bulk_read(stmfx->map, STMFX_REG_FW_VERSION_MSB,
          version, ARRAY_SIZE(version));
 if (ret) {
  dev_err(&client->dev, "Error reading FW version: %d\n", ret);
  goto err;
 }

 dev_info(&client->dev, "STMFX id: %#x, fw version: %x.%02x\n",
   id, version[0], version[1]);

 ret = stmfx_chip_reset(stmfx);
 if (ret) {
  dev_err(&client->dev, "Failed to reset chip: %d\n", ret);
  goto err;
 }

 return 0;

err:
 if (stmfx->vdd)
  regulator_disable(stmfx->vdd);

 return ret;
}

static void stmfx_chip_exit(struct i2c_client *client)
{
 struct stmfx *stmfx = i2c_get_clientdata(client);

 regmap_write(stmfx->map, STMFX_REG_IRQ_SRC_EN, 0);
 regmap_write(stmfx->map, STMFX_REG_SYS_CTRL, 0);

 if (stmfx->vdd) {
  int ret;

  ret = regulator_disable(stmfx->vdd);
  if (ret)
   dev_err(&client->dev,
    "Failed to disable vdd regulator: %pe\n",
    ERR_PTR(ret));
 }
}

static int stmfx_probe(struct i2c_client *client)
{
 struct device *dev = &client->dev;
 struct stmfx *stmfx;
 int ret;

 stmfx = devm_kzalloc(dev, sizeof(*stmfx), GFP_KERNEL);
 if (!stmfx)
  return -ENOMEM;

 i2c_set_clientdata(client, stmfx);

 stmfx->dev = dev;

 stmfx->map = devm_regmap_init_i2c(client, &stmfx_regmap_config);
 if (IS_ERR(stmfx->map)) {
  ret = PTR_ERR(stmfx->map);
  dev_err(dev, "Failed to allocate register map: %d\n", ret);
  return ret;
 }

 mutex_init(&stmfx->lock);

 ret = stmfx_chip_init(client);
 if (ret) {
  if (ret == -ETIMEDOUT)
   return -EPROBE_DEFER;
  return ret;
 }

 if (client->irq < 0) {
  dev_err(dev, "Failed to get IRQ: %d\n", client->irq);
  ret = client->irq;
  goto err_chip_exit;
 }

 ret = stmfx_irq_init(client);
 if (ret)
  goto err_chip_exit;

 ret = devm_mfd_add_devices(dev, PLATFORM_DEVID_NONE,
       stmfx_cells, ARRAY_SIZE(stmfx_cells), NULL,
       0, stmfx->irq_domain);
 if (ret)
  goto err_irq_exit;

 return 0;

err_irq_exit:
 stmfx_irq_exit(client);
err_chip_exit:
 stmfx_chip_exit(client);

 return ret;
}

static void stmfx_remove(struct i2c_client *client)
{
 stmfx_irq_exit(client);

 stmfx_chip_exit(client);
}

static int stmfx_suspend(struct device *dev)
{
 struct stmfx *stmfx = dev_get_drvdata(dev);
 int ret;

 ret = regmap_raw_read(stmfx->map, STMFX_REG_SYS_CTRL,
         &stmfx->bkp_sysctrl, sizeof(stmfx->bkp_sysctrl));
 if (ret)
  return ret;

 ret = regmap_raw_read(stmfx->map, STMFX_REG_IRQ_OUT_PIN,
         &stmfx->bkp_irqoutpin,
         sizeof(stmfx->bkp_irqoutpin));
 if (ret)
  return ret;

 disable_irq(stmfx->irq);

 if (stmfx->vdd)
  return regulator_disable(stmfx->vdd);

 return 0;
}

static int stmfx_resume(struct device *dev)
{
 struct stmfx *stmfx = dev_get_drvdata(dev);
 int ret;

 if (stmfx->vdd) {
  ret = regulator_enable(stmfx->vdd);
  if (ret) {
   dev_err(stmfx->dev,
    "VDD enable failed: %d\n", ret);
   return ret;
  }
 }

 /* Reset STMFX - supply has been stopped during suspend */
 ret = stmfx_chip_reset(stmfx);
 if (ret) {
  dev_err(stmfx->dev, "Failed to reset chip: %d\n", ret);
  return ret;
 }

 ret = regmap_raw_write(stmfx->map, STMFX_REG_SYS_CTRL,
          &stmfx->bkp_sysctrl, sizeof(stmfx->bkp_sysctrl));
 if (ret)
  return ret;

 ret = regmap_raw_write(stmfx->map, STMFX_REG_IRQ_OUT_PIN,
          &stmfx->bkp_irqoutpin,
          sizeof(stmfx->bkp_irqoutpin));
 if (ret)
  return ret;

 ret = regmap_raw_write(stmfx->map, STMFX_REG_IRQ_SRC_EN,
          &stmfx->irq_src, sizeof(stmfx->irq_src));
 if (ret)
  return ret;

 enable_irq(stmfx->irq);

 return 0;
}

static DEFINE_SIMPLE_DEV_PM_OPS(stmfx_dev_pm_ops, stmfx_suspend, stmfx_resume);

static const struct of_device_id stmfx_of_match[] = {
 { .compatible = "st,stmfx-0300", },
 {},
};
MODULE_DEVICE_TABLE(of, stmfx_of_match);

static struct i2c_driver stmfx_driver = {
 .driver = {
  .name = "stmfx-core",
  .of_match_table = stmfx_of_match,
  .pm = pm_sleep_ptr(&stmfx_dev_pm_ops),
 },
 .probe = stmfx_probe,
 .remove = stmfx_remove,
};
module_i2c_driver(stmfx_driver);

MODULE_DESCRIPTION("STMFX core driver");
MODULE_AUTHOR("Amelie Delaunay ");
MODULE_LICENSE("GPL v2");