drivers/spi/mpc8xxx_spi.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Copyright (c) 2006 Ben Warren, Qstreams Networks Inc.
   4  * With help from the common/soft_spi and arch/powerpc/cpu/mpc8260 drivers
   5  */
   6
   7 #include <common.h>
   8
   9 #include <malloc.h>
  10 #include <spi.h>
  11 #include <asm/mpc8xxx_spi.h>
  12
  13 enum {
  14         SPI_EV_NE = BIT(31 - 22),       /* Receiver Not Empty */
  15         SPI_EV_NF = BIT(31 - 23),       /* Transmitter Not Full */
  16 };
  17
  18 enum {
  19         SPI_MODE_LOOP  = BIT(31 - 1),   /* Loopback mode */
  20         SPI_MODE_CI    = BIT(31 - 2),   /* Clock invert */
  21         SPI_MODE_CP    = BIT(31 - 3),   /* Clock phase */
  22         SPI_MODE_DIV16 = BIT(31 - 4),   /* Divide clock source by 16 */
  23         SPI_MODE_REV   = BIT(31 - 5),   /* Reverse mode - MSB first */
  24         SPI_MODE_MS    = BIT(31 - 6),   /* Always master */
  25         SPI_MODE_EN    = BIT(31 - 7),   /* Enable interface */
  26
  27         SPI_MODE_LEN_MASK = 0xf00000,
  28         SPI_MODE_PM_MASK = 0xf0000,
  29
  30         SPI_COM_LST = BIT(31 - 9),
  31 };
  32
  33 static inline u32 to_prescale_mod(u32 val)
  34 {
  35         return (min(val, (u32)15) << 16);
  36 }
  37
  38 static void set_char_len(spi8xxx_t *spi, u32 val)
  39 {
  40         clrsetbits_be32(&spi->mode, SPI_MODE_LEN_MASK, (val << 20));
  41 }
  42
  43 #define SPI_TIMEOUT     1000
  44
  45 struct spi_slave *spi_setup_slave(uint bus, uint cs, uint max_hz, uint mode)
  46 {
  47         struct spi_slave *slave;
  48
  49         if (!spi_cs_is_valid(bus, cs))
  50                 return NULL;
  51
  52         slave = spi_alloc_slave_base(bus, cs);
  53         if (!slave)
  54                 return NULL;
  55
  56         /*
  57          * TODO: Some of the code in spi_init() should probably move
  58          * here, or into spi_claim_bus() below.
  59          */
  60
  61         return slave;
  62 }
  63
  64 void spi_free_slave(struct spi_slave *slave)
  65 {
  66         free(slave);
  67 }
  68
  69 void spi_init(void)
  70 {
  71         spi8xxx_t *spi = &((immap_t *)(CONFIG_SYS_IMMR))->spi;
  72
  73         /*
  74          * SPI pins on the MPC83xx are not muxed, so all we do is initialize
  75          * some registers
  76          */
  77         out_be32(&spi->mode, SPI_MODE_REV | SPI_MODE_MS | SPI_MODE_EN);
  78         /* Use SYSCLK / 8 (16.67MHz typ.) */
  79         clrsetbits_be32(&spi->mode, SPI_MODE_PM_MASK, to_prescale_mod(1));
  80         /* Clear all SPI events */
  81         setbits_be32(&spi->event, 0xffffffff);
  82         /* Mask  all SPI interrupts */
  83         clrbits_be32(&spi->mask, 0xffffffff);
  84         /* LST bit doesn't do anything, so disregard */
  85         out_be32(&spi->com, 0);
  86 }
  87
  88 int spi_claim_bus(struct spi_slave *slave)
  89 {
  90         return 0;
  91 }
  92
  93 void spi_release_bus(struct spi_slave *slave)
  94 {
  95 }
  96
  97 int spi_xfer(struct spi_slave *slave, uint bitlen, const void *dout, void *din,
  98              ulong flags)
  99 {
 100         spi8xxx_t *spi = &((immap_t *)(CONFIG_SYS_IMMR))->spi;
 101         u32 tmpdin;
 102         int num_blks = DIV_ROUND_UP(bitlen, 32);
 103
 104         debug("%s: slave %u:%u dout %08X din %08X bitlen %u\n", __func__,
 105               slave->bus, slave->cs, *(uint *)dout, *(uint *)din, bitlen);
 106
 107         if (flags & SPI_XFER_BEGIN)
 108                 spi_cs_activate(slave);
 109
 110         /* Clear all SPI events */
 111         setbits_be32(&spi->event, 0xffffffff);
 112
 113         /* Handle data in 32-bit chunks */
 114         while (num_blks--) {
 115                 int tm;
 116                 u32 tmpdout = 0;
 117                 uchar xfer_bitlen = (bitlen >= 32 ? 32 : bitlen);
 118
 119                 clrbits_be32(&spi->mode, SPI_MODE_EN);
 120
 121                 /* Set up length for this transfer */
 122
 123                 if (bitlen <= 4) /* 4 bits or less */
 124                         set_char_len(spi, 3);
 125                 else if (bitlen <= 16) /* at most 16 bits */
 126                         set_char_len(spi, bitlen - 1);
 127                 else /* more than 16 bits -> full 32 bit transfer */
 128                         set_char_len(spi, 0);
 129
 130                 setbits_be32(&spi->mode, SPI_MODE_EN);
 131
 132                 /* Shift data so it's msb-justified */
 133                 tmpdout = *(u32 *)dout >> (32 - xfer_bitlen);
 134
 135                 if (bitlen > 32) {
 136                         /* Set up the next iteration if sending > 32 bits */
 137                         bitlen -= 32;
 138                         dout += 4;
 139                 }
 140
 141                 /* Write the data out */
 142                 out_be32(&spi->tx, tmpdout);
 143
 144                 debug("*** %s: ... %08x written\n", __func__, tmpdout);
 145
 146                 /*
 147                  * Wait for SPI transmit to get out
 148                  * or time out (1 second = 1000 ms)
 149                  * The NE event must be read and cleared first
 150                  */
 151                 for (tm = 0; tm < SPI_TIMEOUT; ++tm) {
 152                         u32 event = in_be32(&spi->event);
 153                         bool have_ne = event & SPI_EV_NE;
 154                         bool have_nf = event & SPI_EV_NF;
 155
 156                         if (!have_ne)
 157                                 continue;
 158
 159                         tmpdin = in_be32(&spi->rx);
 160                         setbits_be32(&spi->event, SPI_EV_NE);
 161
 162                         *(u32 *)din = (tmpdin << (32 - xfer_bitlen));
 163                         if (xfer_bitlen == 32) {
 164                                 /* Advance output buffer by 32 bits */
 165                                 din += 4;
 166                         }
 167
 168                         /*
 169                          * Only bail when we've had both NE and NF events.
 170                          * This will cause timeouts on RO devices, so maybe
 171                          * in the future put an arbitrary delay after writing
 172                          * the device.  Arbitrary delays suck, though...
 173                          */
 174                         if (have_nf)
 175                                 break;
 176                 }
 177
 178                 if (tm >= SPI_TIMEOUT)
 179                         debug("*** %s: Time out during SPI transfer\n",
 180                               __func__);
 181
 182                 debug("*** %s: transfer ended. Value=%08x\n", __func__, tmpdin);
 183         }
 184
 185         if (flags & SPI_XFER_END)
 186                 spi_cs_deactivate(slave);
 187
 188         return 0;
 189 }