blob: 9d229f4dc2af2f1d0a7051d103cfd64493d34a84 [file] [log] [blame]
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +00001/*
2 * This file is part of the flashrom project.
3 *
Carl-Daniel Hailfinger64263c72012-11-01 23:38:51 +00004 * Copyright (C) 2009, 2010, 2011, 2012 Carl-Daniel Hailfinger
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +00005 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; version 2 of the License.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18 */
19
20#include <stdio.h>
Carl-Daniel Hailfinger1c6d2ff2012-08-27 00:44:42 +000021#include <strings.h>
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +000022#include <string.h>
23#include <stdlib.h>
24#include <ctype.h>
Carl-Daniel Hailfingerd2f007f2010-09-16 22:34:25 +000025#include <unistd.h>
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +000026#include "flash.h"
Carl-Daniel Hailfinger5b997c32010-07-27 22:41:39 +000027#include "programmer.h"
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +000028#include "spi.h"
29
30/* Change this to #define if you want to test without a serial implementation */
31#undef FAKE_COMMUNICATION
32
Carl-Daniel Hailfingerc4224842011-06-09 20:06:34 +000033struct buspirate_spispeeds {
34 const char *name;
35 const int speed;
36};
37
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +000038#ifndef FAKE_COMMUNICATION
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +000039static int buspirate_serialport_setup(char *dev)
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +000040{
41 /* 115200bps, 8 databits, no parity, 1 stopbit */
42 sp_fd = sp_openserport(dev, 115200);
Stefan Tauneracfc4c62012-11-30 16:46:45 +000043 if (sp_fd == SER_INV_FD)
Niklas Söderlund2a95e872012-07-30 19:42:33 +000044 return 1;
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +000045 return 0;
46}
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +000047#else
48#define buspirate_serialport_setup(...) 0
Carl-Daniel Hailfingerefa151e2010-01-06 16:09:10 +000049#define serialport_shutdown(...) 0
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +000050#define serialport_write(...) 0
51#define serialport_read(...) 0
Patrick Georgi3b6237d2010-01-06 19:09:40 +000052#define sp_flush_incoming(...) 0
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +000053#endif
54
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +000055static unsigned char *bp_commbuf = NULL;
56static int bp_commbufsize = 0;
57
58static int buspirate_commbuf_grow(int bufsize)
59{
60 unsigned char *tmpbuf;
61
62 /* Never shrink. realloc() calls are expensive. */
63 if (bufsize <= bp_commbufsize)
64 return 0;
65
66 tmpbuf = realloc(bp_commbuf, bufsize);
67 if (!tmpbuf) {
68 /* Keep the existing buffer because memory is already tight. */
69 msg_perr("Out of memory!\n");
70 return ERROR_OOM;
71 }
72
73 bp_commbuf = tmpbuf;
74 bp_commbufsize = bufsize;
75 return 0;
76}
77
Uwe Hermann91f4afa2011-07-28 08:13:25 +000078static int buspirate_sendrecv(unsigned char *buf, unsigned int writecnt,
79 unsigned int readcnt)
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +000080{
81 int i, ret = 0;
82
Sean Nelson84f7bce2010-01-09 23:56:41 +000083 msg_pspew("%s: write %i, read %i ", __func__, writecnt, readcnt);
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +000084 if (!writecnt && !readcnt) {
Sean Nelson84f7bce2010-01-09 23:56:41 +000085 msg_perr("Zero length command!\n");
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +000086 return 1;
87 }
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +000088 if (writecnt)
89 msg_pspew("Sending");
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +000090 for (i = 0; i < writecnt; i++)
Sean Nelson84f7bce2010-01-09 23:56:41 +000091 msg_pspew(" 0x%02x", buf[i]);
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +000092#ifdef FAKE_COMMUNICATION
93 /* Placate the caller for now. */
94 if (readcnt) {
95 buf[0] = 0x01;
96 memset(buf + 1, 0xff, readcnt - 1);
97 }
98 ret = 0;
99#else
100 if (writecnt)
101 ret = serialport_write(buf, writecnt);
102 if (ret)
103 return ret;
104 if (readcnt)
105 ret = serialport_read(buf, readcnt);
106 if (ret)
107 return ret;
108#endif
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000109 if (readcnt)
110 msg_pspew(", receiving");
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000111 for (i = 0; i < readcnt; i++)
Sean Nelson84f7bce2010-01-09 23:56:41 +0000112 msg_pspew(" 0x%02x", buf[i]);
113 msg_pspew("\n");
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000114 return 0;
115}
116
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000117static int buspirate_wait_for_string(unsigned char *buf, char *key)
118{
119 unsigned int keylen = strlen(key);
120 int ret;
121
122 ret = buspirate_sendrecv(buf, 0, keylen);
123 while (!ret) {
124 if (!memcmp(buf, key, keylen))
125 return 0;
126 memmove(buf, buf + 1, keylen - 1);
127 ret = buspirate_sendrecv(buf + keylen - 1, 0, 1);
128 }
129 return ret;
130}
131
Carl-Daniel Hailfinger64263c72012-11-01 23:38:51 +0000132static int buspirate_spi_send_command_v1(struct flashctx *flash, unsigned int writecnt, unsigned int readcnt,
133 const unsigned char *writearr, unsigned char *readarr);
134static int buspirate_spi_send_command_v2(struct flashctx *flash, unsigned int writecnt, unsigned int readcnt,
135 const unsigned char *writearr, unsigned char *readarr);
Michael Karcherb9dbe482011-05-11 17:07:07 +0000136
Carl-Daniel Hailfinger64263c72012-11-01 23:38:51 +0000137static struct spi_programmer spi_programmer_buspirate = {
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000138 .type = SPI_CONTROLLER_BUSPIRATE,
Carl-Daniel Hailfinger64263c72012-11-01 23:38:51 +0000139 .max_data_read = MAX_DATA_UNSPECIFIED,
140 .max_data_write = MAX_DATA_UNSPECIFIED,
141 .command = NULL,
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000142 .multicommand = default_spi_send_multicommand,
143 .read = default_spi_read,
144 .write_256 = default_spi_write_256,
Nico Huber7bca1262012-06-15 22:28:12 +0000145 .write_aai = default_spi_write_aai,
Michael Karcherb9dbe482011-05-11 17:07:07 +0000146};
147
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000148static const struct buspirate_spispeeds spispeeds[] = {
149 {"30k", 0x0},
150 {"125k", 0x1},
151 {"250k", 0x2},
152 {"1M", 0x3},
153 {"2M", 0x4},
154 {"2.6M", 0x5},
155 {"4M", 0x6},
156 {"8M", 0x7},
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000157 {NULL, 0x0},
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000158};
159
David Hendricks8bb20212011-06-14 01:35:36 +0000160static int buspirate_spi_shutdown(void *data)
161{
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000162 int ret = 0, ret2 = 0;
163 /* No need to allocate a buffer here, we know that bp_commbuf is at least DEFAULT_BUFSIZE big. */
David Hendricks8bb20212011-06-14 01:35:36 +0000164
165 /* Exit raw SPI mode (enter raw bitbang mode) */
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000166 bp_commbuf[0] = 0x00;
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000167 if ((ret = buspirate_sendrecv(bp_commbuf, 1, 0)))
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000168 goto out_shutdown;
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000169 if ((ret = buspirate_wait_for_string(bp_commbuf, "BBIO")))
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000170 goto out_shutdown;
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000171 if ((ret = buspirate_sendrecv(bp_commbuf, 0, 1)))
172 goto out_shutdown;
173 msg_pdbg("Raw bitbang mode version %c\n", bp_commbuf[0]);
174 if (bp_commbuf[0] != '1') {
175 msg_perr("Can't handle raw bitbang mode version %c!\n", bp_commbuf[0]);
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000176 ret = 1;
177 goto out_shutdown;
David Hendricks8bb20212011-06-14 01:35:36 +0000178 }
179 /* Reset Bus Pirate (return to user terminal) */
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000180 bp_commbuf[0] = 0x0f;
181 ret = buspirate_sendrecv(bp_commbuf, 1, 0);
David Hendricks8bb20212011-06-14 01:35:36 +0000182
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000183out_shutdown:
David Hendricks8bb20212011-06-14 01:35:36 +0000184 /* Shut down serial port communication */
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000185 ret2 = serialport_shutdown(NULL);
186 /* Keep the oldest error, it is probably the best indicator. */
187 if (ret2 && !ret)
188 ret = ret2;
189 bp_commbufsize = 0;
190 free(bp_commbuf);
191 bp_commbuf = NULL;
David Hendricks8bb20212011-06-14 01:35:36 +0000192 if (ret)
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000193 msg_pdbg("Bus Pirate shutdown failed.\n");
194 else
195 msg_pdbg("Bus Pirate shutdown completed.\n");
David Hendricks8bb20212011-06-14 01:35:36 +0000196
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000197 return ret;
David Hendricks8bb20212011-06-14 01:35:36 +0000198}
199
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000200#define BP_FWVERSION(a,b) ((a) << 8 | (b))
201
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000202int buspirate_spi_init(void)
203{
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000204 char *tmp;
Brian Salcedo30dfdba2013-01-03 20:44:30 +0000205 char *dev;
206 int i;
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000207 unsigned int fw_version_major = 0;
208 unsigned int fw_version_minor = 0;
Carl-Daniel Hailfinger082c8b52011-08-15 19:54:20 +0000209 int spispeed = 0x7;
210 int ret = 0;
Brian Salcedo30dfdba2013-01-03 20:44:30 +0000211 int pullup = 0;
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000212
Carl-Daniel Hailfinger2b6dcb32010-07-08 10:13:37 +0000213 dev = extract_programmer_param("dev");
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000214 if (dev && !strlen(dev)) {
215 free(dev);
216 dev = NULL;
217 }
218 if (!dev) {
219 msg_perr("No serial device given. Use flashrom -p buspirate_spi:dev=/dev/ttyUSB0\n");
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000220 return 1;
221 }
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000222
Brian Salcedo30dfdba2013-01-03 20:44:30 +0000223 tmp = extract_programmer_param("spispeed");
224 if (tmp) {
225 for (i = 0; spispeeds[i].name; i++) {
226 if (!strncasecmp(spispeeds[i].name, tmp, strlen(spispeeds[i].name))) {
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000227 spispeed = spispeeds[i].speed;
228 break;
229 }
Brian Salcedo30dfdba2013-01-03 20:44:30 +0000230 }
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000231 if (!spispeeds[i].name)
Sean Nelson84f7bce2010-01-09 23:56:41 +0000232 msg_perr("Invalid SPI speed, using default.\n");
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000233 }
Brian Salcedo30dfdba2013-01-03 20:44:30 +0000234 free(tmp);
235
236 tmp = extract_programmer_param("pullups");
237 if (tmp) {
238 if (strcasecmp("on", tmp) == 0)
239 pullup = 1;
240 else if (strcasecmp("off", tmp) == 0)
241 ; // ignore
242 else
243 msg_perr("Invalid pullups state, not using them.\n");
244 }
245 free(tmp);
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000246
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000247 /* Default buffer size is 19: 16 bytes data, 3 bytes control. */
248#define DEFAULT_BUFSIZE (16 + 3)
249 bp_commbuf = malloc(DEFAULT_BUFSIZE);
250 if (!bp_commbuf) {
251 bp_commbufsize = 0;
252 msg_perr("Out of memory!\n");
253 return ERROR_OOM;
254 }
255 bp_commbufsize = DEFAULT_BUFSIZE;
256
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000257 ret = buspirate_serialport_setup(dev);
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000258 free(dev);
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000259 if (ret) {
260 bp_commbufsize = 0;
261 free(bp_commbuf);
262 bp_commbuf = NULL;
263 return ret;
264 }
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000265
David Hendricks8bb20212011-06-14 01:35:36 +0000266 if (register_shutdown(buspirate_spi_shutdown, NULL))
267 return 1;
268
Carl-Daniel Hailfinger64263c72012-11-01 23:38:51 +0000269 /* This is the brute force version, but it should work.
270 * It is likely to fail if a previous flashrom run was aborted during a write with the new SPI commands
271 * in firmware v5.5 because that firmware may wait for up to 4096 bytes of input before responding to
272 * 0x00 again. The obvious workaround (sending 4096 bytes of \0) may cause significant startup delays.
273 */
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000274 for (i = 0; i < 20; i++) {
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000275 /* Enter raw bitbang mode */
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000276 bp_commbuf[0] = 0x00;
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000277 /* Send the command, don't read the response. */
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000278 ret = buspirate_sendrecv(bp_commbuf, 1, 0);
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000279 if (ret)
280 return ret;
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000281 /* The old way to handle responses from a Bus Pirate already in BBIO mode was to flush any
282 * response which came in over serial. Unfortunately that does not work reliably on Linux
283 * with FTDI USB-serial.
284 */
285 //sp_flush_incoming();
286 /* The Bus Pirate can't handle UART input buffer overflow in BBIO mode, and sending a sequence
287 * of 0x00 too fast apparently triggers such an UART input buffer overflow.
288 */
Maksim Kuleshov73dc0db2013-04-05 08:06:10 +0000289 internal_sleep(10000);
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000290 }
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000291 /* We know that 20 commands of \0 should elicit at least one BBIO1 response. */
292 if ((ret = buspirate_wait_for_string(bp_commbuf, "BBIO")))
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000293 return ret;
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000294
295 /* Reset the Bus Pirate. */
296 bp_commbuf[0] = 0x0f;
297 /* Send the command, don't read the response. */
298 if ((ret = buspirate_sendrecv(bp_commbuf, 1, 0)))
299 return ret;
300 if ((ret = buspirate_wait_for_string(bp_commbuf, "irate ")))
301 return ret;
302 /* Read the hardware version string. Last byte of the buffer is reserved for \0. */
303 for (i = 0; i < DEFAULT_BUFSIZE - 1; i++) {
304 if ((ret = buspirate_sendrecv(bp_commbuf + i, 0, 1)))
305 return ret;
306 if (strchr("\r\n\t ", bp_commbuf[i]))
307 break;
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000308 }
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000309 bp_commbuf[i] = '\0';
310 msg_pdbg("Detected Bus Pirate hardware %s\n", bp_commbuf);
311
312 if ((ret = buspirate_wait_for_string(bp_commbuf, "irmware ")))
313 return ret;
314 /* Read the firmware version string. Last byte of the buffer is reserved for \0. */
315 for (i = 0; i < DEFAULT_BUFSIZE - 1; i++) {
316 if ((ret = buspirate_sendrecv(bp_commbuf + i, 0, 1)))
317 return ret;
318 if (strchr("\r\n\t ", bp_commbuf[i]))
319 break;
320 }
321 bp_commbuf[i] = '\0';
322 msg_pdbg("Detected Bus Pirate firmware ");
323 if (bp_commbuf[0] != 'v')
324 msg_pdbg("(unknown version number format)");
325 else if (!strchr("0123456789", bp_commbuf[1]))
326 msg_pdbg("(unknown version number format)");
327 else {
328 fw_version_major = strtoul((char *)bp_commbuf + 1, &tmp, 10);
329 while ((*tmp != '\0') && !strchr("0123456789", *tmp))
330 tmp++;
331 fw_version_minor = strtoul(tmp, NULL, 10);
332 msg_pdbg("%u.%u", fw_version_major, fw_version_minor);
333 }
334 msg_pdbg2(" (\"%s\")", bp_commbuf);
335 msg_pdbg("\n");
336
337 if ((ret = buspirate_wait_for_string(bp_commbuf, "HiZ>")))
338 return ret;
339
340 /* Tell the user about missing SPI binary mode in firmware 2.3 and older. */
341 if (BP_FWVERSION(fw_version_major, fw_version_minor) < BP_FWVERSION(2, 4)) {
342 msg_pinfo("Bus Pirate firmware 2.3 and older does not support binary SPI access.\n");
343 msg_pinfo("Please upgrade to the latest firmware (at least 2.4).\n");
344 return SPI_PROGRAMMER_ERROR;
345 }
346
Carl-Daniel Hailfinger64263c72012-11-01 23:38:51 +0000347 /* Use fast SPI mode in firmware 5.5 and newer. */
348 if (BP_FWVERSION(fw_version_major, fw_version_minor) >= BP_FWVERSION(5, 5)) {
349 msg_pdbg("Using SPI command set v2.\n");
350 /* Sensible default buffer size. */
351 if (buspirate_commbuf_grow(260 + 5))
352 return ERROR_OOM;
353 spi_programmer_buspirate.max_data_read = 2048;
354 spi_programmer_buspirate.max_data_write = 256;
355 spi_programmer_buspirate.command = buspirate_spi_send_command_v2;
356 } else {
357 msg_pinfo("Bus Pirate firmware 5.4 and older does not support fast SPI access.\n");
358 msg_pinfo("Reading/writing a flash chip may take hours.\n");
359 msg_pinfo("It is recommended to upgrade to firmware 5.5 or newer.\n");
360 /* Sensible default buffer size. */
361 if (buspirate_commbuf_grow(16 + 3))
362 return ERROR_OOM;
363 spi_programmer_buspirate.max_data_read = 12;
364 spi_programmer_buspirate.max_data_write = 12;
365 spi_programmer_buspirate.command = buspirate_spi_send_command_v1;
366 }
367
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000368 /* Workaround for broken speed settings in firmware 6.1 and older. */
369 if (BP_FWVERSION(fw_version_major, fw_version_minor) < BP_FWVERSION(6, 2))
370 if (spispeed > 0x4) {
371 msg_perr("Bus Pirate firmware 6.1 and older does not support SPI speeds above 2 MHz. "
372 "Limiting speed to 2 MHz.\n");
373 msg_pinfo("It is recommended to upgrade to firmware 6.2 or newer.\n");
374 spispeed = 0x4;
375 }
376
377 /* This works because speeds numbering starts at 0 and is contiguous. */
378 msg_pdbg("SPI speed is %sHz\n", spispeeds[spispeed].name);
379
380 /* Enter raw bitbang mode */
381 for (i = 0; i < 20; i++) {
382 bp_commbuf[0] = 0x00;
383 if ((ret = buspirate_sendrecv(bp_commbuf, 1, 0)))
384 return ret;
385 }
386 if ((ret = buspirate_wait_for_string(bp_commbuf, "BBIO")))
387 return ret;
388 if ((ret = buspirate_sendrecv(bp_commbuf, 0, 1)))
389 return ret;
390 msg_pdbg("Raw bitbang mode version %c\n", bp_commbuf[0]);
391 if (bp_commbuf[0] != '1') {
392 msg_perr("Can't handle raw bitbang mode version %c!\n", bp_commbuf[0]);
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000393 return 1;
394 }
395 /* Enter raw SPI mode */
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000396 bp_commbuf[0] = 0x01;
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000397 ret = buspirate_sendrecv(bp_commbuf, 1, 0);
398 if ((ret = buspirate_wait_for_string(bp_commbuf, "SPI")))
Carl-Daniel Hailfingerd2f007f2010-09-16 22:34:25 +0000399 return ret;
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000400 if ((ret = buspirate_sendrecv(bp_commbuf, 0, 1)))
401 return ret;
402 msg_pdbg("Raw SPI mode version %c\n", bp_commbuf[0]);
403 if (bp_commbuf[0] != '1') {
404 msg_perr("Can't handle raw SPI mode version %c!\n", bp_commbuf[0]);
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000405 return 1;
406 }
407
408 /* Initial setup (SPI peripherals config): Enable power, CS high, AUX */
Brian Salcedo30dfdba2013-01-03 20:44:30 +0000409 bp_commbuf[0] = 0x40 | 0x0b;
410 if (pullup == 1) {
411 bp_commbuf[0] |= (1 << 2);
412 msg_pdbg("Enabling pull-up resistors.\n");
413 }
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000414 ret = buspirate_sendrecv(bp_commbuf, 1, 1);
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000415 if (ret)
416 return 1;
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000417 if (bp_commbuf[0] != 0x01) {
Brian Salcedo30dfdba2013-01-03 20:44:30 +0000418 msg_perr("Protocol error while setting power/CS/AUX(/Pull-up resistors)!\n");
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000419 return 1;
420 }
421
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000422 /* Set SPI speed */
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000423 bp_commbuf[0] = 0x60 | spispeed;
424 ret = buspirate_sendrecv(bp_commbuf, 1, 1);
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000425 if (ret)
426 return 1;
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000427 if (bp_commbuf[0] != 0x01) {
Sean Nelson84f7bce2010-01-09 23:56:41 +0000428 msg_perr("Protocol error while setting SPI speed!\n");
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000429 return 1;
430 }
431
432 /* Set SPI config: output type, idle, clock edge, sample */
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000433 bp_commbuf[0] = 0x80 | 0xa;
434 ret = buspirate_sendrecv(bp_commbuf, 1, 1);
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000435 if (ret)
436 return 1;
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000437 if (bp_commbuf[0] != 0x01) {
Sean Nelson84f7bce2010-01-09 23:56:41 +0000438 msg_perr("Protocol error while setting SPI config!\n");
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000439 return 1;
440 }
441
442 /* De-assert CS# */
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000443 bp_commbuf[0] = 0x03;
444 ret = buspirate_sendrecv(bp_commbuf, 1, 1);
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000445 if (ret)
446 return 1;
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000447 if (bp_commbuf[0] != 0x01) {
Sean Nelson84f7bce2010-01-09 23:56:41 +0000448 msg_perr("Protocol error while raising CS#!\n");
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000449 return 1;
450 }
451
Michael Karcherb9dbe482011-05-11 17:07:07 +0000452 register_spi_programmer(&spi_programmer_buspirate);
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000453
454 return 0;
455}
456
Carl-Daniel Hailfinger64263c72012-11-01 23:38:51 +0000457static int buspirate_spi_send_command_v1(struct flashctx *flash, unsigned int writecnt, unsigned int readcnt,
458 const unsigned char *writearr, unsigned char *readarr)
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000459{
Stefan Taunerc69c9c82011-11-23 09:13:48 +0000460 unsigned int i = 0;
461 int ret = 0;
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000462
463 if (writecnt > 16 || readcnt > 16 || (readcnt + writecnt) > 16)
464 return SPI_INVALID_LENGTH;
465
Carl-Daniel Hailfinger04e18be2010-07-29 16:24:09 +0000466 /* 3 bytes extra for CS#, len, CS#. */
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000467 if (buspirate_commbuf_grow(writecnt + readcnt + 3))
468 return ERROR_OOM;
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000469
470 /* Assert CS# */
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000471 bp_commbuf[i++] = 0x02;
Carl-Daniel Hailfinger04e18be2010-07-29 16:24:09 +0000472
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000473 bp_commbuf[i++] = 0x10 | (writecnt + readcnt - 1);
474 memcpy(bp_commbuf + i, writearr, writecnt);
Carl-Daniel Hailfinger04e18be2010-07-29 16:24:09 +0000475 i += writecnt;
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000476 memset(bp_commbuf + i, 0, readcnt);
Carl-Daniel Hailfinger04e18be2010-07-29 16:24:09 +0000477
478 i += readcnt;
479 /* De-assert CS# */
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000480 bp_commbuf[i++] = 0x03;
Carl-Daniel Hailfinger04e18be2010-07-29 16:24:09 +0000481
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000482 ret = buspirate_sendrecv(bp_commbuf, i, i);
Carl-Daniel Hailfinger04e18be2010-07-29 16:24:09 +0000483
484 if (ret) {
485 msg_perr("Bus Pirate communication error!\n");
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000486 return SPI_GENERIC_ERROR;
Carl-Daniel Hailfinger04e18be2010-07-29 16:24:09 +0000487 }
488
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000489 if (bp_commbuf[0] != 0x01) {
Sean Nelson84f7bce2010-01-09 23:56:41 +0000490 msg_perr("Protocol error while lowering CS#!\n");
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000491 return SPI_GENERIC_ERROR;
492 }
493
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000494 if (bp_commbuf[1] != 0x01) {
Sean Nelson84f7bce2010-01-09 23:56:41 +0000495 msg_perr("Protocol error while reading/writing SPI!\n");
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000496 return SPI_GENERIC_ERROR;
497 }
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000498
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000499 if (bp_commbuf[i - 1] != 0x01) {
Sean Nelson84f7bce2010-01-09 23:56:41 +0000500 msg_perr("Protocol error while raising CS#!\n");
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000501 return SPI_GENERIC_ERROR;
502 }
503
Carl-Daniel Hailfinger04e18be2010-07-29 16:24:09 +0000504 /* Skip CS#, length, writearr. */
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000505 memcpy(readarr, bp_commbuf + 2 + writecnt, readcnt);
Carl-Daniel Hailfinger04e18be2010-07-29 16:24:09 +0000506
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000507 return ret;
508}
Carl-Daniel Hailfinger64263c72012-11-01 23:38:51 +0000509
510static int buspirate_spi_send_command_v2(struct flashctx *flash, unsigned int writecnt, unsigned int readcnt,
511 const unsigned char *writearr, unsigned char *readarr)
512{
513 int i = 0, ret = 0;
514
515 if (writecnt > 4096 || readcnt > 4096 || (readcnt + writecnt) > 4096)
516 return SPI_INVALID_LENGTH;
517
518 /* 5 bytes extra for command, writelen, readlen.
519 * 1 byte extra for Ack/Nack.
520 */
521 if (buspirate_commbuf_grow(max(writecnt + 5, readcnt + 1)))
522 return ERROR_OOM;
523
524 /* Combined SPI write/read. */
525 bp_commbuf[i++] = 0x04;
526 bp_commbuf[i++] = (writecnt >> 8) & 0xff;
527 bp_commbuf[i++] = writecnt & 0xff;
528 bp_commbuf[i++] = (readcnt >> 8) & 0xff;
529 bp_commbuf[i++] = readcnt & 0xff;
530 memcpy(bp_commbuf + i, writearr, writecnt);
531
532 ret = buspirate_sendrecv(bp_commbuf, i + writecnt, 1 + readcnt);
533
534 if (ret) {
535 msg_perr("Bus Pirate communication error!\n");
536 return SPI_GENERIC_ERROR;
537 }
538
539 if (bp_commbuf[0] != 0x01) {
540 msg_perr("Protocol error while sending SPI write/read!\n");
541 return SPI_GENERIC_ERROR;
542 }
543
544 /* Skip Ack. */
545 memcpy(readarr, bp_commbuf + 1, readcnt);
546
547 return ret;
548}