Urja Rannikko | 2291535 | 2009-06-23 11:33:43 +0000 | [diff] [blame] | 1 | /* |
| 2 | * This file is part of the flashrom project. |
| 3 | * |
Urja Rannikko | c93f5f1 | 2011-09-15 23:38:14 +0000 | [diff] [blame] | 4 | * Copyright (C) 2009, 2011 Urja Rannikko <urjaman@gmail.com> |
Urja Rannikko | 2291535 | 2009-06-23 11:33:43 +0000 | [diff] [blame] | 5 | * 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 | |
Carl-Daniel Hailfinger | ef58a9c | 2009-08-12 13:32:56 +0000 | [diff] [blame] | 22 | #include <stdio.h> |
Stefan Tauner | 52b6e9d | 2013-04-01 00:46:05 +0000 | [diff] [blame] | 23 | #ifndef _WIN32 /* stuff (presumably) needed for sockets only */ |
Urja Rannikko | 2291535 | 2009-06-23 11:33:43 +0000 | [diff] [blame] | 24 | #include <stdlib.h> |
Carl-Daniel Hailfinger | ef58a9c | 2009-08-12 13:32:56 +0000 | [diff] [blame] | 25 | #include <unistd.h> |
Urja Rannikko | 2291535 | 2009-06-23 11:33:43 +0000 | [diff] [blame] | 26 | #include <fcntl.h> |
Urja Rannikko | 2291535 | 2009-06-23 11:33:43 +0000 | [diff] [blame] | 27 | #include <sys/socket.h> |
| 28 | #include <arpa/inet.h> |
| 29 | #include <netinet/in.h> |
| 30 | #include <netinet/tcp.h> |
| 31 | #include <netdb.h> |
Stefan Tauner | 52b6e9d | 2013-04-01 00:46:05 +0000 | [diff] [blame] | 32 | #endif |
| 33 | #ifdef _WIN32 |
| 34 | #include <conio.h> |
| 35 | #else |
Urja Rannikko | 2291535 | 2009-06-23 11:33:43 +0000 | [diff] [blame] | 36 | #include <termios.h> |
Stefan Tauner | 52b6e9d | 2013-04-01 00:46:05 +0000 | [diff] [blame] | 37 | #endif |
| 38 | #include <string.h> |
| 39 | #include <errno.h> |
Carl-Daniel Hailfinger | 5b997c3 | 2010-07-27 22:41:39 +0000 | [diff] [blame] | 40 | #include "flash.h" |
| 41 | #include "programmer.h" |
Urja Rannikko | c93f5f1 | 2011-09-15 23:38:14 +0000 | [diff] [blame] | 42 | #include "chipdrivers.h" |
Stefan Tauner | 0d82e95 | 2012-10-27 00:34:18 +0000 | [diff] [blame] | 43 | #include "serprog.h" |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 44 | |
Stefan Tauner | 31019d4 | 2011-10-22 21:45:27 +0000 | [diff] [blame] | 45 | #define MSGHEADER "serprog: " |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 46 | |
David Hendricks | 8bb2021 | 2011-06-14 01:35:36 +0000 | [diff] [blame] | 47 | /* |
| 48 | * FIXME: This prototype was added to help reduce diffs for the shutdown |
| 49 | * registration patch, which shifted many lines of code to place |
| 50 | * serprog_shutdown() before serprog_init(). It should be removed soon. |
| 51 | */ |
| 52 | static int serprog_shutdown(void *data); |
| 53 | |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 54 | static uint16_t sp_device_serbuf_size = 16; |
| 55 | static uint16_t sp_device_opbuf_size = 300; |
| 56 | /* Bitmap of supported commands */ |
| 57 | static uint8_t sp_cmdmap[32]; |
| 58 | |
Uwe Hermann | 4e3d0b3 | 2010-03-25 23:18:41 +0000 | [diff] [blame] | 59 | /* sp_prev_was_write used to detect writes with contiguous addresses |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 60 | and combine them to write-n's */ |
| 61 | static int sp_prev_was_write = 0; |
| 62 | /* sp_write_n_addr used as the starting addr of the currently |
| 63 | combined write-n operation */ |
| 64 | static uint32_t sp_write_n_addr; |
| 65 | /* The maximum length of an write_n operation; 0 = write-n not supported */ |
| 66 | static uint32_t sp_max_write_n = 0; |
| 67 | /* The maximum length of a read_n operation; 0 = 2^24 */ |
| 68 | static uint32_t sp_max_read_n = 0; |
| 69 | |
| 70 | /* A malloc'd buffer for combining the operation's data |
| 71 | and a counter that tells how much data is there. */ |
| 72 | static uint8_t *sp_write_n_buf; |
| 73 | static uint32_t sp_write_n_bytes = 0; |
| 74 | |
| 75 | /* sp_streamed_* used for flow control checking */ |
| 76 | static int sp_streamed_transmit_ops = 0; |
| 77 | static int sp_streamed_transmit_bytes = 0; |
| 78 | |
| 79 | /* sp_opbuf_usage used for counting the amount of |
| 80 | on-device operation buffer used */ |
| 81 | static int sp_opbuf_usage = 0; |
| 82 | /* if true causes sp_docommand to automatically check |
| 83 | whether the command is supported before doing it */ |
| 84 | static int sp_check_avail_automatic = 0; |
| 85 | |
Stefan Tauner | 52b6e9d | 2013-04-01 00:46:05 +0000 | [diff] [blame] | 86 | #ifndef WIN32 |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 87 | static int sp_opensocket(char *ip, unsigned int port) |
| 88 | { |
| 89 | int flag = 1; |
| 90 | struct hostent *hostPtr = NULL; |
Carl-Daniel Hailfinger | 6d12560 | 2009-09-05 01:10:23 +0000 | [diff] [blame] | 91 | union { struct sockaddr_in si; struct sockaddr s; } sp = {}; |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 92 | int sock; |
Sean Nelson | 74e8af5 | 2010-01-10 01:06:23 +0000 | [diff] [blame] | 93 | msg_pdbg(MSGHEADER "IP %s port %d\n", ip, port); |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 94 | sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP); |
Niklas Söderlund | 2a95e87 | 2012-07-30 19:42:33 +0000 | [diff] [blame] | 95 | if (sock < 0) { |
| 96 | msg_perr("Error: serprog cannot open socket: %s\n", strerror(errno)); |
| 97 | return -1; |
| 98 | } |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 99 | hostPtr = gethostbyname(ip); |
| 100 | if (NULL == hostPtr) { |
| 101 | hostPtr = gethostbyaddr(ip, strlen(ip), AF_INET); |
Niklas Söderlund | 2a95e87 | 2012-07-30 19:42:33 +0000 | [diff] [blame] | 102 | if (NULL == hostPtr) { |
Stefan Reinauer | b879287 | 2014-04-26 16:12:03 +0000 | [diff] [blame^] | 103 | close(sock); |
Niklas Söderlund | 2a95e87 | 2012-07-30 19:42:33 +0000 | [diff] [blame] | 104 | msg_perr("Error: cannot resolve %s\n", ip); |
| 105 | return -1; |
| 106 | } |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 107 | } |
Carl-Daniel Hailfinger | 6d12560 | 2009-09-05 01:10:23 +0000 | [diff] [blame] | 108 | sp.si.sin_family = AF_INET; |
| 109 | sp.si.sin_port = htons(port); |
Carl-Daniel Hailfinger | 1c6d2ff | 2012-08-27 00:44:42 +0000 | [diff] [blame] | 110 | (void)memcpy(&sp.si.sin_addr, hostPtr->h_addr_list[0], hostPtr->h_length); |
Carl-Daniel Hailfinger | 6d12560 | 2009-09-05 01:10:23 +0000 | [diff] [blame] | 111 | if (connect(sock, &sp.s, sizeof(sp.si)) < 0) { |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 112 | close(sock); |
Niklas Söderlund | 2a95e87 | 2012-07-30 19:42:33 +0000 | [diff] [blame] | 113 | msg_perr("Error: serprog cannot connect: %s\n", strerror(errno)); |
| 114 | return -1; |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 115 | } |
| 116 | /* We are latency limited, and sometimes do write-write-read * |
| 117 | * (write-n) - so enable TCP_NODELAY. */ |
| 118 | setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, &flag, sizeof(int)); |
| 119 | return sock; |
| 120 | } |
Stefan Tauner | 52b6e9d | 2013-04-01 00:46:05 +0000 | [diff] [blame] | 121 | #endif |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 122 | |
Uwe Hermann | 4e3d0b3 | 2010-03-25 23:18:41 +0000 | [diff] [blame] | 123 | /* Synchronize: a bit tricky algorithm that tries to (and in my tests has * |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 124 | * always succeeded in) bring the serial protocol to known waiting-for- * |
Stefan Tauner | ae3d837 | 2013-04-01 00:45:45 +0000 | [diff] [blame] | 125 | * command state - uses nonblocking I/O - rest of the driver uses * |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 126 | * blocking read - TODO: add an alarm() timer for the rest of the app on * |
| 127 | * serial operations, though not such a big issue as the first thing to * |
| 128 | * do is synchronize (eg. check that device is alive). */ |
Niklas Söderlund | 7145a50 | 2012-09-07 07:07:07 +0000 | [diff] [blame] | 129 | static int sp_synchronize(void) |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 130 | { |
| 131 | int i; |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 132 | unsigned char buf[8]; |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 133 | /* First sends 8 NOPs, then flushes the return data - should cause * |
| 134 | * the device serial parser to get to a sane state, unless if it * |
| 135 | * is waiting for a real long write-n. */ |
| 136 | memset(buf, S_CMD_NOP, 8); |
Stefan Tauner | ae3d837 | 2013-04-01 00:45:45 +0000 | [diff] [blame] | 137 | if (serialport_write_nonblock(buf, 8, 1, NULL) != 0) { |
Niklas Söderlund | 7145a50 | 2012-09-07 07:07:07 +0000 | [diff] [blame] | 138 | goto err_out; |
| 139 | } |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 140 | /* A second should be enough to get all the answers to the buffer */ |
Stefan Tauner | 79587f5 | 2013-04-01 00:45:51 +0000 | [diff] [blame] | 141 | internal_delay(1000 * 1000); |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 142 | sp_flush_incoming(); |
| 143 | |
Cristian Măgherușan-Stanciu | 9932c7b | 2011-07-07 19:56:58 +0000 | [diff] [blame] | 144 | /* Then try up to 8 times to send syncnop and get the correct special * |
| 145 | * return of NAK+ACK. Timing note: up to 10 characters, 10*50ms = * |
| 146 | * up to 500ms per try, 8*0.5s = 4s; +1s (above) = up to 5s sync * |
| 147 | * attempt, ~1s if immediate success. */ |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 148 | for (i = 0; i < 8; i++) { |
| 149 | int n; |
| 150 | unsigned char c = S_CMD_SYNCNOP; |
Stefan Tauner | ae3d837 | 2013-04-01 00:45:45 +0000 | [diff] [blame] | 151 | if (serialport_write_nonblock(&c, 1, 1, NULL) != 0) { |
Niklas Söderlund | 7145a50 | 2012-09-07 07:07:07 +0000 | [diff] [blame] | 152 | goto err_out; |
| 153 | } |
Sean Nelson | 74e8af5 | 2010-01-10 01:06:23 +0000 | [diff] [blame] | 154 | msg_pdbg("."); |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 155 | fflush(stdout); |
| 156 | for (n = 0; n < 10; n++) { |
Stefan Tauner | 00e1608 | 2013-04-01 00:45:38 +0000 | [diff] [blame] | 157 | int ret = serialport_read_nonblock(&c, 1, 50, NULL); |
Niklas Söderlund | 7145a50 | 2012-09-07 07:07:07 +0000 | [diff] [blame] | 158 | if (ret < 0) |
| 159 | goto err_out; |
| 160 | if (ret > 0 || c != S_NAK) |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 161 | continue; |
Stefan Tauner | 00e1608 | 2013-04-01 00:45:38 +0000 | [diff] [blame] | 162 | ret = serialport_read_nonblock(&c, 1, 20, NULL); |
Niklas Söderlund | 7145a50 | 2012-09-07 07:07:07 +0000 | [diff] [blame] | 163 | if (ret < 0) |
| 164 | goto err_out; |
| 165 | if (ret > 0 || c != S_ACK) |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 166 | continue; |
| 167 | c = S_CMD_SYNCNOP; |
Stefan Tauner | ae3d837 | 2013-04-01 00:45:45 +0000 | [diff] [blame] | 168 | if (serialport_write_nonblock(&c, 1, 1, NULL) != 0) { |
| 169 | goto err_out; |
Niklas Söderlund | 7145a50 | 2012-09-07 07:07:07 +0000 | [diff] [blame] | 170 | } |
Stefan Tauner | 00e1608 | 2013-04-01 00:45:38 +0000 | [diff] [blame] | 171 | ret = serialport_read_nonblock(&c, 1, 500, NULL); |
Niklas Söderlund | 7145a50 | 2012-09-07 07:07:07 +0000 | [diff] [blame] | 172 | if (ret < 0) |
| 173 | goto err_out; |
| 174 | if (ret > 0 || c != S_NAK) |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 175 | break; /* fail */ |
Stefan Tauner | 00e1608 | 2013-04-01 00:45:38 +0000 | [diff] [blame] | 176 | ret = serialport_read_nonblock(&c, 1, 100, NULL); |
Niklas Söderlund | 7145a50 | 2012-09-07 07:07:07 +0000 | [diff] [blame] | 177 | if (ret > 0 || ret < 0) |
| 178 | goto err_out; |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 179 | if (c != S_ACK) |
| 180 | break; /* fail */ |
Sean Nelson | 74e8af5 | 2010-01-10 01:06:23 +0000 | [diff] [blame] | 181 | msg_pdbg("\n"); |
Niklas Söderlund | 7145a50 | 2012-09-07 07:07:07 +0000 | [diff] [blame] | 182 | return 0; |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 183 | } |
| 184 | } |
Niklas Söderlund | 7145a50 | 2012-09-07 07:07:07 +0000 | [diff] [blame] | 185 | err_out: |
| 186 | msg_perr("Error: cannot synchronize protocol - check communications and reset device?\n"); |
| 187 | return 1; |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 188 | } |
| 189 | |
| 190 | static int sp_check_commandavail(uint8_t command) |
| 191 | { |
| 192 | int byteoffs, bitoffs; |
| 193 | byteoffs = command / 8; |
| 194 | bitoffs = command % 8; |
| 195 | return (sp_cmdmap[byteoffs] & (1 << bitoffs)) ? 1 : 0; |
| 196 | } |
| 197 | |
| 198 | static int sp_automatic_cmdcheck(uint8_t cmd) |
| 199 | { |
| 200 | if ((sp_check_avail_automatic) && (sp_check_commandavail(cmd) == 0)) { |
Stefan Tauner | 31019d4 | 2011-10-22 21:45:27 +0000 | [diff] [blame] | 201 | msg_pdbg("Warning: Automatic command availability check failed " |
Stefan Tauner | e34e3e8 | 2013-01-01 00:06:51 +0000 | [diff] [blame] | 202 | "for cmd 0x%02x - won't execute cmd\n", cmd); |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 203 | return 1; |
| 204 | } |
| 205 | return 0; |
| 206 | } |
| 207 | |
| 208 | static int sp_docommand(uint8_t command, uint32_t parmlen, |
Stefan Tauner | 31019d4 | 2011-10-22 21:45:27 +0000 | [diff] [blame] | 209 | uint8_t *params, uint32_t retlen, void *retparms) |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 210 | { |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 211 | unsigned char c; |
| 212 | if (sp_automatic_cmdcheck(command)) |
| 213 | return 1; |
Stefan Tauner | 79587f5 | 2013-04-01 00:45:51 +0000 | [diff] [blame] | 214 | if (serialport_write(&command, 1) != 0) { |
Niklas Söderlund | 2a95e87 | 2012-07-30 19:42:33 +0000 | [diff] [blame] | 215 | msg_perr("Error: cannot write op code: %s\n", strerror(errno)); |
| 216 | return 1; |
| 217 | } |
Stefan Tauner | 79587f5 | 2013-04-01 00:45:51 +0000 | [diff] [blame] | 218 | if (serialport_write(params, parmlen) != 0) { |
Niklas Söderlund | 2a95e87 | 2012-07-30 19:42:33 +0000 | [diff] [blame] | 219 | msg_perr("Error: cannot write parameters: %s\n", strerror(errno)); |
| 220 | return 1; |
| 221 | } |
Stefan Tauner | 79587f5 | 2013-04-01 00:45:51 +0000 | [diff] [blame] | 222 | if (serialport_read(&c, 1) != 0) { |
Niklas Söderlund | 2a95e87 | 2012-07-30 19:42:33 +0000 | [diff] [blame] | 223 | msg_perr("Error: cannot read from device: %s\n", strerror(errno)); |
| 224 | return 1; |
| 225 | } |
Stefan Tauner | 31019d4 | 2011-10-22 21:45:27 +0000 | [diff] [blame] | 226 | if (c == S_NAK) |
| 227 | return 1; |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 228 | if (c != S_ACK) { |
Niklas Söderlund | 2a95e87 | 2012-07-30 19:42:33 +0000 | [diff] [blame] | 229 | msg_perr("Error: invalid response 0x%02X from device\n", c); |
| 230 | return 1; |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 231 | } |
| 232 | if (retlen) { |
Stefan Tauner | 79587f5 | 2013-04-01 00:45:51 +0000 | [diff] [blame] | 233 | if (serialport_read(retparms, retlen) != 0) { |
| 234 | msg_perr("Error: cannot read return parameters: %s\n", strerror(errno)); |
| 235 | return 1; |
| 236 | } |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 237 | } |
| 238 | return 0; |
| 239 | } |
| 240 | |
Stefan Tauner | bdead0d | 2013-08-24 02:10:18 +0000 | [diff] [blame] | 241 | static int sp_flush_stream(void) |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 242 | { |
| 243 | if (sp_streamed_transmit_ops) |
| 244 | do { |
| 245 | unsigned char c; |
Stefan Tauner | 79587f5 | 2013-04-01 00:45:51 +0000 | [diff] [blame] | 246 | if (serialport_read(&c, 1) != 0) { |
Stefan Tauner | bdead0d | 2013-08-24 02:10:18 +0000 | [diff] [blame] | 247 | msg_perr("Error: cannot read from device (flushing stream)"); |
| 248 | return 1; |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 249 | } |
| 250 | if (c == S_NAK) { |
Sean Nelson | 74e8af5 | 2010-01-10 01:06:23 +0000 | [diff] [blame] | 251 | msg_perr("Error: NAK to a stream buffer operation\n"); |
Stefan Tauner | bdead0d | 2013-08-24 02:10:18 +0000 | [diff] [blame] | 252 | return 1; |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 253 | } |
| 254 | if (c != S_ACK) { |
Sean Nelson | 74e8af5 | 2010-01-10 01:06:23 +0000 | [diff] [blame] | 255 | msg_perr("Error: Invalid reply 0x%02X from device\n", c); |
Stefan Tauner | bdead0d | 2013-08-24 02:10:18 +0000 | [diff] [blame] | 256 | return 1; |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 257 | } |
| 258 | } while (--sp_streamed_transmit_ops); |
| 259 | sp_streamed_transmit_ops = 0; |
| 260 | sp_streamed_transmit_bytes = 0; |
Stefan Tauner | bdead0d | 2013-08-24 02:10:18 +0000 | [diff] [blame] | 261 | return 0; |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 262 | } |
| 263 | |
Stefan Tauner | bdead0d | 2013-08-24 02:10:18 +0000 | [diff] [blame] | 264 | static int sp_stream_buffer_op(uint8_t cmd, uint32_t parmlen, uint8_t *parms) |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 265 | { |
| 266 | uint8_t *sp; |
| 267 | if (sp_automatic_cmdcheck(cmd)) |
| 268 | return 1; |
Stefan Tauner | bdead0d | 2013-08-24 02:10:18 +0000 | [diff] [blame] | 269 | |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 270 | sp = malloc(1 + parmlen); |
Stefan Tauner | bdead0d | 2013-08-24 02:10:18 +0000 | [diff] [blame] | 271 | if (!sp) { |
| 272 | msg_perr("Error: cannot malloc command buffer\n"); |
| 273 | return 1; |
| 274 | } |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 275 | sp[0] = cmd; |
| 276 | memcpy(&(sp[1]), parms, parmlen); |
Stefan Tauner | bdead0d | 2013-08-24 02:10:18 +0000 | [diff] [blame] | 277 | |
| 278 | if (sp_streamed_transmit_bytes >= (1 + parmlen + sp_device_serbuf_size)) { |
| 279 | if (sp_flush_stream() != 0) { |
| 280 | free(sp); |
| 281 | return 1; |
| 282 | } |
| 283 | } |
| 284 | if (serialport_write(sp, 1 + parmlen) != 0) { |
| 285 | msg_perr("Error: cannot write command\n"); |
| 286 | free(sp); |
| 287 | return 1; |
| 288 | } |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 289 | sp_streamed_transmit_ops += 1; |
| 290 | sp_streamed_transmit_bytes += 1 + parmlen; |
Stefan Tauner | bdead0d | 2013-08-24 02:10:18 +0000 | [diff] [blame] | 291 | |
| 292 | free(sp); |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 293 | return 0; |
| 294 | } |
| 295 | |
Carl-Daniel Hailfinger | 8a3c60c | 2011-12-18 15:01:24 +0000 | [diff] [blame] | 296 | static int serprog_spi_send_command(struct flashctx *flash, |
| 297 | unsigned int writecnt, unsigned int readcnt, |
Carl-Daniel Hailfinger | eaacd2d | 2011-11-09 23:40:00 +0000 | [diff] [blame] | 298 | const unsigned char *writearr, |
| 299 | unsigned char *readarr); |
Carl-Daniel Hailfinger | 63fd902 | 2011-12-14 22:25:15 +0000 | [diff] [blame] | 300 | static int serprog_spi_read(struct flashctx *flash, uint8_t *buf, |
Stefan Tauner | c69c9c8 | 2011-11-23 09:13:48 +0000 | [diff] [blame] | 301 | unsigned int start, unsigned int len); |
Urja Rannikko | c93f5f1 | 2011-09-15 23:38:14 +0000 | [diff] [blame] | 302 | static struct spi_programmer spi_programmer_serprog = { |
| 303 | .type = SPI_CONTROLLER_SERPROG, |
| 304 | .max_data_read = MAX_DATA_READ_UNLIMITED, |
| 305 | .max_data_write = MAX_DATA_WRITE_UNLIMITED, |
| 306 | .command = serprog_spi_send_command, |
| 307 | .multicommand = default_spi_send_multicommand, |
| 308 | .read = serprog_spi_read, |
| 309 | .write_256 = default_spi_write_256, |
Nico Huber | 7bca126 | 2012-06-15 22:28:12 +0000 | [diff] [blame] | 310 | .write_aai = default_spi_write_aai, |
Urja Rannikko | c93f5f1 | 2011-09-15 23:38:14 +0000 | [diff] [blame] | 311 | }; |
| 312 | |
Carl-Daniel Hailfinger | 8a3c60c | 2011-12-18 15:01:24 +0000 | [diff] [blame] | 313 | static void serprog_chip_writeb(const struct flashctx *flash, uint8_t val, |
| 314 | chipaddr addr); |
| 315 | static uint8_t serprog_chip_readb(const struct flashctx *flash, |
| 316 | const chipaddr addr); |
| 317 | static void serprog_chip_readn(const struct flashctx *flash, uint8_t *buf, |
| 318 | const chipaddr addr, size_t len); |
Carl-Daniel Hailfinger | eaacd2d | 2011-11-09 23:40:00 +0000 | [diff] [blame] | 319 | static const struct par_programmer par_programmer_serprog = { |
| 320 | .chip_readb = serprog_chip_readb, |
| 321 | .chip_readw = fallback_chip_readw, |
| 322 | .chip_readl = fallback_chip_readl, |
| 323 | .chip_readn = serprog_chip_readn, |
| 324 | .chip_writeb = serprog_chip_writeb, |
| 325 | .chip_writew = fallback_chip_writew, |
| 326 | .chip_writel = fallback_chip_writel, |
| 327 | .chip_writen = fallback_chip_writen, |
| 328 | }; |
| 329 | |
| 330 | static enum chipbustype serprog_buses_supported = BUS_NONE; |
| 331 | |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 332 | int serprog_init(void) |
| 333 | { |
| 334 | uint16_t iface; |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 335 | unsigned char pgmname[17]; |
| 336 | unsigned char rbuf[3]; |
| 337 | unsigned char c; |
Carl-Daniel Hailfinger | 744132a | 2010-07-06 09:55:48 +0000 | [diff] [blame] | 338 | char *device; |
| 339 | char *baudport; |
| 340 | int have_device = 0; |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 341 | |
Carl-Daniel Hailfinger | 744132a | 2010-07-06 09:55:48 +0000 | [diff] [blame] | 342 | /* the parameter is either of format "dev=/dev/device:baud" or "ip=ip:port" */ |
Carl-Daniel Hailfinger | 2b6dcb3 | 2010-07-08 10:13:37 +0000 | [diff] [blame] | 343 | device = extract_programmer_param("dev"); |
Carl-Daniel Hailfinger | 744132a | 2010-07-06 09:55:48 +0000 | [diff] [blame] | 344 | if (device && strlen(device)) { |
| 345 | baudport = strstr(device, ":"); |
| 346 | if (baudport) { |
| 347 | /* Split device from baudrate. */ |
| 348 | *baudport = '\0'; |
| 349 | baudport++; |
| 350 | } |
| 351 | if (!baudport || !strlen(baudport)) { |
| 352 | msg_perr("Error: No baudrate specified.\n" |
| 353 | "Use flashrom -p serprog:dev=/dev/device:baud\n"); |
| 354 | free(device); |
Urja Rannikko | c93f5f1 | 2011-09-15 23:38:14 +0000 | [diff] [blame] | 355 | return 1; |
Carl-Daniel Hailfinger | 744132a | 2010-07-06 09:55:48 +0000 | [diff] [blame] | 356 | } |
| 357 | if (strlen(device)) { |
| 358 | sp_fd = sp_openserport(device, atoi(baudport)); |
Stefan Tauner | acfc4c6 | 2012-11-30 16:46:45 +0000 | [diff] [blame] | 359 | if (sp_fd == SER_INV_FD) { |
Niklas Söderlund | 2a95e87 | 2012-07-30 19:42:33 +0000 | [diff] [blame] | 360 | free(device); |
| 361 | return 1; |
| 362 | } |
Carl-Daniel Hailfinger | 744132a | 2010-07-06 09:55:48 +0000 | [diff] [blame] | 363 | have_device++; |
| 364 | } |
| 365 | } |
| 366 | if (device && !strlen(device)) { |
| 367 | msg_perr("Error: No device specified.\n" |
| 368 | "Use flashrom -p serprog:dev=/dev/device:baud\n"); |
| 369 | free(device); |
| 370 | return 1; |
| 371 | } |
| 372 | free(device); |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 373 | |
Stefan Tauner | 52b6e9d | 2013-04-01 00:46:05 +0000 | [diff] [blame] | 374 | #ifndef _WIN32 |
Carl-Daniel Hailfinger | 2b6dcb3 | 2010-07-08 10:13:37 +0000 | [diff] [blame] | 375 | device = extract_programmer_param("ip"); |
Carl-Daniel Hailfinger | 744132a | 2010-07-06 09:55:48 +0000 | [diff] [blame] | 376 | if (have_device && device) { |
| 377 | msg_perr("Error: Both host and device specified.\n" |
| 378 | "Please use either dev= or ip= but not both.\n"); |
| 379 | free(device); |
| 380 | return 1; |
| 381 | } |
| 382 | if (device && strlen(device)) { |
| 383 | baudport = strstr(device, ":"); |
| 384 | if (baudport) { |
| 385 | /* Split host from port. */ |
| 386 | *baudport = '\0'; |
| 387 | baudport++; |
| 388 | } |
| 389 | if (!baudport || !strlen(baudport)) { |
| 390 | msg_perr("Error: No port specified.\n" |
| 391 | "Use flashrom -p serprog:ip=ipaddr:port\n"); |
| 392 | free(device); |
Urja Rannikko | c93f5f1 | 2011-09-15 23:38:14 +0000 | [diff] [blame] | 393 | return 1; |
Carl-Daniel Hailfinger | 744132a | 2010-07-06 09:55:48 +0000 | [diff] [blame] | 394 | } |
| 395 | if (strlen(device)) { |
| 396 | sp_fd = sp_opensocket(device, atoi(baudport)); |
Niklas Söderlund | 2a95e87 | 2012-07-30 19:42:33 +0000 | [diff] [blame] | 397 | if (sp_fd < 0) { |
| 398 | free(device); |
| 399 | return 1; |
| 400 | } |
Carl-Daniel Hailfinger | 744132a | 2010-07-06 09:55:48 +0000 | [diff] [blame] | 401 | have_device++; |
| 402 | } |
| 403 | } |
| 404 | if (device && !strlen(device)) { |
| 405 | msg_perr("Error: No host specified.\n" |
| 406 | "Use flashrom -p serprog:ip=ipaddr:port\n"); |
| 407 | free(device); |
| 408 | return 1; |
| 409 | } |
| 410 | free(device); |
| 411 | |
| 412 | if (!have_device) { |
| 413 | msg_perr("Error: Neither host nor device specified.\n" |
| 414 | "Use flashrom -p serprog:dev=/dev/device:baud or " |
| 415 | "flashrom -p serprog:ip=ipaddr:port\n"); |
| 416 | return 1; |
| 417 | } |
Stefan Tauner | 52b6e9d | 2013-04-01 00:46:05 +0000 | [diff] [blame] | 418 | #endif |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 419 | |
David Hendricks | 8bb2021 | 2011-06-14 01:35:36 +0000 | [diff] [blame] | 420 | if (register_shutdown(serprog_shutdown, NULL)) |
| 421 | return 1; |
| 422 | |
Sean Nelson | 74e8af5 | 2010-01-10 01:06:23 +0000 | [diff] [blame] | 423 | msg_pdbg(MSGHEADER "connected - attempting to synchronize\n"); |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 424 | |
| 425 | sp_check_avail_automatic = 0; |
| 426 | |
Niklas Söderlund | 7145a50 | 2012-09-07 07:07:07 +0000 | [diff] [blame] | 427 | if (sp_synchronize()) |
| 428 | return 1; |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 429 | |
Sean Nelson | 74e8af5 | 2010-01-10 01:06:23 +0000 | [diff] [blame] | 430 | msg_pdbg(MSGHEADER "Synchronized\n"); |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 431 | |
| 432 | if (sp_docommand(S_CMD_Q_IFACE, 0, NULL, 2, &iface)) { |
Stefan Tauner | 31019d4 | 2011-10-22 21:45:27 +0000 | [diff] [blame] | 433 | msg_perr("Error: NAK to query interface version\n"); |
Carl-Daniel Hailfinger | eaacd2d | 2011-11-09 23:40:00 +0000 | [diff] [blame] | 434 | return 1; |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 435 | } |
| 436 | |
| 437 | if (iface != 1) { |
Stefan Tauner | 31019d4 | 2011-10-22 21:45:27 +0000 | [diff] [blame] | 438 | msg_perr("Error: Unknown interface version: %d\n", iface); |
Carl-Daniel Hailfinger | eaacd2d | 2011-11-09 23:40:00 +0000 | [diff] [blame] | 439 | return 1; |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 440 | } |
| 441 | |
Sean Nelson | 74e8af5 | 2010-01-10 01:06:23 +0000 | [diff] [blame] | 442 | msg_pdbg(MSGHEADER "Interface version ok.\n"); |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 443 | |
| 444 | if (sp_docommand(S_CMD_Q_CMDMAP, 0, NULL, 32, sp_cmdmap)) { |
Sean Nelson | 74e8af5 | 2010-01-10 01:06:23 +0000 | [diff] [blame] | 445 | msg_perr("Error: query command map not supported\n"); |
Carl-Daniel Hailfinger | eaacd2d | 2011-11-09 23:40:00 +0000 | [diff] [blame] | 446 | return 1; |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 447 | } |
| 448 | |
| 449 | sp_check_avail_automatic = 1; |
| 450 | |
Carl-Daniel Hailfinger | eaacd2d | 2011-11-09 23:40:00 +0000 | [diff] [blame] | 451 | /* FIXME: This assumes that serprog device bustypes are always |
| 452 | * identical with flashrom bustype enums and that they all fit |
| 453 | * in a single byte. |
| 454 | */ |
Urja Rannikko | c93f5f1 | 2011-09-15 23:38:14 +0000 | [diff] [blame] | 455 | if (sp_docommand(S_CMD_Q_BUSTYPE, 0, NULL, 1, &c)) { |
Stefan Tauner | c6fa32d | 2013-01-04 22:54:07 +0000 | [diff] [blame] | 456 | msg_pwarn("Warning: NAK to query supported buses\n"); |
Urja Rannikko | c93f5f1 | 2011-09-15 23:38:14 +0000 | [diff] [blame] | 457 | c = BUS_NONSPI; /* A reasonable default for now. */ |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 458 | } |
Carl-Daniel Hailfinger | eaacd2d | 2011-11-09 23:40:00 +0000 | [diff] [blame] | 459 | serprog_buses_supported = c; |
| 460 | |
Stefan Tauner | 31019d4 | 2011-10-22 21:45:27 +0000 | [diff] [blame] | 461 | msg_pdbg(MSGHEADER "Bus support: parallel=%s, LPC=%s, FWH=%s, SPI=%s\n", |
| 462 | (c & BUS_PARALLEL) ? "on" : "off", |
| 463 | (c & BUS_LPC) ? "on" : "off", |
| 464 | (c & BUS_FWH) ? "on" : "off", |
| 465 | (c & BUS_SPI) ? "on" : "off"); |
Urja Rannikko | c93f5f1 | 2011-09-15 23:38:14 +0000 | [diff] [blame] | 466 | /* Check for the minimum operational set of commands. */ |
Carl-Daniel Hailfinger | eaacd2d | 2011-11-09 23:40:00 +0000 | [diff] [blame] | 467 | if (serprog_buses_supported & BUS_SPI) { |
Urja Rannikko | c93f5f1 | 2011-09-15 23:38:14 +0000 | [diff] [blame] | 468 | uint8_t bt = BUS_SPI; |
Stefan Tauner | b98f6eb | 2012-08-13 16:33:04 +0000 | [diff] [blame] | 469 | char *spispeed; |
Urja Rannikko | c93f5f1 | 2011-09-15 23:38:14 +0000 | [diff] [blame] | 470 | if (sp_check_commandavail(S_CMD_O_SPIOP) == 0) { |
| 471 | msg_perr("Error: SPI operation not supported while the " |
| 472 | "bustype is SPI\n"); |
Carl-Daniel Hailfinger | eaacd2d | 2011-11-09 23:40:00 +0000 | [diff] [blame] | 473 | return 1; |
Urja Rannikko | c93f5f1 | 2011-09-15 23:38:14 +0000 | [diff] [blame] | 474 | } |
Niklas Söderlund | 2a95e87 | 2012-07-30 19:42:33 +0000 | [diff] [blame] | 475 | if (sp_docommand(S_CMD_S_BUSTYPE, 1, &bt, 0, NULL)) |
| 476 | return 1; |
Urja Rannikko | c93f5f1 | 2011-09-15 23:38:14 +0000 | [diff] [blame] | 477 | /* Success of any of these commands is optional. We don't need |
| 478 | the programmer to tell us its limits, but if it doesn't, we |
| 479 | will assume stuff, so it's in the programmers best interest |
| 480 | to tell us. */ |
Urja Rannikko | c93f5f1 | 2011-09-15 23:38:14 +0000 | [diff] [blame] | 481 | if (!sp_docommand(S_CMD_Q_WRNMAXLEN, 0, NULL, 3, rbuf)) { |
| 482 | uint32_t v; |
| 483 | v = ((unsigned int)(rbuf[0]) << 0); |
| 484 | v |= ((unsigned int)(rbuf[1]) << 8); |
| 485 | v |= ((unsigned int)(rbuf[2]) << 16); |
| 486 | if (v == 0) |
| 487 | v = (1 << 24) - 1; /* SPI-op maximum. */ |
| 488 | spi_programmer_serprog.max_data_write = v; |
| 489 | msg_pdbg(MSGHEADER "Maximum write-n length is %d\n", v); |
| 490 | } |
| 491 | if (!sp_docommand(S_CMD_Q_RDNMAXLEN, 0, NULL, 3, rbuf)) { |
| 492 | uint32_t v; |
| 493 | v = ((unsigned int)(rbuf[0]) << 0); |
| 494 | v |= ((unsigned int)(rbuf[1]) << 8); |
| 495 | v |= ((unsigned int)(rbuf[2]) << 16); |
| 496 | if (v == 0) |
| 497 | v = (1 << 24) - 1; /* SPI-op maximum. */ |
| 498 | spi_programmer_serprog.max_data_read = v; |
| 499 | msg_pdbg(MSGHEADER "Maximum read-n length is %d\n", v); |
| 500 | } |
Stefan Tauner | b98f6eb | 2012-08-13 16:33:04 +0000 | [diff] [blame] | 501 | spispeed = extract_programmer_param("spispeed"); |
| 502 | if (spispeed && strlen(spispeed)) { |
| 503 | uint32_t f_spi_req, f_spi; |
| 504 | uint8_t buf[4]; |
| 505 | char *f_spi_suffix; |
| 506 | |
| 507 | errno = 0; |
| 508 | f_spi_req = strtol(spispeed, &f_spi_suffix, 0); |
| 509 | if (errno != 0 || spispeed == f_spi_suffix) { |
| 510 | msg_perr("Error: Could not convert 'spispeed'.\n"); |
Stefan Tauner | e34e3e8 | 2013-01-01 00:06:51 +0000 | [diff] [blame] | 511 | free(spispeed); |
Stefan Tauner | b98f6eb | 2012-08-13 16:33:04 +0000 | [diff] [blame] | 512 | return 1; |
| 513 | } |
| 514 | if (strlen(f_spi_suffix) == 1) { |
| 515 | if (!strcasecmp(f_spi_suffix, "M")) |
| 516 | f_spi_req *= 1000000; |
| 517 | else if (!strcasecmp(f_spi_suffix, "k")) |
| 518 | f_spi_req *= 1000; |
| 519 | else { |
| 520 | msg_perr("Error: Garbage following 'spispeed' value.\n"); |
Stefan Tauner | e34e3e8 | 2013-01-01 00:06:51 +0000 | [diff] [blame] | 521 | free(spispeed); |
Stefan Tauner | b98f6eb | 2012-08-13 16:33:04 +0000 | [diff] [blame] | 522 | return 1; |
| 523 | } |
| 524 | } else if (strlen(f_spi_suffix) > 1) { |
| 525 | msg_perr("Error: Garbage following 'spispeed' value.\n"); |
Stefan Tauner | e34e3e8 | 2013-01-01 00:06:51 +0000 | [diff] [blame] | 526 | free(spispeed); |
Stefan Tauner | b98f6eb | 2012-08-13 16:33:04 +0000 | [diff] [blame] | 527 | return 1; |
| 528 | } |
| 529 | |
| 530 | buf[0] = (f_spi_req >> (0 * 8)) & 0xFF; |
| 531 | buf[1] = (f_spi_req >> (1 * 8)) & 0xFF; |
| 532 | buf[2] = (f_spi_req >> (2 * 8)) & 0xFF; |
| 533 | buf[3] = (f_spi_req >> (3 * 8)) & 0xFF; |
| 534 | |
| 535 | if (sp_check_commandavail(S_CMD_S_SPI_FREQ) == 0) |
Stefan Tauner | c6fa32d | 2013-01-04 22:54:07 +0000 | [diff] [blame] | 536 | msg_pwarn(MSGHEADER "Warning: Setting the SPI clock rate is not supported!\n"); |
| 537 | else if (sp_docommand(S_CMD_S_SPI_FREQ, 4, buf, 4, buf) == 0) { |
Stefan Tauner | b98f6eb | 2012-08-13 16:33:04 +0000 | [diff] [blame] | 538 | f_spi = buf[0]; |
| 539 | f_spi |= buf[1] << (1 * 8); |
| 540 | f_spi |= buf[2] << (2 * 8); |
| 541 | f_spi |= buf[3] << (3 * 8); |
| 542 | msg_pdbg(MSGHEADER "Requested to set SPI clock frequency to %u Hz. " |
| 543 | "It was actually set to %u Hz\n", f_spi_req, f_spi); |
| 544 | } else |
Stefan Tauner | c6fa32d | 2013-01-04 22:54:07 +0000 | [diff] [blame] | 545 | msg_pwarn(MSGHEADER "Setting SPI clock rate to %u Hz failed!\n", f_spi_req); |
Stefan Tauner | b98f6eb | 2012-08-13 16:33:04 +0000 | [diff] [blame] | 546 | } |
| 547 | free(spispeed); |
Carl-Daniel Hailfinger | eaacd2d | 2011-11-09 23:40:00 +0000 | [diff] [blame] | 548 | bt = serprog_buses_supported; |
Niklas Söderlund | 2a95e87 | 2012-07-30 19:42:33 +0000 | [diff] [blame] | 549 | if (sp_docommand(S_CMD_S_BUSTYPE, 1, &bt, 0, NULL)) |
| 550 | return 1; |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 551 | } |
Urja Rannikko | c93f5f1 | 2011-09-15 23:38:14 +0000 | [diff] [blame] | 552 | |
Carl-Daniel Hailfinger | eaacd2d | 2011-11-09 23:40:00 +0000 | [diff] [blame] | 553 | if (serprog_buses_supported & BUS_NONSPI) { |
Urja Rannikko | c93f5f1 | 2011-09-15 23:38:14 +0000 | [diff] [blame] | 554 | if (sp_check_commandavail(S_CMD_O_INIT) == 0) { |
| 555 | msg_perr("Error: Initialize operation buffer " |
| 556 | "not supported\n"); |
Carl-Daniel Hailfinger | eaacd2d | 2011-11-09 23:40:00 +0000 | [diff] [blame] | 557 | return 1; |
Urja Rannikko | c93f5f1 | 2011-09-15 23:38:14 +0000 | [diff] [blame] | 558 | } |
| 559 | |
| 560 | if (sp_check_commandavail(S_CMD_O_DELAY) == 0) { |
| 561 | msg_perr("Error: Write to opbuf: " |
| 562 | "delay not supported\n"); |
Carl-Daniel Hailfinger | eaacd2d | 2011-11-09 23:40:00 +0000 | [diff] [blame] | 563 | return 1; |
Urja Rannikko | c93f5f1 | 2011-09-15 23:38:14 +0000 | [diff] [blame] | 564 | } |
| 565 | |
| 566 | /* S_CMD_O_EXEC availability checked later. */ |
| 567 | |
| 568 | if (sp_check_commandavail(S_CMD_R_BYTE) == 0) { |
| 569 | msg_perr("Error: Single byte read not supported\n"); |
Carl-Daniel Hailfinger | eaacd2d | 2011-11-09 23:40:00 +0000 | [diff] [blame] | 570 | return 1; |
Urja Rannikko | c93f5f1 | 2011-09-15 23:38:14 +0000 | [diff] [blame] | 571 | } |
| 572 | /* This could be translated to single byte reads (if missing), |
| 573 | * but now we don't support that. */ |
| 574 | if (sp_check_commandavail(S_CMD_R_NBYTES) == 0) { |
| 575 | msg_perr("Error: Read n bytes not supported\n"); |
Carl-Daniel Hailfinger | eaacd2d | 2011-11-09 23:40:00 +0000 | [diff] [blame] | 576 | return 1; |
Urja Rannikko | c93f5f1 | 2011-09-15 23:38:14 +0000 | [diff] [blame] | 577 | } |
| 578 | if (sp_check_commandavail(S_CMD_O_WRITEB) == 0) { |
| 579 | msg_perr("Error: Write to opbuf: " |
| 580 | "write byte not supported\n"); |
Carl-Daniel Hailfinger | eaacd2d | 2011-11-09 23:40:00 +0000 | [diff] [blame] | 581 | return 1; |
Urja Rannikko | c93f5f1 | 2011-09-15 23:38:14 +0000 | [diff] [blame] | 582 | } |
| 583 | |
| 584 | if (sp_docommand(S_CMD_Q_WRNMAXLEN, 0, NULL, 3, rbuf)) { |
| 585 | msg_pdbg(MSGHEADER "Write-n not supported"); |
| 586 | sp_max_write_n = 0; |
| 587 | } else { |
| 588 | sp_max_write_n = ((unsigned int)(rbuf[0]) << 0); |
| 589 | sp_max_write_n |= ((unsigned int)(rbuf[1]) << 8); |
| 590 | sp_max_write_n |= ((unsigned int)(rbuf[2]) << 16); |
| 591 | if (!sp_max_write_n) { |
| 592 | sp_max_write_n = (1 << 24); |
| 593 | } |
| 594 | msg_pdbg(MSGHEADER "Maximum write-n length is %d\n", |
| 595 | sp_max_write_n); |
| 596 | sp_write_n_buf = malloc(sp_max_write_n); |
| 597 | if (!sp_write_n_buf) { |
| 598 | msg_perr("Error: cannot allocate memory for " |
| 599 | "Write-n buffer\n"); |
Carl-Daniel Hailfinger | eaacd2d | 2011-11-09 23:40:00 +0000 | [diff] [blame] | 600 | return 1; |
Urja Rannikko | c93f5f1 | 2011-09-15 23:38:14 +0000 | [diff] [blame] | 601 | } |
| 602 | sp_write_n_bytes = 0; |
| 603 | } |
| 604 | |
| 605 | if (sp_check_commandavail(S_CMD_Q_RDNMAXLEN) && |
| 606 | (sp_docommand(S_CMD_Q_RDNMAXLEN, 0, NULL, 3, rbuf) == 0)) { |
| 607 | sp_max_read_n = ((unsigned int)(rbuf[0]) << 0); |
| 608 | sp_max_read_n |= ((unsigned int)(rbuf[1]) << 8); |
| 609 | sp_max_read_n |= ((unsigned int)(rbuf[2]) << 16); |
| 610 | msg_pdbg(MSGHEADER "Maximum read-n length is %d\n", |
| 611 | sp_max_read_n ? sp_max_read_n : (1 << 24)); |
| 612 | } else { |
| 613 | msg_pdbg(MSGHEADER "Maximum read-n length " |
| 614 | "not reported\n"); |
| 615 | sp_max_read_n = 0; |
| 616 | } |
| 617 | |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 618 | } |
| 619 | |
| 620 | if (sp_docommand(S_CMD_Q_PGMNAME, 0, NULL, 16, pgmname)) { |
Stefan Tauner | c6fa32d | 2013-01-04 22:54:07 +0000 | [diff] [blame] | 621 | msg_pwarn("Warning: NAK to query programmer name\n"); |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 622 | strcpy((char *)pgmname, "(unknown)"); |
| 623 | } |
| 624 | pgmname[16] = 0; |
Stefan Tauner | 31019d4 | 2011-10-22 21:45:27 +0000 | [diff] [blame] | 625 | msg_pinfo(MSGHEADER "Programmer name is \"%s\"\n", pgmname); |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 626 | |
| 627 | if (sp_docommand(S_CMD_Q_SERBUF, 0, NULL, 2, &sp_device_serbuf_size)) { |
Stefan Tauner | c6fa32d | 2013-01-04 22:54:07 +0000 | [diff] [blame] | 628 | msg_pwarn("Warning: NAK to query serial buffer size\n"); |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 629 | } |
Stefan Tauner | 31019d4 | 2011-10-22 21:45:27 +0000 | [diff] [blame] | 630 | msg_pdbg(MSGHEADER "Serial buffer size is %d\n", |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 631 | sp_device_serbuf_size); |
| 632 | |
Urja Rannikko | c93f5f1 | 2011-09-15 23:38:14 +0000 | [diff] [blame] | 633 | if (sp_check_commandavail(S_CMD_O_INIT)) { |
| 634 | /* This would be inconsistent. */ |
| 635 | if (sp_check_commandavail(S_CMD_O_EXEC) == 0) { |
| 636 | msg_perr("Error: Execute operation buffer not " |
| 637 | "supported\n"); |
Carl-Daniel Hailfinger | eaacd2d | 2011-11-09 23:40:00 +0000 | [diff] [blame] | 638 | return 1; |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 639 | } |
Urja Rannikko | c93f5f1 | 2011-09-15 23:38:14 +0000 | [diff] [blame] | 640 | |
| 641 | if (sp_docommand(S_CMD_O_INIT, 0, NULL, 0, NULL)) { |
| 642 | msg_perr("Error: NAK to initialize operation buffer\n"); |
Carl-Daniel Hailfinger | eaacd2d | 2011-11-09 23:40:00 +0000 | [diff] [blame] | 643 | return 1; |
Urja Rannikko | c93f5f1 | 2011-09-15 23:38:14 +0000 | [diff] [blame] | 644 | } |
| 645 | |
| 646 | if (sp_docommand(S_CMD_Q_OPBUF, 0, NULL, 2, |
| 647 | &sp_device_opbuf_size)) { |
Stefan Tauner | c6fa32d | 2013-01-04 22:54:07 +0000 | [diff] [blame] | 648 | msg_pwarn("Warning: NAK to query operation buffer size\n"); |
Urja Rannikko | c93f5f1 | 2011-09-15 23:38:14 +0000 | [diff] [blame] | 649 | } |
Stefan Tauner | 31019d4 | 2011-10-22 21:45:27 +0000 | [diff] [blame] | 650 | msg_pdbg(MSGHEADER "operation buffer size is %d\n", |
Urja Rannikko | c93f5f1 | 2011-09-15 23:38:14 +0000 | [diff] [blame] | 651 | sp_device_opbuf_size); |
| 652 | } |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 653 | |
Stefan Tauner | 92fefc9 | 2012-10-27 00:34:23 +0000 | [diff] [blame] | 654 | if (sp_check_commandavail(S_CMD_S_PIN_STATE)) { |
| 655 | uint8_t en = 1; |
| 656 | if (sp_docommand(S_CMD_S_PIN_STATE, 1, &en, 0, NULL) != 0) { |
| 657 | msg_perr("Error: could not enable output buffers\n"); |
| 658 | return 1; |
| 659 | } else |
| 660 | msg_pdbg(MSGHEADER "Output drivers enabled\n"); |
| 661 | } else |
| 662 | msg_pdbg(MSGHEADER "Warning: Programmer does not support toggling its output drivers\n"); |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 663 | sp_prev_was_write = 0; |
| 664 | sp_streamed_transmit_ops = 0; |
| 665 | sp_streamed_transmit_bytes = 0; |
| 666 | sp_opbuf_usage = 0; |
Carl-Daniel Hailfinger | eaacd2d | 2011-11-09 23:40:00 +0000 | [diff] [blame] | 667 | if (serprog_buses_supported & BUS_SPI) |
| 668 | register_spi_programmer(&spi_programmer_serprog); |
| 669 | if (serprog_buses_supported & BUS_NONSPI) |
| 670 | register_par_programmer(&par_programmer_serprog, |
| 671 | serprog_buses_supported & BUS_NONSPI); |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 672 | return 0; |
| 673 | } |
| 674 | |
Stefan Tauner | bdead0d | 2013-08-24 02:10:18 +0000 | [diff] [blame] | 675 | /* Move an in flashrom buffer existing write-n operation to the on-device operation buffer. */ |
| 676 | static int sp_pass_writen(void) |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 677 | { |
| 678 | unsigned char header[7]; |
Stefan Tauner | bdead0d | 2013-08-24 02:10:18 +0000 | [diff] [blame] | 679 | msg_pspew(MSGHEADER "Passing write-n bytes=%d addr=0x%x\n", sp_write_n_bytes, sp_write_n_addr); |
| 680 | if (sp_streamed_transmit_bytes >= (7 + sp_write_n_bytes + sp_device_serbuf_size)) { |
| 681 | if (sp_flush_stream() != 0) { |
| 682 | return 1; |
| 683 | } |
| 684 | } |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 685 | /* In case it's just a single byte send it as a single write. */ |
| 686 | if (sp_write_n_bytes == 1) { |
| 687 | sp_write_n_bytes = 0; |
| 688 | header[0] = (sp_write_n_addr >> 0) & 0xFF; |
| 689 | header[1] = (sp_write_n_addr >> 8) & 0xFF; |
| 690 | header[2] = (sp_write_n_addr >> 16) & 0xFF; |
| 691 | header[3] = sp_write_n_buf[0]; |
Stefan Tauner | bdead0d | 2013-08-24 02:10:18 +0000 | [diff] [blame] | 692 | if (sp_stream_buffer_op(S_CMD_O_WRITEB, 4, header) != 0) |
| 693 | return 1; |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 694 | sp_opbuf_usage += 5; |
Stefan Tauner | bdead0d | 2013-08-24 02:10:18 +0000 | [diff] [blame] | 695 | return 0; |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 696 | } |
| 697 | header[0] = S_CMD_O_WRITEN; |
| 698 | header[1] = (sp_write_n_bytes >> 0) & 0xFF; |
| 699 | header[2] = (sp_write_n_bytes >> 8) & 0xFF; |
| 700 | header[3] = (sp_write_n_bytes >> 16) & 0xFF; |
| 701 | header[4] = (sp_write_n_addr >> 0) & 0xFF; |
| 702 | header[5] = (sp_write_n_addr >> 8) & 0xFF; |
| 703 | header[6] = (sp_write_n_addr >> 16) & 0xFF; |
Stefan Tauner | bdead0d | 2013-08-24 02:10:18 +0000 | [diff] [blame] | 704 | if (serialport_write(header, 7) != 0) { |
| 705 | msg_perr(MSGHEADER "Error: cannot write write-n command\n"); |
| 706 | return 1; |
| 707 | } |
| 708 | if (serialport_write(sp_write_n_buf, sp_write_n_bytes) != 0) { |
| 709 | msg_perr(MSGHEADER "Error: cannot write write-n data"); |
| 710 | return 1; |
| 711 | } |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 712 | sp_streamed_transmit_bytes += 7 + sp_write_n_bytes; |
| 713 | sp_streamed_transmit_ops += 1; |
| 714 | sp_opbuf_usage += 7 + sp_write_n_bytes; |
| 715 | sp_write_n_bytes = 0; |
| 716 | sp_prev_was_write = 0; |
Stefan Tauner | bdead0d | 2013-08-24 02:10:18 +0000 | [diff] [blame] | 717 | return 0; |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 718 | } |
| 719 | |
Stefan Tauner | bdead0d | 2013-08-24 02:10:18 +0000 | [diff] [blame] | 720 | static int sp_execute_opbuf_noflush(void) |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 721 | { |
Stefan Tauner | bdead0d | 2013-08-24 02:10:18 +0000 | [diff] [blame] | 722 | if ((sp_max_write_n) && (sp_write_n_bytes)) { |
| 723 | if (sp_pass_writen() != 0) { |
| 724 | msg_perr("Error: could not transfer write buffer\n"); |
| 725 | return 1; |
| 726 | } |
| 727 | } |
| 728 | if (sp_stream_buffer_op(S_CMD_O_EXEC, 0, NULL) != 0) { |
| 729 | msg_perr("Error: could not execute command buffer\n"); |
| 730 | return 1; |
| 731 | } |
| 732 | msg_pspew(MSGHEADER "Executed operation buffer of %d bytes\n", sp_opbuf_usage); |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 733 | sp_opbuf_usage = 0; |
| 734 | sp_prev_was_write = 0; |
Stefan Tauner | bdead0d | 2013-08-24 02:10:18 +0000 | [diff] [blame] | 735 | return 0; |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 736 | } |
| 737 | |
Stefan Tauner | bdead0d | 2013-08-24 02:10:18 +0000 | [diff] [blame] | 738 | static int sp_execute_opbuf(void) |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 739 | { |
Stefan Tauner | bdead0d | 2013-08-24 02:10:18 +0000 | [diff] [blame] | 740 | if (sp_execute_opbuf_noflush() != 0) |
| 741 | return 1; |
| 742 | if (sp_flush_stream() != 0) |
| 743 | return 1; |
| 744 | |
| 745 | return 0; |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 746 | } |
| 747 | |
David Hendricks | 8bb2021 | 2011-06-14 01:35:36 +0000 | [diff] [blame] | 748 | static int serprog_shutdown(void *data) |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 749 | { |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 750 | if ((sp_opbuf_usage) || (sp_max_write_n && sp_write_n_bytes)) |
Stefan Tauner | bdead0d | 2013-08-24 02:10:18 +0000 | [diff] [blame] | 751 | if (sp_execute_opbuf() != 0) |
| 752 | msg_pwarn("Could not flush command buffer.\n"); |
Stefan Tauner | 92fefc9 | 2012-10-27 00:34:23 +0000 | [diff] [blame] | 753 | if (sp_check_commandavail(S_CMD_S_PIN_STATE)) { |
| 754 | uint8_t dis = 0; |
| 755 | if (sp_docommand(S_CMD_S_PIN_STATE, 1, &dis, 0, NULL) == 0) |
| 756 | msg_pdbg(MSGHEADER "Output drivers disabled\n"); |
| 757 | else |
Stefan Tauner | c6fa32d | 2013-01-04 22:54:07 +0000 | [diff] [blame] | 758 | msg_pwarn(MSGHEADER "%s: Warning: could not disable output buffers\n", __func__); |
Stefan Tauner | 92fefc9 | 2012-10-27 00:34:23 +0000 | [diff] [blame] | 759 | } |
Niklas Söderlund | 7145a50 | 2012-09-07 07:07:07 +0000 | [diff] [blame] | 760 | /* FIXME: fix sockets on windows(?), especially closing */ |
| 761 | serialport_shutdown(&sp_fd); |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 762 | if (sp_max_write_n) |
| 763 | free(sp_write_n_buf); |
| 764 | return 0; |
| 765 | } |
| 766 | |
Stefan Tauner | bdead0d | 2013-08-24 02:10:18 +0000 | [diff] [blame] | 767 | static int sp_check_opbuf_usage(int bytes_to_be_added) |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 768 | { |
| 769 | if (sp_device_opbuf_size <= (sp_opbuf_usage + bytes_to_be_added)) { |
Stefan Tauner | bdead0d | 2013-08-24 02:10:18 +0000 | [diff] [blame] | 770 | /* If this happens in the middle of a page load the page load will probably fail. */ |
| 771 | msg_pwarn(MSGHEADER "Warning: executed operation buffer due to size reasons\n"); |
| 772 | if (sp_execute_opbuf() != 0) |
| 773 | return 1; |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 774 | } |
Stefan Tauner | bdead0d | 2013-08-24 02:10:18 +0000 | [diff] [blame] | 775 | return 0; |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 776 | } |
| 777 | |
Carl-Daniel Hailfinger | 8a3c60c | 2011-12-18 15:01:24 +0000 | [diff] [blame] | 778 | static void serprog_chip_writeb(const struct flashctx *flash, uint8_t val, |
| 779 | chipaddr addr) |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 780 | { |
Sean Nelson | 74e8af5 | 2010-01-10 01:06:23 +0000 | [diff] [blame] | 781 | msg_pspew("%s\n", __func__); |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 782 | if (sp_max_write_n) { |
| 783 | if ((sp_prev_was_write) |
| 784 | && (addr == (sp_write_n_addr + sp_write_n_bytes))) { |
| 785 | sp_write_n_buf[sp_write_n_bytes++] = val; |
| 786 | } else { |
| 787 | if ((sp_prev_was_write) && (sp_write_n_bytes)) |
| 788 | sp_pass_writen(); |
| 789 | sp_prev_was_write = 1; |
| 790 | sp_write_n_addr = addr; |
| 791 | sp_write_n_bytes = 1; |
| 792 | sp_write_n_buf[0] = val; |
| 793 | } |
| 794 | sp_check_opbuf_usage(7 + sp_write_n_bytes); |
| 795 | if (sp_write_n_bytes >= sp_max_write_n) |
| 796 | sp_pass_writen(); |
| 797 | } else { |
| 798 | /* We will have to do single writeb ops. */ |
| 799 | unsigned char writeb_parm[4]; |
| 800 | sp_check_opbuf_usage(6); |
| 801 | writeb_parm[0] = (addr >> 0) & 0xFF; |
| 802 | writeb_parm[1] = (addr >> 8) & 0xFF; |
| 803 | writeb_parm[2] = (addr >> 16) & 0xFF; |
| 804 | writeb_parm[3] = val; |
Stefan Tauner | bdead0d | 2013-08-24 02:10:18 +0000 | [diff] [blame] | 805 | sp_stream_buffer_op(S_CMD_O_WRITEB, 4, writeb_parm); // FIXME: return error |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 806 | sp_opbuf_usage += 5; |
| 807 | } |
| 808 | } |
| 809 | |
Carl-Daniel Hailfinger | 8a3c60c | 2011-12-18 15:01:24 +0000 | [diff] [blame] | 810 | static uint8_t serprog_chip_readb(const struct flashctx *flash, |
| 811 | const chipaddr addr) |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 812 | { |
| 813 | unsigned char c; |
| 814 | unsigned char buf[3]; |
| 815 | /* Will stream the read operation - eg. add it to the stream buffer, * |
| 816 | * then flush the buffer, then read the read answer. */ |
| 817 | if ((sp_opbuf_usage) || (sp_max_write_n && sp_write_n_bytes)) |
| 818 | sp_execute_opbuf_noflush(); |
| 819 | buf[0] = ((addr >> 0) & 0xFF); |
| 820 | buf[1] = ((addr >> 8) & 0xFF); |
| 821 | buf[2] = ((addr >> 16) & 0xFF); |
Stefan Tauner | bdead0d | 2013-08-24 02:10:18 +0000 | [diff] [blame] | 822 | sp_stream_buffer_op(S_CMD_R_BYTE, 3, buf); // FIXME: return error |
| 823 | sp_flush_stream(); // FIXME: return error |
Stefan Tauner | 79587f5 | 2013-04-01 00:45:51 +0000 | [diff] [blame] | 824 | if (serialport_read(&c, 1) != 0) |
Stefan Tauner | bdead0d | 2013-08-24 02:10:18 +0000 | [diff] [blame] | 825 | msg_perr(MSGHEADER "readb byteread"); // FIXME: return error |
Stefan Tauner | c233375 | 2013-07-13 23:31:37 +0000 | [diff] [blame] | 826 | msg_pspew("%s addr=0x%" PRIxPTR " returning 0x%02X\n", __func__, addr, c); |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 827 | return c; |
| 828 | } |
| 829 | |
Uwe Hermann | 4e3d0b3 | 2010-03-25 23:18:41 +0000 | [diff] [blame] | 830 | /* Local version that really does the job, doesn't care of max_read_n. */ |
Stefan Tauner | bdead0d | 2013-08-24 02:10:18 +0000 | [diff] [blame] | 831 | static int sp_do_read_n(uint8_t * buf, const chipaddr addr, size_t len) |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 832 | { |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 833 | unsigned char sbuf[6]; |
Stefan Tauner | 0554ca5 | 2013-07-25 22:54:25 +0000 | [diff] [blame] | 834 | msg_pspew("%s: addr=0x%" PRIxPTR " len=%zu\n", __func__, addr, len); |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 835 | /* Stream the read-n -- as above. */ |
| 836 | if ((sp_opbuf_usage) || (sp_max_write_n && sp_write_n_bytes)) |
| 837 | sp_execute_opbuf_noflush(); |
| 838 | sbuf[0] = ((addr >> 0) & 0xFF); |
| 839 | sbuf[1] = ((addr >> 8) & 0xFF); |
| 840 | sbuf[2] = ((addr >> 16) & 0xFF); |
| 841 | sbuf[3] = ((len >> 0) & 0xFF); |
| 842 | sbuf[4] = ((len >> 8) & 0xFF); |
| 843 | sbuf[5] = ((len >> 16) & 0xFF); |
| 844 | sp_stream_buffer_op(S_CMD_R_NBYTES, 6, sbuf); |
Stefan Tauner | bdead0d | 2013-08-24 02:10:18 +0000 | [diff] [blame] | 845 | if (sp_flush_stream() != 0) |
| 846 | return 1; |
| 847 | if (serialport_read(buf, len) != 0) { |
| 848 | msg_perr(MSGHEADER "Error: cannot read read-n data"); |
| 849 | return 1; |
| 850 | } |
| 851 | return 0; |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 852 | } |
| 853 | |
| 854 | /* The externally called version that makes sure that max_read_n is obeyed. */ |
Carl-Daniel Hailfinger | 8a3c60c | 2011-12-18 15:01:24 +0000 | [diff] [blame] | 855 | static void serprog_chip_readn(const struct flashctx *flash, uint8_t * buf, |
| 856 | const chipaddr addr, size_t len) |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 857 | { |
| 858 | size_t lenm = len; |
| 859 | chipaddr addrm = addr; |
Stefan Tauner | 31019d4 | 2011-10-22 21:45:27 +0000 | [diff] [blame] | 860 | while ((sp_max_read_n != 0) && (lenm > sp_max_read_n)) { |
Stefan Tauner | bdead0d | 2013-08-24 02:10:18 +0000 | [diff] [blame] | 861 | sp_do_read_n(&(buf[addrm-addr]), addrm, sp_max_read_n); // FIXME: return error |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 862 | addrm += sp_max_read_n; |
| 863 | lenm -= sp_max_read_n; |
| 864 | } |
Stefan Tauner | 31019d4 | 2011-10-22 21:45:27 +0000 | [diff] [blame] | 865 | if (lenm) |
Stefan Tauner | bdead0d | 2013-08-24 02:10:18 +0000 | [diff] [blame] | 866 | sp_do_read_n(&(buf[addrm-addr]), addrm, lenm); // FIXME: return error |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 867 | } |
| 868 | |
Stefan Tauner | 31019d4 | 2011-10-22 21:45:27 +0000 | [diff] [blame] | 869 | void serprog_delay(int usecs) |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 870 | { |
| 871 | unsigned char buf[4]; |
Stefan Tauner | 31019d4 | 2011-10-22 21:45:27 +0000 | [diff] [blame] | 872 | msg_pspew("%s usecs=%d\n", __func__, usecs); |
Urja Rannikko | c93f5f1 | 2011-09-15 23:38:14 +0000 | [diff] [blame] | 873 | if (!sp_check_commandavail(S_CMD_O_DELAY)) { |
Stefan Tauner | d7d423b | 2012-10-20 09:13:16 +0000 | [diff] [blame] | 874 | msg_pdbg2("serprog_delay used, but programmer doesn't support delays natively - emulating\n"); |
Stefan Tauner | 31019d4 | 2011-10-22 21:45:27 +0000 | [diff] [blame] | 875 | internal_delay(usecs); |
Urja Rannikko | c93f5f1 | 2011-09-15 23:38:14 +0000 | [diff] [blame] | 876 | return; |
| 877 | } |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 878 | if ((sp_max_write_n) && (sp_write_n_bytes)) |
| 879 | sp_pass_writen(); |
| 880 | sp_check_opbuf_usage(5); |
Stefan Tauner | 31019d4 | 2011-10-22 21:45:27 +0000 | [diff] [blame] | 881 | buf[0] = ((usecs >> 0) & 0xFF); |
| 882 | buf[1] = ((usecs >> 8) & 0xFF); |
| 883 | buf[2] = ((usecs >> 16) & 0xFF); |
| 884 | buf[3] = ((usecs >> 24) & 0xFF); |
Urja Rannikko | f3196df | 2009-07-21 13:02:59 +0000 | [diff] [blame] | 885 | sp_stream_buffer_op(S_CMD_O_DELAY, 4, buf); |
| 886 | sp_opbuf_usage += 5; |
| 887 | sp_prev_was_write = 0; |
| 888 | } |
Urja Rannikko | c93f5f1 | 2011-09-15 23:38:14 +0000 | [diff] [blame] | 889 | |
Carl-Daniel Hailfinger | 8a3c60c | 2011-12-18 15:01:24 +0000 | [diff] [blame] | 890 | static int serprog_spi_send_command(struct flashctx *flash, |
| 891 | unsigned int writecnt, unsigned int readcnt, |
| 892 | const unsigned char *writearr, |
| 893 | unsigned char *readarr) |
Urja Rannikko | c93f5f1 | 2011-09-15 23:38:14 +0000 | [diff] [blame] | 894 | { |
| 895 | unsigned char *parmbuf; |
| 896 | int ret; |
| 897 | msg_pspew("%s, writecnt=%i, readcnt=%i\n", __func__, writecnt, readcnt); |
Stefan Tauner | bdead0d | 2013-08-24 02:10:18 +0000 | [diff] [blame] | 898 | if ((sp_opbuf_usage) || (sp_max_write_n && sp_write_n_bytes)) { |
| 899 | if (sp_execute_opbuf() != 0) { |
| 900 | msg_perr("Error: could not execute command buffer before sending SPI commands.\n"); |
| 901 | return 1; |
| 902 | } |
| 903 | } |
| 904 | |
Urja Rannikko | c93f5f1 | 2011-09-15 23:38:14 +0000 | [diff] [blame] | 905 | parmbuf = malloc(writecnt + 6); |
Stefan Tauner | bdead0d | 2013-08-24 02:10:18 +0000 | [diff] [blame] | 906 | if (!parmbuf) { |
| 907 | msg_perr("Error: could not allocate SPI send param buffer.\n"); |
| 908 | return 1; |
| 909 | } |
Urja Rannikko | c93f5f1 | 2011-09-15 23:38:14 +0000 | [diff] [blame] | 910 | parmbuf[0] = (writecnt >> 0) & 0xFF; |
| 911 | parmbuf[1] = (writecnt >> 8) & 0xFF; |
| 912 | parmbuf[2] = (writecnt >> 16) & 0xFF; |
| 913 | parmbuf[3] = (readcnt >> 0) & 0xFF; |
| 914 | parmbuf[4] = (readcnt >> 8) & 0xFF; |
| 915 | parmbuf[5] = (readcnt >> 16) & 0xFF; |
| 916 | memcpy(parmbuf + 6, writearr, writecnt); |
| 917 | ret = sp_docommand(S_CMD_O_SPIOP, writecnt + 6, parmbuf, readcnt, |
| 918 | readarr); |
| 919 | free(parmbuf); |
| 920 | return ret; |
| 921 | } |
| 922 | |
| 923 | /* FIXME: This function is optimized so that it does not split each transaction |
| 924 | * into chip page_size long blocks unnecessarily like spi_read_chunked. This has |
| 925 | * the advantage that it is much faster for most chips, but breaks those with |
Aidan Thornton | db4e87d | 2013-08-27 18:01:53 +0000 | [diff] [blame] | 926 | * non-continuous reads. When spi_read_chunked is fixed this method can be removed. */ |
Carl-Daniel Hailfinger | 8a3c60c | 2011-12-18 15:01:24 +0000 | [diff] [blame] | 927 | static int serprog_spi_read(struct flashctx *flash, uint8_t *buf, |
| 928 | unsigned int start, unsigned int len) |
Urja Rannikko | c93f5f1 | 2011-09-15 23:38:14 +0000 | [diff] [blame] | 929 | { |
Stefan Tauner | c69c9c8 | 2011-11-23 09:13:48 +0000 | [diff] [blame] | 930 | unsigned int i, cur_len; |
| 931 | const unsigned int max_read = spi_programmer_serprog.max_data_read; |
Urja Rannikko | c93f5f1 | 2011-09-15 23:38:14 +0000 | [diff] [blame] | 932 | for (i = 0; i < len; i += cur_len) { |
| 933 | int ret; |
| 934 | cur_len = min(max_read, (len - i)); |
Carl-Daniel Hailfinger | 8a3c60c | 2011-12-18 15:01:24 +0000 | [diff] [blame] | 935 | ret = spi_nbyte_read(flash, start + i, buf + i, cur_len); |
Urja Rannikko | c93f5f1 | 2011-09-15 23:38:14 +0000 | [diff] [blame] | 936 | if (ret) |
| 937 | return ret; |
| 938 | } |
| 939 | return 0; |
| 940 | } |