blob: 6a2d1f27ba52f141d43334ce2caac55785f2399a [file] [log] [blame]
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +00001/*
2 * This file is part of the flashrom project.
3 *
4 * Copyright (C) 2010 Carl-Daniel Hailfinger
Simon Glass557eb4f2015-07-05 16:53:22 +00005 * Copyright (C) 2015 Simon Glass
6 * Copyright (C) 2015 Stefan Tauner
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +00007 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; version 2 of the License.
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.
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +000016 */
17
Stefan Tauner0cbd8c22015-01-26 22:06:04 +000018#include "platform.h"
19
Nico Huber4d440a72017-08-15 11:26:48 +020020#include <sys/types.h>
Stefan Tauner5c316f92015-02-08 21:57:52 +000021#include <stdlib.h>
Mathias Krausedb7afc52010-11-09 23:30:43 +000022#include <stdio.h>
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +000023#include <string.h>
Stefan Taunere34e3e82013-01-01 00:06:51 +000024#include <limits.h>
Nathan Laredo21541a62012-12-24 22:07:36 +000025#include <errno.h>
Nico Huberd99a2bd2016-02-18 21:42:49 +000026#include <libusb.h>
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +000027#include "flash.h"
Sean Nelson14ba6682010-02-26 05:48:29 +000028#include "chipdrivers.h"
Carl-Daniel Hailfinger5b997c32010-07-27 22:41:39 +000029#include "programmer.h"
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +000030#include "spi.h"
31
Nico Huberd99a2bd2016-02-18 21:42:49 +000032/* LIBUSB_CALL ensures the right calling conventions on libusb callbacks.
33 * However, the macro is not defined everywhere. m(
34 */
35#ifndef LIBUSB_CALL
36#define LIBUSB_CALL
37#endif
38
Stefan Reinauer915b8402011-01-28 09:00:15 +000039#define FIRMWARE_VERSION(x,y,z) ((x << 16) | (y << 8) | z)
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +000040#define DEFAULT_TIMEOUT 3000
Nico Huberd99a2bd2016-02-18 21:42:49 +000041#define DEDIPROG_ASYNC_TRANSFERS 8 /* at most 8 asynchronous transfers */
David Hendricks9b6fb742020-06-23 17:36:09 -070042#define REQTYPE_OTHER_OUT (LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_OTHER) /* 0x43 */
Nico Huberd99a2bd2016-02-18 21:42:49 +000043#define REQTYPE_OTHER_IN (LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_OTHER) /* 0xC3 */
44#define REQTYPE_EP_OUT (LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_ENDPOINT) /* 0x42 */
45#define REQTYPE_EP_IN (LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_ENDPOINT) /* 0xC2 */
Jacob Garberafc3ad62019-06-24 16:05:28 -060046static struct libusb_context *usb_ctx;
Nico Huberd99a2bd2016-02-18 21:42:49 +000047static libusb_device_handle *dediprog_handle;
David Woodhouse7f3b89f2016-02-18 21:42:15 +000048static int dediprog_in_endpoint;
49static int dediprog_out_endpoint;
50
51enum dediprog_devtype {
52 DEV_UNKNOWN = 0,
53 DEV_SF100 = 100,
Jay Thompsoncabe3202018-08-17 14:30:04 -050054 DEV_SF200 = 200,
David Woodhouse7f3b89f2016-02-18 21:42:15 +000055 DEV_SF600 = 600,
56};
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +000057
Simon Glass25e9f402015-06-28 13:31:19 +000058enum dediprog_leds {
59 LED_INVALID = -1,
60 LED_NONE = 0,
61 LED_PASS = 1 << 0,
62 LED_BUSY = 1 << 1,
63 LED_ERROR = 1 << 2,
64 LED_ALL = 7,
65};
66
Simon Glass557eb4f2015-07-05 16:53:22 +000067/* IO bits for CMD_SET_IO_LED message */
68enum dediprog_ios {
69 IO1 = 1 << 0,
70 IO2 = 1 << 1,
71 IO3 = 1 << 2,
72 IO4 = 1 << 3,
73};
74
75enum dediprog_cmds {
76 CMD_TRANSCEIVE = 0x01,
77 CMD_POLL_STATUS_REG = 0x02,
78 CMD_SET_VPP = 0x03,
79 CMD_SET_TARGET = 0x04,
80 CMD_READ_EEPROM = 0x05,
81 CMD_WRITE_EEPROM = 0x06,
82 CMD_SET_IO_LED = 0x07,
83 CMD_READ_PROG_INFO = 0x08,
84 CMD_SET_VCC = 0x09,
85 CMD_SET_STANDALONE = 0x0A,
David Hendricksc05900f2016-02-18 21:42:41 +000086 CMD_SET_VOLTAGE = 0x0B, /* Only in firmware older than 6.0.0 */
Simon Glass557eb4f2015-07-05 16:53:22 +000087 CMD_GET_BUTTON = 0x11,
88 CMD_GET_UID = 0x12,
89 CMD_SET_CS = 0x14,
90 CMD_IO_MODE = 0x15,
91 CMD_FW_UPDATE = 0x1A,
92 CMD_FPGA_UPDATE = 0x1B,
93 CMD_READ_FPGA_VERSION = 0x1C,
94 CMD_SET_HOLD = 0x1D,
95 CMD_READ = 0x20,
96 CMD_WRITE = 0x30,
97 CMD_WRITE_AT45DB = 0x31,
98 CMD_NAND_WRITE = 0x32,
99 CMD_NAND_READ = 0x33,
100 CMD_SET_SPI_CLK = 0x61,
101 CMD_CHECK_SOCKET = 0x62,
102 CMD_DOWNLOAD_PRJ = 0x63,
103 CMD_READ_PRJ_NAME = 0x64,
104 // New protocol/firmware only
105 CMD_CHECK_SDCARD = 0x65,
106 CMD_READ_PRJ = 0x66,
107};
108
109enum dediprog_target {
110 FLASH_TYPE_APPLICATION_FLASH_1 = 0,
111 FLASH_TYPE_FLASH_CARD,
112 FLASH_TYPE_APPLICATION_FLASH_2,
113 FLASH_TYPE_SOCKET,
114};
115
116enum dediprog_readmode {
117 READ_MODE_STD = 1,
118 READ_MODE_FAST = 2,
119 READ_MODE_ATMEL45 = 3,
120 READ_MODE_4B_ADDR_FAST = 4,
121 READ_MODE_4B_ADDR_FAST_0x0C = 5, /* New protocol only */
122};
123
124enum dediprog_writemode {
Elyes HAOUASac01baa2018-05-28 16:52:21 +0200125 WRITE_MODE_PAGE_PGM = 1,
Simon Glass557eb4f2015-07-05 16:53:22 +0000126 WRITE_MODE_PAGE_WRITE = 2,
127 WRITE_MODE_1B_AAI = 3,
128 WRITE_MODE_2B_AAI = 4,
129 WRITE_MODE_128B_PAGE = 5,
130 WRITE_MODE_PAGE_AT26DF041 = 6,
131 WRITE_MODE_SILICON_BLUE_FPGA = 7,
Simon Glassae616512016-01-23 23:27:58 +0000132 WRITE_MODE_64B_PAGE_NUMONYX_PCM = 8, /* unit of 512 bytes */
Simon Glass557eb4f2015-07-05 16:53:22 +0000133 WRITE_MODE_4B_ADDR_256B_PAGE_PGM = 9,
Simon Glassae616512016-01-23 23:27:58 +0000134 WRITE_MODE_32B_PAGE_PGM_MXIC_512K = 10, /* unit of 512 bytes */
Simon Glass557eb4f2015-07-05 16:53:22 +0000135 WRITE_MODE_4B_ADDR_256B_PAGE_PGM_0x12 = 11,
136 WRITE_MODE_4B_ADDR_256B_PAGE_PGM_FLAGS = 12,
137};
138
David Woodhouse7f3b89f2016-02-18 21:42:15 +0000139enum dediprog_standalone_mode {
140 ENTER_STANDALONE_MODE = 0,
141 LEAVE_STANDALONE_MODE = 1,
142};
143
David Hendricksf73f8a72018-02-21 07:34:34 -0800144/*
145 * These are not official designations; they are for use in flashrom only.
146 * Order must be preserved so that comparison operators work.
147 */
148enum protocol {
149 PROTOCOL_UNKNOWN,
150 PROTOCOL_V1,
151 PROTOCOL_V2,
152 PROTOCOL_V3,
153};
154
Thomas Heijligen4f5169d2021-05-04 15:32:17 +0200155static const struct dev_entry devs_dediprog[] = {
Jay Thompsoncabe3202018-08-17 14:30:04 -0500156 {0x0483, 0xDADA, OK, "Dediprog", "SF100/SF200/SF600"},
Stefan Taunerfdec7472016-02-22 08:59:27 +0000157
158 {0},
159};
Simon Glass557eb4f2015-07-05 16:53:22 +0000160
161static int dediprog_firmwareversion = FIRMWARE_VERSION(0, 0, 0);
Jacob Garberafc3ad62019-06-24 16:05:28 -0600162static enum dediprog_devtype dediprog_devicetype = DEV_UNKNOWN;
Simon Glass557eb4f2015-07-05 16:53:22 +0000163
Nico Huberd99a2bd2016-02-18 21:42:49 +0000164#if defined(LIBUSB_MAJOR) && defined(LIBUSB_MINOR) && defined(LIBUSB_MICRO) && \
165 LIBUSB_MAJOR <= 1 && LIBUSB_MINOR == 0 && LIBUSB_MICRO < 9
166/* Quick and dirty replacement for missing libusb_error_name in libusb < 1.0.9 */
167const char * LIBUSB_CALL libusb_error_name(int error_code)
168{
169 if (error_code >= INT16_MIN && error_code <= INT16_MAX) {
170 /* 18 chars for text, rest for number (16 b should be enough), sign, nullbyte. */
171 static char my_libusb_error[18 + 5 + 2];
172 sprintf(my_libusb_error, "libusb error code %i", error_code);
173 return my_libusb_error;
174 } else {
175 return "UNKNOWN";
176 }
177}
178#endif
179
David Hendricksf73f8a72018-02-21 07:34:34 -0800180static enum protocol protocol(void)
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000181{
David Hendricksf73f8a72018-02-21 07:34:34 -0800182 /* Firmware version < 5.0.0 is handled explicitly in some cases. */
David Woodhouse7f3b89f2016-02-18 21:42:15 +0000183 switch (dediprog_devicetype) {
184 case DEV_SF100:
Jay Thompsoncabe3202018-08-17 14:30:04 -0500185 case DEV_SF200:
David Hendricksf73f8a72018-02-21 07:34:34 -0800186 if (dediprog_firmwareversion < FIRMWARE_VERSION(5, 5, 0))
187 return PROTOCOL_V1;
188 else
189 return PROTOCOL_V2;
David Woodhouse7f3b89f2016-02-18 21:42:15 +0000190 case DEV_SF600:
David Hendricksf73f8a72018-02-21 07:34:34 -0800191 if (dediprog_firmwareversion < FIRMWARE_VERSION(6, 9, 0))
192 return PROTOCOL_V1;
193 else if (dediprog_firmwareversion <= FIRMWARE_VERSION(7, 2, 21))
194 return PROTOCOL_V2;
195 else
196 return PROTOCOL_V3;
David Woodhouse7f3b89f2016-02-18 21:42:15 +0000197 default:
David Hendricksf73f8a72018-02-21 07:34:34 -0800198 return PROTOCOL_UNKNOWN;
David Woodhouse7f3b89f2016-02-18 21:42:15 +0000199 }
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000200}
Simon Glassae616512016-01-23 23:27:58 +0000201
Nico Huberd99a2bd2016-02-18 21:42:49 +0000202struct dediprog_transfer_status {
203 int error; /* OK if 0, ERROR else */
204 unsigned int queued_idx;
205 unsigned int finished_idx;
206};
207
208static void LIBUSB_CALL dediprog_bulk_read_cb(struct libusb_transfer *const transfer)
209{
210 struct dediprog_transfer_status *const status = (struct dediprog_transfer_status *)transfer->user_data;
211 if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
212 status->error = 1;
213 msg_perr("SPI bulk read failed!\n");
214 }
215 ++status->finished_idx;
216}
217
218static int dediprog_bulk_read_poll(const struct dediprog_transfer_status *const status, const int finish)
219{
220 if (status->finished_idx >= status->queued_idx)
221 return 0;
222
223 do {
224 struct timeval timeout = { 10, 0 };
225 const int ret = libusb_handle_events_timeout(usb_ctx, &timeout);
226 if (ret < 0) {
227 msg_perr("Polling read events failed: %i %s!\n", ret, libusb_error_name(ret));
228 return 1;
229 }
230 } while (finish && (status->finished_idx < status->queued_idx));
231 return 0;
232}
233
Simon Glassae616512016-01-23 23:27:58 +0000234static int dediprog_read(enum dediprog_cmds cmd, unsigned int value, unsigned int idx, uint8_t *bytes, size_t size)
235{
Nico Huberd99a2bd2016-02-18 21:42:49 +0000236 return libusb_control_transfer(dediprog_handle, REQTYPE_EP_IN, cmd, value, idx,
237 (unsigned char *)bytes, size, DEFAULT_TIMEOUT);
Simon Glassae616512016-01-23 23:27:58 +0000238}
239
240static int dediprog_write(enum dediprog_cmds cmd, unsigned int value, unsigned int idx, const uint8_t *bytes, size_t size)
241{
Nico Huberd99a2bd2016-02-18 21:42:49 +0000242 return libusb_control_transfer(dediprog_handle, REQTYPE_EP_OUT, cmd, value, idx,
243 (unsigned char *)bytes, size, DEFAULT_TIMEOUT);
Simon Glassae616512016-01-23 23:27:58 +0000244}
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000245
Nico Huberd99a2bd2016-02-18 21:42:49 +0000246
Simon Glass25e9f402015-06-28 13:31:19 +0000247/* This function sets the GPIOs connected to the LEDs as well as IO1-IO4. */
Stefan Reinauer915b8402011-01-28 09:00:15 +0000248static int dediprog_set_leds(int leds)
249{
Simon Glass25e9f402015-06-28 13:31:19 +0000250 if (leds < LED_NONE || leds > LED_ALL)
251 leds = LED_ALL;
Stefan Reinauer915b8402011-01-28 09:00:15 +0000252
Simon Glassae616512016-01-23 23:27:58 +0000253 /* Older Dediprogs with 2.x.x and 3.x.x firmware only had two LEDs, assigned to different bits. So map
254 * them around if we have an old device. On those devices the LEDs map as follows:
Stefan Reinauer915b8402011-01-28 09:00:15 +0000255 * bit 2 == 0: green light is on.
Simon Glassae616512016-01-23 23:27:58 +0000256 * bit 0 == 0: red light is on.
257 *
258 * Additionally, the command structure has changed with the "new" protocol.
259 *
260 * FIXME: take IO pins into account
Stefan Reinauer915b8402011-01-28 09:00:15 +0000261 */
Simon Glassae616512016-01-23 23:27:58 +0000262 int target_leds, ret;
David Hendricksf73f8a72018-02-21 07:34:34 -0800263 if (protocol() >= PROTOCOL_V2) {
Simon Glassae616512016-01-23 23:27:58 +0000264 target_leds = (leds ^ 7) << 8;
265 ret = dediprog_write(CMD_SET_IO_LED, target_leds, 0, NULL, 0);
Stefan Reinauer915b8402011-01-28 09:00:15 +0000266 } else {
Simon Glassae616512016-01-23 23:27:58 +0000267 if (dediprog_firmwareversion < FIRMWARE_VERSION(5, 0, 0)) {
268 target_leds = ((leds & LED_ERROR) >> 2) | ((leds & LED_PASS) << 2);
269 } else {
270 target_leds = leds;
271 }
272 target_leds ^= 7;
273
274 ret = dediprog_write(CMD_SET_IO_LED, 0x9, target_leds, NULL, 0);
Stefan Reinauer915b8402011-01-28 09:00:15 +0000275 }
276
Stefan Reinauer915b8402011-01-28 09:00:15 +0000277 if (ret != 0x0) {
Nico Huberd99a2bd2016-02-18 21:42:49 +0000278 msg_perr("Command Set LED 0x%x failed (%s)!\n", leds, libusb_error_name(ret));
Stefan Reinauer915b8402011-01-28 09:00:15 +0000279 return 1;
280 }
281
Stefan Reinauer915b8402011-01-28 09:00:15 +0000282 return 0;
283}
284
Carl-Daniel Hailfingerc2441382010-11-09 22:00:31 +0000285static int dediprog_set_spi_voltage(int millivolt)
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000286{
287 int ret;
Carl-Daniel Hailfingerc2441382010-11-09 22:00:31 +0000288 uint16_t voltage_selector;
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000289
Carl-Daniel Hailfingerc2441382010-11-09 22:00:31 +0000290 switch (millivolt) {
291 case 0:
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000292 /* Admittedly this one is an assumption. */
Carl-Daniel Hailfingerc2441382010-11-09 22:00:31 +0000293 voltage_selector = 0x0;
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000294 break;
Carl-Daniel Hailfingerc2441382010-11-09 22:00:31 +0000295 case 1800:
296 voltage_selector = 0x12;
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000297 break;
Carl-Daniel Hailfingerc2441382010-11-09 22:00:31 +0000298 case 2500:
299 voltage_selector = 0x11;
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000300 break;
Carl-Daniel Hailfingerc2441382010-11-09 22:00:31 +0000301 case 3500:
302 voltage_selector = 0x10;
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000303 break;
304 default:
Carl-Daniel Hailfingerc2441382010-11-09 22:00:31 +0000305 msg_perr("Unknown voltage %i mV! Aborting.\n", millivolt);
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000306 return 1;
307 }
Carl-Daniel Hailfingerc2441382010-11-09 22:00:31 +0000308 msg_pdbg("Setting SPI voltage to %u.%03u V\n", millivolt / 1000,
309 millivolt % 1000);
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000310
Nico Huber4099a8a2012-06-16 00:02:27 +0000311 if (voltage_selector == 0) {
312 /* Wait some time as the original driver does. */
313 programmer_delay(200 * 1000);
314 }
Simon Glassae616512016-01-23 23:27:58 +0000315 ret = dediprog_write(CMD_SET_VCC, voltage_selector, 0, NULL, 0);
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000316 if (ret != 0x0) {
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000317 msg_perr("Command Set SPI Voltage 0x%x failed!\n",
318 voltage_selector);
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000319 return 1;
320 }
Nico Huber4099a8a2012-06-16 00:02:27 +0000321 if (voltage_selector != 0) {
322 /* Wait some time as the original driver does. */
323 programmer_delay(200 * 1000);
324 }
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000325 return 0;
326}
327
Nico Huber77fa67d2013-02-20 18:03:36 +0000328struct dediprog_spispeeds {
329 const char *const name;
330 const int speed;
331};
332
333static const struct dediprog_spispeeds spispeeds[] = {
334 { "24M", 0x0 },
335 { "12M", 0x2 },
336 { "8M", 0x1 },
337 { "3M", 0x3 },
338 { "2.18M", 0x4 },
339 { "1.5M", 0x5 },
340 { "750k", 0x6 },
341 { "375k", 0x7 },
342 { NULL, 0x0 },
343};
344
Nico Huber77fa67d2013-02-20 18:03:36 +0000345static int dediprog_set_spi_speed(unsigned int spispeed_idx)
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000346{
Patrick Georgiefe2d432013-05-23 21:47:46 +0000347 if (dediprog_firmwareversion < FIRMWARE_VERSION(5, 0, 0)) {
348 msg_pwarn("Skipping to set SPI speed because firmware is too old.\n");
349 return 0;
350 }
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000351
Simon Glass557eb4f2015-07-05 16:53:22 +0000352 const struct dediprog_spispeeds *spispeed = &spispeeds[spispeed_idx];
353 msg_pdbg("SPI speed is %sHz\n", spispeed->name);
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000354
Simon Glassae616512016-01-23 23:27:58 +0000355 int ret = dediprog_write(CMD_SET_SPI_CLK, spispeed->speed, 0, NULL, 0);
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000356 if (ret != 0x0) {
Simon Glass557eb4f2015-07-05 16:53:22 +0000357 msg_perr("Command Set SPI Speed 0x%x failed!\n", spispeed->speed);
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000358 return 1;
359 }
360 return 0;
361}
362
Nico Huber7eb38aa2019-03-21 15:42:54 +0100363static int prepare_rw_cmd(
Nico Huber93db6e12018-09-30 01:18:43 +0200364 struct flashctx *const flash, uint8_t *data_packet, unsigned int count,
Nico Huber477e1692019-06-18 23:56:01 +0200365 uint8_t dedi_spi_cmd, unsigned int *value, unsigned int *idx, unsigned int start, int is_read)
366{
367 if (count >= 1 << 16) {
368 msg_perr("%s: Unsupported transfer length of %u blocks! "
369 "Please report a bug at flashrom@flashrom.org\n",
370 __func__, count);
371 return 1;
372 }
373
Simon Glassae616512016-01-23 23:27:58 +0000374 /* First 5 bytes are common in both generations. */
375 data_packet[0] = count & 0xff;
376 data_packet[1] = (count >> 8) & 0xff;
377 data_packet[2] = 0; /* RFU */
378 data_packet[3] = dedi_spi_cmd; /* Read/Write Mode (currently READ_MODE_STD, WRITE_MODE_PAGE_PGM or WRITE_MODE_2B_AAI) */
379 data_packet[4] = 0; /* "Opcode". Specs imply necessity only for READ_MODE_4B_ADDR_FAST and WRITE_MODE_4B_ADDR_256B_PAGE_PGM */
380
David Hendricksf73f8a72018-02-21 07:34:34 -0800381 if (protocol() >= PROTOCOL_V2) {
Nico Huber93db6e12018-09-30 01:18:43 +0200382 if (is_read && flash->chip->feature_bits & FEATURE_4BA_FAST_READ) {
383 data_packet[3] = READ_MODE_4B_ADDR_FAST_0x0C;
384 data_packet[4] = JEDEC_READ_4BA_FAST;
385 } else if (dedi_spi_cmd == WRITE_MODE_PAGE_PGM
386 && (flash->chip->feature_bits & FEATURE_4BA_WRITE)) {
387 data_packet[3] = WRITE_MODE_4B_ADDR_256B_PAGE_PGM_0x12;
388 data_packet[4] = JEDEC_BYTE_PROGRAM_4BA;
389 }
390
Simon Glassae616512016-01-23 23:27:58 +0000391 *value = *idx = 0;
392 data_packet[5] = 0; /* RFU */
393 data_packet[6] = (start >> 0) & 0xff;
394 data_packet[7] = (start >> 8) & 0xff;
395 data_packet[8] = (start >> 16) & 0xff;
396 data_packet[9] = (start >> 24) & 0xff;
David Hendricksf73f8a72018-02-21 07:34:34 -0800397 if (protocol() >= PROTOCOL_V3) {
398 if (is_read) {
399 data_packet[10] = 0x00; /* address length (3 or 4) */
400 data_packet[11] = 0x00; /* dummy cycle / 2 */
401 } else {
402 /* 16 LSBs and 16 HSBs of page size */
403 /* FIXME: This assumes page size of 256. */
404 data_packet[10] = 0x00;
405 data_packet[11] = 0x01;
406 data_packet[12] = 0x00;
407 data_packet[13] = 0x00;
408 }
409 }
Simon Glassae616512016-01-23 23:27:58 +0000410 } else {
Nico Huber7eb38aa2019-03-21 15:42:54 +0100411 if (flash->chip->feature_bits & FEATURE_4BA_EXT_ADDR) {
412 if (spi_set_extended_address(flash, start >> 24))
413 return 1;
414 } else if (start >> 24) {
415 msg_cerr("Can't handle 4-byte address with dediprog.\n");
416 return 1;
417 }
418 /*
419 * We don't know how the dediprog firmware handles 4-byte
420 * addresses. So let's not tell it what we are doing and
421 * only send the lower 3 bytes.
422 */
423 *value = start & 0xffff;
424 *idx = (start >> 16) & 0xff;
Simon Glassae616512016-01-23 23:27:58 +0000425 }
Nico Huber7eb38aa2019-03-21 15:42:54 +0100426
427 return 0;
Simon Glassae616512016-01-23 23:27:58 +0000428}
429
Carl-Daniel Hailfinger482e9742010-11-16 21:25:29 +0000430/* Bulk read interface, will read multiple 512 byte chunks aligned to 512 bytes.
431 * @start start address
432 * @len length
433 * @return 0 on success, 1 on failure
434 */
Simon Glassae616512016-01-23 23:27:58 +0000435static int dediprog_spi_bulk_read(struct flashctx *flash, uint8_t *buf, unsigned int start, unsigned int len)
Carl-Daniel Hailfinger482e9742010-11-16 21:25:29 +0000436{
Nico Huberd99a2bd2016-02-18 21:42:49 +0000437 int err = 1;
438
Carl-Daniel Hailfinger482e9742010-11-16 21:25:29 +0000439 /* chunksize must be 512, other sizes will NOT work at all. */
Simon Glassae616512016-01-23 23:27:58 +0000440 const unsigned int chunksize = 512;
Stefan Taunerc69c9c82011-11-23 09:13:48 +0000441 const unsigned int count = len / chunksize;
Carl-Daniel Hailfinger482e9742010-11-16 21:25:29 +0000442
Nico Huberd99a2bd2016-02-18 21:42:49 +0000443 struct dediprog_transfer_status status = { 0, 0, 0 };
444 struct libusb_transfer *transfers[DEDIPROG_ASYNC_TRANSFERS] = { NULL, };
445 struct libusb_transfer *transfer;
446
Nico Huberbbaa1712018-12-05 13:26:20 +0100447 if (len == 0)
448 return 0;
449
Carl-Daniel Hailfinger482e9742010-11-16 21:25:29 +0000450 if ((start % chunksize) || (len % chunksize)) {
Simon Glassae616512016-01-23 23:27:58 +0000451 msg_perr("%s: Unaligned start=%i, len=%i! Please report a bug at flashrom@flashrom.org\n",
452 __func__, start, len);
Carl-Daniel Hailfinger482e9742010-11-16 21:25:29 +0000453 return 1;
454 }
455
David Hendricksf73f8a72018-02-21 07:34:34 -0800456 int command_packet_size;
457 switch (protocol()) {
458 case PROTOCOL_V1:
459 command_packet_size = 5;
460 break;
461 case PROTOCOL_V2:
462 command_packet_size = 10;
463 break;
464 case PROTOCOL_V3:
465 command_packet_size = 12;
466 break;
467 default:
468 return 1;
469 }
470
471 uint8_t data_packet[command_packet_size];
Simon Glassae616512016-01-23 23:27:58 +0000472 unsigned int value, idx;
Nico Huber7eb38aa2019-03-21 15:42:54 +0100473 if (prepare_rw_cmd(flash, data_packet, count, READ_MODE_STD, &value, &idx, start, 1))
474 return 1;
Simon Glassae616512016-01-23 23:27:58 +0000475
476 int ret = dediprog_write(CMD_READ, value, idx, data_packet, sizeof(data_packet));
Nico Huber519be662018-12-23 20:03:35 +0100477 if (ret != (int)sizeof(data_packet)) {
Nico Huberd99a2bd2016-02-18 21:42:49 +0000478 msg_perr("Command Read SPI Bulk failed, %i %s!\n", ret, libusb_error_name(ret));
Carl-Daniel Hailfinger482e9742010-11-16 21:25:29 +0000479 return 1;
480 }
481
Nico Huberd99a2bd2016-02-18 21:42:49 +0000482 /*
483 * Ring buffer of bulk transfers.
484 * Poll until at least one transfer is ready,
485 * schedule next transfers until buffer is full.
486 */
Carl-Daniel Hailfinger482e9742010-11-16 21:25:29 +0000487
Nico Huberd99a2bd2016-02-18 21:42:49 +0000488 /* Allocate bulk transfers. */
489 unsigned int i;
Nico Huber519be662018-12-23 20:03:35 +0100490 for (i = 0; i < MIN(DEDIPROG_ASYNC_TRANSFERS, count); ++i) {
Nico Huberd99a2bd2016-02-18 21:42:49 +0000491 transfers[i] = libusb_alloc_transfer(0);
492 if (!transfers[i]) {
493 msg_perr("Allocating libusb transfer %i failed: %s!\n", i, libusb_error_name(ret));
494 goto err_free;
Elyes HAOUAS124ef382018-03-27 12:15:09 +0200495 }
496 }
Nico Huberd99a2bd2016-02-18 21:42:49 +0000497
498 /* Now transfer requested chunks using libusb's asynchronous interface. */
499 while (!status.error && (status.queued_idx < count)) {
Nico Huberf84df9a2016-05-04 13:24:07 +0200500 while ((status.queued_idx < count) &&
501 (status.queued_idx - status.finished_idx) < DEDIPROG_ASYNC_TRANSFERS)
502 {
Nico Huberd99a2bd2016-02-18 21:42:49 +0000503 transfer = transfers[status.queued_idx % DEDIPROG_ASYNC_TRANSFERS];
504 libusb_fill_bulk_transfer(transfer, dediprog_handle, 0x80 | dediprog_in_endpoint,
505 (unsigned char *)buf + status.queued_idx * chunksize, chunksize,
506 dediprog_bulk_read_cb, &status, DEFAULT_TIMEOUT);
507 transfer->flags |= LIBUSB_TRANSFER_SHORT_NOT_OK;
508 ret = libusb_submit_transfer(transfer);
509 if (ret < 0) {
510 msg_perr("Submitting SPI bulk read %i failed: %s!\n",
511 status.queued_idx, libusb_error_name(ret));
512 goto err_free;
513 }
514 ++status.queued_idx;
515 }
516 if (dediprog_bulk_read_poll(&status, 0))
517 goto err_free;
518 }
519 /* Wait for transfers to finish. */
520 if (dediprog_bulk_read_poll(&status, 1))
521 goto err_free;
522 /* Check if everything has been transmitted. */
523 if ((status.finished_idx < count) || status.error)
524 goto err_free;
525
526 err = 0;
527
528err_free:
529 dediprog_bulk_read_poll(&status, 1);
530 for (i = 0; i < DEDIPROG_ASYNC_TRANSFERS; ++i)
531 if (transfers[i]) libusb_free_transfer(transfers[i]);
532 return err;
Carl-Daniel Hailfinger482e9742010-11-16 21:25:29 +0000533}
534
Simon Glassae616512016-01-23 23:27:58 +0000535static int dediprog_spi_read(struct flashctx *flash, uint8_t *buf, unsigned int start, unsigned int len)
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000536{
Carl-Daniel Hailfinger482e9742010-11-16 21:25:29 +0000537 int ret;
538 /* chunksize must be 512, other sizes will NOT work at all. */
Stefan Taunerc69c9c82011-11-23 09:13:48 +0000539 const unsigned int chunksize = 0x200;
Nico Huberbbaa1712018-12-05 13:26:20 +0100540 unsigned int residue = start % chunksize ? min(len, chunksize - start % chunksize) : 0;
Stefan Taunerc69c9c82011-11-23 09:13:48 +0000541 unsigned int bulklen;
Carl-Daniel Hailfinger482e9742010-11-16 21:25:29 +0000542
Simon Glass25e9f402015-06-28 13:31:19 +0000543 dediprog_set_leds(LED_BUSY);
Stefan Reinauer915b8402011-01-28 09:00:15 +0000544
Carl-Daniel Hailfinger482e9742010-11-16 21:25:29 +0000545 if (residue) {
546 msg_pdbg("Slow read for partial block from 0x%x, length 0x%x\n",
547 start, residue);
Edward O'Callaghan91c10ae2020-10-09 12:56:53 +1100548 ret = default_spi_read(flash, buf, start, residue);
Simon Glass25e9f402015-06-28 13:31:19 +0000549 if (ret)
550 goto err;
Carl-Daniel Hailfinger482e9742010-11-16 21:25:29 +0000551 }
552
553 /* Round down. */
554 bulklen = (len - residue) / chunksize * chunksize;
Simon Glassae616512016-01-23 23:27:58 +0000555 ret = dediprog_spi_bulk_read(flash, buf + residue, start + residue, bulklen);
Simon Glass25e9f402015-06-28 13:31:19 +0000556 if (ret)
557 goto err;
Carl-Daniel Hailfinger482e9742010-11-16 21:25:29 +0000558
559 len -= residue + bulklen;
Simon Glassae616512016-01-23 23:27:58 +0000560 if (len != 0) {
Carl-Daniel Hailfinger482e9742010-11-16 21:25:29 +0000561 msg_pdbg("Slow read for partial block from 0x%x, length 0x%x\n",
562 start, len);
Edward O'Callaghan91c10ae2020-10-09 12:56:53 +1100563 ret = default_spi_read(flash, buf + residue + bulklen,
564 start + residue + bulklen, len);
Simon Glass25e9f402015-06-28 13:31:19 +0000565 if (ret)
566 goto err;
Carl-Daniel Hailfinger482e9742010-11-16 21:25:29 +0000567 }
568
Simon Glass25e9f402015-06-28 13:31:19 +0000569 dediprog_set_leds(LED_PASS);
Carl-Daniel Hailfinger482e9742010-11-16 21:25:29 +0000570 return 0;
Simon Glass25e9f402015-06-28 13:31:19 +0000571err:
572 dediprog_set_leds(LED_ERROR);
573 return ret;
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000574}
575
Nico Hubera4b14f72012-06-19 12:06:53 +0000576/* Bulk write interface, will write multiple chunksize byte chunks aligned to chunksize bytes.
577 * @chunksize length of data chunks, only 256 supported by now
578 * @start start address
579 * @len length
580 * @dedi_spi_cmd dediprog specific write command for spi bus
581 * @return 0 on success, 1 on failure
Carl-Daniel Hailfinger64204b52011-12-20 01:54:19 +0000582 */
Stefan Taunerffb0cf62014-05-25 07:47:47 +0000583static int dediprog_spi_bulk_write(struct flashctx *flash, const uint8_t *buf, unsigned int chunksize,
Nico Hubera4b14f72012-06-19 12:06:53 +0000584 unsigned int start, unsigned int len, uint8_t dedi_spi_cmd)
Carl-Daniel Hailfinger64204b52011-12-20 01:54:19 +0000585{
Carl-Daniel Hailfinger64204b52011-12-20 01:54:19 +0000586 /* USB transfer size must be 512, other sizes will NOT work at all.
587 * chunksize is the real data size per USB bulk transfer. The remaining
588 * space in a USB bulk transfer must be filled with 0xff padding.
589 */
Carl-Daniel Hailfinger64204b52011-12-20 01:54:19 +0000590 const unsigned int count = len / chunksize;
Carl-Daniel Hailfinger64204b52011-12-20 01:54:19 +0000591
Nico Hubera4b14f72012-06-19 12:06:53 +0000592 /*
593 * We should change this check to
594 * chunksize > 512
595 * once we know how to handle different chunk sizes.
596 */
597 if (chunksize != 256) {
598 msg_perr("%s: Chunk sizes other than 256 bytes are unsupported, chunksize=%u!\n"
599 "Please report a bug at flashrom@flashrom.org\n", __func__, chunksize);
600 return 1;
601 }
602
Carl-Daniel Hailfinger64204b52011-12-20 01:54:19 +0000603 if ((start % chunksize) || (len % chunksize)) {
604 msg_perr("%s: Unaligned start=%i, len=%i! Please report a bug "
605 "at flashrom@flashrom.org\n", __func__, start, len);
606 return 1;
607 }
608
609 /* No idea if the hardware can handle empty writes, so chicken out. */
Simon Glassae616512016-01-23 23:27:58 +0000610 if (len == 0)
Carl-Daniel Hailfinger64204b52011-12-20 01:54:19 +0000611 return 0;
Simon Glassae616512016-01-23 23:27:58 +0000612
David Hendricksf73f8a72018-02-21 07:34:34 -0800613 int command_packet_size;
614 switch (protocol()) {
615 case PROTOCOL_V1:
616 command_packet_size = 5;
617 break;
618 case PROTOCOL_V2:
619 command_packet_size = 10;
620 break;
621 case PROTOCOL_V3:
622 command_packet_size = 14;
623 break;
624 default:
625 return 1;
626 }
627
628 uint8_t data_packet[command_packet_size];
Simon Glassae616512016-01-23 23:27:58 +0000629 unsigned int value, idx;
Nico Huber7eb38aa2019-03-21 15:42:54 +0100630 if (prepare_rw_cmd(flash, data_packet, count, dedi_spi_cmd, &value, &idx, start, 0))
631 return 1;
Simon Glassae616512016-01-23 23:27:58 +0000632 int ret = dediprog_write(CMD_WRITE, value, idx, data_packet, sizeof(data_packet));
Nico Huber519be662018-12-23 20:03:35 +0100633 if (ret != (int)sizeof(data_packet)) {
Nico Huberd99a2bd2016-02-18 21:42:49 +0000634 msg_perr("Command Write SPI Bulk failed, %s!\n", libusb_error_name(ret));
Carl-Daniel Hailfinger64204b52011-12-20 01:54:19 +0000635 return 1;
636 }
637
Simon Glassae616512016-01-23 23:27:58 +0000638 unsigned int i;
Carl-Daniel Hailfinger64204b52011-12-20 01:54:19 +0000639 for (i = 0; i < count; i++) {
Nico Huberd99a2bd2016-02-18 21:42:49 +0000640 unsigned char usbbuf[512];
Carl-Daniel Hailfinger64204b52011-12-20 01:54:19 +0000641 memcpy(usbbuf, buf + i * chunksize, chunksize);
Simon Glassae616512016-01-23 23:27:58 +0000642 memset(usbbuf + chunksize, 0xff, sizeof(usbbuf) - chunksize); // fill up with 0xFF
Nico Huberd99a2bd2016-02-18 21:42:49 +0000643 int transferred;
644 ret = libusb_bulk_transfer(dediprog_handle, dediprog_out_endpoint, usbbuf, 512, &transferred,
645 DEFAULT_TIMEOUT);
646 if ((ret < 0) || (transferred != 512)) {
647 msg_perr("SPI bulk write failed, expected %i, got %s!\n", 512, libusb_error_name(ret));
Carl-Daniel Hailfinger64204b52011-12-20 01:54:19 +0000648 return 1;
649 }
650 }
651
652 return 0;
653}
654
Stefan Taunerffb0cf62014-05-25 07:47:47 +0000655static int dediprog_spi_write(struct flashctx *flash, const uint8_t *buf,
Nico Hubera4b14f72012-06-19 12:06:53 +0000656 unsigned int start, unsigned int len, uint8_t dedi_spi_cmd)
Carl-Daniel Hailfinger306b8182010-11-23 21:28:16 +0000657{
Stefan Reinauer915b8402011-01-28 09:00:15 +0000658 int ret;
Carl-Daniel Hailfinger5a7cb842012-08-25 01:17:58 +0000659 const unsigned int chunksize = flash->chip->page_size;
Carl-Daniel Hailfinger64204b52011-12-20 01:54:19 +0000660 unsigned int residue = start % chunksize ? chunksize - start % chunksize : 0;
661 unsigned int bulklen;
Stefan Reinauer915b8402011-01-28 09:00:15 +0000662
Simon Glass25e9f402015-06-28 13:31:19 +0000663 dediprog_set_leds(LED_BUSY);
Stefan Reinauer915b8402011-01-28 09:00:15 +0000664
Nico Hubera4b14f72012-06-19 12:06:53 +0000665 if (chunksize != 256) {
666 msg_pdbg("Page sizes other than 256 bytes are unsupported as "
667 "we don't know how dediprog\nhandles them.\n");
668 /* Write everything like it was residue. */
669 residue = len;
670 }
671
Carl-Daniel Hailfinger64204b52011-12-20 01:54:19 +0000672 if (residue) {
673 msg_pdbg("Slow write for partial block from 0x%x, length 0x%x\n",
674 start, residue);
Nico Huber93db6e12018-09-30 01:18:43 +0200675 /* No idea about the real limit. Maybe 16 including command and address, maybe more. */
676 ret = spi_write_chunked(flash, buf, start, residue, 11);
Carl-Daniel Hailfinger64204b52011-12-20 01:54:19 +0000677 if (ret) {
Simon Glass25e9f402015-06-28 13:31:19 +0000678 dediprog_set_leds(LED_ERROR);
Carl-Daniel Hailfinger64204b52011-12-20 01:54:19 +0000679 return ret;
680 }
681 }
Stefan Reinauer915b8402011-01-28 09:00:15 +0000682
Carl-Daniel Hailfinger64204b52011-12-20 01:54:19 +0000683 /* Round down. */
684 bulklen = (len - residue) / chunksize * chunksize;
Nico Hubera4b14f72012-06-19 12:06:53 +0000685 ret = dediprog_spi_bulk_write(flash, buf + residue, chunksize, start + residue, bulklen, dedi_spi_cmd);
Carl-Daniel Hailfinger64204b52011-12-20 01:54:19 +0000686 if (ret) {
Simon Glass25e9f402015-06-28 13:31:19 +0000687 dediprog_set_leds(LED_ERROR);
Carl-Daniel Hailfinger64204b52011-12-20 01:54:19 +0000688 return ret;
689 }
Stefan Reinauer915b8402011-01-28 09:00:15 +0000690
Carl-Daniel Hailfinger64204b52011-12-20 01:54:19 +0000691 len -= residue + bulklen;
692 if (len) {
693 msg_pdbg("Slow write for partial block from 0x%x, length 0x%x\n",
694 start, len);
695 ret = spi_write_chunked(flash, buf + residue + bulklen,
Nico Huber93db6e12018-09-30 01:18:43 +0200696 start + residue + bulklen, len, 11);
Carl-Daniel Hailfinger64204b52011-12-20 01:54:19 +0000697 if (ret) {
Simon Glass25e9f402015-06-28 13:31:19 +0000698 dediprog_set_leds(LED_ERROR);
Carl-Daniel Hailfinger64204b52011-12-20 01:54:19 +0000699 return ret;
700 }
701 }
702
Simon Glass25e9f402015-06-28 13:31:19 +0000703 dediprog_set_leds(LED_PASS);
Carl-Daniel Hailfinger64204b52011-12-20 01:54:19 +0000704 return 0;
Carl-Daniel Hailfinger306b8182010-11-23 21:28:16 +0000705}
706
Stefan Taunerffb0cf62014-05-25 07:47:47 +0000707static int dediprog_spi_write_256(struct flashctx *flash, const uint8_t *buf, unsigned int start, unsigned int len)
Nico Hubera4b14f72012-06-19 12:06:53 +0000708{
Simon Glass557eb4f2015-07-05 16:53:22 +0000709 return dediprog_spi_write(flash, buf, start, len, WRITE_MODE_PAGE_PGM);
Nico Hubera4b14f72012-06-19 12:06:53 +0000710}
711
Stefan Taunerffb0cf62014-05-25 07:47:47 +0000712static int dediprog_spi_write_aai(struct flashctx *flash, const uint8_t *buf, unsigned int start, unsigned int len)
Nico Hubera4b14f72012-06-19 12:06:53 +0000713{
Simon Glass557eb4f2015-07-05 16:53:22 +0000714 return dediprog_spi_write(flash, buf, start, len, WRITE_MODE_2B_AAI);
Nico Hubera4b14f72012-06-19 12:06:53 +0000715}
716
Edward O'Callaghane4ddc362020-04-12 17:27:53 +1000717static int dediprog_spi_send_command(const struct flashctx *flash,
Carl-Daniel Hailfinger8a3c60c2011-12-18 15:01:24 +0000718 unsigned int writecnt,
719 unsigned int readcnt,
720 const unsigned char *writearr,
721 unsigned char *readarr)
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000722{
723 int ret;
724
Carl-Daniel Hailfingereac65792010-01-22 02:53:30 +0000725 msg_pspew("%s, writecnt=%i, readcnt=%i\n", __func__, writecnt, readcnt);
Simon Glassae616512016-01-23 23:27:58 +0000726 if (writecnt > flash->mst->spi.max_data_write) {
Simon Glass557eb4f2015-07-05 16:53:22 +0000727 msg_perr("Invalid writecnt=%i, aborting.\n", writecnt);
Carl-Daniel Hailfingereac65792010-01-22 02:53:30 +0000728 return 1;
729 }
Simon Glassae616512016-01-23 23:27:58 +0000730 if (readcnt > flash->mst->spi.max_data_read) {
Simon Glass557eb4f2015-07-05 16:53:22 +0000731 msg_perr("Invalid readcnt=%i, aborting.\n", readcnt);
Carl-Daniel Hailfingereac65792010-01-22 02:53:30 +0000732 return 1;
733 }
Elyes HAOUAS0cacb112019-02-04 12:16:38 +0100734
Simon Glassae616512016-01-23 23:27:58 +0000735 unsigned int idx, value;
736 /* New protocol has options and timeout combined as value while the old one used the value field for
737 * timeout and the index field for options. */
David Hendricksf73f8a72018-02-21 07:34:34 -0800738 if (protocol() >= PROTOCOL_V2) {
Simon Glassae616512016-01-23 23:27:58 +0000739 idx = 0;
740 value = readcnt ? 0x1 : 0x0; // Indicate if we require a read
741 } else {
742 idx = readcnt ? 0x1 : 0x0; // Indicate if we require a read
743 value = 0;
744 }
745 ret = dediprog_write(CMD_TRANSCEIVE, value, idx, writearr, writecnt);
Nico Huber519be662018-12-23 20:03:35 +0100746 if (ret != (int)writecnt) {
Carl-Daniel Hailfingereac65792010-01-22 02:53:30 +0000747 msg_perr("Send SPI failed, expected %i, got %i %s!\n",
Nico Huberd99a2bd2016-02-18 21:42:49 +0000748 writecnt, ret, libusb_error_name(ret));
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000749 return 1;
750 }
Simon Glassae616512016-01-23 23:27:58 +0000751 if (readcnt == 0) // If we don't require a response, we are done here
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000752 return 0;
Simon Glass557eb4f2015-07-05 16:53:22 +0000753
Stefan Tauner74367bf2016-02-20 20:53:46 +0000754 /* The specifications do state the possibility to set a timeout for transceive transactions.
755 * Apparently the "timeout" is a delay, and you can use long delays to accelerate writing - in case you
756 * can predict the time needed by the previous command or so (untested). In any case, using this
757 * "feature" to set sane-looking timouts for the read below will completely trash performance with
758 * SF600 and/or firmwares >= 6.0 while they seem to be benign on SF100 with firmwares <= 5.5.2. *shrug*
759 *
760 * The specification also uses only 0 in its examples, so the lesson to learn here:
761 * "Never trust the description of an interface in the documentation but use the example code and pray."
Simon Glassae616512016-01-23 23:27:58 +0000762 const uint8_t read_timeout = 10 + readcnt/512;
David Hendricksf73f8a72018-02-21 07:34:34 -0800763 if (protocol() >= PROTOCOL_V2) {
Simon Glassae616512016-01-23 23:27:58 +0000764 idx = 0;
765 value = min(read_timeout, 0xFF) | (0 << 8) ; // Timeout in lower byte, option in upper byte
766 } else {
767 idx = (0 & 0xFF); // Lower byte is option (0x01 = require SR, 0x02 keep CS low)
768 value = min(read_timeout, 0xFF); // Possibly two bytes but we play safe here
769 }
770 ret = dediprog_read(CMD_TRANSCEIVE, value, idx, readarr, readcnt);
Stefan Tauner74367bf2016-02-20 20:53:46 +0000771 */
772 ret = dediprog_read(CMD_TRANSCEIVE, 0, 0, readarr, readcnt);
Nico Huber519be662018-12-23 20:03:35 +0100773 if (ret != (int)readcnt) {
Nico Huberd99a2bd2016-02-18 21:42:49 +0000774 msg_perr("Receive SPI failed, expected %i, got %i %s!\n", readcnt, ret, libusb_error_name(ret));
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000775 return 1;
776 }
777 return 0;
778}
779
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000780static int dediprog_check_devicestring(void)
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000781{
782 int ret;
783 char buf[0x11];
784
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000785 /* Command Receive Device String. */
Simon Glassae616512016-01-23 23:27:58 +0000786 ret = dediprog_read(CMD_READ_PROG_INFO, 0, 0, (uint8_t *)buf, 0x10);
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000787 if (ret != 0x10) {
788 msg_perr("Incomplete/failed Command Receive Device String!\n");
789 return 1;
790 }
791 buf[0x10] = '\0';
792 msg_pdbg("Found a %s\n", buf);
David Woodhouse7f3b89f2016-02-18 21:42:15 +0000793 if (memcmp(buf, "SF100", 0x5) == 0)
794 dediprog_devicetype = DEV_SF100;
Jay Thompsoncabe3202018-08-17 14:30:04 -0500795 else if (memcmp(buf, "SF200", 0x5) == 0)
796 dediprog_devicetype = DEV_SF200;
David Woodhouse7f3b89f2016-02-18 21:42:15 +0000797 else if (memcmp(buf, "SF600", 0x5) == 0)
798 dediprog_devicetype = DEV_SF600;
799 else {
Jay Thompsoncabe3202018-08-17 14:30:04 -0500800 msg_perr("Device not a SF100, SF200, or SF600!\n");
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000801 return 1;
802 }
David Woodhouse7f3b89f2016-02-18 21:42:15 +0000803
804 int sfnum;
805 int fw[3];
806 if (sscanf(buf, "SF%d V:%d.%d.%d ", &sfnum, &fw[0], &fw[1], &fw[2]) != 4 ||
Nico Huber519be662018-12-23 20:03:35 +0100807 sfnum != (int)dediprog_devicetype) {
Simon Glassae616512016-01-23 23:27:58 +0000808 msg_perr("Unexpected firmware version string '%s'\n", buf);
Mathias Krausedb7afc52010-11-09 23:30:43 +0000809 return 1;
810 }
Simon Glassae616512016-01-23 23:27:58 +0000811 /* Only these major versions were tested. */
David Woodhouse7f3b89f2016-02-18 21:42:15 +0000812 if (fw[0] < 2 || fw[0] > 7) {
Simon Glassae616512016-01-23 23:27:58 +0000813 msg_perr("Unexpected firmware version %d.%d.%d!\n", fw[0], fw[1], fw[2]);
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000814 return 1;
815 }
David Hendricksf73f8a72018-02-21 07:34:34 -0800816
Stefan Reinauer915b8402011-01-28 09:00:15 +0000817 dediprog_firmwareversion = FIRMWARE_VERSION(fw[0], fw[1], fw[2]);
David Hendricksf73f8a72018-02-21 07:34:34 -0800818 if (protocol() == PROTOCOL_UNKNOWN) {
819 msg_perr("Internal error: Unable to determine protocol version.\n");
820 return 1;
821 }
Simon Glassae616512016-01-23 23:27:58 +0000822
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000823 return 0;
824}
825
David Hendricksc05900f2016-02-18 21:42:41 +0000826/*
Ryan O'Leary301ae222019-06-24 19:14:33 -0700827 * Read the id from the dediprog. This should return the numeric part of the
828 * serial number found on a sticker on the back of the dediprog. Note this
829 * number is stored in writable eeprom, so it could get out of sync. Also note,
830 * this function only supports SF100 at this time, but SF600 support is not too
831 * much different.
832 * @return the id on success, -1 on failure
833 */
834static int dediprog_read_id(void)
835{
836 int ret;
837 uint8_t buf[3];
838
839 ret = libusb_control_transfer(dediprog_handle, REQTYPE_OTHER_IN,
840 0x7, /* request */
841 0, /* value */
842 0xEF00, /* index */
843 buf, sizeof(buf),
844 DEFAULT_TIMEOUT);
845 if (ret != sizeof(buf)) {
846 msg_perr("Failed to read dediprog id, error %d!\n", ret);
847 return -1;
848 }
849
850 return buf[0] << 16 | buf[1] << 8 | buf[2];
851}
852
853/*
David Hendricksc05900f2016-02-18 21:42:41 +0000854 * This command presumably sets the voltage for the SF100 itself (not the
855 * SPI flash). Only use this command with firmware older than V6.0.0. Newer
856 * (including all SF600s) do not support it.
857 */
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000858
David Hendricksc05900f2016-02-18 21:42:41 +0000859/* This command presumably sets the voltage for the SF100 itself (not the SPI flash).
860 * Only use dediprog_set_voltage on SF100 programmers with firmware older
861 * than V6.0.0. Newer programmers (including all SF600s) do not support it. */
862static int dediprog_set_voltage(void)
863{
Nico Huberd99a2bd2016-02-18 21:42:49 +0000864 unsigned char buf[1] = {0};
865 int ret = libusb_control_transfer(dediprog_handle, REQTYPE_OTHER_IN, CMD_SET_VOLTAGE, 0x0, 0x0,
Simon Glass557eb4f2015-07-05 16:53:22 +0000866 buf, 0x1, DEFAULT_TIMEOUT);
Mathias Krausedb7afc52010-11-09 23:30:43 +0000867 if (ret < 0) {
Nico Huberd99a2bd2016-02-18 21:42:49 +0000868 msg_perr("Command Set Voltage failed (%s)!\n", libusb_error_name(ret));
Mathias Krausedb7afc52010-11-09 23:30:43 +0000869 return 1;
870 }
David Hendricksc05900f2016-02-18 21:42:41 +0000871 if ((ret != 1) || (buf[0] != 0x6f)) {
Simon Glass557eb4f2015-07-05 16:53:22 +0000872 msg_perr("Unexpected response to init!\n");
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000873 return 1;
874 }
David Hendricksc05900f2016-02-18 21:42:41 +0000875
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000876 return 0;
877}
878
David Woodhouse7f3b89f2016-02-18 21:42:15 +0000879static int dediprog_standalone_mode(void)
880{
881 int ret;
882
883 if (dediprog_devicetype != DEV_SF600)
884 return 0;
885
886 msg_pdbg2("Disabling standalone mode.\n");
887 ret = dediprog_write(CMD_SET_STANDALONE, LEAVE_STANDALONE_MODE, 0, NULL, 0);
888 if (ret) {
Nico Huberd99a2bd2016-02-18 21:42:49 +0000889 msg_perr("Failed to disable standalone mode: %s\n", libusb_error_name(ret));
David Woodhouse7f3b89f2016-02-18 21:42:15 +0000890 return 1;
891 }
892
893 return 0;
894}
895
Carl-Daniel Hailfingerff30d8a2011-01-20 21:05:15 +0000896#if 0
897/* Something.
898 * Present in eng_detect_blink.log with firmware 3.1.8
899 * Always preceded by Command Receive Device String
900 */
901static int dediprog_command_b(void)
902{
903 int ret;
904 char buf[0x3];
905
Simon Glass557eb4f2015-07-05 16:53:22 +0000906 ret = usb_control_msg(dediprog_handle, REQTYPE_OTHER_IN, 0x7, 0x0, 0xef00,
907 buf, 0x3, DEFAULT_TIMEOUT);
Carl-Daniel Hailfingerff30d8a2011-01-20 21:05:15 +0000908 if (ret < 0) {
Nico Huberd99a2bd2016-02-18 21:42:49 +0000909 msg_perr("Command B failed (%s)!\n", libusb_error_name(ret));
Carl-Daniel Hailfingerff30d8a2011-01-20 21:05:15 +0000910 return 1;
911 }
912 if ((ret != 0x3) || (buf[0] != 0xff) || (buf[1] != 0xff) ||
913 (buf[2] != 0xff)) {
914 msg_perr("Unexpected response to Command B!\n");
915 return 1;
916 }
917
918 return 0;
919}
920#endif
921
Simon Glass557eb4f2015-07-05 16:53:22 +0000922static int set_target_flash(enum dediprog_target target)
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000923{
Nico Huberd99a2bd2016-02-18 21:42:49 +0000924 int ret = dediprog_write(CMD_SET_TARGET, target, 0, NULL, 0);
Simon Glass557eb4f2015-07-05 16:53:22 +0000925 if (ret != 0) {
Nico Huberd99a2bd2016-02-18 21:42:49 +0000926 msg_perr("set_target_flash failed (%s)!\n", libusb_error_name(ret));
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000927 return 1;
928 }
929 return 0;
930}
931
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000932#if 0
Simon Glass557eb4f2015-07-05 16:53:22 +0000933/* Returns true if the button is currently pressed. */
934static bool dediprog_get_button(void)
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000935{
Simon Glass557eb4f2015-07-05 16:53:22 +0000936 char buf[1];
937 int ret = usb_control_msg(dediprog_handle, REQTYPE_EP_IN, CMD_GET_BUTTON, 0, 0,
938 buf, 0x1, DEFAULT_TIMEOUT);
939 if (ret != 0) {
Nico Huberd99a2bd2016-02-18 21:42:49 +0000940 msg_perr("Could not get button state (%s)!\n", libusb_error_name(ret));
Carl-Daniel Hailfingerff30d8a2011-01-20 21:05:15 +0000941 return 1;
942 }
Simon Glass557eb4f2015-07-05 16:53:22 +0000943 return buf[0] != 1;
Carl-Daniel Hailfinger64204b52011-12-20 01:54:19 +0000944}
Carl-Daniel Hailfingerad3cc552010-07-03 11:02:10 +0000945#endif
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +0000946
Carl-Daniel Hailfingerc2441382010-11-09 22:00:31 +0000947static int parse_voltage(char *voltage)
948{
949 char *tmp = NULL;
Carl-Daniel Hailfinger082c8b52011-08-15 19:54:20 +0000950 int i;
951 int millivolt = 0, fraction = 0;
Carl-Daniel Hailfingerc2441382010-11-09 22:00:31 +0000952
953 if (!voltage || !strlen(voltage)) {
954 msg_perr("Empty voltage= specified.\n");
955 return -1;
956 }
957 millivolt = (int)strtol(voltage, &tmp, 0);
958 voltage = tmp;
959 /* Handle "," and "." as decimal point. Everything after it is assumed
960 * to be in decimal notation.
961 */
962 if ((*voltage == '.') || (*voltage == ',')) {
963 voltage++;
964 for (i = 0; i < 3; i++) {
965 fraction *= 10;
966 /* Don't advance if the current character is invalid,
967 * but continue multiplying.
968 */
969 if ((*voltage < '0') || (*voltage > '9'))
970 continue;
971 fraction += *voltage - '0';
972 voltage++;
973 }
974 /* Throw away remaining digits. */
975 voltage += strspn(voltage, "0123456789");
976 }
977 /* The remaining string must be empty or "mV" or "V". */
978 tolower_string(voltage);
979
980 /* No unit or "V". */
981 if ((*voltage == '\0') || !strncmp(voltage, "v", 1)) {
982 millivolt *= 1000;
983 millivolt += fraction;
984 } else if (!strncmp(voltage, "mv", 2) ||
985 !strncmp(voltage, "milliv", 6)) {
986 /* No adjustment. fraction is discarded. */
987 } else {
988 /* Garbage at the end of the string. */
989 msg_perr("Garbage voltage= specified.\n");
990 return -1;
991 }
992 return millivolt;
993}
994
Nico Huber93db6e12018-09-30 01:18:43 +0200995static struct spi_master spi_master_dediprog = {
Nico Huberdc5af542018-12-22 16:54:59 +0100996 .features = SPI_MASTER_NO_4BA_MODES,
Simon Glassae616512016-01-23 23:27:58 +0000997 .max_data_read = 16, /* 18 seems to work fine as well, but 19 times out sometimes with FW 5.15. */
998 .max_data_write = 16,
Uwe Hermann91f4afa2011-07-28 08:13:25 +0000999 .command = dediprog_spi_send_command,
1000 .multicommand = default_spi_send_multicommand,
1001 .read = dediprog_spi_read,
1002 .write_256 = dediprog_spi_write_256,
Nico Hubera4b14f72012-06-19 12:06:53 +00001003 .write_aai = dediprog_spi_write_aai,
Michael Karcherb9dbe482011-05-11 17:07:07 +00001004};
1005
Ryan O'Leary301ae222019-06-24 19:14:33 -07001006/*
1007 * Open a dediprog_handle with the USB device at the given index.
1008 * @index index of the USB device
1009 * @return 0 for success, -1 for error, -2 for busy device
1010 */
1011static int dediprog_open(int index)
1012{
1013 const uint16_t vid = devs_dediprog[0].vendor_id;
1014 const uint16_t pid = devs_dediprog[0].device_id;
1015 int ret;
1016
1017 dediprog_handle = usb_dev_get_by_vid_pid_number(usb_ctx, vid, pid, (unsigned int) index);
1018 if (!dediprog_handle) {
1019 msg_perr("Could not find a Dediprog programmer on USB.\n");
1020 libusb_exit(usb_ctx);
1021 return -1;
1022 }
1023 ret = libusb_set_configuration(dediprog_handle, 1);
1024 if (ret != 0) {
1025 msg_perr("Could not set USB device configuration: %i %s\n",
1026 ret, libusb_error_name(ret));
1027 libusb_close(dediprog_handle);
1028 return -2;
1029 }
1030 ret = libusb_claim_interface(dediprog_handle, 0);
1031 if (ret < 0) {
1032 msg_perr("Could not claim USB device interface %i: %i %s\n",
1033 0, ret, libusb_error_name(ret));
1034 libusb_close(dediprog_handle);
1035 return -2;
1036 }
1037 return 0;
1038}
1039
David Hendricks8bb20212011-06-14 01:35:36 +00001040static int dediprog_shutdown(void *data)
1041{
David Woodhouse7f3b89f2016-02-18 21:42:15 +00001042 dediprog_devicetype = DEV_UNKNOWN;
Carl-Daniel Hailfinger64204b52011-12-20 01:54:19 +00001043
David Hendricks8bb20212011-06-14 01:35:36 +00001044 /* URB 28. Command Set SPI Voltage to 0. */
1045 if (dediprog_set_spi_voltage(0x0))
1046 return 1;
1047
Nico Huberd99a2bd2016-02-18 21:42:49 +00001048 if (libusb_release_interface(dediprog_handle, 0)) {
David Hendricks8bb20212011-06-14 01:35:36 +00001049 msg_perr("Could not release USB interface!\n");
1050 return 1;
1051 }
Nico Huberd99a2bd2016-02-18 21:42:49 +00001052 libusb_close(dediprog_handle);
1053 libusb_exit(usb_ctx);
1054
David Hendricks8bb20212011-06-14 01:35:36 +00001055 return 0;
1056}
1057
Thomas Heijligen4f5169d2021-05-04 15:32:17 +02001058static int dediprog_init(void)
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +00001059{
Ryan O'Leary301ae222019-06-24 19:14:33 -07001060 char *voltage, *id_str, *device, *spispeed, *target_str;
Patrick Georgiefe2d432013-05-23 21:47:46 +00001061 int spispeed_idx = 1;
Carl-Daniel Hailfinger082c8b52011-08-15 19:54:20 +00001062 int millivolt = 3500;
Ryan O'Leary301ae222019-06-24 19:14:33 -07001063 int id = -1; /* -1 defaults to enumeration order */
1064 int found_id;
Nathan Laredo21541a62012-12-24 22:07:36 +00001065 long usedevice = 0;
Nico Huber5e5e8212016-05-04 12:27:58 +02001066 long target = FLASH_TYPE_APPLICATION_FLASH_1;
Nico Huber77fa67d2013-02-20 18:03:36 +00001067 int i, ret;
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +00001068
Nico Huber77fa67d2013-02-20 18:03:36 +00001069 spispeed = extract_programmer_param("spispeed");
1070 if (spispeed) {
1071 for (i = 0; spispeeds[i].name; ++i) {
1072 if (!strcasecmp(spispeeds[i].name, spispeed)) {
1073 spispeed_idx = i;
1074 break;
1075 }
1076 }
1077 if (!spispeeds[i].name) {
Patrick Georgiefe2d432013-05-23 21:47:46 +00001078 msg_perr("Error: Invalid spispeed value: '%s'.\n", spispeed);
Nico Huber77fa67d2013-02-20 18:03:36 +00001079 free(spispeed);
1080 return 1;
1081 }
1082 free(spispeed);
1083 }
Simon Glass557eb4f2015-07-05 16:53:22 +00001084
Carl-Daniel Hailfingerc2441382010-11-09 22:00:31 +00001085 voltage = extract_programmer_param("voltage");
1086 if (voltage) {
1087 millivolt = parse_voltage(voltage);
1088 free(voltage);
Uwe Hermann91f4afa2011-07-28 08:13:25 +00001089 if (millivolt < 0)
Carl-Daniel Hailfingerc2441382010-11-09 22:00:31 +00001090 return 1;
Carl-Daniel Hailfingerc2441382010-11-09 22:00:31 +00001091 msg_pinfo("Setting voltage to %i mV\n", millivolt);
1092 }
1093
Ryan O'Leary301ae222019-06-24 19:14:33 -07001094 id_str = extract_programmer_param("id");
1095 if (id_str) {
1096 char prefix0, prefix1;
1097 if (sscanf(id_str, "%c%c%d", &prefix0, &prefix1, &id) != 3) {
1098 msg_perr("Error: Could not parse dediprog 'id'.\n");
1099 msg_perr("Expected a string like SF012345 or DP012345.\n");
1100 free(id_str);
1101 return 1;
1102 }
1103 if (id < 0 || id >= 0x1000000) {
1104 msg_perr("Error: id %s is out of range!\n", id_str);
1105 free(id_str);
1106 return 1;
1107 }
1108 if (!(prefix0 == 'S' && prefix1 == 'F') && !(prefix0 == 'D' && prefix1 == 'P')) {
1109 msg_perr("Error: %s is an invalid id!\n", id_str);
1110 free(id_str);
1111 return 1;
1112 }
1113 msg_pinfo("Will search for dediprog id %s.\n", id_str);
1114 }
1115 free(id_str);
1116
Nathan Laredo21541a62012-12-24 22:07:36 +00001117 device = extract_programmer_param("device");
1118 if (device) {
1119 char *dev_suffix;
Ryan O'Leary301ae222019-06-24 19:14:33 -07001120 if (id != -1) {
1121 msg_perr("Error: Cannot use 'id' and 'device'.\n");
1122 }
Nathan Laredo21541a62012-12-24 22:07:36 +00001123 errno = 0;
1124 usedevice = strtol(device, &dev_suffix, 10);
1125 if (errno != 0 || device == dev_suffix) {
1126 msg_perr("Error: Could not convert 'device'.\n");
1127 free(device);
1128 return 1;
1129 }
Nico Huber961f4a12019-10-04 17:34:22 +02001130 if (usedevice < 0 || usedevice > INT_MAX) {
Nathan Laredo21541a62012-12-24 22:07:36 +00001131 msg_perr("Error: Value for 'device' is out of range.\n");
1132 free(device);
1133 return 1;
1134 }
1135 if (strlen(dev_suffix) > 0) {
1136 msg_perr("Error: Garbage following 'device' value.\n");
1137 free(device);
1138 return 1;
1139 }
1140 msg_pinfo("Using device %li.\n", usedevice);
1141 }
1142 free(device);
1143
Stefan Taunere659d2d2013-05-03 21:58:28 +00001144 target_str = extract_programmer_param("target");
1145 if (target_str) {
1146 char *target_suffix;
1147 errno = 0;
1148 target = strtol(target_str, &target_suffix, 10);
1149 if (errno != 0 || target_str == target_suffix) {
1150 msg_perr("Error: Could not convert 'target'.\n");
1151 free(target_str);
1152 return 1;
1153 }
1154 if (target < 1 || target > 2) {
1155 msg_perr("Error: Value for 'target' is out of range.\n");
1156 free(target_str);
1157 return 1;
1158 }
1159 if (strlen(target_suffix) > 0) {
1160 msg_perr("Error: Garbage following 'target' value.\n");
1161 free(target_str);
1162 return 1;
1163 }
Nico Huber5e5e8212016-05-04 12:27:58 +02001164 switch (target) {
1165 case 1:
1166 msg_pinfo("Using target %s.\n", "FLASH_TYPE_APPLICATION_FLASH_1");
1167 target = FLASH_TYPE_APPLICATION_FLASH_1;
1168 break;
1169 case 2:
1170 msg_pinfo("Using target %s.\n", "FLASH_TYPE_APPLICATION_FLASH_2");
1171 target = FLASH_TYPE_APPLICATION_FLASH_2;
1172 break;
1173 default:
1174 break;
1175 }
Stefan Taunere659d2d2013-05-03 21:58:28 +00001176 }
1177 free(target_str);
1178
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +00001179 /* Here comes the USB stuff. */
Nico Huberd99a2bd2016-02-18 21:42:49 +00001180 libusb_init(&usb_ctx);
1181 if (!usb_ctx) {
1182 msg_perr("Could not initialize libusb!\n");
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +00001183 return 1;
1184 }
Stefan Taunerfdec7472016-02-22 08:59:27 +00001185
Ryan O'Leary301ae222019-06-24 19:14:33 -07001186 if (id != -1) {
1187 for (i = 0; ; i++) {
1188 ret = dediprog_open(i);
1189 if (ret == -1) {
1190 /* no dev */
Ryan O'Leary301ae222019-06-24 19:14:33 -07001191 return 1;
1192 } else if (ret == -2) {
1193 /* busy dev */
1194 continue;
1195 }
1196
1197 /* Notice we can only call dediprog_read_id() after
1198 * libusb_set_configuration() and
1199 * libusb_claim_interface(). When searching by id and
1200 * either configuration or claim fails (usually the
1201 * device is in use by another instance of flashrom),
1202 * the device is skipped and the next device is tried.
1203 */
1204 found_id = dediprog_read_id();
1205 if (found_id < 0) {
1206 msg_perr("Could not read id.\n");
1207 libusb_release_interface(dediprog_handle, 0);
1208 libusb_close(dediprog_handle);
1209 continue;
1210 }
1211 msg_pinfo("Found dediprog id SF%06d.\n", found_id);
1212 if (found_id != id) {
1213 libusb_release_interface(dediprog_handle, 0);
1214 libusb_close(dediprog_handle);
1215 continue;
1216 }
1217 break;
1218 }
1219 } else {
1220 if (dediprog_open(usedevice)) {
1221 return 1;
1222 }
1223 found_id = dediprog_read_id();
David Woodhoused2a7e872013-07-30 09:34:44 +00001224 }
Ryan O'Leary301ae222019-06-24 19:14:33 -07001225
1226 if (found_id >= 0) {
1227 msg_pinfo("Using dediprog id SF%06d.\n", found_id);
Carl-Daniel Hailfinger482e9742010-11-16 21:25:29 +00001228 }
Nico Huber77fa67d2013-02-20 18:03:36 +00001229
David Hendricks8bb20212011-06-14 01:35:36 +00001230 if (register_shutdown(dediprog_shutdown, NULL))
1231 return 1;
1232
David Hendricksc05900f2016-02-18 21:42:41 +00001233 /* Try reading the devicestring. If that fails and the device is old (FW < 6.0.0, which we can not know)
1234 * then we need to try the "set voltage" command and then attempt to read the devicestring again. */
1235 if (dediprog_check_devicestring()) {
1236 if (dediprog_set_voltage())
1237 return 1;
1238 if (dediprog_check_devicestring())
1239 return 1;
1240 }
Nico Huber77fa67d2013-02-20 18:03:36 +00001241
Jay Thompsoncabe3202018-08-17 14:30:04 -05001242 /* SF100/SF200 uses one in/out endpoint, SF600 uses separate in/out endpoints */
David Woodhouse7f3b89f2016-02-18 21:42:15 +00001243 dediprog_in_endpoint = 2;
Jay Thompsoncabe3202018-08-17 14:30:04 -05001244 switch (dediprog_devicetype) {
1245 case DEV_SF100:
1246 case DEV_SF200:
David Woodhouse7f3b89f2016-02-18 21:42:15 +00001247 dediprog_out_endpoint = 2;
Jay Thompsoncabe3202018-08-17 14:30:04 -05001248 break;
1249 default:
David Woodhouse7f3b89f2016-02-18 21:42:15 +00001250 dediprog_out_endpoint = 1;
Jay Thompsoncabe3202018-08-17 14:30:04 -05001251 break;
1252 }
David Woodhouse7f3b89f2016-02-18 21:42:15 +00001253
Simon Glass25e9f402015-06-28 13:31:19 +00001254 /* Set all possible LEDs as soon as possible to indicate activity.
1255 * Because knowing the firmware version is required to set the LEDs correctly we need to this after
David Hendricksf73f8a72018-02-21 07:34:34 -08001256 * dediprog_check_devicestring() has queried the device. */
Simon Glass25e9f402015-06-28 13:31:19 +00001257 dediprog_set_leds(LED_ALL);
1258
Simon Glass557eb4f2015-07-05 16:53:22 +00001259 /* Select target/socket, frequency and VCC. */
Nico Huber5e5e8212016-05-04 12:27:58 +02001260 if (set_target_flash(target) ||
Simon Glass557eb4f2015-07-05 16:53:22 +00001261 dediprog_set_spi_speed(spispeed_idx) ||
1262 dediprog_set_spi_voltage(millivolt)) {
Simon Glass25e9f402015-06-28 13:31:19 +00001263 dediprog_set_leds(LED_ERROR);
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +00001264 return 1;
Stefan Reinauer915b8402011-01-28 09:00:15 +00001265 }
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +00001266
David Woodhouse7f3b89f2016-02-18 21:42:15 +00001267 if (dediprog_standalone_mode())
1268 return 1;
1269
Patrick Rudolph12a55bc2020-08-26 07:58:16 +02001270 if ((dediprog_devicetype == DEV_SF100) ||
1271 (dediprog_devicetype == DEV_SF600 && protocol() == PROTOCOL_V3))
Nico Huber7eb38aa2019-03-21 15:42:54 +01001272 spi_master_dediprog.features &= ~SPI_MASTER_NO_4BA_MODES;
1273
Patrick Rudolph9e8486e2020-08-26 10:02:08 +02001274 if (protocol() >= PROTOCOL_V2)
Nico Huber93db6e12018-09-30 01:18:43 +02001275 spi_master_dediprog.features |= SPI_MASTER_4BA;
1276
Nico Huber7e496852021-05-11 17:38:14 +02001277 if (register_spi_master(&spi_master_dediprog, NULL) || dediprog_set_leds(LED_NONE))
Simon Glassae616512016-01-23 23:27:58 +00001278 return 1;
Stefan Reinauer915b8402011-01-28 09:00:15 +00001279
Carl-Daniel Hailfingerd38fac82010-01-19 11:15:48 +00001280 return 0;
1281}
Thomas Heijligen4f5169d2021-05-04 15:32:17 +02001282
1283const struct programmer_entry programmer_dediprog = {
1284 .name = "dediprog",
1285 .type = USB,
1286 .devs.dev = devs_dediprog,
1287 .init = dediprog_init,
1288 .map_flash_region = fallback_map,
1289 .unmap_flash_region = fallback_unmap,
1290 .delay = internal_delay,
1291};