drivers/spmi/spmi-sandbox.c

   1 /*
   2  * Sample SPMI bus driver
   3  *
   4  * It emulates bus with single pm8916-like pmic that has only GPIO reigsters.
   5  *
   6  * (C) Copyright 2015 Mateusz Kulikowski <mateusz.kulikowski@gmail.com>
   7  *
   8  * SPDX-License-Identifier:     GPL-2.0+
   9  */
  10
  11 #include <common.h>
  12 #include <dm.h>
  13 #include <errno.h>
  14 #include <spmi/spmi.h>
  15 #include <asm/gpio.h>
  16 #include <asm/io.h>
  17
  18 DECLARE_GLOBAL_DATA_PTR;
  19
  20 #define EMUL_GPIO_PID_START 0xC0
  21 #define EMUL_GPIO_PID_END   0xC3
  22
  23 #define EMUL_GPIO_COUNT 4
  24
  25 #define EMUL_GPIO_REG_END 0x46 /* Last valid register */
  26
  27 #define EMUL_PERM_R 0x1
  28 #define EMUL_PERM_W 0x2
  29 #define EMUL_PERM_RW (EMUL_PERM_R | EMUL_PERM_W)
  30
  31 struct sandbox_emul_fake_regs {
  32         u8 value;
  33         u8 access_mask;
  34         u8 perms; /* Access permissions */
  35 };
  36
  37 struct sandbox_emul_gpio {
  38         /* Fake registers - need one more entry as REG_END is valid address. */
  39         struct sandbox_emul_fake_regs r[EMUL_GPIO_REG_END + 1];
  40 };
  41
  42 struct sandbox_spmi_priv {
  43         struct sandbox_emul_gpio gpios[EMUL_GPIO_COUNT];
  44 };
  45
  46 /* Check if valid register was requested */
  47 static bool check_address_valid(int usid, int pid, int off)
  48 {
  49         if (usid != 0)
  50                 return false;
  51         if (pid < EMUL_GPIO_PID_START || pid > EMUL_GPIO_PID_END)
  52                 return false;
  53         if (off > EMUL_GPIO_REG_END)
  54                 return false;
  55         return true;
  56 }
  57
  58 static int sandbox_spmi_write(struct udevice *dev, const void *buf, int usid,
  59                           int pid, int off, uint8_t bc)
  60 {
  61         struct sandbox_spmi_priv *priv = dev_get_priv(dev);
  62         struct sandbox_emul_fake_regs *regs;
  63         uint8_t val;
  64
  65         if (!check_address_valid(usid, pid, off))
  66                 return -EIO;
  67
  68         memcpy(&val, buf, 1);
  69         regs = priv->gpios[pid & 0x3].r; /* Last 3 bits of pid are gpio # */
  70
  71         switch (off) {
  72         case 0x40: /* Control */
  73                 val &= regs[off].access_mask;
  74                 if (((val & 0x30) == 0x10) || ((val & 0x30) == 0x20)) {
  75                         /* out/inout - set status register */
  76                         regs[0x8].value &= ~0x1;
  77                         regs[0x8].value |= val & 0x1;
  78                 }
  79                 break;
  80         default:
  81                 if (regs[off].perms & EMUL_PERM_W)
  82                         regs[off].value = val & regs[off].access_mask;
  83         }
  84         return 0;
  85 }
  86
  87 static int sandbox_spmi_read(struct udevice *dev, void *buf, int usid, int pid,
  88                         int off, uint8_t bc)
  89 {
  90         struct sandbox_spmi_priv *priv = dev_get_priv(dev);
  91         struct sandbox_emul_fake_regs *regs;
  92
  93         if (!check_address_valid(usid, pid, off))
  94                 return -EIO;
  95
  96         regs = priv->gpios[pid & 0x3].r; /* Last 3 bits of pid are gpio # */
  97
  98         if (regs[0x46].value == 0) /* Block disabled */
  99                 return 0;
 100
 101         switch (off) {
 102         case 0x8: /* Status */
 103                 if (regs[0x46].value == 0) /* Block disabled */
 104                         return 0;
 105                 memcpy(buf, &regs[off].value, 1);
 106                 break;
 107         default:
 108                 if (regs[off].perms & EMUL_PERM_R)
 109                         memcpy(buf, &regs[off].value, 1);
 110         }
 111         return 0;
 112 }
 113
 114 static struct dm_spmi_ops sandbox_spmi_ops = {
 115         .read = sandbox_spmi_read,
 116         .write = sandbox_spmi_write,
 117 };
 118
 119 static int sandbox_spmi_probe(struct udevice *dev)
 120 {
 121         struct sandbox_spmi_priv *priv = dev_get_priv(dev);
 122         int i;
 123
 124         for (i = 0; i < EMUL_GPIO_COUNT; ++i) {
 125                 struct sandbox_emul_fake_regs *regs = priv->gpios[i].r;
 126                 regs[4].perms = EMUL_PERM_R;
 127                 regs[4].value = 0x10;
 128                 regs[5].perms = EMUL_PERM_R;
 129                 regs[5].value = 0x5;
 130                 regs[8].access_mask = 0x81;
 131                 regs[8].perms = EMUL_PERM_RW;
 132                 regs[0x40].access_mask = 0x7F;
 133                 regs[0x40].perms = EMUL_PERM_RW;
 134                 regs[0x41].access_mask = 7;
 135                 regs[0x41].perms = EMUL_PERM_RW;
 136                 regs[0x42].access_mask = 7;
 137                 regs[0x42].perms = EMUL_PERM_RW;
 138                 regs[0x42].value = 0x4;
 139                 regs[0x45].access_mask = 0x3F;
 140                 regs[0x45].perms = EMUL_PERM_RW;
 141                 regs[0x45].value = 0x1;
 142                 regs[0x46].access_mask = 0x80;
 143                 regs[0x46].perms = EMUL_PERM_RW;
 144                 regs[0x46].value = 0x80;
 145         }
 146         return 0;
 147 }
 148
 149 static const struct udevice_id sandbox_spmi_ids[] = {
 150         { .compatible = "sandbox,spmi" },
 151         { }
 152 };
 153
 154 U_BOOT_DRIVER(msm_spmi) = {
 155         .name = "sandbox_spmi",
 156         .id = UCLASS_SPMI,
 157         .of_match = sandbox_spmi_ids,
 158         .ops = &sandbox_spmi_ops,
 159         .probe = sandbox_spmi_probe,
 160         .priv_auto_alloc_size = sizeof(struct sandbox_spmi_priv),
 161 };