Merge tag 'ti-v2020.07-rc3' of https://gitlab.denx.de/u-boot/custodians/u-boot-ti

[oweals/u-boot.git] / drivers / power / pmic / i2c_pmic_emul.c

diff --git a/drivers/power/pmic/i2c_pmic_emul.c b/drivers/power/pmic/i2c_pmic_emul.c
index 2d35d09d454cc0dff05bca46cac343615e9a05db..404fe008fe6b9161c93056b6234324257b2c19a3 100644 (file)
--- a/drivers/power/pmic/i2c_pmic_emul.c
+++ b/drivers/power/pmic/i2c_pmic_emul.c
@@ -1,19 +1,18 @@
+// SPDX-License-Identifier: GPL-2.0+
 /*
  *  Copyright (C) 2015 Samsung Electronics
  *  Przemyslaw Marczak  <p.marczak@samsung.com>
- *
- * SPDX-License-Identifier:    GPL-2.0+
  */
 
 #include <common.h>
 #include <errno.h>
 #include <dm.h>
 #include <i2c.h>
+#include <log.h>
+#include <malloc.h>
 #include <power/pmic.h>
 #include <power/sandbox_pmic.h>
 
-DECLARE_GLOBAL_DATA_PTR;
-
 /**
  * struct sandbox_i2c_pmic_plat_data - platform data for the PMIC
  *
@@ -21,8 +20,11 @@ DECLARE_GLOBAL_DATA_PTR;
  * @reg:    PMICs registers array
  */
 struct sandbox_i2c_pmic_plat_data {
-       u8 rw_reg;
-       u8 reg[SANDBOX_PMIC_REG_COUNT];
+       u8 rw_reg, rw_idx;
+       u8 reg_count;
+       u8 trans_len;
+       u8 buf_size;
+       u8 *reg;
 };
 
 static int sandbox_i2c_pmic_read_data(struct udevice *emul, uchar chip,
@@ -30,16 +32,16 @@ static int sandbox_i2c_pmic_read_data(struct udevice *emul, uchar chip,
 {
        struct sandbox_i2c_pmic_plat_data *plat = dev_get_platdata(emul);
 
-       if (plat->rw_reg + len > SANDBOX_PMIC_REG_COUNT) {
-               error("Request exceeds PMIC register range! Max register: %#x",
-                     SANDBOX_PMIC_REG_COUNT);
+       if (plat->rw_idx + len > plat->buf_size) {
+               pr_err("Request exceeds PMIC register range! Max register: %#x",
+                     plat->reg_count);
                return -EFAULT;
        }
 
-       debug("Read PMIC: %#x at register: %#x count: %d\n",
-             (unsigned)chip & 0xff, plat->rw_reg, len);
+       debug("Read PMIC: %#x at register: %#x idx: %#x count: %d\n",
+             (unsigned int)chip & 0xff, plat->rw_reg, plat->rw_idx, len);
 
-       memcpy(buffer, &plat->reg[plat->rw_reg], len);
+       memcpy(buffer, plat->reg + plat->rw_idx, len);
 
        return 0;
 }
@@ -56,9 +58,10 @@ static int sandbox_i2c_pmic_write_data(struct udevice *emul, uchar chip,
 
        /* Set PMIC register for I/O */
        plat->rw_reg = *buffer;
+       plat->rw_idx = plat->rw_reg * plat->trans_len;
 
-       debug("Write PMIC: %#x at register: %#x count: %d\n",
-             (unsigned)chip & 0xff, plat->rw_reg, len);
+       debug("Write PMIC: %#x at register: %#x idx: %#x count: %d\n",
+             (unsigned int)chip & 0xff, plat->rw_reg, plat->rw_idx, len);
 
        /* For read operation, set (write) only chip reg */
        if (next_is_read)
@@ -67,12 +70,12 @@ static int sandbox_i2c_pmic_write_data(struct udevice *emul, uchar chip,
        buffer++;
        len--;
 
-       if (plat->rw_reg + len > SANDBOX_PMIC_REG_COUNT) {
-               error("Request exceeds PMIC register range! Max register: %#x",
-                     SANDBOX_PMIC_REG_COUNT);
+       if (plat->rw_idx + len > plat->buf_size) {
+               pr_err("Request exceeds PMIC register range! Max register: %#x",
+                     plat->reg_count);
        }
 
-       memcpy(&plat->reg[plat->rw_reg], buffer, len);
+       memcpy(plat->reg + plat->rw_idx, buffer, len);
 
        return 0;
 }
@@ -103,20 +106,42 @@ static int sandbox_i2c_pmic_xfer(struct udevice *emul, struct i2c_msg *msg,
 static int sandbox_i2c_pmic_ofdata_to_platdata(struct udevice *emul)
 {
        struct sandbox_i2c_pmic_plat_data *plat = dev_get_platdata(emul);
-       const u8 *reg_defaults;
+       struct udevice *pmic_dev = i2c_emul_get_device(emul);
 
        debug("%s:%d Setting PMIC default registers\n", __func__, __LINE__);
+       plat->reg_count = pmic_reg_count(pmic_dev);
+
+       return 0;
+}
+
+static int sandbox_i2c_pmic_probe(struct udevice *emul)
+{
+       struct sandbox_i2c_pmic_plat_data *plat = dev_get_platdata(emul);
+       struct udevice *pmic_dev = i2c_emul_get_device(emul);
+       struct uc_pmic_priv *upriv = dev_get_uclass_priv(pmic_dev);
+       const u8 *reg_defaults;
+
+       plat->trans_len = upriv->trans_len;
+       plat->buf_size = plat->reg_count * plat->trans_len;
+
+       plat->reg = calloc(1, plat->buf_size);
+       if (!plat->reg) {
+               debug("Canot allocate memory (%d B) for PMIC I2C emulation!\n",
+                     plat->buf_size);
+               return -ENOMEM;
+       }
 
        reg_defaults = dev_read_u8_array_ptr(emul, "reg-defaults",
-                                            SANDBOX_PMIC_REG_COUNT);
+                                            plat->buf_size);
 
        if (!reg_defaults) {
-               error("Property \"reg-defaults\" not found for device: %s!",
+               pr_err("Property \"reg-defaults\" not found for device: %s!",
                      emul->name);
+               free(plat->reg);
                return -EINVAL;
        }
 
-       memcpy(&plat->reg, reg_defaults, SANDBOX_PMIC_REG_COUNT);
+       memcpy(plat->reg, reg_defaults, plat->buf_size);
 
        return 0;
 }
@@ -135,6 +160,7 @@ U_BOOT_DRIVER(sandbox_i2c_pmic_emul) = {
        .id             = UCLASS_I2C_EMUL,
        .of_match       = sandbox_i2c_pmic_ids,
        .ofdata_to_platdata = sandbox_i2c_pmic_ofdata_to_platdata,
+       .probe          = sandbox_i2c_pmic_probe,
        .platdata_auto_alloc_size = sizeof(struct sandbox_i2c_pmic_plat_data),
        .ops            = &sandbox_i2c_pmic_emul_ops,
 };