drivers/spi/sandbox_spi.c

   1 /*
   2  * Simulate a SPI port
   3  *
   4  * Copyright (c) 2011-2013 The Chromium OS Authors.
   5  * See file CREDITS for list of people who contributed to this
   6  * project.
   7  *
   8  * Licensed under the GPL-2 or later.
   9  */
  10
  11 #define LOG_CATEGORY UCLASS_SPI
  12
  13 #include <common.h>
  14 #include <dm.h>
  15 #include <log.h>
  16 #include <malloc.h>
  17 #include <spi.h>
  18 #include <spi_flash.h>
  19 #include <os.h>
  20
  21 #include <linux/errno.h>
  22 #include <asm/spi.h>
  23 #include <asm/state.h>
  24 #include <dm/acpi.h>
  25 #include <dm/device-internal.h>
  26
  27 /**
  28  * struct sandbox_spi_priv - Sandbox SPI private data
  29  *
  30  * Helper struct to keep track of the sandbox SPI bus internal state. It is
  31  * used in unit tests to verify that dm spi functions update the bus
  32  * speed/mode properly (for instance, when jumping back and forth between spi
  33  * slaves claiming the bus, we need to make sure that the bus speed is updated
  34  * accordingly for each slave).
  35  *
  36  * @speed:      Current bus speed.
  37  * @mode:       Current bus mode.
  38  */
  39 struct sandbox_spi_priv {
  40         uint speed;
  41         uint mode;
  42 };
  43
  44 __weak int sandbox_spi_get_emul(struct sandbox_state *state,
  45                                 struct udevice *bus, struct udevice *slave,
  46                                 struct udevice **emulp)
  47 {
  48         return -ENOENT;
  49 }
  50
  51 uint sandbox_spi_get_speed(struct udevice *dev)
  52 {
  53         struct sandbox_spi_priv *priv = dev_get_priv(dev);
  54
  55         return priv->speed;
  56 }
  57
  58 uint sandbox_spi_get_mode(struct udevice *dev)
  59 {
  60         struct sandbox_spi_priv *priv = dev_get_priv(dev);
  61
  62         return priv->mode;
  63 }
  64
  65 static int sandbox_spi_xfer(struct udevice *slave, unsigned int bitlen,
  66                             const void *dout, void *din, unsigned long flags)
  67 {
  68         struct udevice *bus = slave->parent;
  69         struct sandbox_state *state = state_get_current();
  70         struct dm_spi_emul_ops *ops;
  71         struct udevice *emul;
  72         uint bytes = bitlen / 8, i;
  73         int ret;
  74         uint busnum, cs;
  75
  76         if (bitlen == 0)
  77                 return 0;
  78
  79         /* we can only do 8 bit transfers */
  80         if (bitlen % 8) {
  81                 printf("sandbox_spi: xfer: invalid bitlen size %u; needs to be 8bit\n",
  82                        bitlen);
  83                 return -EINVAL;
  84         }
  85
  86         busnum = dev_seq(bus);
  87         cs = spi_chip_select(slave);
  88         if (busnum >= CONFIG_SANDBOX_SPI_MAX_BUS ||
  89             cs >= CONFIG_SANDBOX_SPI_MAX_CS) {
  90                 printf("%s: busnum=%u, cs=%u: out of range\n", __func__,
  91                        busnum, cs);
  92                 return -ENOENT;
  93         }
  94         ret = sandbox_spi_get_emul(state, bus, slave, &emul);
  95         if (ret) {
  96                 printf("%s: busnum=%u, cs=%u: no emulation available (err=%d)\n",
  97                        __func__, busnum, cs, ret);
  98                 return -ENOENT;
  99         }
 100         ret = device_probe(emul);
 101         if (ret)
 102                 return ret;
 103
 104         ops = spi_emul_get_ops(emul);
 105         ret = ops->xfer(emul, bitlen, dout, din, flags);
 106
 107         log_content("sandbox_spi: xfer: got back %i (that's %s)\n rx:",
 108                     ret, ret ? "bad" : "good");
 109         if (din) {
 110                 for (i = 0; i < bytes; ++i)
 111                         log_content(" %u:%02x", i, ((u8 *)din)[i]);
 112         }
 113         log_content("\n");
 114
 115         return ret;
 116 }
 117
 118 static int sandbox_spi_set_speed(struct udevice *bus, uint speed)
 119 {
 120         struct sandbox_spi_priv *priv = dev_get_priv(bus);
 121
 122         priv->speed = speed;
 123
 124         return 0;
 125 }
 126
 127 static int sandbox_spi_set_mode(struct udevice *bus, uint mode)
 128 {
 129         struct sandbox_spi_priv *priv = dev_get_priv(bus);
 130
 131         priv->mode = mode;
 132
 133         return 0;
 134 }
 135
 136 static int sandbox_cs_info(struct udevice *bus, uint cs,
 137                            struct spi_cs_info *info)
 138 {
 139         /* Always allow activity on CS 0, CS 1 */
 140         if (cs >= 2)
 141                 return -EINVAL;
 142
 143         return 0;
 144 }
 145
 146 static int sandbox_spi_get_mmap(struct udevice *dev, ulong *map_basep,
 147                                 uint *map_sizep, uint *offsetp)
 148 {
 149         *map_basep = 0x1000;
 150         *map_sizep = 0x2000;
 151         *offsetp = 0x100;
 152
 153         return 0;
 154 }
 155
 156 static const struct dm_spi_ops sandbox_spi_ops = {
 157         .xfer           = sandbox_spi_xfer,
 158         .set_speed      = sandbox_spi_set_speed,
 159         .set_mode       = sandbox_spi_set_mode,
 160         .cs_info        = sandbox_cs_info,
 161         .get_mmap       = sandbox_spi_get_mmap,
 162 };
 163
 164 static const struct udevice_id sandbox_spi_ids[] = {
 165         { .compatible = "sandbox,spi" },
 166         { }
 167 };
 168
 169 U_BOOT_DRIVER(sandbox_spi) = {
 170         .name   = "sandbox_spi",
 171         .id     = UCLASS_SPI,
 172         .of_match = sandbox_spi_ids,
 173         .ops    = &sandbox_spi_ops,
 174         .priv_auto = sizeof(struct sandbox_spi_priv),
 175 };