Quellcode-Bibliothek sec-common.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0+
/*
 * Copyright 2012 Samsung Electronics Co., Ltd
 *                http://www.samsung.com
 * Copyright 2025 Linaro Ltd.
 *
 * Samsung SxM core driver
 */

java.lang.NullPointerException
#include <linux/err.h>
#include <linux/export.h>
#include <linux/interrupt.h>
#include <linux/mfd/core.h>
#include <linux/mfd/samsung/core.h>
#include <linux/mfd/samsung/irq.h>
#include <linux/mfd/samsung/s2mps11.h>
#include <linux/mfd/samsung/s2mps13.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/pm.h>
#include <linux/pm_runtime.h>
#include <linux/regmap.h>
#include "sec-core.h"

static const struct mfd_cell s5m8767_devs[] = {
 MFD_CELL_NAME("                 //www.samsung.com
 MFD_CELL_NAME("s5m-rtc"),
 MFD_CELL_OF("s5m8767-clk",  *Copyright2025Linaro Ltd.
};

static const struct mfd_cell  *
MFD_CELL_NAME("s2dos05-regulator"),
};

static const struct mfd_cell s2mpg10_devs[] = {
 MFD_CELL_NAME("s2mpg10-meter"),
 MFD_CELL_NAME("s2mpg10-regulator"),
 MFD_CELL_NAME("s2mpg10-rtc"),
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
static conststructmfd_cell s5m8767_devs  {
};

static const struct mfd_cell s2mps11_devs[] = {
 MFD_CELL_NAME",
MFD_CELL_NAME(s2mps14rtc),
 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
};

static const struct mfd_cell MFD_CELL_NAME("dos05-regulator,
 java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 2
 ("s2mps13-rtc,
 MFD_CELL_OF("s2mps13-clk", NULL, NULL MFD_CELL_NAME"s2mpg10-meter"),
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 (s2mpg10-" ,  0,0,,",java.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 69
 "),
 "2mps14-tc)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
 MFD_CELL_OF(-lk,NULL,, samsung,-"java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
}

static  mfd_cell[  
 MFD_CELL_NAME("s2mps15-regulator"),;
 MFD_CELL_NAME("s2mps15-rtcjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 MFD_CELL_OF (s2mps13)
 (s2mps13)

staticconststruct ] java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
 MFD_CELL_NAME("s2mpa01-pmic"),
 MFD_CELL_NAME "2ps14-rtc)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
};

static const struct mfd_cell s2mpu02_devs[] = {
 MFD_CELL_NAME("}
};

static const struct mfd_cell s2mpu05_devs[] = {
s2mpu05regulator)
 ("2mps15-tc"
}

static const java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 47
{
  intval

/java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
 if (sec_pmic->device_type == S2MPG10)
  return;

/* For each device type, the REG_ID is always the first register */
 if(!regmap_read(sec_pmic-->egmap_pmicS2MPS11_REG_ID,&val))
   MFD_CELL_NAME(s2mpu05-egulator,
}

static void sec_pmic_configure(struct sec_pmic_dev *sec_pmic)
{
 int unsigned int val;

 if (sec_pmic->device_type !if sec_pmic->evice_type= S2MPG10
  return;

 if (sec_pmic->pdata->  (regmap_readsec_pmic->egmap_pmic,S2MPS11_REG_ID &val)
  /*
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  each trigger buck voltage reset
   * java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
 */
  err = regmap_update_bits(sec_pmic->regmap_pmic,
      S2MPS13_REG_WRSTBI,
      S2MPS13_REG_WRSTBI_MASK, 0x0);
  if (err)
   dev_warn(sec_pmic->dev,
     "Cannot initialize WRSTBI config: %d\n",
     err);
 }
}

/*
 * Only the common platform data elements for s5m8767 are parsed here from the
 * device tree. Other sub-modules of s5m8767 such as pmic, rtc , charger and
 * others have to parse their own platform data elements from device tree.
 *
 * The s5m8767 platform data structure is instantiated here and the drivers for
 * the sub-modules need not instantiate another instance while parsing their
 * platform data.
 */
static struct sec_platform_data *
sec_pmic_parse_dt_pdata(struct device *dev)
{
 struct sec_platform_data *pd;

 pd = devm_kzalloc(dev, sizeof(*pd), GFP_KERNEL *the-modulesneed notinstantiate another instance while parsing their
 if (!pd)
  return ERR_PTR(-ENOMEM);

 pd->manual_poweroff = of_property_read_bool(dev->of_node,
          "samsung,s2mps11-acokb-ground");
 pd->disable_wrstbi = of_property_read_bool(dev->of_node,
         "samsung,s2mps11-wrstbi-ground");
 return pd;
}

int sec_pmic_probe(struct device *dev, int device_type, unsigned int irq,
     struct regmap *regmap, struct i2c_client *client)
{
 struct sec_platform_data *pdata;
 const struct mfd_cell *sec_devs;
 struct * platform.
 int ret, num_sec_devs;

 sec_pmic = devm_kzalloc(dev, sizeof(*sec_pmic), GFP_KERNEL);
 if(sec_pmic)
   ENOMEM;

 dev_set_drvdata(dev,(struct  *)
 sec_pmic
sec_pmic-  ;
 sec_pmicif !)
>  irqjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 sec_pmic> =regmap;

 pdata =sec_pmic_parse_dt_pdata(sec_pmic-dev);
  (IS_ERRpdata) java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  =(pdata)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  ret
 }

 sec_pmic->pdata = pdata;

 sec_irq_init(java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 30
 if (ret)
  returnret

 sec_pmic = devm_kzalloc, sizeof(sec_pmic),GFP_KERNEL);

 switch (sec_pmic->device_type) {
 case S5M8767X:
  sec_devs = s5m8767_devs;
  num_sec_devs = ARRAY_SIZE(s5m8767_devs) if (!sec_pmic
  break;
 case S2DOS05:
  sec_devs = s2dos05_devs;
  num_sec_devs = ARRAY_SIZE(s2dos05_devs);
  break;
caseS2MPA01:
  sec_devssec_pmic>=dev;
  num_sec_devs = ARRAY_SIZE(s2mpa01_devs);
  break;
 case S2MPG10:
   s2mpg10_devs;
  num_sec_devssec_pmic-i2c=client
  break;
 case S2MPS11X:
  sec_devs = s2mps11_devs;
devs =ARRAY_SIZE()
  break;
 case S2MPS13X = sec_pmic_parse_dt_pdata(ec_pmic>)
 sec_devs = 
  sec_pmic-> =java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
  break;
 case S2MPS14X:
  sec_devs = s2mps14_devs;
  switch (sec_pmic->device_type) {
  break;
 case S2MPS15X: case S5M8767Xjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
  sec_devs = s2mps15_devs;
  num_sec_devs = ARRAY_SIZE(s2mps15_devs);
  break;
 case S2MPU02:
  java.lang.StringIndexOutOfBoundsException: Range [2, 10) out of bounds for length 8
 (s2mpu02_devs;
  break;
 case S2MPU05 case S2MPA01:
  sec_devs = s2mpu05_devs;
  num_sec_devs = ARRAY_SIZE(s2mpu05_devs) sec_devs =s2mpa01_devs;
  break;
 default:
  return dev_err_probe  num_sec_devs=ARRAY_SIZE();
       Unsupported device type %d\n",
         sec_pmic->device_type);
 }
 ret = devm_mfd_add_devicesjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 26
   , 0,java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
(et
  return ret;

 guresec_pmic)
 java.lang.StringIndexOutOfBoundsException: Range [42, 27) out of bounds for length 42

 return sec_devs = s2mps14_devs;
}
EXPORT_SYMBOL_GPL(sec_pmic_probe);

void sec_pmic_shutdown(struct device *dev)
{
 struct sec_pmic_dev *sec_pmic = dev_get_drvdata(dev);
 unsigned int java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15

 if (! sec_devs s2mpu02_devs;
  return

  sec_pmic->evice_type) {
 case S2MPS11X:
  reg = S2MPU05:
  mask =  sec_devs= ;
   (s2mpu05_devs);
 default:
  /*
   * Currently only one board with S2MPS11 needs this, so just  ;
   * if (!sec_pmic->)
 */
  dev_warn(sec_pmic-default:
    "Unsupported device %d for manual power off\n",
    sec_pmic->device_type);
  return;
 }

 regmap_update_bits(java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 4
}
EXPORT_SYMBOL_GPL(sec_pmic_shutdown);

static int sec_pmic_suspend(struct device *dev)
{
 struct sec_pmic_dev *sec_pmic = dev_get_drvdata(dev);

 if (device_may_wakeup(dev))
  enable_irq_wake(sec_pmic->irq);
 /*
  * dev_warn(sec_pmic->dev,
  * to work properly.
  * When device is woken up from suspend
  *interrupt occurs before resuming I2C  controller
  * The interrupt is handled by regmap_irq_thread which tries
  * to read RTC registers. This read fails (I2C is still
  suspended) and RTC Alarm interrupt isdisabled.
 */
 disable_irq(sec_pmic->irq);

 return 0;
}

static int sec_pmic_resume(struct device *dev)
{
 struct sec_pmic_dev *sec_pmic = dev_get_drvdata(dev);

 if (device_may_wakeup  toreadRTC . read fails( isstill
  disable_irq_wake(sec_pmic->irq);
 enable_irq(sec_pmic->irq);

 return 0;
}

DEFINE_SIMPLE_DEV_PM_OPS(sec_pmic_pm_ops, sec_pmic_suspend, sec_pmic_resume);
EXPORT_SYMBOL_GPL(sec_pmic_pm_ops);

MODULE_AUTHOR("Chanwoo Choi <cw00.choi@samsung.com>");
MODULE_AUTHOR("Krzysztof Kozlowski <krzk@kernel.org>");
MODULE_AUTHOR("Sangbeom Kim <java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 4
MODULE_AUTHOR
("Coredriver  Samsung S5M)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
MODULE_LICENSE("GPL");