blob: 981798f9925ddbededa86c854953193597359b5e [file] [log] [blame]
Urja Rannikko22915352009-06-23 11:33:43 +00001/*
2 * This file is part of the flashrom project.
3 *
Urja Rannikkoc93f5f12011-09-15 23:38:14 +00004 * Copyright (C) 2009, 2011 Urja Rannikko <urjaman@gmail.com>
Urja Rannikko22915352009-06-23 11:33:43 +00005 * Copyright (C) 2009 Carl-Daniel Hailfinger
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
Stefan Taunerb0eee9b2015-01-10 09:32:50 +000022#include "platform.h"
23
Carl-Daniel Hailfingeref58a9c2009-08-12 13:32:56 +000024#include <stdio.h>
Stefan Taunerb0eee9b2015-01-10 09:32:50 +000025#if ! IS_WINDOWS /* stuff (presumably) needed for sockets only */
Urja Rannikko22915352009-06-23 11:33:43 +000026#include <stdlib.h>
Carl-Daniel Hailfingeref58a9c2009-08-12 13:32:56 +000027#include <unistd.h>
Urja Rannikko22915352009-06-23 11:33:43 +000028#include <fcntl.h>
Urja Rannikko22915352009-06-23 11:33:43 +000029#include <sys/socket.h>
30#include <arpa/inet.h>
31#include <netinet/in.h>
32#include <netinet/tcp.h>
33#include <netdb.h>
Stefan Tauner52b6e9d2013-04-01 00:46:05 +000034#endif
Stefan Taunerb0eee9b2015-01-10 09:32:50 +000035#if IS_WINDOWS
Stefan Tauner52b6e9d2013-04-01 00:46:05 +000036#include <conio.h>
37#else
Urja Rannikko22915352009-06-23 11:33:43 +000038#include <termios.h>
Stefan Tauner52b6e9d2013-04-01 00:46:05 +000039#endif
40#include <string.h>
41#include <errno.h>
Carl-Daniel Hailfinger5b997c32010-07-27 22:41:39 +000042#include "flash.h"
43#include "programmer.h"
Urja Rannikkoc93f5f12011-09-15 23:38:14 +000044#include "chipdrivers.h"
Stefan Tauner0d82e952012-10-27 00:34:18 +000045#include "serprog.h"
Urja Rannikkof3196df2009-07-21 13:02:59 +000046
Stefan Tauner31019d42011-10-22 21:45:27 +000047#define MSGHEADER "serprog: "
Urja Rannikkof3196df2009-07-21 13:02:59 +000048
David Hendricks8bb20212011-06-14 01:35:36 +000049/*
50 * FIXME: This prototype was added to help reduce diffs for the shutdown
51 * registration patch, which shifted many lines of code to place
52 * serprog_shutdown() before serprog_init(). It should be removed soon.
53 */
54static int serprog_shutdown(void *data);
55
Urja Rannikkof3196df2009-07-21 13:02:59 +000056static uint16_t sp_device_serbuf_size = 16;
57static uint16_t sp_device_opbuf_size = 300;
58/* Bitmap of supported commands */
59static uint8_t sp_cmdmap[32];
60
Uwe Hermann4e3d0b32010-03-25 23:18:41 +000061/* sp_prev_was_write used to detect writes with contiguous addresses
Urja Rannikkof3196df2009-07-21 13:02:59 +000062 and combine them to write-n's */
63static int sp_prev_was_write = 0;
64/* sp_write_n_addr used as the starting addr of the currently
65 combined write-n operation */
66static uint32_t sp_write_n_addr;
67/* The maximum length of an write_n operation; 0 = write-n not supported */
68static uint32_t sp_max_write_n = 0;
69/* The maximum length of a read_n operation; 0 = 2^24 */
70static uint32_t sp_max_read_n = 0;
71
72/* A malloc'd buffer for combining the operation's data
73 and a counter that tells how much data is there. */
74static uint8_t *sp_write_n_buf;
75static uint32_t sp_write_n_bytes = 0;
76
77/* sp_streamed_* used for flow control checking */
78static int sp_streamed_transmit_ops = 0;
79static int sp_streamed_transmit_bytes = 0;
80
81/* sp_opbuf_usage used for counting the amount of
82 on-device operation buffer used */
83static int sp_opbuf_usage = 0;
84/* if true causes sp_docommand to automatically check
85 whether the command is supported before doing it */
86static int sp_check_avail_automatic = 0;
87
Stefan Taunerb0eee9b2015-01-10 09:32:50 +000088#if ! IS_WINDOWS
Urja Rannikkof3196df2009-07-21 13:02:59 +000089static int sp_opensocket(char *ip, unsigned int port)
90{
91 int flag = 1;
92 struct hostent *hostPtr = NULL;
Carl-Daniel Hailfinger6d125602009-09-05 01:10:23 +000093 union { struct sockaddr_in si; struct sockaddr s; } sp = {};
Urja Rannikkof3196df2009-07-21 13:02:59 +000094 int sock;
Sean Nelson74e8af52010-01-10 01:06:23 +000095 msg_pdbg(MSGHEADER "IP %s port %d\n", ip, port);
Urja Rannikkof3196df2009-07-21 13:02:59 +000096 sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
Niklas Söderlund2a95e872012-07-30 19:42:33 +000097 if (sock < 0) {
98 msg_perr("Error: serprog cannot open socket: %s\n", strerror(errno));
99 return -1;
100 }
Urja Rannikkof3196df2009-07-21 13:02:59 +0000101 hostPtr = gethostbyname(ip);
102 if (NULL == hostPtr) {
103 hostPtr = gethostbyaddr(ip, strlen(ip), AF_INET);
Niklas Söderlund2a95e872012-07-30 19:42:33 +0000104 if (NULL == hostPtr) {
Stefan Reinauerb8792872014-04-26 16:12:03 +0000105 close(sock);
Niklas Söderlund2a95e872012-07-30 19:42:33 +0000106 msg_perr("Error: cannot resolve %s\n", ip);
107 return -1;
108 }
Urja Rannikkof3196df2009-07-21 13:02:59 +0000109 }
Carl-Daniel Hailfinger6d125602009-09-05 01:10:23 +0000110 sp.si.sin_family = AF_INET;
111 sp.si.sin_port = htons(port);
Carl-Daniel Hailfinger1c6d2ff2012-08-27 00:44:42 +0000112 (void)memcpy(&sp.si.sin_addr, hostPtr->h_addr_list[0], hostPtr->h_length);
Carl-Daniel Hailfinger6d125602009-09-05 01:10:23 +0000113 if (connect(sock, &sp.s, sizeof(sp.si)) < 0) {
Urja Rannikkof3196df2009-07-21 13:02:59 +0000114 close(sock);
Niklas Söderlund2a95e872012-07-30 19:42:33 +0000115 msg_perr("Error: serprog cannot connect: %s\n", strerror(errno));
116 return -1;
Urja Rannikkof3196df2009-07-21 13:02:59 +0000117 }
118 /* We are latency limited, and sometimes do write-write-read *
119 * (write-n) - so enable TCP_NODELAY. */
Stefan Reinauer907c3eb2014-04-26 16:12:31 +0000120 if (setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, &flag, sizeof(int))) {
121 close(sock);
122 msg_perr("Error: serprog cannot set socket options: %s\n", strerror(errno));
123 return -1;
124 }
Urja Rannikkof3196df2009-07-21 13:02:59 +0000125 return sock;
126}
Stefan Tauner52b6e9d2013-04-01 00:46:05 +0000127#endif
Urja Rannikkof3196df2009-07-21 13:02:59 +0000128
Uwe Hermann4e3d0b32010-03-25 23:18:41 +0000129/* Synchronize: a bit tricky algorithm that tries to (and in my tests has *
Urja Rannikkof3196df2009-07-21 13:02:59 +0000130 * always succeeded in) bring the serial protocol to known waiting-for- *
Stefan Taunerae3d8372013-04-01 00:45:45 +0000131 * command state - uses nonblocking I/O - rest of the driver uses *
Urja Rannikkof3196df2009-07-21 13:02:59 +0000132 * blocking read - TODO: add an alarm() timer for the rest of the app on *
133 * serial operations, though not such a big issue as the first thing to *
134 * do is synchronize (eg. check that device is alive). */
Niklas Söderlund7145a502012-09-07 07:07:07 +0000135static int sp_synchronize(void)
Urja Rannikkof3196df2009-07-21 13:02:59 +0000136{
137 int i;
Urja Rannikkof3196df2009-07-21 13:02:59 +0000138 unsigned char buf[8];
Urja Rannikkof3196df2009-07-21 13:02:59 +0000139 /* First sends 8 NOPs, then flushes the return data - should cause *
140 * the device serial parser to get to a sane state, unless if it *
141 * is waiting for a real long write-n. */
142 memset(buf, S_CMD_NOP, 8);
Stefan Taunerae3d8372013-04-01 00:45:45 +0000143 if (serialport_write_nonblock(buf, 8, 1, NULL) != 0) {
Niklas Söderlund7145a502012-09-07 07:07:07 +0000144 goto err_out;
145 }
Urja Rannikkof3196df2009-07-21 13:02:59 +0000146 /* A second should be enough to get all the answers to the buffer */
Stefan Tauner79587f52013-04-01 00:45:51 +0000147 internal_delay(1000 * 1000);
Urja Rannikkof3196df2009-07-21 13:02:59 +0000148 sp_flush_incoming();
149
Cristian Măgherușan-Stanciu9932c7b2011-07-07 19:56:58 +0000150 /* Then try up to 8 times to send syncnop and get the correct special *
151 * return of NAK+ACK. Timing note: up to 10 characters, 10*50ms = *
152 * up to 500ms per try, 8*0.5s = 4s; +1s (above) = up to 5s sync *
153 * attempt, ~1s if immediate success. */
Urja Rannikkof3196df2009-07-21 13:02:59 +0000154 for (i = 0; i < 8; i++) {
155 int n;
156 unsigned char c = S_CMD_SYNCNOP;
Stefan Taunerae3d8372013-04-01 00:45:45 +0000157 if (serialport_write_nonblock(&c, 1, 1, NULL) != 0) {
Niklas Söderlund7145a502012-09-07 07:07:07 +0000158 goto err_out;
159 }
Sean Nelson74e8af52010-01-10 01:06:23 +0000160 msg_pdbg(".");
Urja Rannikkof3196df2009-07-21 13:02:59 +0000161 fflush(stdout);
162 for (n = 0; n < 10; n++) {
Stefan Tauner00e16082013-04-01 00:45:38 +0000163 int ret = serialport_read_nonblock(&c, 1, 50, NULL);
Niklas Söderlund7145a502012-09-07 07:07:07 +0000164 if (ret < 0)
165 goto err_out;
166 if (ret > 0 || c != S_NAK)
Urja Rannikkof3196df2009-07-21 13:02:59 +0000167 continue;
Stefan Tauner00e16082013-04-01 00:45:38 +0000168 ret = serialport_read_nonblock(&c, 1, 20, NULL);
Niklas Söderlund7145a502012-09-07 07:07:07 +0000169 if (ret < 0)
170 goto err_out;
171 if (ret > 0 || c != S_ACK)
Urja Rannikkof3196df2009-07-21 13:02:59 +0000172 continue;
173 c = S_CMD_SYNCNOP;
Stefan Taunerae3d8372013-04-01 00:45:45 +0000174 if (serialport_write_nonblock(&c, 1, 1, NULL) != 0) {
175 goto err_out;
Niklas Söderlund7145a502012-09-07 07:07:07 +0000176 }
Stefan Tauner00e16082013-04-01 00:45:38 +0000177 ret = serialport_read_nonblock(&c, 1, 500, NULL);
Niklas Söderlund7145a502012-09-07 07:07:07 +0000178 if (ret < 0)
179 goto err_out;
180 if (ret > 0 || c != S_NAK)
Urja Rannikkof3196df2009-07-21 13:02:59 +0000181 break; /* fail */
Stefan Tauner00e16082013-04-01 00:45:38 +0000182 ret = serialport_read_nonblock(&c, 1, 100, NULL);
Niklas Söderlund7145a502012-09-07 07:07:07 +0000183 if (ret > 0 || ret < 0)
184 goto err_out;
Urja Rannikkof3196df2009-07-21 13:02:59 +0000185 if (c != S_ACK)
186 break; /* fail */
Sean Nelson74e8af52010-01-10 01:06:23 +0000187 msg_pdbg("\n");
Niklas Söderlund7145a502012-09-07 07:07:07 +0000188 return 0;
Urja Rannikkof3196df2009-07-21 13:02:59 +0000189 }
190 }
Niklas Söderlund7145a502012-09-07 07:07:07 +0000191err_out:
192 msg_perr("Error: cannot synchronize protocol - check communications and reset device?\n");
193 return 1;
Urja Rannikkof3196df2009-07-21 13:02:59 +0000194}
195
196static int sp_check_commandavail(uint8_t command)
197{
198 int byteoffs, bitoffs;
199 byteoffs = command / 8;
200 bitoffs = command % 8;
201 return (sp_cmdmap[byteoffs] & (1 << bitoffs)) ? 1 : 0;
202}
203
204static int sp_automatic_cmdcheck(uint8_t cmd)
205{
206 if ((sp_check_avail_automatic) && (sp_check_commandavail(cmd) == 0)) {
Stefan Tauner31019d42011-10-22 21:45:27 +0000207 msg_pdbg("Warning: Automatic command availability check failed "
Stefan Taunere34e3e82013-01-01 00:06:51 +0000208 "for cmd 0x%02x - won't execute cmd\n", cmd);
Urja Rannikkof3196df2009-07-21 13:02:59 +0000209 return 1;
210 }
211 return 0;
212}
213
214static int sp_docommand(uint8_t command, uint32_t parmlen,
Stefan Tauner31019d42011-10-22 21:45:27 +0000215 uint8_t *params, uint32_t retlen, void *retparms)
Urja Rannikkof3196df2009-07-21 13:02:59 +0000216{
Urja Rannikkof3196df2009-07-21 13:02:59 +0000217 unsigned char c;
218 if (sp_automatic_cmdcheck(command))
219 return 1;
Stefan Tauner79587f52013-04-01 00:45:51 +0000220 if (serialport_write(&command, 1) != 0) {
Niklas Söderlund2a95e872012-07-30 19:42:33 +0000221 msg_perr("Error: cannot write op code: %s\n", strerror(errno));
222 return 1;
223 }
Stefan Tauner79587f52013-04-01 00:45:51 +0000224 if (serialport_write(params, parmlen) != 0) {
Niklas Söderlund2a95e872012-07-30 19:42:33 +0000225 msg_perr("Error: cannot write parameters: %s\n", strerror(errno));
226 return 1;
227 }
Stefan Tauner79587f52013-04-01 00:45:51 +0000228 if (serialport_read(&c, 1) != 0) {
Niklas Söderlund2a95e872012-07-30 19:42:33 +0000229 msg_perr("Error: cannot read from device: %s\n", strerror(errno));
230 return 1;
231 }
Stefan Tauner31019d42011-10-22 21:45:27 +0000232 if (c == S_NAK)
233 return 1;
Urja Rannikkof3196df2009-07-21 13:02:59 +0000234 if (c != S_ACK) {
Niklas Söderlund2a95e872012-07-30 19:42:33 +0000235 msg_perr("Error: invalid response 0x%02X from device\n", c);
236 return 1;
Urja Rannikkof3196df2009-07-21 13:02:59 +0000237 }
238 if (retlen) {
Stefan Tauner79587f52013-04-01 00:45:51 +0000239 if (serialport_read(retparms, retlen) != 0) {
240 msg_perr("Error: cannot read return parameters: %s\n", strerror(errno));
241 return 1;
242 }
Urja Rannikkof3196df2009-07-21 13:02:59 +0000243 }
244 return 0;
245}
246
Stefan Taunerbdead0d2013-08-24 02:10:18 +0000247static int sp_flush_stream(void)
Urja Rannikkof3196df2009-07-21 13:02:59 +0000248{
249 if (sp_streamed_transmit_ops)
250 do {
251 unsigned char c;
Stefan Tauner79587f52013-04-01 00:45:51 +0000252 if (serialport_read(&c, 1) != 0) {
Stefan Taunerbdead0d2013-08-24 02:10:18 +0000253 msg_perr("Error: cannot read from device (flushing stream)");
254 return 1;
Urja Rannikkof3196df2009-07-21 13:02:59 +0000255 }
256 if (c == S_NAK) {
Sean Nelson74e8af52010-01-10 01:06:23 +0000257 msg_perr("Error: NAK to a stream buffer operation\n");
Stefan Taunerbdead0d2013-08-24 02:10:18 +0000258 return 1;
Urja Rannikkof3196df2009-07-21 13:02:59 +0000259 }
260 if (c != S_ACK) {
Sean Nelson74e8af52010-01-10 01:06:23 +0000261 msg_perr("Error: Invalid reply 0x%02X from device\n", c);
Stefan Taunerbdead0d2013-08-24 02:10:18 +0000262 return 1;
Urja Rannikkof3196df2009-07-21 13:02:59 +0000263 }
264 } while (--sp_streamed_transmit_ops);
265 sp_streamed_transmit_ops = 0;
266 sp_streamed_transmit_bytes = 0;
Stefan Taunerbdead0d2013-08-24 02:10:18 +0000267 return 0;
Urja Rannikkof3196df2009-07-21 13:02:59 +0000268}
269
Stefan Taunerbdead0d2013-08-24 02:10:18 +0000270static int sp_stream_buffer_op(uint8_t cmd, uint32_t parmlen, uint8_t *parms)
Urja Rannikkof3196df2009-07-21 13:02:59 +0000271{
272 uint8_t *sp;
273 if (sp_automatic_cmdcheck(cmd))
274 return 1;
Stefan Taunerbdead0d2013-08-24 02:10:18 +0000275
Urja Rannikkof3196df2009-07-21 13:02:59 +0000276 sp = malloc(1 + parmlen);
Stefan Taunerbdead0d2013-08-24 02:10:18 +0000277 if (!sp) {
278 msg_perr("Error: cannot malloc command buffer\n");
279 return 1;
280 }
Urja Rannikkof3196df2009-07-21 13:02:59 +0000281 sp[0] = cmd;
282 memcpy(&(sp[1]), parms, parmlen);
Stefan Taunerbdead0d2013-08-24 02:10:18 +0000283
284 if (sp_streamed_transmit_bytes >= (1 + parmlen + sp_device_serbuf_size)) {
285 if (sp_flush_stream() != 0) {
286 free(sp);
287 return 1;
288 }
289 }
290 if (serialport_write(sp, 1 + parmlen) != 0) {
291 msg_perr("Error: cannot write command\n");
292 free(sp);
293 return 1;
294 }
Urja Rannikkof3196df2009-07-21 13:02:59 +0000295 sp_streamed_transmit_ops += 1;
296 sp_streamed_transmit_bytes += 1 + parmlen;
Stefan Taunerbdead0d2013-08-24 02:10:18 +0000297
298 free(sp);
Urja Rannikkof3196df2009-07-21 13:02:59 +0000299 return 0;
300}
301
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000302static int serprog_spi_send_command(struct flashctx *flash,
303 unsigned int writecnt, unsigned int readcnt,
Carl-Daniel Hailfingereaacd2d2011-11-09 23:40:00 +0000304 const unsigned char *writearr,
305 unsigned char *readarr);
Carl-Daniel Hailfinger63fd9022011-12-14 22:25:15 +0000306static int serprog_spi_read(struct flashctx *flash, uint8_t *buf,
Stefan Taunerc69c9c82011-11-23 09:13:48 +0000307 unsigned int start, unsigned int len);
Carl-Daniel Hailfingera5bcbce2014-07-19 22:03:29 +0000308static struct spi_master spi_master_serprog = {
Urja Rannikkoc93f5f12011-09-15 23:38:14 +0000309 .type = SPI_CONTROLLER_SERPROG,
310 .max_data_read = MAX_DATA_READ_UNLIMITED,
311 .max_data_write = MAX_DATA_WRITE_UNLIMITED,
312 .command = serprog_spi_send_command,
313 .multicommand = default_spi_send_multicommand,
314 .read = serprog_spi_read,
315 .write_256 = default_spi_write_256,
Nico Huber7bca1262012-06-15 22:28:12 +0000316 .write_aai = default_spi_write_aai,
Urja Rannikkoc93f5f12011-09-15 23:38:14 +0000317};
318
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000319static void serprog_chip_writeb(const struct flashctx *flash, uint8_t val,
320 chipaddr addr);
321static uint8_t serprog_chip_readb(const struct flashctx *flash,
322 const chipaddr addr);
323static void serprog_chip_readn(const struct flashctx *flash, uint8_t *buf,
324 const chipaddr addr, size_t len);
Carl-Daniel Hailfingera5bcbce2014-07-19 22:03:29 +0000325static const struct par_master par_master_serprog = {
Carl-Daniel Hailfingereaacd2d2011-11-09 23:40:00 +0000326 .chip_readb = serprog_chip_readb,
327 .chip_readw = fallback_chip_readw,
328 .chip_readl = fallback_chip_readl,
329 .chip_readn = serprog_chip_readn,
330 .chip_writeb = serprog_chip_writeb,
331 .chip_writew = fallback_chip_writew,
332 .chip_writel = fallback_chip_writel,
333 .chip_writen = fallback_chip_writen,
334};
335
336static enum chipbustype serprog_buses_supported = BUS_NONE;
337
Urja Rannikkof3196df2009-07-21 13:02:59 +0000338int serprog_init(void)
339{
340 uint16_t iface;
Urja Rannikkof3196df2009-07-21 13:02:59 +0000341 unsigned char pgmname[17];
342 unsigned char rbuf[3];
343 unsigned char c;
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000344 char *device;
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000345 int have_device = 0;
Urja Rannikkof3196df2009-07-21 13:02:59 +0000346
Stefan Tauner72587f82016-01-04 03:05:15 +0000347 /* the parameter is either of format "dev=/dev/device[:baud]" or "ip=ip:port" */
Carl-Daniel Hailfinger2b6dcb32010-07-08 10:13:37 +0000348 device = extract_programmer_param("dev");
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000349 if (device && strlen(device)) {
Stefan Tauner72587f82016-01-04 03:05:15 +0000350 char *baud_str = strstr(device, ":");
351 if (baud_str != NULL) {
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000352 /* Split device from baudrate. */
Stefan Tauner72587f82016-01-04 03:05:15 +0000353 *baud_str = '\0';
354 baud_str++;
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000355 }
Stefan Tauner72587f82016-01-04 03:05:15 +0000356 int baud;
357 /* Convert baud string to value.
358 * baud_str is either NULL (if strstr can't find the colon), points to the \0 after the colon
359 * if no characters where given after the colon, or a string to convert... */
360 if (baud_str == NULL || *baud_str == '\0') {
361 baud = -1;
362 msg_pdbg("No baudrate specified, using the hardware's defaults.\n");
363 } else
364 baud = atoi(baud_str); // FIXME: replace atoi with strtoul
365 if (strlen(device) > 0) {
366 sp_fd = sp_openserport(device, baud);
Stefan Tauneracfc4c62012-11-30 16:46:45 +0000367 if (sp_fd == SER_INV_FD) {
Niklas Söderlund2a95e872012-07-30 19:42:33 +0000368 free(device);
369 return 1;
370 }
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000371 have_device++;
372 }
373 }
Urja Rannikko27b431b2016-01-04 03:05:23 +0000374
375#if !IS_WINDOWS
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000376 if (device && !strlen(device)) {
377 msg_perr("Error: No device specified.\n"
Stefan Tauner72587f82016-01-04 03:05:15 +0000378 "Use flashrom -p serprog:dev=/dev/device[:baud]\n");
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000379 free(device);
380 return 1;
381 }
382 free(device);
Urja Rannikkof3196df2009-07-21 13:02:59 +0000383
Carl-Daniel Hailfinger2b6dcb32010-07-08 10:13:37 +0000384 device = extract_programmer_param("ip");
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000385 if (have_device && device) {
386 msg_perr("Error: Both host and device specified.\n"
387 "Please use either dev= or ip= but not both.\n");
388 free(device);
389 return 1;
390 }
391 if (device && strlen(device)) {
Stefan Tauner72587f82016-01-04 03:05:15 +0000392 char *port = strstr(device, ":");
393 if (port != NULL) {
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000394 /* Split host from port. */
Stefan Tauner72587f82016-01-04 03:05:15 +0000395 *port = '\0';
396 port++;
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000397 }
Stefan Tauner72587f82016-01-04 03:05:15 +0000398 if (!port || !strlen(port)) {
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000399 msg_perr("Error: No port specified.\n"
400 "Use flashrom -p serprog:ip=ipaddr:port\n");
401 free(device);
Urja Rannikkoc93f5f12011-09-15 23:38:14 +0000402 return 1;
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000403 }
404 if (strlen(device)) {
Stefan Tauner72587f82016-01-04 03:05:15 +0000405 sp_fd = sp_opensocket(device, atoi(port)); // FIXME: replace atoi with strtoul
Niklas Söderlund2a95e872012-07-30 19:42:33 +0000406 if (sp_fd < 0) {
407 free(device);
408 return 1;
409 }
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000410 have_device++;
411 }
412 }
413 if (device && !strlen(device)) {
414 msg_perr("Error: No host specified.\n"
415 "Use flashrom -p serprog:ip=ipaddr:port\n");
416 free(device);
417 return 1;
418 }
Urja Rannikko27b431b2016-01-04 03:05:23 +0000419#endif
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000420 free(device);
421
422 if (!have_device) {
Urja Rannikko27b431b2016-01-04 03:05:23 +0000423#if IS_WINDOWS
424 msg_perr("Error: No device specified.\n"
425 "Use flashrom -p serprog:dev=comN[:baud]\n");
426#else
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000427 msg_perr("Error: Neither host nor device specified.\n"
428 "Use flashrom -p serprog:dev=/dev/device:baud or "
429 "flashrom -p serprog:ip=ipaddr:port\n");
Urja Rannikko27b431b2016-01-04 03:05:23 +0000430#endif
Carl-Daniel Hailfinger744132a2010-07-06 09:55:48 +0000431 return 1;
432 }
Urja Rannikkof3196df2009-07-21 13:02:59 +0000433
David Hendricks8bb20212011-06-14 01:35:36 +0000434 if (register_shutdown(serprog_shutdown, NULL))
435 return 1;
436
Sean Nelson74e8af52010-01-10 01:06:23 +0000437 msg_pdbg(MSGHEADER "connected - attempting to synchronize\n");
Urja Rannikkof3196df2009-07-21 13:02:59 +0000438
439 sp_check_avail_automatic = 0;
440
Niklas Söderlund7145a502012-09-07 07:07:07 +0000441 if (sp_synchronize())
442 return 1;
Urja Rannikkof3196df2009-07-21 13:02:59 +0000443
Sean Nelson74e8af52010-01-10 01:06:23 +0000444 msg_pdbg(MSGHEADER "Synchronized\n");
Urja Rannikkof3196df2009-07-21 13:02:59 +0000445
446 if (sp_docommand(S_CMD_Q_IFACE, 0, NULL, 2, &iface)) {
Stefan Tauner31019d42011-10-22 21:45:27 +0000447 msg_perr("Error: NAK to query interface version\n");
Carl-Daniel Hailfingereaacd2d2011-11-09 23:40:00 +0000448 return 1;
Urja Rannikkof3196df2009-07-21 13:02:59 +0000449 }
450
451 if (iface != 1) {
Stefan Tauner31019d42011-10-22 21:45:27 +0000452 msg_perr("Error: Unknown interface version: %d\n", iface);
Carl-Daniel Hailfingereaacd2d2011-11-09 23:40:00 +0000453 return 1;
Urja Rannikkof3196df2009-07-21 13:02:59 +0000454 }
455
Sean Nelson74e8af52010-01-10 01:06:23 +0000456 msg_pdbg(MSGHEADER "Interface version ok.\n");
Urja Rannikkof3196df2009-07-21 13:02:59 +0000457
458 if (sp_docommand(S_CMD_Q_CMDMAP, 0, NULL, 32, sp_cmdmap)) {
Sean Nelson74e8af52010-01-10 01:06:23 +0000459 msg_perr("Error: query command map not supported\n");
Carl-Daniel Hailfingereaacd2d2011-11-09 23:40:00 +0000460 return 1;
Urja Rannikkof3196df2009-07-21 13:02:59 +0000461 }
462
463 sp_check_avail_automatic = 1;
464
Carl-Daniel Hailfingereaacd2d2011-11-09 23:40:00 +0000465 /* FIXME: This assumes that serprog device bustypes are always
466 * identical with flashrom bustype enums and that they all fit
467 * in a single byte.
468 */
Urja Rannikkoc93f5f12011-09-15 23:38:14 +0000469 if (sp_docommand(S_CMD_Q_BUSTYPE, 0, NULL, 1, &c)) {
Stefan Taunerc6fa32d2013-01-04 22:54:07 +0000470 msg_pwarn("Warning: NAK to query supported buses\n");
Urja Rannikkoc93f5f12011-09-15 23:38:14 +0000471 c = BUS_NONSPI; /* A reasonable default for now. */
Urja Rannikkof3196df2009-07-21 13:02:59 +0000472 }
Carl-Daniel Hailfingereaacd2d2011-11-09 23:40:00 +0000473 serprog_buses_supported = c;
474
Stefan Tauner31019d42011-10-22 21:45:27 +0000475 msg_pdbg(MSGHEADER "Bus support: parallel=%s, LPC=%s, FWH=%s, SPI=%s\n",
476 (c & BUS_PARALLEL) ? "on" : "off",
477 (c & BUS_LPC) ? "on" : "off",
478 (c & BUS_FWH) ? "on" : "off",
479 (c & BUS_SPI) ? "on" : "off");
Urja Rannikkoc93f5f12011-09-15 23:38:14 +0000480 /* Check for the minimum operational set of commands. */
Carl-Daniel Hailfingereaacd2d2011-11-09 23:40:00 +0000481 if (serprog_buses_supported & BUS_SPI) {
Urja Rannikkoc93f5f12011-09-15 23:38:14 +0000482 uint8_t bt = BUS_SPI;
Stefan Taunerb98f6eb2012-08-13 16:33:04 +0000483 char *spispeed;
Urja Rannikkoc93f5f12011-09-15 23:38:14 +0000484 if (sp_check_commandavail(S_CMD_O_SPIOP) == 0) {
485 msg_perr("Error: SPI operation not supported while the "
486 "bustype is SPI\n");
Carl-Daniel Hailfingereaacd2d2011-11-09 23:40:00 +0000487 return 1;
Urja Rannikkoc93f5f12011-09-15 23:38:14 +0000488 }
Niklas Söderlund2a95e872012-07-30 19:42:33 +0000489 if (sp_docommand(S_CMD_S_BUSTYPE, 1, &bt, 0, NULL))
490 return 1;
Urja Rannikkoc93f5f12011-09-15 23:38:14 +0000491 /* Success of any of these commands is optional. We don't need
492 the programmer to tell us its limits, but if it doesn't, we
493 will assume stuff, so it's in the programmers best interest
494 to tell us. */
Urja Rannikkoc93f5f12011-09-15 23:38:14 +0000495 if (!sp_docommand(S_CMD_Q_WRNMAXLEN, 0, NULL, 3, rbuf)) {
496 uint32_t v;
497 v = ((unsigned int)(rbuf[0]) << 0);
498 v |= ((unsigned int)(rbuf[1]) << 8);
499 v |= ((unsigned int)(rbuf[2]) << 16);
500 if (v == 0)
501 v = (1 << 24) - 1; /* SPI-op maximum. */
Carl-Daniel Hailfingera5bcbce2014-07-19 22:03:29 +0000502 spi_master_serprog.max_data_write = v;
Urja Rannikkoc93f5f12011-09-15 23:38:14 +0000503 msg_pdbg(MSGHEADER "Maximum write-n length is %d\n", v);
504 }
505 if (!sp_docommand(S_CMD_Q_RDNMAXLEN, 0, NULL, 3, rbuf)) {
506 uint32_t v;
507 v = ((unsigned int)(rbuf[0]) << 0);
508 v |= ((unsigned int)(rbuf[1]) << 8);
509 v |= ((unsigned int)(rbuf[2]) << 16);
510 if (v == 0)
511 v = (1 << 24) - 1; /* SPI-op maximum. */
Carl-Daniel Hailfingera5bcbce2014-07-19 22:03:29 +0000512 spi_master_serprog.max_data_read = v;
Urja Rannikkoc93f5f12011-09-15 23:38:14 +0000513 msg_pdbg(MSGHEADER "Maximum read-n length is %d\n", v);
514 }
Stefan Taunerb98f6eb2012-08-13 16:33:04 +0000515 spispeed = extract_programmer_param("spispeed");
516 if (spispeed && strlen(spispeed)) {
517 uint32_t f_spi_req, f_spi;
518 uint8_t buf[4];
519 char *f_spi_suffix;
520
521 errno = 0;
522 f_spi_req = strtol(spispeed, &f_spi_suffix, 0);
523 if (errno != 0 || spispeed == f_spi_suffix) {
524 msg_perr("Error: Could not convert 'spispeed'.\n");
Stefan Taunere34e3e82013-01-01 00:06:51 +0000525 free(spispeed);
Stefan Taunerb98f6eb2012-08-13 16:33:04 +0000526 return 1;
527 }
528 if (strlen(f_spi_suffix) == 1) {
529 if (!strcasecmp(f_spi_suffix, "M"))
530 f_spi_req *= 1000000;
531 else if (!strcasecmp(f_spi_suffix, "k"))
532 f_spi_req *= 1000;
533 else {
534 msg_perr("Error: Garbage following 'spispeed' value.\n");
Stefan Taunere34e3e82013-01-01 00:06:51 +0000535 free(spispeed);
Stefan Taunerb98f6eb2012-08-13 16:33:04 +0000536 return 1;
537 }
538 } else if (strlen(f_spi_suffix) > 1) {
539 msg_perr("Error: Garbage following 'spispeed' value.\n");
Stefan Taunere34e3e82013-01-01 00:06:51 +0000540 free(spispeed);
Stefan Taunerb98f6eb2012-08-13 16:33:04 +0000541 return 1;
542 }
543
544 buf[0] = (f_spi_req >> (0 * 8)) & 0xFF;
545 buf[1] = (f_spi_req >> (1 * 8)) & 0xFF;
546 buf[2] = (f_spi_req >> (2 * 8)) & 0xFF;
547 buf[3] = (f_spi_req >> (3 * 8)) & 0xFF;
548
549 if (sp_check_commandavail(S_CMD_S_SPI_FREQ) == 0)
Stefan Taunerc6fa32d2013-01-04 22:54:07 +0000550 msg_pwarn(MSGHEADER "Warning: Setting the SPI clock rate is not supported!\n");
551 else if (sp_docommand(S_CMD_S_SPI_FREQ, 4, buf, 4, buf) == 0) {
Stefan Taunerb98f6eb2012-08-13 16:33:04 +0000552 f_spi = buf[0];
553 f_spi |= buf[1] << (1 * 8);
554 f_spi |= buf[2] << (2 * 8);
555 f_spi |= buf[3] << (3 * 8);
556 msg_pdbg(MSGHEADER "Requested to set SPI clock frequency to %u Hz. "
557 "It was actually set to %u Hz\n", f_spi_req, f_spi);
558 } else
Stefan Taunerc6fa32d2013-01-04 22:54:07 +0000559 msg_pwarn(MSGHEADER "Setting SPI clock rate to %u Hz failed!\n", f_spi_req);
Stefan Taunerb98f6eb2012-08-13 16:33:04 +0000560 }
561 free(spispeed);
Carl-Daniel Hailfingereaacd2d2011-11-09 23:40:00 +0000562 bt = serprog_buses_supported;
Niklas Söderlund2a95e872012-07-30 19:42:33 +0000563 if (sp_docommand(S_CMD_S_BUSTYPE, 1, &bt, 0, NULL))
564 return 1;
Urja Rannikkof3196df2009-07-21 13:02:59 +0000565 }
Urja Rannikkoc93f5f12011-09-15 23:38:14 +0000566
Carl-Daniel Hailfingereaacd2d2011-11-09 23:40:00 +0000567 if (serprog_buses_supported & BUS_NONSPI) {
Urja Rannikkoc93f5f12011-09-15 23:38:14 +0000568 if (sp_check_commandavail(S_CMD_O_INIT) == 0) {
569 msg_perr("Error: Initialize operation buffer "
570 "not supported\n");
Carl-Daniel Hailfingereaacd2d2011-11-09 23:40:00 +0000571 return 1;
Urja Rannikkoc93f5f12011-09-15 23:38:14 +0000572 }
573
574 if (sp_check_commandavail(S_CMD_O_DELAY) == 0) {
575 msg_perr("Error: Write to opbuf: "
576 "delay not supported\n");
Carl-Daniel Hailfingereaacd2d2011-11-09 23:40:00 +0000577 return 1;
Urja Rannikkoc93f5f12011-09-15 23:38:14 +0000578 }
579
580 /* S_CMD_O_EXEC availability checked later. */
581
582 if (sp_check_commandavail(S_CMD_R_BYTE) == 0) {
583 msg_perr("Error: Single byte read not supported\n");
Carl-Daniel Hailfingereaacd2d2011-11-09 23:40:00 +0000584 return 1;
Urja Rannikkoc93f5f12011-09-15 23:38:14 +0000585 }
586 /* This could be translated to single byte reads (if missing),
587 * but now we don't support that. */
588 if (sp_check_commandavail(S_CMD_R_NBYTES) == 0) {
589 msg_perr("Error: Read n bytes not supported\n");
Carl-Daniel Hailfingereaacd2d2011-11-09 23:40:00 +0000590 return 1;
Urja Rannikkoc93f5f12011-09-15 23:38:14 +0000591 }
592 if (sp_check_commandavail(S_CMD_O_WRITEB) == 0) {
593 msg_perr("Error: Write to opbuf: "
594 "write byte not supported\n");
Carl-Daniel Hailfingereaacd2d2011-11-09 23:40:00 +0000595 return 1;
Urja Rannikkoc93f5f12011-09-15 23:38:14 +0000596 }
597
598 if (sp_docommand(S_CMD_Q_WRNMAXLEN, 0, NULL, 3, rbuf)) {
599 msg_pdbg(MSGHEADER "Write-n not supported");
600 sp_max_write_n = 0;
601 } else {
602 sp_max_write_n = ((unsigned int)(rbuf[0]) << 0);
603 sp_max_write_n |= ((unsigned int)(rbuf[1]) << 8);
604 sp_max_write_n |= ((unsigned int)(rbuf[2]) << 16);
605 if (!sp_max_write_n) {
606 sp_max_write_n = (1 << 24);
607 }
608 msg_pdbg(MSGHEADER "Maximum write-n length is %d\n",
609 sp_max_write_n);
610 sp_write_n_buf = malloc(sp_max_write_n);
611 if (!sp_write_n_buf) {
612 msg_perr("Error: cannot allocate memory for "
613 "Write-n buffer\n");
Carl-Daniel Hailfingereaacd2d2011-11-09 23:40:00 +0000614 return 1;
Urja Rannikkoc93f5f12011-09-15 23:38:14 +0000615 }
616 sp_write_n_bytes = 0;
617 }
618
619 if (sp_check_commandavail(S_CMD_Q_RDNMAXLEN) &&
620 (sp_docommand(S_CMD_Q_RDNMAXLEN, 0, NULL, 3, rbuf) == 0)) {
621 sp_max_read_n = ((unsigned int)(rbuf[0]) << 0);
622 sp_max_read_n |= ((unsigned int)(rbuf[1]) << 8);
623 sp_max_read_n |= ((unsigned int)(rbuf[2]) << 16);
624 msg_pdbg(MSGHEADER "Maximum read-n length is %d\n",
625 sp_max_read_n ? sp_max_read_n : (1 << 24));
626 } else {
627 msg_pdbg(MSGHEADER "Maximum read-n length "
628 "not reported\n");
629 sp_max_read_n = 0;
630 }
631
Urja Rannikkof3196df2009-07-21 13:02:59 +0000632 }
633
634 if (sp_docommand(S_CMD_Q_PGMNAME, 0, NULL, 16, pgmname)) {
Stefan Taunerc6fa32d2013-01-04 22:54:07 +0000635 msg_pwarn("Warning: NAK to query programmer name\n");
Urja Rannikkof3196df2009-07-21 13:02:59 +0000636 strcpy((char *)pgmname, "(unknown)");
637 }
638 pgmname[16] = 0;
Stefan Tauner31019d42011-10-22 21:45:27 +0000639 msg_pinfo(MSGHEADER "Programmer name is \"%s\"\n", pgmname);
Urja Rannikkof3196df2009-07-21 13:02:59 +0000640
641 if (sp_docommand(S_CMD_Q_SERBUF, 0, NULL, 2, &sp_device_serbuf_size)) {
Stefan Taunerc6fa32d2013-01-04 22:54:07 +0000642 msg_pwarn("Warning: NAK to query serial buffer size\n");
Urja Rannikkof3196df2009-07-21 13:02:59 +0000643 }
Stefan Tauner31019d42011-10-22 21:45:27 +0000644 msg_pdbg(MSGHEADER "Serial buffer size is %d\n",
Urja Rannikkof3196df2009-07-21 13:02:59 +0000645 sp_device_serbuf_size);
646
Urja Rannikkoc93f5f12011-09-15 23:38:14 +0000647 if (sp_check_commandavail(S_CMD_O_INIT)) {
648 /* This would be inconsistent. */
649 if (sp_check_commandavail(S_CMD_O_EXEC) == 0) {
650 msg_perr("Error: Execute operation buffer not "
651 "supported\n");
Carl-Daniel Hailfingereaacd2d2011-11-09 23:40:00 +0000652 return 1;
Urja Rannikkof3196df2009-07-21 13:02:59 +0000653 }
Urja Rannikkoc93f5f12011-09-15 23:38:14 +0000654
655 if (sp_docommand(S_CMD_O_INIT, 0, NULL, 0, NULL)) {
656 msg_perr("Error: NAK to initialize operation buffer\n");
Carl-Daniel Hailfingereaacd2d2011-11-09 23:40:00 +0000657 return 1;
Urja Rannikkoc93f5f12011-09-15 23:38:14 +0000658 }
659
660 if (sp_docommand(S_CMD_Q_OPBUF, 0, NULL, 2,
661 &sp_device_opbuf_size)) {
Stefan Taunerc6fa32d2013-01-04 22:54:07 +0000662 msg_pwarn("Warning: NAK to query operation buffer size\n");
Urja Rannikkoc93f5f12011-09-15 23:38:14 +0000663 }
Stefan Tauner31019d42011-10-22 21:45:27 +0000664 msg_pdbg(MSGHEADER "operation buffer size is %d\n",
Urja Rannikkoc93f5f12011-09-15 23:38:14 +0000665 sp_device_opbuf_size);
666 }
Urja Rannikkof3196df2009-07-21 13:02:59 +0000667
Stefan Tauner92fefc92012-10-27 00:34:23 +0000668 if (sp_check_commandavail(S_CMD_S_PIN_STATE)) {
669 uint8_t en = 1;
670 if (sp_docommand(S_CMD_S_PIN_STATE, 1, &en, 0, NULL) != 0) {
671 msg_perr("Error: could not enable output buffers\n");
672 return 1;
673 } else
674 msg_pdbg(MSGHEADER "Output drivers enabled\n");
675 } else
676 msg_pdbg(MSGHEADER "Warning: Programmer does not support toggling its output drivers\n");
Urja Rannikkof3196df2009-07-21 13:02:59 +0000677 sp_prev_was_write = 0;
678 sp_streamed_transmit_ops = 0;
679 sp_streamed_transmit_bytes = 0;
680 sp_opbuf_usage = 0;
Carl-Daniel Hailfingereaacd2d2011-11-09 23:40:00 +0000681 if (serprog_buses_supported & BUS_SPI)
Carl-Daniel Hailfingera5bcbce2014-07-19 22:03:29 +0000682 register_spi_master(&spi_master_serprog);
Carl-Daniel Hailfingereaacd2d2011-11-09 23:40:00 +0000683 if (serprog_buses_supported & BUS_NONSPI)
Carl-Daniel Hailfingera5bcbce2014-07-19 22:03:29 +0000684 register_par_master(&par_master_serprog, serprog_buses_supported & BUS_NONSPI);
Urja Rannikkof3196df2009-07-21 13:02:59 +0000685 return 0;
686}
687
Stefan Taunerbdead0d2013-08-24 02:10:18 +0000688/* Move an in flashrom buffer existing write-n operation to the on-device operation buffer. */
689static int sp_pass_writen(void)
Urja Rannikkof3196df2009-07-21 13:02:59 +0000690{
691 unsigned char header[7];
Stefan Taunerbdead0d2013-08-24 02:10:18 +0000692 msg_pspew(MSGHEADER "Passing write-n bytes=%d addr=0x%x\n", sp_write_n_bytes, sp_write_n_addr);
693 if (sp_streamed_transmit_bytes >= (7 + sp_write_n_bytes + sp_device_serbuf_size)) {
694 if (sp_flush_stream() != 0) {
695 return 1;
696 }
697 }
Urja Rannikkof3196df2009-07-21 13:02:59 +0000698 /* In case it's just a single byte send it as a single write. */
699 if (sp_write_n_bytes == 1) {
700 sp_write_n_bytes = 0;
701 header[0] = (sp_write_n_addr >> 0) & 0xFF;
702 header[1] = (sp_write_n_addr >> 8) & 0xFF;
703 header[2] = (sp_write_n_addr >> 16) & 0xFF;
704 header[3] = sp_write_n_buf[0];
Stefan Taunerbdead0d2013-08-24 02:10:18 +0000705 if (sp_stream_buffer_op(S_CMD_O_WRITEB, 4, header) != 0)
706 return 1;
Urja Rannikkof3196df2009-07-21 13:02:59 +0000707 sp_opbuf_usage += 5;
Stefan Taunerbdead0d2013-08-24 02:10:18 +0000708 return 0;
Urja Rannikkof3196df2009-07-21 13:02:59 +0000709 }
710 header[0] = S_CMD_O_WRITEN;
711 header[1] = (sp_write_n_bytes >> 0) & 0xFF;
712 header[2] = (sp_write_n_bytes >> 8) & 0xFF;
713 header[3] = (sp_write_n_bytes >> 16) & 0xFF;
714 header[4] = (sp_write_n_addr >> 0) & 0xFF;
715 header[5] = (sp_write_n_addr >> 8) & 0xFF;
716 header[6] = (sp_write_n_addr >> 16) & 0xFF;
Stefan Taunerbdead0d2013-08-24 02:10:18 +0000717 if (serialport_write(header, 7) != 0) {
718 msg_perr(MSGHEADER "Error: cannot write write-n command\n");
719 return 1;
720 }
721 if (serialport_write(sp_write_n_buf, sp_write_n_bytes) != 0) {
722 msg_perr(MSGHEADER "Error: cannot write write-n data");
723 return 1;
724 }
Urja Rannikkof3196df2009-07-21 13:02:59 +0000725 sp_streamed_transmit_bytes += 7 + sp_write_n_bytes;
726 sp_streamed_transmit_ops += 1;
727 sp_opbuf_usage += 7 + sp_write_n_bytes;
728 sp_write_n_bytes = 0;
729 sp_prev_was_write = 0;
Stefan Taunerbdead0d2013-08-24 02:10:18 +0000730 return 0;
Urja Rannikkof3196df2009-07-21 13:02:59 +0000731}
732
Stefan Taunerbdead0d2013-08-24 02:10:18 +0000733static int sp_execute_opbuf_noflush(void)
Urja Rannikkof3196df2009-07-21 13:02:59 +0000734{
Stefan Taunerbdead0d2013-08-24 02:10:18 +0000735 if ((sp_max_write_n) && (sp_write_n_bytes)) {
736 if (sp_pass_writen() != 0) {
737 msg_perr("Error: could not transfer write buffer\n");
738 return 1;
739 }
740 }
741 if (sp_stream_buffer_op(S_CMD_O_EXEC, 0, NULL) != 0) {
742 msg_perr("Error: could not execute command buffer\n");
743 return 1;
744 }
745 msg_pspew(MSGHEADER "Executed operation buffer of %d bytes\n", sp_opbuf_usage);
Urja Rannikkof3196df2009-07-21 13:02:59 +0000746 sp_opbuf_usage = 0;
747 sp_prev_was_write = 0;
Stefan Taunerbdead0d2013-08-24 02:10:18 +0000748 return 0;
Urja Rannikkof3196df2009-07-21 13:02:59 +0000749}
750
Stefan Taunerbdead0d2013-08-24 02:10:18 +0000751static int sp_execute_opbuf(void)
Urja Rannikkof3196df2009-07-21 13:02:59 +0000752{
Stefan Taunerbdead0d2013-08-24 02:10:18 +0000753 if (sp_execute_opbuf_noflush() != 0)
754 return 1;
755 if (sp_flush_stream() != 0)
756 return 1;
757
758 return 0;
Urja Rannikkof3196df2009-07-21 13:02:59 +0000759}
760
David Hendricks8bb20212011-06-14 01:35:36 +0000761static int serprog_shutdown(void *data)
Urja Rannikkof3196df2009-07-21 13:02:59 +0000762{
Urja Rannikkof3196df2009-07-21 13:02:59 +0000763 if ((sp_opbuf_usage) || (sp_max_write_n && sp_write_n_bytes))
Stefan Taunerbdead0d2013-08-24 02:10:18 +0000764 if (sp_execute_opbuf() != 0)
765 msg_pwarn("Could not flush command buffer.\n");
Stefan Tauner92fefc92012-10-27 00:34:23 +0000766 if (sp_check_commandavail(S_CMD_S_PIN_STATE)) {
767 uint8_t dis = 0;
768 if (sp_docommand(S_CMD_S_PIN_STATE, 1, &dis, 0, NULL) == 0)
769 msg_pdbg(MSGHEADER "Output drivers disabled\n");
770 else
Stefan Taunerc6fa32d2013-01-04 22:54:07 +0000771 msg_pwarn(MSGHEADER "%s: Warning: could not disable output buffers\n", __func__);
Stefan Tauner92fefc92012-10-27 00:34:23 +0000772 }
Niklas Söderlund7145a502012-09-07 07:07:07 +0000773 /* FIXME: fix sockets on windows(?), especially closing */
774 serialport_shutdown(&sp_fd);
Urja Rannikkof3196df2009-07-21 13:02:59 +0000775 if (sp_max_write_n)
776 free(sp_write_n_buf);
777 return 0;
778}
779
Stefan Taunerbdead0d2013-08-24 02:10:18 +0000780static int sp_check_opbuf_usage(int bytes_to_be_added)
Urja Rannikkof3196df2009-07-21 13:02:59 +0000781{
782 if (sp_device_opbuf_size <= (sp_opbuf_usage + bytes_to_be_added)) {
Stefan Taunerbdead0d2013-08-24 02:10:18 +0000783 /* If this happens in the middle of a page load the page load will probably fail. */
784 msg_pwarn(MSGHEADER "Warning: executed operation buffer due to size reasons\n");
785 if (sp_execute_opbuf() != 0)
786 return 1;
Urja Rannikkof3196df2009-07-21 13:02:59 +0000787 }
Stefan Taunerbdead0d2013-08-24 02:10:18 +0000788 return 0;
Urja Rannikkof3196df2009-07-21 13:02:59 +0000789}
790
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000791static void serprog_chip_writeb(const struct flashctx *flash, uint8_t val,
792 chipaddr addr)
Urja Rannikkof3196df2009-07-21 13:02:59 +0000793{
Sean Nelson74e8af52010-01-10 01:06:23 +0000794 msg_pspew("%s\n", __func__);
Urja Rannikkof3196df2009-07-21 13:02:59 +0000795 if (sp_max_write_n) {
796 if ((sp_prev_was_write)
797 && (addr == (sp_write_n_addr + sp_write_n_bytes))) {
798 sp_write_n_buf[sp_write_n_bytes++] = val;
799 } else {
800 if ((sp_prev_was_write) && (sp_write_n_bytes))
801 sp_pass_writen();
802 sp_prev_was_write = 1;
803 sp_write_n_addr = addr;
804 sp_write_n_bytes = 1;
805 sp_write_n_buf[0] = val;
806 }
807 sp_check_opbuf_usage(7 + sp_write_n_bytes);
808 if (sp_write_n_bytes >= sp_max_write_n)
809 sp_pass_writen();
810 } else {
811 /* We will have to do single writeb ops. */
812 unsigned char writeb_parm[4];
813 sp_check_opbuf_usage(6);
814 writeb_parm[0] = (addr >> 0) & 0xFF;
815 writeb_parm[1] = (addr >> 8) & 0xFF;
816 writeb_parm[2] = (addr >> 16) & 0xFF;
817 writeb_parm[3] = val;
Stefan Taunerbdead0d2013-08-24 02:10:18 +0000818 sp_stream_buffer_op(S_CMD_O_WRITEB, 4, writeb_parm); // FIXME: return error
Urja Rannikkof3196df2009-07-21 13:02:59 +0000819 sp_opbuf_usage += 5;
820 }
821}
822
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000823static uint8_t serprog_chip_readb(const struct flashctx *flash,
824 const chipaddr addr)
Urja Rannikkof3196df2009-07-21 13:02:59 +0000825{
826 unsigned char c;
827 unsigned char buf[3];
828 /* Will stream the read operation - eg. add it to the stream buffer, *
829 * then flush the buffer, then read the read answer. */
830 if ((sp_opbuf_usage) || (sp_max_write_n && sp_write_n_bytes))
831 sp_execute_opbuf_noflush();
832 buf[0] = ((addr >> 0) & 0xFF);
833 buf[1] = ((addr >> 8) & 0xFF);
834 buf[2] = ((addr >> 16) & 0xFF);
Stefan Taunerbdead0d2013-08-24 02:10:18 +0000835 sp_stream_buffer_op(S_CMD_R_BYTE, 3, buf); // FIXME: return error
836 sp_flush_stream(); // FIXME: return error
Stefan Tauner79587f52013-04-01 00:45:51 +0000837 if (serialport_read(&c, 1) != 0)
Stefan Taunerbdead0d2013-08-24 02:10:18 +0000838 msg_perr(MSGHEADER "readb byteread"); // FIXME: return error
Stefan Taunerc2333752013-07-13 23:31:37 +0000839 msg_pspew("%s addr=0x%" PRIxPTR " returning 0x%02X\n", __func__, addr, c);
Urja Rannikkof3196df2009-07-21 13:02:59 +0000840 return c;
841}
842
Uwe Hermann4e3d0b32010-03-25 23:18:41 +0000843/* Local version that really does the job, doesn't care of max_read_n. */
Stefan Taunerbdead0d2013-08-24 02:10:18 +0000844static int sp_do_read_n(uint8_t * buf, const chipaddr addr, size_t len)
Urja Rannikkof3196df2009-07-21 13:02:59 +0000845{
Urja Rannikkof3196df2009-07-21 13:02:59 +0000846 unsigned char sbuf[6];
Stefan Tauner0554ca52013-07-25 22:54:25 +0000847 msg_pspew("%s: addr=0x%" PRIxPTR " len=%zu\n", __func__, addr, len);
Urja Rannikkof3196df2009-07-21 13:02:59 +0000848 /* Stream the read-n -- as above. */
849 if ((sp_opbuf_usage) || (sp_max_write_n && sp_write_n_bytes))
850 sp_execute_opbuf_noflush();
851 sbuf[0] = ((addr >> 0) & 0xFF);
852 sbuf[1] = ((addr >> 8) & 0xFF);
853 sbuf[2] = ((addr >> 16) & 0xFF);
854 sbuf[3] = ((len >> 0) & 0xFF);
855 sbuf[4] = ((len >> 8) & 0xFF);
856 sbuf[5] = ((len >> 16) & 0xFF);
857 sp_stream_buffer_op(S_CMD_R_NBYTES, 6, sbuf);
Stefan Taunerbdead0d2013-08-24 02:10:18 +0000858 if (sp_flush_stream() != 0)
859 return 1;
860 if (serialport_read(buf, len) != 0) {
861 msg_perr(MSGHEADER "Error: cannot read read-n data");
862 return 1;
863 }
864 return 0;
Urja Rannikkof3196df2009-07-21 13:02:59 +0000865}
866
867/* The externally called version that makes sure that max_read_n is obeyed. */
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000868static void serprog_chip_readn(const struct flashctx *flash, uint8_t * buf,
869 const chipaddr addr, size_t len)
Urja Rannikkof3196df2009-07-21 13:02:59 +0000870{
871 size_t lenm = len;
872 chipaddr addrm = addr;
Stefan Tauner31019d42011-10-22 21:45:27 +0000873 while ((sp_max_read_n != 0) && (lenm > sp_max_read_n)) {
Stefan Taunerbdead0d2013-08-24 02:10:18 +0000874 sp_do_read_n(&(buf[addrm-addr]), addrm, sp_max_read_n); // FIXME: return error
Urja Rannikkof3196df2009-07-21 13:02:59 +0000875 addrm += sp_max_read_n;
876 lenm -= sp_max_read_n;
877 }
Stefan Tauner31019d42011-10-22 21:45:27 +0000878 if (lenm)
Stefan Taunerbdead0d2013-08-24 02:10:18 +0000879 sp_do_read_n(&(buf[addrm-addr]), addrm, lenm); // FIXME: return error
Urja Rannikkof3196df2009-07-21 13:02:59 +0000880}
881
Stefan Taunerf80419c2014-05-02 15:41:42 +0000882void serprog_delay(unsigned int usecs)
Urja Rannikkof3196df2009-07-21 13:02:59 +0000883{
884 unsigned char buf[4];
Stefan Tauner31019d42011-10-22 21:45:27 +0000885 msg_pspew("%s usecs=%d\n", __func__, usecs);
Urja Rannikkoc93f5f12011-09-15 23:38:14 +0000886 if (!sp_check_commandavail(S_CMD_O_DELAY)) {
Stefan Taunerd7d423b2012-10-20 09:13:16 +0000887 msg_pdbg2("serprog_delay used, but programmer doesn't support delays natively - emulating\n");
Stefan Tauner31019d42011-10-22 21:45:27 +0000888 internal_delay(usecs);
Urja Rannikkoc93f5f12011-09-15 23:38:14 +0000889 return;
890 }
Urja Rannikkof3196df2009-07-21 13:02:59 +0000891 if ((sp_max_write_n) && (sp_write_n_bytes))
892 sp_pass_writen();
893 sp_check_opbuf_usage(5);
Stefan Tauner31019d42011-10-22 21:45:27 +0000894 buf[0] = ((usecs >> 0) & 0xFF);
895 buf[1] = ((usecs >> 8) & 0xFF);
896 buf[2] = ((usecs >> 16) & 0xFF);
897 buf[3] = ((usecs >> 24) & 0xFF);
Urja Rannikkof3196df2009-07-21 13:02:59 +0000898 sp_stream_buffer_op(S_CMD_O_DELAY, 4, buf);
899 sp_opbuf_usage += 5;
900 sp_prev_was_write = 0;
901}
Urja Rannikkoc93f5f12011-09-15 23:38:14 +0000902
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000903static int serprog_spi_send_command(struct flashctx *flash,
904 unsigned int writecnt, unsigned int readcnt,
905 const unsigned char *writearr,
906 unsigned char *readarr)
Urja Rannikkoc93f5f12011-09-15 23:38:14 +0000907{
908 unsigned char *parmbuf;
909 int ret;
910 msg_pspew("%s, writecnt=%i, readcnt=%i\n", __func__, writecnt, readcnt);
Stefan Taunerbdead0d2013-08-24 02:10:18 +0000911 if ((sp_opbuf_usage) || (sp_max_write_n && sp_write_n_bytes)) {
912 if (sp_execute_opbuf() != 0) {
913 msg_perr("Error: could not execute command buffer before sending SPI commands.\n");
914 return 1;
915 }
916 }
917
Urja Rannikkoc93f5f12011-09-15 23:38:14 +0000918 parmbuf = malloc(writecnt + 6);
Stefan Taunerbdead0d2013-08-24 02:10:18 +0000919 if (!parmbuf) {
920 msg_perr("Error: could not allocate SPI send param buffer.\n");
921 return 1;
922 }
Urja Rannikkoc93f5f12011-09-15 23:38:14 +0000923 parmbuf[0] = (writecnt >> 0) & 0xFF;
924 parmbuf[1] = (writecnt >> 8) & 0xFF;
925 parmbuf[2] = (writecnt >> 16) & 0xFF;
926 parmbuf[3] = (readcnt >> 0) & 0xFF;
927 parmbuf[4] = (readcnt >> 8) & 0xFF;
928 parmbuf[5] = (readcnt >> 16) & 0xFF;
929 memcpy(parmbuf + 6, writearr, writecnt);
930 ret = sp_docommand(S_CMD_O_SPIOP, writecnt + 6, parmbuf, readcnt,
931 readarr);
932 free(parmbuf);
933 return ret;
934}
935
936/* FIXME: This function is optimized so that it does not split each transaction
937 * into chip page_size long blocks unnecessarily like spi_read_chunked. This has
938 * the advantage that it is much faster for most chips, but breaks those with
Aidan Thorntondb4e87d2013-08-27 18:01:53 +0000939 * non-continuous reads. When spi_read_chunked is fixed this method can be removed. */
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000940static int serprog_spi_read(struct flashctx *flash, uint8_t *buf,
941 unsigned int start, unsigned int len)
Urja Rannikkoc93f5f12011-09-15 23:38:14 +0000942{
Stefan Taunerc69c9c82011-11-23 09:13:48 +0000943 unsigned int i, cur_len;
Carl-Daniel Hailfingera5bcbce2014-07-19 22:03:29 +0000944 const unsigned int max_read = spi_master_serprog.max_data_read;
Urja Rannikkoc93f5f12011-09-15 23:38:14 +0000945 for (i = 0; i < len; i += cur_len) {
946 int ret;
947 cur_len = min(max_read, (len - i));
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000948 ret = spi_nbyte_read(flash, start + i, buf + i, cur_len);
Urja Rannikkoc93f5f12011-09-15 23:38:14 +0000949 if (ret)
950 return ret;
951 }
952 return 0;
953}
Urja Rannikko0b4ffd52015-06-29 23:24:23 +0000954
955void *serprog_map(const char *descr, uintptr_t phys_addr, size_t len)
956{
957 /* Serprog transmits 24 bits only and assumes the underlying implementation handles any remaining bits
958 * correctly (usually setting them to one either in software (for FWH/LPC) or relying on the fact that
959 * the hardware observes a subset of the address bits only). Combined with the standard mapping of
960 * flashrom this creates a 16 MB-wide window just below the 4 GB boundary where serprog can operate (as
961 * needed for non-SPI chips). Below we make sure that the requested range is within this window. */
962 if ((phys_addr & 0xFF000000) == 0xFF000000) {
963 return (void*)phys_addr;
964 } else {
965 msg_pwarn(MSGHEADER "requested mapping %s is incompatible: 0x%zx bytes at 0x%0*" PRIxPTR ".\n",
966 descr, len, PRIxPTR_WIDTH, phys_addr);
967 return NULL;
968 }
969}