common/cmd_spi.c

   1 /*
   2  * (C) Copyright 2002
   3  * Gerald Van Baren, Custom IDEAS, vanbaren@cideas.com
   4  *
   5  * SPDX-License-Identifier:     GPL-2.0+
   6  */
   7
   8 /*
   9  * SPI Read/Write Utilities
  10  */
  11
  12 #include <common.h>
  13 #include <command.h>
  14 #include <errno.h>
  15 #include <spi.h>
  16
  17 /*-----------------------------------------------------------------------
  18  * Definitions
  19  */
  20
  21 #ifndef MAX_SPI_BYTES
  22 #   define MAX_SPI_BYTES 32     /* Maximum number of bytes we can handle */
  23 #endif
  24
  25 #ifndef CONFIG_DEFAULT_SPI_BUS
  26 #   define CONFIG_DEFAULT_SPI_BUS       0
  27 #endif
  28 #ifndef CONFIG_DEFAULT_SPI_MODE
  29 #   define CONFIG_DEFAULT_SPI_MODE      SPI_MODE_0
  30 #endif
  31
  32 /*
  33  * Values from last command.
  34  */
  35 static unsigned int     bus;
  36 static unsigned int     cs;
  37 static unsigned int     mode;
  38 static int              bitlen;
  39 static uchar            dout[MAX_SPI_BYTES];
  40 static uchar            din[MAX_SPI_BYTES];
  41
  42 static int do_spi_xfer(int bus, int cs)
  43 {
  44         struct spi_slave *slave;
  45         int rcode = 0;
  46
  47         slave = spi_setup_slave(bus, cs, 1000000, mode);
  48         if (!slave) {
  49                 printf("Invalid device %d:%d\n", bus, cs);
  50                 return -EINVAL;
  51         }
  52
  53         spi_claim_bus(slave);
  54         if (spi_xfer(slave, bitlen, dout, din,
  55                      SPI_XFER_BEGIN | SPI_XFER_END) != 0) {
  56                 printf("Error during SPI transaction\n");
  57                 rcode = -EIO;
  58         } else {
  59                 int j;
  60
  61                 for (j = 0; j < ((bitlen + 7) / 8); j++)
  62                         printf("%02X", din[j]);
  63                 printf("\n");
  64         }
  65         spi_release_bus(slave);
  66         spi_free_slave(slave);
  67
  68         return rcode;
  69 }
  70
  71 /*
  72  * SPI read/write
  73  *
  74  * Syntax:
  75  *   spi {dev} {num_bits} {dout}
  76  *     {dev} is the device number for controlling chip select (see TBD)
  77  *     {num_bits} is the number of bits to send & receive (base 10)
  78  *     {dout} is a hexadecimal string of data to send
  79  * The command prints out the hexadecimal string received via SPI.
  80  */
  81
  82 int do_spi (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
  83 {
  84         char  *cp = 0;
  85         uchar tmp;
  86         int   j;
  87
  88         /*
  89          * We use the last specified parameters, unless new ones are
  90          * entered.
  91          */
  92
  93         if ((flag & CMD_FLAG_REPEAT) == 0)
  94         {
  95                 if (argc >= 2) {
  96                         mode = CONFIG_DEFAULT_SPI_MODE;
  97                         bus = simple_strtoul(argv[1], &cp, 10);
  98                         if (*cp == ':') {
  99                                 cs = simple_strtoul(cp+1, &cp, 10);
 100                         } else {
 101                                 cs = bus;
 102                                 bus = CONFIG_DEFAULT_SPI_BUS;
 103                         }
 104                         if (*cp == '.')
 105                                 mode = simple_strtoul(cp+1, NULL, 10);
 106                 }
 107                 if (argc >= 3)
 108                         bitlen = simple_strtoul(argv[2], NULL, 10);
 109                 if (argc >= 4) {
 110                         cp = argv[3];
 111                         for(j = 0; *cp; j++, cp++) {
 112                                 tmp = *cp - '0';
 113                                 if(tmp > 9)
 114                                         tmp -= ('A' - '0') - 10;
 115                                 if(tmp > 15)
 116                                         tmp -= ('a' - 'A');
 117                                 if(tmp > 15) {
 118                                         printf("Hex conversion error on %c\n", *cp);
 119                                         return 1;
 120                                 }
 121                                 if((j % 2) == 0)
 122                                         dout[j / 2] = (tmp << 4);
 123                                 else
 124                                         dout[j / 2] |= tmp;
 125                         }
 126                 }
 127         }
 128
 129         if ((bitlen < 0) || (bitlen >  (MAX_SPI_BYTES * 8))) {
 130                 printf("Invalid bitlen %d\n", bitlen);
 131                 return 1;
 132         }
 133
 134         if (do_spi_xfer(bus, cs))
 135                 return 1;
 136
 137         return 0;
 138 }
 139
 140 /***************************************************/
 141
 142 U_BOOT_CMD(
 143         sspi,   5,      1,      do_spi,
 144         "SPI utility command",
 145         "[<bus>:]<cs>[.<mode>] <bit_len> <dout> - Send and receive bits\n"
 146         "<bus>     - Identifies the SPI bus\n"
 147         "<cs>      - Identifies the chip select\n"
 148         "<mode>    - Identifies the SPI mode to use\n"
 149         "<bit_len> - Number of bits to send (base 10)\n"
 150         "<dout>    - Hexadecimal string that gets sent"
 151 );