dm: spi: Adjust cmd_spi to work with driver model
[karo-tx-uboot.git] / 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 <dm.h>
15 #include <errno.h>
16 #include <spi.h>
17
18 /*-----------------------------------------------------------------------
19  * Definitions
20  */
21
22 #ifndef MAX_SPI_BYTES
23 #   define MAX_SPI_BYTES 32     /* Maximum number of bytes we can handle */
24 #endif
25
26 #ifndef CONFIG_DEFAULT_SPI_BUS
27 #   define CONFIG_DEFAULT_SPI_BUS       0
28 #endif
29 #ifndef CONFIG_DEFAULT_SPI_MODE
30 #   define CONFIG_DEFAULT_SPI_MODE      SPI_MODE_0
31 #endif
32
33 /*
34  * Values from last command.
35  */
36 static unsigned int     bus;
37 static unsigned int     cs;
38 static unsigned int     mode;
39 static int              bitlen;
40 static uchar            dout[MAX_SPI_BYTES];
41 static uchar            din[MAX_SPI_BYTES];
42
43 static int do_spi_xfer(int bus, int cs)
44 {
45         struct spi_slave *slave;
46         int ret = 0;
47
48 #ifdef CONFIG_DM_SPI
49         char name[30], *str;
50         struct udevice *dev;
51
52         snprintf(name, sizeof(name), "generic_%d:%d", bus, cs);
53         str = strdup(name);
54         ret = spi_get_bus_and_cs(bus, cs, 1000000, mode, "spi_generic_drv",
55                                  str, &dev, &slave);
56         if (ret)
57                 return ret;
58 #else
59         slave = spi_setup_slave(bus, cs, 1000000, mode);
60         if (!slave) {
61                 printf("Invalid device %d:%d\n", bus, cs);
62                 return -EINVAL;
63         }
64 #endif
65
66         ret = spi_claim_bus(slave);
67         if (ret)
68                 goto done;
69         ret = spi_xfer(slave, bitlen, dout, din,
70                        SPI_XFER_BEGIN | SPI_XFER_END);
71 #ifndef CONFIG_DM_SPI
72         /* We don't get an error code in this case */
73         if (ret)
74                 ret = -EIO;
75 #endif
76         if (ret) {
77                 printf("Error %d during SPI transaction\n", ret);
78         } else {
79                 int j;
80
81                 for (j = 0; j < ((bitlen + 7) / 8); j++)
82                         printf("%02X", din[j]);
83                 printf("\n");
84         }
85 done:
86         spi_release_bus(slave);
87 #ifndef CONFIG_DM_SPI
88         spi_free_slave(slave);
89 #endif
90
91         return ret;
92 }
93
94 /*
95  * SPI read/write
96  *
97  * Syntax:
98  *   spi {dev} {num_bits} {dout}
99  *     {dev} is the device number for controlling chip select (see TBD)
100  *     {num_bits} is the number of bits to send & receive (base 10)
101  *     {dout} is a hexadecimal string of data to send
102  * The command prints out the hexadecimal string received via SPI.
103  */
104
105 int do_spi (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
106 {
107         char  *cp = 0;
108         uchar tmp;
109         int   j;
110
111         /*
112          * We use the last specified parameters, unless new ones are
113          * entered.
114          */
115
116         if ((flag & CMD_FLAG_REPEAT) == 0)
117         {
118                 if (argc >= 2) {
119                         mode = CONFIG_DEFAULT_SPI_MODE;
120                         bus = simple_strtoul(argv[1], &cp, 10);
121                         if (*cp == ':') {
122                                 cs = simple_strtoul(cp+1, &cp, 10);
123                         } else {
124                                 cs = bus;
125                                 bus = CONFIG_DEFAULT_SPI_BUS;
126                         }
127                         if (*cp == '.')
128                                 mode = simple_strtoul(cp+1, NULL, 10);
129                 }
130                 if (argc >= 3)
131                         bitlen = simple_strtoul(argv[2], NULL, 10);
132                 if (argc >= 4) {
133                         cp = argv[3];
134                         for(j = 0; *cp; j++, cp++) {
135                                 tmp = *cp - '0';
136                                 if(tmp > 9)
137                                         tmp -= ('A' - '0') - 10;
138                                 if(tmp > 15)
139                                         tmp -= ('a' - 'A');
140                                 if(tmp > 15) {
141                                         printf("Hex conversion error on %c\n", *cp);
142                                         return 1;
143                                 }
144                                 if((j % 2) == 0)
145                                         dout[j / 2] = (tmp << 4);
146                                 else
147                                         dout[j / 2] |= tmp;
148                         }
149                 }
150         }
151
152         if ((bitlen < 0) || (bitlen >  (MAX_SPI_BYTES * 8))) {
153                 printf("Invalid bitlen %d\n", bitlen);
154                 return 1;
155         }
156
157         if (do_spi_xfer(bus, cs))
158                 return 1;
159
160         return 0;
161 }
162
163 /***************************************************/
164
165 U_BOOT_CMD(
166         sspi,   5,      1,      do_spi,
167         "SPI utility command",
168         "[<bus>:]<cs>[.<mode>] <bit_len> <dout> - Send and receive bits\n"
169         "<bus>     - Identifies the SPI bus\n"
170         "<cs>      - Identifies the chip select\n"
171         "<mode>    - Identifies the SPI mode to use\n"
172         "<bit_len> - Number of bits to send (base 10)\n"
173         "<dout>    - Hexadecimal string that gets sent"
174 );