drivers/spmi/spmi-msm.c

   1 /*
   2  * Qualcomm SPMI bus driver
   3  *
   4  * (C) Copyright 2015 Mateusz Kulikowski <mateusz.kulikowski@gmail.com>
   5  *
   6  * Loosely based on Little Kernel driver
   7  *
   8  * SPDX-License-Identifier:     BSD-3-Clause
   9  */
  10
  11 #include <common.h>
  12 #include <dm.h>
  13 #include <errno.h>
  14 #include <fdtdec.h>
  15 #include <asm/io.h>
  16 #include <spmi/spmi.h>
  17
  18 DECLARE_GLOBAL_DATA_PTR;
  19
  20 #define ARB_CHANNEL_OFFSET(n)           (0x4 * (n))
  21 #define SPMI_CH_OFFSET(chnl)            ((chnl) * 0x8000)
  22
  23 #define PMIC_ARB_VERSION                0x0000
  24 #define PMIC_ARB_VERSION_V2_MIN         0x20010000
  25
  26 #define SPMI_REG_CMD0                   0x0
  27 #define SPMI_REG_CONFIG                 0x4
  28 #define SPMI_REG_STATUS                 0x8
  29 #define SPMI_REG_WDATA                  0x10
  30 #define SPMI_REG_RDATA                  0x18
  31
  32 #define SPMI_CMD_OPCODE_SHIFT           27
  33 #define SPMI_CMD_SLAVE_ID_SHIFT         20
  34 #define SPMI_CMD_ADDR_SHIFT             12
  35 #define SPMI_CMD_ADDR_OFFSET_SHIFT      4
  36 #define SPMI_CMD_BYTE_CNT_SHIFT         0
  37
  38 #define SPMI_V2_CMD_OPCODE_SHIFT        27
  39 #define SPMI_V2_CMD_ADDR_OFFSET_SHIFT   4
  40 #define SPMI_V2_CMD_BYTE_CNT_SHIFT      0
  41
  42 #define SPMI_CMD_EXT_REG_WRITE_LONG     0x00
  43 #define SPMI_CMD_EXT_REG_READ_LONG      0x01
  44
  45 #define SPMI_STATUS_DONE                0x1
  46
  47 #define SPMI_MAX_CHANNELS               128
  48 #define SPMI_MAX_SLAVES                 16
  49 #define SPMI_MAX_PERIPH                 256
  50
  51 #define SPMI_READ_TIMEOUT               100
  52 #define SPMI_WRITE_TIMEOUT              100
  53
  54 static int pmic_arb_ver;
  55
  56 static inline int pmic_arb_is_v1(void)
  57 {
  58         return pmic_arb_ver < PMIC_ARB_VERSION_V2_MIN;
  59 }
  60
  61 struct msm_spmi_priv {
  62         phys_addr_t arb_chnl; /* ARB channel mapping base */
  63         phys_addr_t spmi_core; /* SPMI core */
  64         phys_addr_t spmi_chnls; /* SPMI chnls */
  65         phys_addr_t spmi_obs; /* SPMI observer */
  66         /* SPMI channel map */
  67         uint8_t channel_map[SPMI_MAX_SLAVES][SPMI_MAX_PERIPH];
  68 };
  69
  70 static int msm_spmi_write(struct udevice *dev, int usid, int pid, int off,
  71                           uint8_t val)
  72 {
  73         struct msm_spmi_priv *priv = dev_get_priv(dev);
  74         unsigned channel;
  75         uint32_t reg = 0;
  76         int timeout = SPMI_WRITE_TIMEOUT;
  77
  78         if (usid >= SPMI_MAX_SLAVES)
  79                 return -EINVAL;
  80         if (pid >= SPMI_MAX_PERIPH)
  81                 return -EINVAL;
  82
  83         channel = priv->channel_map[usid][pid];
  84
  85         /* Disable IRQ mode for the current channel */
  86         writel(0x0, priv->spmi_chnls + SPMI_CH_OFFSET(channel) +
  87                SPMI_REG_CONFIG);
  88
  89         /* Write single byte */
  90         writel(val, priv->spmi_chnls + SPMI_CH_OFFSET(channel) + SPMI_REG_WDATA);
  91
  92         /* Prepare write command */
  93         if (pmic_arb_is_v1()) {
  94                 reg |= SPMI_CMD_EXT_REG_WRITE_LONG << SPMI_CMD_OPCODE_SHIFT;
  95                 reg |= (usid << SPMI_CMD_SLAVE_ID_SHIFT);
  96                 reg |= (pid << SPMI_CMD_ADDR_SHIFT);
  97                 reg |= (off << SPMI_CMD_ADDR_OFFSET_SHIFT);
  98                 reg |= 1; /* byte count */
  99         } else {
 100                 reg |= SPMI_CMD_EXT_REG_WRITE_LONG << SPMI_CMD_OPCODE_SHIFT;
 101                 reg |= ((off & 0xff) << SPMI_CMD_ADDR_OFFSET_SHIFT);
 102                 reg |= 0; /* byte count - 1 */
 103         }
 104         /* Send write command */
 105         writel(reg, priv->spmi_chnls + SPMI_CH_OFFSET(channel) + SPMI_REG_CMD0);
 106
 107         /* Wait till CMD DONE status */
 108         do {
 109                 reg = readl(priv->spmi_chnls + SPMI_CH_OFFSET(channel) +
 110                             SPMI_REG_STATUS);
 111                 if (reg)
 112                         break;
 113                 udelay(1);
 114         } while (timeout-- > 0);
 115         if (!(reg & SPMI_STATUS_DONE)) {
 116                 printf("SPMI write timed out\n");
 117                 return -ETIMEDOUT;
 118         }
 119
 120         if (reg ^ SPMI_STATUS_DONE) {
 121                 printf("SPMI write failure.\n");
 122                 return -EIO;
 123         }
 124
 125         return 0;
 126 }
 127
 128 static int msm_spmi_read(struct udevice *dev, int usid, int pid, int off)
 129 {
 130         struct msm_spmi_priv *priv = dev_get_priv(dev);
 131         unsigned channel;
 132         uint32_t reg = 0;
 133
 134         if (usid >= SPMI_MAX_SLAVES)
 135                 return -EINVAL;
 136         if (pid >= SPMI_MAX_PERIPH)
 137                 return -EINVAL;
 138
 139         channel = priv->channel_map[usid][pid];
 140
 141         /* Disable IRQ mode for the current channel*/
 142         writel(0x0, priv->spmi_obs + SPMI_CH_OFFSET(channel) + SPMI_REG_CONFIG);
 143
 144         /* Prepare read command */
 145         if (pmic_arb_is_v1()) {
 146                 reg |= SPMI_CMD_EXT_REG_READ_LONG << SPMI_CMD_OPCODE_SHIFT;
 147                 reg |= (usid << SPMI_CMD_SLAVE_ID_SHIFT);
 148                 reg |= (pid << SPMI_CMD_ADDR_SHIFT);
 149                 reg |= (off << SPMI_CMD_ADDR_OFFSET_SHIFT);
 150                 reg |= 1; /* byte count */
 151         } else {
 152                 reg |= SPMI_CMD_EXT_REG_READ_LONG << SPMI_CMD_OPCODE_SHIFT;
 153                 reg |= ((off & 0xff) << SPMI_CMD_ADDR_OFFSET_SHIFT);
 154                 reg |= 0; /* byte count - 1 */
 155         }
 156
 157         /* Request read */
 158         writel(reg, priv->spmi_obs + SPMI_CH_OFFSET(channel) + SPMI_REG_CMD0);
 159
 160         /* Wait till CMD DONE status */
 161         reg = 0;
 162         while (!reg) {
 163                 reg = readl(priv->spmi_obs + SPMI_CH_OFFSET(channel) +
 164                             SPMI_REG_STATUS);
 165         }
 166
 167         if (reg ^ SPMI_STATUS_DONE) {
 168                 printf("SPMI read failure.\n");
 169                 return -EIO;
 170         }
 171
 172         /* Read the data */
 173         return readl(priv->spmi_obs + SPMI_CH_OFFSET(channel) +
 174                      SPMI_REG_RDATA) & 0xFF;
 175 }
 176
 177 static struct dm_spmi_ops msm_spmi_ops = {
 178         .read = msm_spmi_read,
 179         .write = msm_spmi_write,
 180 };
 181
 182 static int msm_spmi_probe(struct udevice *dev)
 183 {
 184         struct udevice *parent = dev->parent;
 185         struct msm_spmi_priv *priv = dev_get_priv(dev);
 186         int i;
 187
 188         priv->spmi_core = dev_get_addr(dev);
 189         priv->spmi_chnls = fdtdec_get_addr_size_auto_parent(gd->fdt_blob,
 190                                                            parent->of_offset,
 191                                                            dev->of_offset,
 192                                                            "reg", 1, NULL,
 193                                                            false);
 194         priv->spmi_obs = fdtdec_get_addr_size_auto_parent(gd->fdt_blob,
 195                                                           parent->of_offset,
 196                                                           dev->of_offset, "reg",
 197                                                           2, NULL, false);
 198         if (priv->spmi_core == FDT_ADDR_T_NONE ||
 199             priv->spmi_chnls == FDT_ADDR_T_NONE ||
 200             priv->spmi_obs == FDT_ADDR_T_NONE)
 201                 return -EINVAL;
 202
 203         priv->arb_chnl = priv->spmi_core + 0x800;
 204
 205         /* Scan peripherals connected to each SPMI channel */
 206         for (i = 0; i < SPMI_MAX_CHANNELS ; i++) {
 207                 uint32_t periph = readl(priv->arb_chnl + ARB_CHANNEL_OFFSET(i));
 208                 uint8_t slave_id = (periph & 0xf0000) >> 16;
 209                 uint8_t pid = (periph & 0xff00) >> 8;
 210
 211                 priv->channel_map[slave_id][pid] = i;
 212         }
 213         pmic_arb_ver = readl(priv->spmi_core + PMIC_ARB_VERSION);
 214         printf("PMIC: PM8916 ARB version %d\n", pmic_arb_is_v1() ? 1 : 2);
 215         return 0;
 216 }
 217
 218 static const struct udevice_id msm_spmi_ids[] = {
 219         { .compatible = "qcom,spmi-pmic-arb" },
 220         { }
 221 };
 222
 223 U_BOOT_DRIVER(msm_spmi) = {
 224         .name = "msm_spmi",
 225         .id = UCLASS_SPMI,
 226         .of_match = msm_spmi_ids,
 227         .ops = &msm_spmi_ops,
 228         .probe = msm_spmi_probe,
 229         .priv_auto_alloc_size = sizeof(struct msm_spmi_priv),
 230 };