blob: e7c2b2956a55d4c0e7f1bc695940a76d50cbd11a [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.
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +000014 */
15
16#include <stdio.h>
Carl-Daniel Hailfinger1c6d2ff2012-08-27 00:44:42 +000017#include <strings.h>
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +000018#include <string.h>
19#include <stdlib.h>
20#include <ctype.h>
Carl-Daniel Hailfingerd2f007f2010-09-16 22:34:25 +000021#include <unistd.h>
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +000022#include "flash.h"
Carl-Daniel Hailfinger5b997c32010-07-27 22:41:39 +000023#include "programmer.h"
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +000024#include "spi.h"
25
26/* Change this to #define if you want to test without a serial implementation */
27#undef FAKE_COMMUNICATION
28
Shawn Anastasio2b5adfb2017-12-31 00:17:15 -060029struct buspirate_speeds {
Carl-Daniel Hailfingerc4224842011-06-09 20:06:34 +000030 const char *name;
31 const int speed;
32};
33
Shawn Anastasio2b5adfb2017-12-31 00:17:15 -060034#define BP_DEFAULTBAUD 115200
35
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +000036#ifndef FAKE_COMMUNICATION
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +000037static int buspirate_serialport_setup(char *dev)
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +000038{
39 /* 115200bps, 8 databits, no parity, 1 stopbit */
Shawn Anastasio2b5adfb2017-12-31 00:17:15 -060040 sp_fd = sp_openserport(dev, BP_DEFAULTBAUD);
Elyes HAOUAS124ef382018-03-27 12:15:09 +020041 if (sp_fd == SER_INV_FD)
Niklas Söderlund2a95e872012-07-30 19:42:33 +000042 return 1;
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +000043 return 0;
44}
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +000045#else
46#define buspirate_serialport_setup(...) 0
Carl-Daniel Hailfingerefa151e2010-01-06 16:09:10 +000047#define serialport_shutdown(...) 0
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +000048#define serialport_write(...) 0
49#define serialport_read(...) 0
Patrick Georgi3b6237d2010-01-06 19:09:40 +000050#define sp_flush_incoming(...) 0
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +000051#endif
52
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +000053static unsigned char *bp_commbuf = NULL;
54static int bp_commbufsize = 0;
55
56static int buspirate_commbuf_grow(int bufsize)
57{
58 unsigned char *tmpbuf;
59
60 /* Never shrink. realloc() calls are expensive. */
61 if (bufsize <= bp_commbufsize)
62 return 0;
63
64 tmpbuf = realloc(bp_commbuf, bufsize);
65 if (!tmpbuf) {
66 /* Keep the existing buffer because memory is already tight. */
67 msg_perr("Out of memory!\n");
68 return ERROR_OOM;
69 }
70
71 bp_commbuf = tmpbuf;
72 bp_commbufsize = bufsize;
73 return 0;
74}
75
Uwe Hermann91f4afa2011-07-28 08:13:25 +000076static int buspirate_sendrecv(unsigned char *buf, unsigned int writecnt,
77 unsigned int readcnt)
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +000078{
Nico Huber519be662018-12-23 20:03:35 +010079 unsigned int i;
80 int ret = 0;
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +000081
Sean Nelson84f7bce2010-01-09 23:56:41 +000082 msg_pspew("%s: write %i, read %i ", __func__, writecnt, readcnt);
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +000083 if (!writecnt && !readcnt) {
Sean Nelson84f7bce2010-01-09 23:56:41 +000084 msg_perr("Zero length command!\n");
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +000085 return 1;
86 }
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +000087 if (writecnt)
88 msg_pspew("Sending");
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +000089 for (i = 0; i < writecnt; i++)
Sean Nelson84f7bce2010-01-09 23:56:41 +000090 msg_pspew(" 0x%02x", buf[i]);
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +000091#ifdef FAKE_COMMUNICATION
92 /* Placate the caller for now. */
93 if (readcnt) {
94 buf[0] = 0x01;
95 memset(buf + 1, 0xff, readcnt - 1);
96 }
97 ret = 0;
98#else
99 if (writecnt)
100 ret = serialport_write(buf, writecnt);
101 if (ret)
102 return ret;
103 if (readcnt)
104 ret = serialport_read(buf, readcnt);
105 if (ret)
106 return ret;
107#endif
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000108 if (readcnt)
109 msg_pspew(", receiving");
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000110 for (i = 0; i < readcnt; i++)
Sean Nelson84f7bce2010-01-09 23:56:41 +0000111 msg_pspew(" 0x%02x", buf[i]);
112 msg_pspew("\n");
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000113 return 0;
114}
115
Jacob Garber4a84ec22019-07-25 19:12:31 -0600116static int buspirate_wait_for_string(unsigned char *buf, const char *key)
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000117{
118 unsigned int keylen = strlen(key);
119 int ret;
120
121 ret = buspirate_sendrecv(buf, 0, keylen);
122 while (!ret) {
123 if (!memcmp(buf, key, keylen))
124 return 0;
125 memmove(buf, buf + 1, keylen - 1);
126 ret = buspirate_sendrecv(buf + keylen - 1, 0, 1);
127 }
128 return ret;
129}
130
Edward O'Callaghan5eca4272020-04-12 17:27:53 +1000131static int buspirate_spi_send_command_v1(const struct flashctx *flash, unsigned int writecnt, unsigned int readcnt,
Carl-Daniel Hailfinger64263c72012-11-01 23:38:51 +0000132 const unsigned char *writearr, unsigned char *readarr);
Edward O'Callaghan5eca4272020-04-12 17:27:53 +1000133static int buspirate_spi_send_command_v2(const struct flashctx *flash, unsigned int writecnt, unsigned int readcnt,
Carl-Daniel Hailfinger64263c72012-11-01 23:38:51 +0000134 const unsigned char *writearr, unsigned char *readarr);
Michael Karcherb9dbe482011-05-11 17:07:07 +0000135
Carl-Daniel Hailfingera5bcbce2014-07-19 22:03:29 +0000136static struct spi_master spi_master_buspirate = {
Nico Huber1cf407b2017-11-10 20:18:23 +0100137 .features = SPI_MASTER_4BA,
Carl-Daniel Hailfinger64263c72012-11-01 23:38:51 +0000138 .max_data_read = MAX_DATA_UNSPECIFIED,
139 .max_data_write = MAX_DATA_UNSPECIFIED,
140 .command = NULL,
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000141 .multicommand = default_spi_send_multicommand,
142 .read = default_spi_read,
143 .write_256 = default_spi_write_256,
Nico Huber7bca1262012-06-15 22:28:12 +0000144 .write_aai = default_spi_write_aai,
Michael Karcherb9dbe482011-05-11 17:07:07 +0000145};
146
Shawn Anastasio2b5adfb2017-12-31 00:17:15 -0600147static const struct buspirate_speeds spispeeds[] = {
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000148 {"30k", 0x0},
149 {"125k", 0x1},
150 {"250k", 0x2},
151 {"1M", 0x3},
152 {"2M", 0x4},
153 {"2.6M", 0x5},
154 {"4M", 0x6},
155 {"8M", 0x7},
Shawn Anastasio2b5adfb2017-12-31 00:17:15 -0600156 {NULL, 0x0}
157};
158
159static const struct buspirate_speeds serialspeeds[] = {
160 {"115200", 115200},
161 {"230400", 230400},
162 {"250000", 250000},
163 {"2000000", 2000000},
164 {"2M", 2000000},
165 {NULL, 0}
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000166};
167
David Hendricks8bb20212011-06-14 01:35:36 +0000168static int buspirate_spi_shutdown(void *data)
169{
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000170 int ret = 0, ret2 = 0;
171 /* 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 +0000172
173 /* Exit raw SPI mode (enter raw bitbang mode) */
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000174 bp_commbuf[0] = 0x00;
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000175 if ((ret = buspirate_sendrecv(bp_commbuf, 1, 0)))
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000176 goto out_shutdown;
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000177 if ((ret = buspirate_wait_for_string(bp_commbuf, "BBIO")))
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000178 goto out_shutdown;
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000179 if ((ret = buspirate_sendrecv(bp_commbuf, 0, 1)))
180 goto out_shutdown;
181 msg_pdbg("Raw bitbang mode version %c\n", bp_commbuf[0]);
182 if (bp_commbuf[0] != '1') {
183 msg_perr("Can't handle raw bitbang mode version %c!\n", bp_commbuf[0]);
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000184 ret = 1;
185 goto out_shutdown;
David Hendricks8bb20212011-06-14 01:35:36 +0000186 }
187 /* Reset Bus Pirate (return to user terminal) */
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000188 bp_commbuf[0] = 0x0f;
189 ret = buspirate_sendrecv(bp_commbuf, 1, 0);
David Hendricks8bb20212011-06-14 01:35:36 +0000190
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000191out_shutdown:
David Hendricks8bb20212011-06-14 01:35:36 +0000192 /* Shut down serial port communication */
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000193 ret2 = serialport_shutdown(NULL);
194 /* Keep the oldest error, it is probably the best indicator. */
195 if (ret2 && !ret)
196 ret = ret2;
197 bp_commbufsize = 0;
198 free(bp_commbuf);
199 bp_commbuf = NULL;
David Hendricks8bb20212011-06-14 01:35:36 +0000200 if (ret)
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000201 msg_pdbg("Bus Pirate shutdown failed.\n");
202 else
203 msg_pdbg("Bus Pirate shutdown completed.\n");
David Hendricks8bb20212011-06-14 01:35:36 +0000204
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000205 return ret;
David Hendricks8bb20212011-06-14 01:35:36 +0000206}
207
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000208#define BP_FWVERSION(a,b) ((a) << 8 | (b))
Shawn Anastasio2b5adfb2017-12-31 00:17:15 -0600209#define BP_HWVERSION(a,b) BP_FWVERSION(a,b)
210
211/**
212 * The Bus Pirate's PIC microcontroller supports custom baud rates by manually specifying a
213 * clock divisor that can be calculated with the formula (16000000 / (4 * baud)) - 1.
214 */
215#define BP_DIVISOR(baud) ((4000000/(baud)) - 1)
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000216
Thomas Heijligencc853d82021-05-04 15:32:17 +0200217static int buspirate_spi_init(void)
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000218{
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000219 char *tmp;
Brian Salcedo30dfdba2013-01-03 20:44:30 +0000220 char *dev;
221 int i;
Shawn Anastasio2b5adfb2017-12-31 00:17:15 -0600222 int cnt;
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000223 unsigned int fw_version_major = 0;
224 unsigned int fw_version_minor = 0;
Shawn Anastasio2b5adfb2017-12-31 00:17:15 -0600225 unsigned int hw_version_major = 0;
226 unsigned int hw_version_minor = 0;
Carl-Daniel Hailfinger082c8b52011-08-15 19:54:20 +0000227 int spispeed = 0x7;
Shawn Anastasio2b5adfb2017-12-31 00:17:15 -0600228 int serialspeed_index = -1;
Carl-Daniel Hailfinger082c8b52011-08-15 19:54:20 +0000229 int ret = 0;
Brian Salcedo30dfdba2013-01-03 20:44:30 +0000230 int pullup = 0;
Jeremy Kerr98bdcb42021-05-23 17:58:06 +0800231 int psu = 0;
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000232
Carl-Daniel Hailfinger2b6dcb32010-07-08 10:13:37 +0000233 dev = extract_programmer_param("dev");
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000234 if (dev && !strlen(dev)) {
235 free(dev);
236 dev = NULL;
237 }
238 if (!dev) {
239 msg_perr("No serial device given. Use flashrom -p buspirate_spi:dev=/dev/ttyUSB0\n");
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000240 return 1;
241 }
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000242
Brian Salcedo30dfdba2013-01-03 20:44:30 +0000243 tmp = extract_programmer_param("spispeed");
244 if (tmp) {
245 for (i = 0; spispeeds[i].name; i++) {
246 if (!strncasecmp(spispeeds[i].name, tmp, strlen(spispeeds[i].name))) {
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000247 spispeed = spispeeds[i].speed;
248 break;
249 }
Brian Salcedo30dfdba2013-01-03 20:44:30 +0000250 }
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000251 if (!spispeeds[i].name)
Sean Nelson84f7bce2010-01-09 23:56:41 +0000252 msg_perr("Invalid SPI speed, using default.\n");
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000253 }
Brian Salcedo30dfdba2013-01-03 20:44:30 +0000254 free(tmp);
255
Elyes HAOUASe2c90c42018-08-18 09:04:41 +0200256 /* Extract serialspeed parameter */
Shawn Anastasio2b5adfb2017-12-31 00:17:15 -0600257 tmp = extract_programmer_param("serialspeed");
258 if (tmp) {
259 for (i = 0; serialspeeds[i].name; i++) {
260 if (!strncasecmp(serialspeeds[i].name, tmp, strlen(serialspeeds[i].name))) {
261 serialspeed_index = i;
262 break;
263 }
264 }
265 if (!serialspeeds[i].name)
266 msg_perr("Invalid serial speed %s, using default.\n", tmp);
267 }
268 free(tmp);
269
Brian Salcedo30dfdba2013-01-03 20:44:30 +0000270 tmp = extract_programmer_param("pullups");
271 if (tmp) {
272 if (strcasecmp("on", tmp) == 0)
273 pullup = 1;
274 else if (strcasecmp("off", tmp) == 0)
275 ; // ignore
276 else
277 msg_perr("Invalid pullups state, not using them.\n");
278 }
279 free(tmp);
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000280
Jeremy Kerr98bdcb42021-05-23 17:58:06 +0800281 tmp = extract_programmer_param("psus");
282 if (tmp) {
283 if (strcasecmp("on", tmp) == 0)
284 psu = 1;
285 else if (strcasecmp("off", tmp) == 0)
286 ; // ignore
287 else
288 msg_perr("Invalid psus state, not enabling.\n");
289 }
290 free(tmp);
291
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000292 /* Default buffer size is 19: 16 bytes data, 3 bytes control. */
293#define DEFAULT_BUFSIZE (16 + 3)
294 bp_commbuf = malloc(DEFAULT_BUFSIZE);
295 if (!bp_commbuf) {
296 bp_commbufsize = 0;
297 msg_perr("Out of memory!\n");
Stefan Reinauer18385912014-04-26 16:12:45 +0000298 free(dev);
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000299 return ERROR_OOM;
300 }
301 bp_commbufsize = DEFAULT_BUFSIZE;
302
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000303 ret = buspirate_serialport_setup(dev);
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000304 free(dev);
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000305 if (ret) {
306 bp_commbufsize = 0;
307 free(bp_commbuf);
308 bp_commbuf = NULL;
309 return ret;
310 }
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000311
Carl-Daniel Hailfinger64263c72012-11-01 23:38:51 +0000312 /* This is the brute force version, but it should work.
313 * It is likely to fail if a previous flashrom run was aborted during a write with the new SPI commands
314 * in firmware v5.5 because that firmware may wait for up to 4096 bytes of input before responding to
315 * 0x00 again. The obvious workaround (sending 4096 bytes of \0) may cause significant startup delays.
316 */
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000317 for (i = 0; i < 20; i++) {
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000318 /* Enter raw bitbang mode */
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000319 bp_commbuf[0] = 0x00;
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000320 /* Send the command, don't read the response. */
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000321 ret = buspirate_sendrecv(bp_commbuf, 1, 0);
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000322 if (ret)
Anastasia Klimchuk7dcb6f32021-05-24 15:12:10 +1000323 goto init_err_cleanup_exit;
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000324 /* The old way to handle responses from a Bus Pirate already in BBIO mode was to flush any
325 * response which came in over serial. Unfortunately that does not work reliably on Linux
326 * with FTDI USB-serial.
327 */
328 //sp_flush_incoming();
329 /* The Bus Pirate can't handle UART input buffer overflow in BBIO mode, and sending a sequence
330 * of 0x00 too fast apparently triggers such an UART input buffer overflow.
331 */
Maksim Kuleshov73dc0db2013-04-05 08:06:10 +0000332 internal_sleep(10000);
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000333 }
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000334 /* We know that 20 commands of \0 should elicit at least one BBIO1 response. */
335 if ((ret = buspirate_wait_for_string(bp_commbuf, "BBIO")))
Anastasia Klimchuk7dcb6f32021-05-24 15:12:10 +1000336 goto init_err_cleanup_exit;
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000337
338 /* Reset the Bus Pirate. */
339 bp_commbuf[0] = 0x0f;
340 /* Send the command, don't read the response. */
341 if ((ret = buspirate_sendrecv(bp_commbuf, 1, 0)))
Anastasia Klimchuk7dcb6f32021-05-24 15:12:10 +1000342 goto init_err_cleanup_exit;
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000343 if ((ret = buspirate_wait_for_string(bp_commbuf, "irate ")))
Anastasia Klimchuk7dcb6f32021-05-24 15:12:10 +1000344 goto init_err_cleanup_exit;
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000345 /* Read the hardware version string. Last byte of the buffer is reserved for \0. */
346 for (i = 0; i < DEFAULT_BUFSIZE - 1; i++) {
347 if ((ret = buspirate_sendrecv(bp_commbuf + i, 0, 1)))
Anastasia Klimchuk7dcb6f32021-05-24 15:12:10 +1000348 goto init_err_cleanup_exit;
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000349 if (strchr("\r\n\t ", bp_commbuf[i]))
350 break;
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000351 }
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000352 bp_commbuf[i] = '\0';
Shawn Anastasio2b5adfb2017-12-31 00:17:15 -0600353 msg_pdbg("Detected Bus Pirate hardware ");
354 if (bp_commbuf[0] != 'v')
355 msg_pdbg("(unknown version number format)");
356 else if (!strchr("0123456789", bp_commbuf[1]))
357 msg_pdbg("(unknown version number format)");
358 else {
359 hw_version_major = strtoul((char *)bp_commbuf + 1, &tmp, 10);
360 while ((*tmp != '\0') && !strchr("0123456789", *tmp))
361 tmp++;
362 hw_version_minor = strtoul(tmp, NULL, 10);
363 msg_pdbg("%u.%u", hw_version_major, hw_version_minor);
364 }
365 msg_pdbg2(" (\"%s\")", bp_commbuf);
366 msg_pdbg("\n");
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000367
368 if ((ret = buspirate_wait_for_string(bp_commbuf, "irmware ")))
Anastasia Klimchuk7dcb6f32021-05-24 15:12:10 +1000369 goto init_err_cleanup_exit;
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000370 /* Read the firmware version string. Last byte of the buffer is reserved for \0. */
371 for (i = 0; i < DEFAULT_BUFSIZE - 1; i++) {
372 if ((ret = buspirate_sendrecv(bp_commbuf + i, 0, 1)))
Anastasia Klimchuk7dcb6f32021-05-24 15:12:10 +1000373 goto init_err_cleanup_exit;
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000374 if (strchr("\r\n\t ", bp_commbuf[i]))
375 break;
376 }
377 bp_commbuf[i] = '\0';
378 msg_pdbg("Detected Bus Pirate firmware ");
379 if (bp_commbuf[0] != 'v')
380 msg_pdbg("(unknown version number format)");
381 else if (!strchr("0123456789", bp_commbuf[1]))
382 msg_pdbg("(unknown version number format)");
383 else {
384 fw_version_major = strtoul((char *)bp_commbuf + 1, &tmp, 10);
385 while ((*tmp != '\0') && !strchr("0123456789", *tmp))
386 tmp++;
387 fw_version_minor = strtoul(tmp, NULL, 10);
388 msg_pdbg("%u.%u", fw_version_major, fw_version_minor);
389 }
390 msg_pdbg2(" (\"%s\")", bp_commbuf);
391 msg_pdbg("\n");
392
393 if ((ret = buspirate_wait_for_string(bp_commbuf, "HiZ>")))
Anastasia Klimchuk7dcb6f32021-05-24 15:12:10 +1000394 goto init_err_cleanup_exit;
Shawn Anastasio2b5adfb2017-12-31 00:17:15 -0600395
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000396 /* Tell the user about missing SPI binary mode in firmware 2.3 and older. */
397 if (BP_FWVERSION(fw_version_major, fw_version_minor) < BP_FWVERSION(2, 4)) {
398 msg_pinfo("Bus Pirate firmware 2.3 and older does not support binary SPI access.\n");
399 msg_pinfo("Please upgrade to the latest firmware (at least 2.4).\n");
Anastasia Klimchuk7dcb6f32021-05-24 15:12:10 +1000400 ret = SPI_PROGRAMMER_ERROR;
401 goto init_err_cleanup_exit;
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000402 }
403
Carl-Daniel Hailfinger64263c72012-11-01 23:38:51 +0000404 /* Use fast SPI mode in firmware 5.5 and newer. */
405 if (BP_FWVERSION(fw_version_major, fw_version_minor) >= BP_FWVERSION(5, 5)) {
Shawn Anastasio2b5adfb2017-12-31 00:17:15 -0600406 msg_pdbg("Using SPI command set v2.\n");
Carl-Daniel Hailfinger64263c72012-11-01 23:38:51 +0000407 /* Sensible default buffer size. */
Anastasia Klimchuk7dcb6f32021-05-24 15:12:10 +1000408 if (buspirate_commbuf_grow(260 + 5)) {
409 ret = ERROR_OOM;
410 goto init_err_cleanup_exit;
411 }
Carl-Daniel Hailfingera5bcbce2014-07-19 22:03:29 +0000412 spi_master_buspirate.max_data_read = 2048;
413 spi_master_buspirate.max_data_write = 256;
414 spi_master_buspirate.command = buspirate_spi_send_command_v2;
Carl-Daniel Hailfinger64263c72012-11-01 23:38:51 +0000415 } else {
416 msg_pinfo("Bus Pirate firmware 5.4 and older does not support fast SPI access.\n");
417 msg_pinfo("Reading/writing a flash chip may take hours.\n");
418 msg_pinfo("It is recommended to upgrade to firmware 5.5 or newer.\n");
419 /* Sensible default buffer size. */
Anastasia Klimchuk7dcb6f32021-05-24 15:12:10 +1000420 if (buspirate_commbuf_grow(16 + 3)) {
421 ret = ERROR_OOM;
422 goto init_err_cleanup_exit;
423 }
Carl-Daniel Hailfingera5bcbce2014-07-19 22:03:29 +0000424 spi_master_buspirate.max_data_read = 12;
425 spi_master_buspirate.max_data_write = 12;
426 spi_master_buspirate.command = buspirate_spi_send_command_v1;
Carl-Daniel Hailfinger64263c72012-11-01 23:38:51 +0000427 }
428
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000429 /* Workaround for broken speed settings in firmware 6.1 and older. */
430 if (BP_FWVERSION(fw_version_major, fw_version_minor) < BP_FWVERSION(6, 2))
431 if (spispeed > 0x4) {
432 msg_perr("Bus Pirate firmware 6.1 and older does not support SPI speeds above 2 MHz. "
433 "Limiting speed to 2 MHz.\n");
434 msg_pinfo("It is recommended to upgrade to firmware 6.2 or newer.\n");
435 spispeed = 0x4;
436 }
Shawn Anastasio2b5adfb2017-12-31 00:17:15 -0600437
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000438 /* This works because speeds numbering starts at 0 and is contiguous. */
439 msg_pdbg("SPI speed is %sHz\n", spispeeds[spispeed].name);
440
Shawn Anastasio2b5adfb2017-12-31 00:17:15 -0600441 /* Set 2M baud serial speed by default on hardware 3.0 and newer if a custom speed was not set */
442 if (serialspeed_index == -1 && BP_HWVERSION(hw_version_major, hw_version_minor) >= BP_HWVERSION(3, 0)) {
443 serialspeed_index = ARRAY_SIZE(serialspeeds) - 2;
444 msg_pdbg("Bus Pirate v3 or newer detected. Set serial speed to 2M baud.\n");
445 }
446
447 /* Set custom serial speed if specified */
448 if (serialspeed_index != -1) {
449 if (BP_FWVERSION(fw_version_major, fw_version_minor) < BP_FWVERSION(5, 5)) {
450 /* This feature requires firmware 5.5 or newer */
451 msg_perr("Bus Pirate firmware 5.4 and older does not support custom serial speeds."
452 "Using default speed of 115200 baud.\n");
453 } else if (serialspeeds[serialspeed_index].speed != BP_DEFAULTBAUD) {
454 /* Set the serial speed to match the user's choice if it doesn't already */
455
456 if (BP_HWVERSION(hw_version_major, hw_version_minor) < BP_HWVERSION(3, 0))
457 msg_pwarn("Increased serial speeds may not work on older (<3.0) Bus Pirates."
458 " Continue at your own risk.\n");
459
460 /* Enter baud rate configuration mode */
461 cnt = snprintf((char *)bp_commbuf, DEFAULT_BUFSIZE, "b\n");
462 if ((ret = buspirate_sendrecv(bp_commbuf, cnt, 0)))
Anastasia Klimchuk7dcb6f32021-05-24 15:12:10 +1000463 goto init_err_cleanup_exit;
Shawn Anastasio2b5adfb2017-12-31 00:17:15 -0600464 if ((ret = buspirate_wait_for_string(bp_commbuf, ">")))
Anastasia Klimchuk7dcb6f32021-05-24 15:12:10 +1000465 goto init_err_cleanup_exit;
Shawn Anastasio2b5adfb2017-12-31 00:17:15 -0600466
467 /* Enter manual clock divisor entry mode */
468 cnt = snprintf((char *)bp_commbuf, DEFAULT_BUFSIZE, "10\n");
469 if ((ret = buspirate_sendrecv(bp_commbuf, cnt, 0)))
Anastasia Klimchuk7dcb6f32021-05-24 15:12:10 +1000470 goto init_err_cleanup_exit;
Shawn Anastasio2b5adfb2017-12-31 00:17:15 -0600471 if ((ret = buspirate_wait_for_string(bp_commbuf, ">")))
Anastasia Klimchuk7dcb6f32021-05-24 15:12:10 +1000472 goto init_err_cleanup_exit;
Shawn Anastasio2b5adfb2017-12-31 00:17:15 -0600473
474 /* Set the clock divisor to the value calculated from the user's input */
475 cnt = snprintf((char *)bp_commbuf, DEFAULT_BUFSIZE, "%d\n",
476 BP_DIVISOR(serialspeeds[serialspeed_index].speed));
477
478 if ((ret = buspirate_sendrecv(bp_commbuf, cnt, 0)))
Anastasia Klimchuk7dcb6f32021-05-24 15:12:10 +1000479 goto init_err_cleanup_exit;
Shawn Anastasio2b5adfb2017-12-31 00:17:15 -0600480 sleep(1);
481
482 /* Reconfigure the host's serial baud rate to the new value */
483 if ((ret = serialport_config(sp_fd, serialspeeds[serialspeed_index].speed))) {
484 msg_perr("Unable to configure system baud rate to specified value.");
Anastasia Klimchuk7dcb6f32021-05-24 15:12:10 +1000485 goto init_err_cleanup_exit;
Shawn Anastasio2b5adfb2017-12-31 00:17:15 -0600486 }
487
488 /* Return to the main prompt */
489 bp_commbuf[0] = ' ';
490 if ((ret = buspirate_sendrecv(bp_commbuf, 1, 0)))
Anastasia Klimchuk7dcb6f32021-05-24 15:12:10 +1000491 goto init_err_cleanup_exit;
Shawn Anastasio2b5adfb2017-12-31 00:17:15 -0600492 if ((ret = buspirate_wait_for_string(bp_commbuf, "HiZ>")))
Anastasia Klimchuk7dcb6f32021-05-24 15:12:10 +1000493 goto init_err_cleanup_exit;
Shawn Anastasio2b5adfb2017-12-31 00:17:15 -0600494
495 msg_pdbg("Serial speed is %d baud\n", serialspeeds[serialspeed_index].speed);
496 }
497
498 }
499
500
501
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000502 /* Enter raw bitbang mode */
503 for (i = 0; i < 20; i++) {
504 bp_commbuf[0] = 0x00;
505 if ((ret = buspirate_sendrecv(bp_commbuf, 1, 0)))
Anastasia Klimchuk7dcb6f32021-05-24 15:12:10 +1000506 goto init_err_cleanup_exit;
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000507 }
508 if ((ret = buspirate_wait_for_string(bp_commbuf, "BBIO")))
Anastasia Klimchuk7dcb6f32021-05-24 15:12:10 +1000509 goto init_err_cleanup_exit;
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000510 if ((ret = buspirate_sendrecv(bp_commbuf, 0, 1)))
Anastasia Klimchuk7dcb6f32021-05-24 15:12:10 +1000511 goto init_err_cleanup_exit;
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000512 msg_pdbg("Raw bitbang mode version %c\n", bp_commbuf[0]);
513 if (bp_commbuf[0] != '1') {
514 msg_perr("Can't handle raw bitbang mode version %c!\n", bp_commbuf[0]);
Anastasia Klimchuk7dcb6f32021-05-24 15:12:10 +1000515 ret = 1;
516 goto init_err_cleanup_exit;
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000517 }
518 /* Enter raw SPI mode */
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000519 bp_commbuf[0] = 0x01;
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000520 ret = buspirate_sendrecv(bp_commbuf, 1, 0);
Anastasia Klimchukee6d5482021-06-24 16:25:43 +1000521 if (ret)
Anastasia Klimchuk7dcb6f32021-05-24 15:12:10 +1000522 goto init_err_cleanup_exit;
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000523 if ((ret = buspirate_wait_for_string(bp_commbuf, "SPI")))
Anastasia Klimchuk7dcb6f32021-05-24 15:12:10 +1000524 goto init_err_cleanup_exit;
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000525 if ((ret = buspirate_sendrecv(bp_commbuf, 0, 1)))
Anastasia Klimchuk7dcb6f32021-05-24 15:12:10 +1000526 goto init_err_cleanup_exit;
Carl-Daniel Hailfingera16a8922012-08-17 17:30:43 +0000527 msg_pdbg("Raw SPI mode version %c\n", bp_commbuf[0]);
528 if (bp_commbuf[0] != '1') {
529 msg_perr("Can't handle raw SPI mode version %c!\n", bp_commbuf[0]);
Anastasia Klimchuk7dcb6f32021-05-24 15:12:10 +1000530 ret = 1;
531 goto init_err_cleanup_exit;
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000532 }
533
534 /* Initial setup (SPI peripherals config): Enable power, CS high, AUX */
Brian Salcedo30dfdba2013-01-03 20:44:30 +0000535 bp_commbuf[0] = 0x40 | 0x0b;
536 if (pullup == 1) {
537 bp_commbuf[0] |= (1 << 2);
538 msg_pdbg("Enabling pull-up resistors.\n");
539 }
Jeremy Kerr98bdcb42021-05-23 17:58:06 +0800540 if (psu == 1) {
541 bp_commbuf[0] |= (1 << 3);
542 msg_pdbg("Enabling PSUs.\n");
543 }
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000544 ret = buspirate_sendrecv(bp_commbuf, 1, 1);
Anastasia Klimchukee6d5482021-06-24 16:25:43 +1000545 if (ret)
Anastasia Klimchuk7dcb6f32021-05-24 15:12:10 +1000546 goto init_err_cleanup_exit;
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000547 if (bp_commbuf[0] != 0x01) {
Brian Salcedo30dfdba2013-01-03 20:44:30 +0000548 msg_perr("Protocol error while setting power/CS/AUX(/Pull-up resistors)!\n");
Anastasia Klimchuk7dcb6f32021-05-24 15:12:10 +1000549 ret = 1;
550 goto init_err_cleanup_exit;
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000551 }
552
Carl-Daniel Hailfingerd5b28fa2009-11-24 18:27:10 +0000553 /* Set SPI speed */
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000554 bp_commbuf[0] = 0x60 | spispeed;
555 ret = buspirate_sendrecv(bp_commbuf, 1, 1);
Anastasia Klimchukee6d5482021-06-24 16:25:43 +1000556 if (ret)
Anastasia Klimchuk7dcb6f32021-05-24 15:12:10 +1000557 goto init_err_cleanup_exit;
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000558 if (bp_commbuf[0] != 0x01) {
Sean Nelson84f7bce2010-01-09 23:56:41 +0000559 msg_perr("Protocol error while setting SPI speed!\n");
Anastasia Klimchuk7dcb6f32021-05-24 15:12:10 +1000560 ret = 1;
561 goto init_err_cleanup_exit;
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000562 }
Shawn Anastasio2b5adfb2017-12-31 00:17:15 -0600563
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000564 /* Set SPI config: output type, idle, clock edge, sample */
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000565 bp_commbuf[0] = 0x80 | 0xa;
Maxime Vincent2099c642017-11-24 13:04:08 +0100566 if (pullup == 1) {
567 bp_commbuf[0] &= ~(1 << 3);
568 msg_pdbg("Pull-ups enabled, so using HiZ pin output! (Open-Drain mode)\n");
569 }
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000570 ret = buspirate_sendrecv(bp_commbuf, 1, 1);
Anastasia Klimchukee6d5482021-06-24 16:25:43 +1000571 if (ret)
Anastasia Klimchuk7dcb6f32021-05-24 15:12:10 +1000572 goto init_err_cleanup_exit;
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000573 if (bp_commbuf[0] != 0x01) {
Sean Nelson84f7bce2010-01-09 23:56:41 +0000574 msg_perr("Protocol error while setting SPI config!\n");
Anastasia Klimchuk7dcb6f32021-05-24 15:12:10 +1000575 ret = 1;
576 goto init_err_cleanup_exit;
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000577 }
578
579 /* De-assert CS# */
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000580 bp_commbuf[0] = 0x03;
581 ret = buspirate_sendrecv(bp_commbuf, 1, 1);
Anastasia Klimchukee6d5482021-06-24 16:25:43 +1000582 if (ret)
Anastasia Klimchuk7dcb6f32021-05-24 15:12:10 +1000583 goto init_err_cleanup_exit;
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000584 if (bp_commbuf[0] != 0x01) {
Sean Nelson84f7bce2010-01-09 23:56:41 +0000585 msg_perr("Protocol error while raising CS#!\n");
Anastasia Klimchuk7dcb6f32021-05-24 15:12:10 +1000586 ret = 1;
587 goto init_err_cleanup_exit;
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000588 }
589
Anastasia Klimchuk7dcb6f32021-05-24 15:12:10 +1000590 if (register_shutdown(buspirate_spi_shutdown, NULL) != 0) {
591 ret = 1;
592 goto init_err_cleanup_exit;
593 }
Carl-Daniel Hailfingera5bcbce2014-07-19 22:03:29 +0000594 register_spi_master(&spi_master_buspirate);
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000595
596 return 0;
Anastasia Klimchuk7dcb6f32021-05-24 15:12:10 +1000597
598init_err_cleanup_exit:
599 buspirate_spi_shutdown(NULL);
600 return ret;
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000601}
602
Edward O'Callaghan5eca4272020-04-12 17:27:53 +1000603static int buspirate_spi_send_command_v1(const struct flashctx *flash, unsigned int writecnt, unsigned int readcnt,
Carl-Daniel Hailfinger64263c72012-11-01 23:38:51 +0000604 const unsigned char *writearr, unsigned char *readarr)
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000605{
Stefan Taunerc69c9c82011-11-23 09:13:48 +0000606 unsigned int i = 0;
607 int ret = 0;
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000608
609 if (writecnt > 16 || readcnt > 16 || (readcnt + writecnt) > 16)
610 return SPI_INVALID_LENGTH;
611
Carl-Daniel Hailfinger04e18be2010-07-29 16:24:09 +0000612 /* 3 bytes extra for CS#, len, CS#. */
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000613 if (buspirate_commbuf_grow(writecnt + readcnt + 3))
614 return ERROR_OOM;
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000615
616 /* Assert CS# */
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000617 bp_commbuf[i++] = 0x02;
Carl-Daniel Hailfinger04e18be2010-07-29 16:24:09 +0000618
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000619 bp_commbuf[i++] = 0x10 | (writecnt + readcnt - 1);
620 memcpy(bp_commbuf + i, writearr, writecnt);
Carl-Daniel Hailfinger04e18be2010-07-29 16:24:09 +0000621 i += writecnt;
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000622 memset(bp_commbuf + i, 0, readcnt);
Carl-Daniel Hailfinger04e18be2010-07-29 16:24:09 +0000623
624 i += readcnt;
625 /* De-assert CS# */
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000626 bp_commbuf[i++] = 0x03;
Carl-Daniel Hailfinger04e18be2010-07-29 16:24:09 +0000627
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000628 ret = buspirate_sendrecv(bp_commbuf, i, i);
Carl-Daniel Hailfinger04e18be2010-07-29 16:24:09 +0000629
630 if (ret) {
631 msg_perr("Bus Pirate communication error!\n");
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000632 return SPI_GENERIC_ERROR;
Carl-Daniel Hailfinger04e18be2010-07-29 16:24:09 +0000633 }
634
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000635 if (bp_commbuf[0] != 0x01) {
Sean Nelson84f7bce2010-01-09 23:56:41 +0000636 msg_perr("Protocol error while lowering CS#!\n");
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000637 return SPI_GENERIC_ERROR;
638 }
639
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000640 if (bp_commbuf[1] != 0x01) {
Sean Nelson84f7bce2010-01-09 23:56:41 +0000641 msg_perr("Protocol error while reading/writing SPI!\n");
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000642 return SPI_GENERIC_ERROR;
643 }
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000644
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000645 if (bp_commbuf[i - 1] != 0x01) {
Sean Nelson84f7bce2010-01-09 23:56:41 +0000646 msg_perr("Protocol error while raising CS#!\n");
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000647 return SPI_GENERIC_ERROR;
648 }
649
Carl-Daniel Hailfinger04e18be2010-07-29 16:24:09 +0000650 /* Skip CS#, length, writearr. */
Carl-Daniel Hailfinger316fdfb2012-06-08 15:27:47 +0000651 memcpy(readarr, bp_commbuf + 2 + writecnt, readcnt);
Carl-Daniel Hailfinger04e18be2010-07-29 16:24:09 +0000652
Carl-Daniel Hailfinger5cca01f2009-11-24 00:20:03 +0000653 return ret;
654}
Carl-Daniel Hailfinger64263c72012-11-01 23:38:51 +0000655
Edward O'Callaghan5eca4272020-04-12 17:27:53 +1000656static int buspirate_spi_send_command_v2(const struct flashctx *flash, unsigned int writecnt, unsigned int readcnt,
Carl-Daniel Hailfinger64263c72012-11-01 23:38:51 +0000657 const unsigned char *writearr, unsigned char *readarr)
658{
659 int i = 0, ret = 0;
660
661 if (writecnt > 4096 || readcnt > 4096 || (readcnt + writecnt) > 4096)
662 return SPI_INVALID_LENGTH;
663
664 /* 5 bytes extra for command, writelen, readlen.
665 * 1 byte extra for Ack/Nack.
666 */
667 if (buspirate_commbuf_grow(max(writecnt + 5, readcnt + 1)))
668 return ERROR_OOM;
669
670 /* Combined SPI write/read. */
671 bp_commbuf[i++] = 0x04;
672 bp_commbuf[i++] = (writecnt >> 8) & 0xff;
673 bp_commbuf[i++] = writecnt & 0xff;
674 bp_commbuf[i++] = (readcnt >> 8) & 0xff;
675 bp_commbuf[i++] = readcnt & 0xff;
676 memcpy(bp_commbuf + i, writearr, writecnt);
Shawn Anastasio2b5adfb2017-12-31 00:17:15 -0600677
Carl-Daniel Hailfinger64263c72012-11-01 23:38:51 +0000678 ret = buspirate_sendrecv(bp_commbuf, i + writecnt, 1 + readcnt);
679
680 if (ret) {
681 msg_perr("Bus Pirate communication error!\n");
682 return SPI_GENERIC_ERROR;
683 }
684
685 if (bp_commbuf[0] != 0x01) {
686 msg_perr("Protocol error while sending SPI write/read!\n");
687 return SPI_GENERIC_ERROR;
688 }
689
690 /* Skip Ack. */
691 memcpy(readarr, bp_commbuf + 1, readcnt);
692
693 return ret;
Nico Huberdeeac7e2017-04-22 00:09:42 +0200694}
Thomas Heijligencc853d82021-05-04 15:32:17 +0200695
696const struct programmer_entry programmer_buspirate_spi = {
697 .name = "buspirate_spi",
698 .type = OTHER,
699 /* FIXME */
700 .devs.note = "Dangerous Prototypes Bus Pirate\n",
701 .init = buspirate_spi_init,
702 .map_flash_region = fallback_map,
703 .unmap_flash_region = fallback_unmap,
704 .delay = internal_delay,
705};