git.sur5r.net Git - u-boot/blob - drivers/spi/soft_spi_legacy.c

   1 /*
   2  * (C) Copyright 2002
   3  * Gerald Van Baren, Custom IDEAS, vanbaren@cideas.com.
   4  *
   5  * Influenced by code from:
   6  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
   7  *
   8  * SPDX-License-Identifier:     GPL-2.0+
   9  */
  10
  11 #include <common.h>
  12 #include <spi.h>
  13
  14 #include <malloc.h>
  15
  16 /*-----------------------------------------------------------------------
  17  * Definitions
  18  */
  19
  20 #ifdef DEBUG_SPI
  21 #define PRINTD(fmt,args...)     printf (fmt ,##args)
  22 #else
  23 #define PRINTD(fmt,args...)
  24 #endif
  25
  26 struct soft_spi_slave {
  27         struct spi_slave slave;
  28         unsigned int mode;
  29 };
  30
  31 static inline struct soft_spi_slave *to_soft_spi(struct spi_slave *slave)
  32 {
  33         return container_of(slave, struct soft_spi_slave, slave);
  34 }
  35
  36 /*=====================================================================*/
  37 /*                         Public Functions                            */
  38 /*=====================================================================*/
  39
  40 /*-----------------------------------------------------------------------
  41  * Initialization
  42  */
  43 void spi_init (void)
  44 {
  45 }
  46
  47 struct spi_slave *spi_setup_slave(unsigned int bus, unsigned int cs,
  48                 unsigned int max_hz, unsigned int mode)
  49 {
  50         struct soft_spi_slave *ss;
  51
  52         if (!spi_cs_is_valid(bus, cs))
  53                 return NULL;
  54
  55         ss = spi_alloc_slave(struct soft_spi_slave, bus, cs);
  56         if (!ss)
  57                 return NULL;
  58
  59         ss->mode = mode;
  60
  61         /* TODO: Use max_hz to limit the SCK rate */
  62
  63         return &ss->slave;
  64 }
  65
  66 void spi_free_slave(struct spi_slave *slave)
  67 {
  68         struct soft_spi_slave *ss = to_soft_spi(slave);
  69
  70         free(ss);
  71 }
  72
  73 int spi_claim_bus(struct spi_slave *slave)
  74 {
  75 #ifdef CONFIG_SYS_IMMR
  76         volatile immap_t *immr = (immap_t *)CONFIG_SYS_IMMR;
  77 #endif
  78         struct soft_spi_slave *ss = to_soft_spi(slave);
  79
  80         /*
  81          * Make sure the SPI clock is in idle state as defined for
  82          * this slave.
  83          */
  84         if (ss->mode & SPI_CPOL)
  85                 SPI_SCL(1);
  86         else
  87                 SPI_SCL(0);
  88
  89         return 0;
  90 }
  91
  92 void spi_release_bus(struct spi_slave *slave)
  93 {
  94         /* Nothing to do */
  95 }
  96
  97 /*-----------------------------------------------------------------------
  98  * SPI transfer
  99  *
 100  * This writes "bitlen" bits out the SPI MOSI port and simultaneously clocks
 101  * "bitlen" bits in the SPI MISO port.  That's just the way SPI works.
 102  *
 103  * The source of the outgoing bits is the "dout" parameter and the
 104  * destination of the input bits is the "din" parameter.  Note that "dout"
 105  * and "din" can point to the same memory location, in which case the
 106  * input data overwrites the output data (since both are buffered by
 107  * temporary variables, this is OK).
 108  */
 109 int  spi_xfer(struct spi_slave *slave, unsigned int bitlen,
 110                 const void *dout, void *din, unsigned long flags)
 111 {
 112 #ifdef CONFIG_SYS_IMMR
 113         volatile immap_t *immr = (immap_t *)CONFIG_SYS_IMMR;
 114 #endif
 115         struct soft_spi_slave *ss = to_soft_spi(slave);
 116         uchar           tmpdin  = 0;
 117         uchar           tmpdout = 0;
 118         const u8        *txd = dout;
 119         u8              *rxd = din;
 120         int             cpol = ss->mode & SPI_CPOL;
 121         int             cpha = ss->mode & SPI_CPHA;
 122         unsigned int    j;
 123
 124         PRINTD("spi_xfer: slave %u:%u dout %08X din %08X bitlen %u\n",
 125                 slave->bus, slave->cs, *(uint *)txd, *(uint *)rxd, bitlen);
 126
 127         if (flags & SPI_XFER_BEGIN)
 128                 spi_cs_activate(slave);
 129
 130         for(j = 0; j < bitlen; j++) {
 131                 /*
 132                  * Check if it is time to work on a new byte.
 133                  */
 134                 if ((j % 8) == 0) {
 135                         if (txd)
 136                                 tmpdout = *txd++;
 137                         else
 138                                 tmpdout = 0;
 139                         if(j != 0) {
 140                                 if (rxd)
 141                                         *rxd++ = tmpdin;
 142                         }
 143                         tmpdin  = 0;
 144                 }
 145
 146                 if (!cpha)
 147                         SPI_SCL(!cpol);
 148                 SPI_SDA(tmpdout & 0x80);
 149                 SPI_DELAY;
 150                 if (cpha)
 151                         SPI_SCL(!cpol);
 152                 else
 153                         SPI_SCL(cpol);
 154                 tmpdin  <<= 1;
 155                 tmpdin  |= SPI_READ;
 156                 tmpdout <<= 1;
 157                 SPI_DELAY;
 158                 if (cpha)
 159                         SPI_SCL(cpol);
 160         }
 161         /*
 162          * If the number of bits isn't a multiple of 8, shift the last
 163          * bits over to left-justify them.  Then store the last byte
 164          * read in.
 165          */
 166         if (rxd) {
 167                 if ((bitlen % 8) != 0)
 168                         tmpdin <<= 8 - (bitlen % 8);
 169                 *rxd++ = tmpdin;
 170         }
 171
 172         if (flags & SPI_XFER_END)
 173                 spi_cs_deactivate(slave);
 174
 175         return(0);
 176 }