Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 1 | /* |
| 2 | * This file is part of the flashrom project. |
| 3 | * |
| 4 | * Copyright (C) 2010 Carl-Daniel Hailfinger |
Simon Glass | 557eb4f | 2015-07-05 16:53:22 +0000 | [diff] [blame] | 5 | * Copyright (C) 2015 Simon Glass |
| 6 | * Copyright (C) 2015 Stefan Tauner |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 7 | * |
| 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. |
| 16 | * |
| 17 | * You should have received a copy of the GNU General Public License |
| 18 | * along with this program; if not, write to the Free Software |
| 19 | * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA |
| 20 | */ |
| 21 | |
Stefan Tauner | 0cbd8c2 | 2015-01-26 22:06:04 +0000 | [diff] [blame] | 22 | #include "platform.h" |
| 23 | |
Stefan Tauner | 5c316f9 | 2015-02-08 21:57:52 +0000 | [diff] [blame] | 24 | #include <stdlib.h> |
Mathias Krause | db7afc5 | 2010-11-09 23:30:43 +0000 | [diff] [blame] | 25 | #include <stdio.h> |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 26 | #include <string.h> |
Stefan Tauner | e34e3e8 | 2013-01-01 00:06:51 +0000 | [diff] [blame] | 27 | #include <limits.h> |
Nathan Laredo | 21541a6 | 2012-12-24 22:07:36 +0000 | [diff] [blame] | 28 | #include <errno.h> |
Stefan Tauner | 0cbd8c2 | 2015-01-26 22:06:04 +0000 | [diff] [blame] | 29 | |
| 30 | #if IS_WINDOWS |
| 31 | #include <lusb0_usb.h> |
| 32 | #else |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 33 | #include <usb.h> |
Stefan Tauner | 0cbd8c2 | 2015-01-26 22:06:04 +0000 | [diff] [blame] | 34 | #endif |
| 35 | |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 36 | #include "flash.h" |
Sean Nelson | 14ba668 | 2010-02-26 05:48:29 +0000 | [diff] [blame] | 37 | #include "chipdrivers.h" |
Carl-Daniel Hailfinger | 5b997c3 | 2010-07-27 22:41:39 +0000 | [diff] [blame] | 38 | #include "programmer.h" |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 39 | #include "spi.h" |
| 40 | |
Stefan Reinauer | 915b840 | 2011-01-28 09:00:15 +0000 | [diff] [blame] | 41 | #define FIRMWARE_VERSION(x,y,z) ((x << 16) | (y << 8) | z) |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 42 | #define DEFAULT_TIMEOUT 3000 |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 43 | #define REQTYPE_OTHER_OUT (USB_ENDPOINT_OUT | USB_TYPE_VENDOR | USB_RECIP_OTHER) /* 0x43 */ |
Simon Glass | 557eb4f | 2015-07-05 16:53:22 +0000 | [diff] [blame] | 44 | #define REQTYPE_OTHER_IN (USB_ENDPOINT_IN | USB_TYPE_VENDOR | USB_RECIP_OTHER) /* 0xC3 */ |
| 45 | #define REQTYPE_EP_OUT (USB_ENDPOINT_OUT | USB_TYPE_VENDOR | USB_RECIP_ENDPOINT) /* 0x42 */ |
| 46 | #define REQTYPE_EP_IN (USB_ENDPOINT_IN | USB_TYPE_VENDOR | USB_RECIP_ENDPOINT) /* 0xC2 */ |
Carl-Daniel Hailfinger | ad3cc55 | 2010-07-03 11:02:10 +0000 | [diff] [blame] | 47 | static usb_dev_handle *dediprog_handle; |
David Woodhouse | 7f3b89f | 2016-02-18 21:42:15 +0000 | [diff] [blame] | 48 | static int dediprog_in_endpoint; |
| 49 | static int dediprog_out_endpoint; |
| 50 | |
| 51 | enum dediprog_devtype { |
| 52 | DEV_UNKNOWN = 0, |
| 53 | DEV_SF100 = 100, |
| 54 | DEV_SF600 = 600, |
| 55 | }; |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 56 | |
Simon Glass | 25e9f40 | 2015-06-28 13:31:19 +0000 | [diff] [blame] | 57 | enum dediprog_leds { |
| 58 | LED_INVALID = -1, |
| 59 | LED_NONE = 0, |
| 60 | LED_PASS = 1 << 0, |
| 61 | LED_BUSY = 1 << 1, |
| 62 | LED_ERROR = 1 << 2, |
| 63 | LED_ALL = 7, |
| 64 | }; |
| 65 | |
Simon Glass | 557eb4f | 2015-07-05 16:53:22 +0000 | [diff] [blame] | 66 | /* IO bits for CMD_SET_IO_LED message */ |
| 67 | enum dediprog_ios { |
| 68 | IO1 = 1 << 0, |
| 69 | IO2 = 1 << 1, |
| 70 | IO3 = 1 << 2, |
| 71 | IO4 = 1 << 3, |
| 72 | }; |
| 73 | |
| 74 | enum dediprog_cmds { |
| 75 | CMD_TRANSCEIVE = 0x01, |
| 76 | CMD_POLL_STATUS_REG = 0x02, |
| 77 | CMD_SET_VPP = 0x03, |
| 78 | CMD_SET_TARGET = 0x04, |
| 79 | CMD_READ_EEPROM = 0x05, |
| 80 | CMD_WRITE_EEPROM = 0x06, |
| 81 | CMD_SET_IO_LED = 0x07, |
| 82 | CMD_READ_PROG_INFO = 0x08, |
| 83 | CMD_SET_VCC = 0x09, |
| 84 | CMD_SET_STANDALONE = 0x0A, |
David Hendricks | c05900f | 2016-02-18 21:42:41 +0000 | [diff] [blame^] | 85 | CMD_SET_VOLTAGE = 0x0B, /* Only in firmware older than 6.0.0 */ |
Simon Glass | 557eb4f | 2015-07-05 16:53:22 +0000 | [diff] [blame] | 86 | CMD_GET_BUTTON = 0x11, |
| 87 | CMD_GET_UID = 0x12, |
| 88 | CMD_SET_CS = 0x14, |
| 89 | CMD_IO_MODE = 0x15, |
| 90 | CMD_FW_UPDATE = 0x1A, |
| 91 | CMD_FPGA_UPDATE = 0x1B, |
| 92 | CMD_READ_FPGA_VERSION = 0x1C, |
| 93 | CMD_SET_HOLD = 0x1D, |
| 94 | CMD_READ = 0x20, |
| 95 | CMD_WRITE = 0x30, |
| 96 | CMD_WRITE_AT45DB = 0x31, |
| 97 | CMD_NAND_WRITE = 0x32, |
| 98 | CMD_NAND_READ = 0x33, |
| 99 | CMD_SET_SPI_CLK = 0x61, |
| 100 | CMD_CHECK_SOCKET = 0x62, |
| 101 | CMD_DOWNLOAD_PRJ = 0x63, |
| 102 | CMD_READ_PRJ_NAME = 0x64, |
| 103 | // New protocol/firmware only |
| 104 | CMD_CHECK_SDCARD = 0x65, |
| 105 | CMD_READ_PRJ = 0x66, |
| 106 | }; |
| 107 | |
| 108 | enum dediprog_target { |
| 109 | FLASH_TYPE_APPLICATION_FLASH_1 = 0, |
| 110 | FLASH_TYPE_FLASH_CARD, |
| 111 | FLASH_TYPE_APPLICATION_FLASH_2, |
| 112 | FLASH_TYPE_SOCKET, |
| 113 | }; |
| 114 | |
| 115 | enum dediprog_readmode { |
| 116 | READ_MODE_STD = 1, |
| 117 | READ_MODE_FAST = 2, |
| 118 | READ_MODE_ATMEL45 = 3, |
| 119 | READ_MODE_4B_ADDR_FAST = 4, |
| 120 | READ_MODE_4B_ADDR_FAST_0x0C = 5, /* New protocol only */ |
| 121 | }; |
| 122 | |
| 123 | enum dediprog_writemode { |
| 124 | WRITE_MODE_PAGE_PGM = 1, |
| 125 | WRITE_MODE_PAGE_WRITE = 2, |
| 126 | WRITE_MODE_1B_AAI = 3, |
| 127 | WRITE_MODE_2B_AAI = 4, |
| 128 | WRITE_MODE_128B_PAGE = 5, |
| 129 | WRITE_MODE_PAGE_AT26DF041 = 6, |
| 130 | WRITE_MODE_SILICON_BLUE_FPGA = 7, |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 131 | WRITE_MODE_64B_PAGE_NUMONYX_PCM = 8, /* unit of 512 bytes */ |
Simon Glass | 557eb4f | 2015-07-05 16:53:22 +0000 | [diff] [blame] | 132 | WRITE_MODE_4B_ADDR_256B_PAGE_PGM = 9, |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 133 | WRITE_MODE_32B_PAGE_PGM_MXIC_512K = 10, /* unit of 512 bytes */ |
Simon Glass | 557eb4f | 2015-07-05 16:53:22 +0000 | [diff] [blame] | 134 | WRITE_MODE_4B_ADDR_256B_PAGE_PGM_0x12 = 11, |
| 135 | WRITE_MODE_4B_ADDR_256B_PAGE_PGM_FLAGS = 12, |
| 136 | }; |
| 137 | |
David Woodhouse | 7f3b89f | 2016-02-18 21:42:15 +0000 | [diff] [blame] | 138 | enum dediprog_standalone_mode { |
| 139 | ENTER_STANDALONE_MODE = 0, |
| 140 | LEAVE_STANDALONE_MODE = 1, |
| 141 | }; |
| 142 | |
Simon Glass | 557eb4f | 2015-07-05 16:53:22 +0000 | [diff] [blame] | 143 | |
| 144 | static int dediprog_firmwareversion = FIRMWARE_VERSION(0, 0, 0); |
David Woodhouse | 7f3b89f | 2016-02-18 21:42:15 +0000 | [diff] [blame] | 145 | enum dediprog_devtype dediprog_devicetype = DEV_UNKNOWN; |
Simon Glass | 557eb4f | 2015-07-05 16:53:22 +0000 | [diff] [blame] | 146 | |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 147 | /* Returns true if firmware (and thus hardware) supports the "new" protocol */ |
| 148 | static bool is_new_prot(void) |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 149 | { |
David Woodhouse | 7f3b89f | 2016-02-18 21:42:15 +0000 | [diff] [blame] | 150 | switch (dediprog_devicetype) { |
| 151 | case DEV_SF100: |
| 152 | return dediprog_firmwareversion >= FIRMWARE_VERSION(5, 5, 0); |
| 153 | case DEV_SF600: |
| 154 | return dediprog_firmwareversion >= FIRMWARE_VERSION(6, 9, 0); |
| 155 | default: |
| 156 | return 0; |
| 157 | } |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 158 | } |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 159 | |
| 160 | static int dediprog_read(enum dediprog_cmds cmd, unsigned int value, unsigned int idx, uint8_t *bytes, size_t size) |
| 161 | { |
| 162 | return usb_control_msg(dediprog_handle, REQTYPE_EP_IN, cmd, value, idx, |
| 163 | (char *)bytes, size, DEFAULT_TIMEOUT); |
| 164 | } |
| 165 | |
| 166 | static int dediprog_write(enum dediprog_cmds cmd, unsigned int value, unsigned int idx, const uint8_t *bytes, size_t size) |
| 167 | { |
| 168 | return usb_control_msg(dediprog_handle, REQTYPE_EP_OUT, cmd, value, idx, |
| 169 | (char *)bytes, size, DEFAULT_TIMEOUT); |
| 170 | } |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 171 | |
Carl-Daniel Hailfinger | ad3cc55 | 2010-07-03 11:02:10 +0000 | [diff] [blame] | 172 | /* Might be useful for other USB devices as well. static for now. */ |
Nathan Laredo | 21541a6 | 2012-12-24 22:07:36 +0000 | [diff] [blame] | 173 | /* device parameter allows user to specify one device of multiple installed */ |
| 174 | static struct usb_device *get_device_by_vid_pid(uint16_t vid, uint16_t pid, unsigned int device) |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 175 | { |
| 176 | struct usb_bus *bus; |
| 177 | struct usb_device *dev; |
| 178 | |
| 179 | for (bus = usb_get_busses(); bus; bus = bus->next) |
| 180 | for (dev = bus->devices; dev; dev = dev->next) |
| 181 | if ((dev->descriptor.idVendor == vid) && |
Nathan Laredo | 21541a6 | 2012-12-24 22:07:36 +0000 | [diff] [blame] | 182 | (dev->descriptor.idProduct == pid)) { |
| 183 | if (device == 0) |
| 184 | return dev; |
| 185 | device--; |
| 186 | } |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 187 | |
| 188 | return NULL; |
| 189 | } |
| 190 | |
Simon Glass | 25e9f40 | 2015-06-28 13:31:19 +0000 | [diff] [blame] | 191 | /* This function sets the GPIOs connected to the LEDs as well as IO1-IO4. */ |
Stefan Reinauer | 915b840 | 2011-01-28 09:00:15 +0000 | [diff] [blame] | 192 | static int dediprog_set_leds(int leds) |
| 193 | { |
Simon Glass | 25e9f40 | 2015-06-28 13:31:19 +0000 | [diff] [blame] | 194 | if (leds < LED_NONE || leds > LED_ALL) |
| 195 | leds = LED_ALL; |
Stefan Reinauer | 915b840 | 2011-01-28 09:00:15 +0000 | [diff] [blame] | 196 | |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 197 | /* Older Dediprogs with 2.x.x and 3.x.x firmware only had two LEDs, assigned to different bits. So map |
| 198 | * them around if we have an old device. On those devices the LEDs map as follows: |
Stefan Reinauer | 915b840 | 2011-01-28 09:00:15 +0000 | [diff] [blame] | 199 | * bit 2 == 0: green light is on. |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 200 | * bit 0 == 0: red light is on. |
| 201 | * |
| 202 | * Additionally, the command structure has changed with the "new" protocol. |
| 203 | * |
| 204 | * FIXME: take IO pins into account |
Stefan Reinauer | 915b840 | 2011-01-28 09:00:15 +0000 | [diff] [blame] | 205 | */ |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 206 | int target_leds, ret; |
| 207 | if (is_new_prot()) { |
| 208 | target_leds = (leds ^ 7) << 8; |
| 209 | ret = dediprog_write(CMD_SET_IO_LED, target_leds, 0, NULL, 0); |
Stefan Reinauer | 915b840 | 2011-01-28 09:00:15 +0000 | [diff] [blame] | 210 | } else { |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 211 | if (dediprog_firmwareversion < FIRMWARE_VERSION(5, 0, 0)) { |
| 212 | target_leds = ((leds & LED_ERROR) >> 2) | ((leds & LED_PASS) << 2); |
| 213 | } else { |
| 214 | target_leds = leds; |
| 215 | } |
| 216 | target_leds ^= 7; |
| 217 | |
| 218 | ret = dediprog_write(CMD_SET_IO_LED, 0x9, target_leds, NULL, 0); |
Stefan Reinauer | 915b840 | 2011-01-28 09:00:15 +0000 | [diff] [blame] | 219 | } |
| 220 | |
Stefan Reinauer | 915b840 | 2011-01-28 09:00:15 +0000 | [diff] [blame] | 221 | if (ret != 0x0) { |
Simon Glass | 25e9f40 | 2015-06-28 13:31:19 +0000 | [diff] [blame] | 222 | msg_perr("Command Set LED 0x%x failed (%s)!\n", leds, usb_strerror()); |
Stefan Reinauer | 915b840 | 2011-01-28 09:00:15 +0000 | [diff] [blame] | 223 | return 1; |
| 224 | } |
| 225 | |
Stefan Reinauer | 915b840 | 2011-01-28 09:00:15 +0000 | [diff] [blame] | 226 | return 0; |
| 227 | } |
| 228 | |
Carl-Daniel Hailfinger | c244138 | 2010-11-09 22:00:31 +0000 | [diff] [blame] | 229 | static int dediprog_set_spi_voltage(int millivolt) |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 230 | { |
| 231 | int ret; |
Carl-Daniel Hailfinger | c244138 | 2010-11-09 22:00:31 +0000 | [diff] [blame] | 232 | uint16_t voltage_selector; |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 233 | |
Carl-Daniel Hailfinger | c244138 | 2010-11-09 22:00:31 +0000 | [diff] [blame] | 234 | switch (millivolt) { |
| 235 | case 0: |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 236 | /* Admittedly this one is an assumption. */ |
Carl-Daniel Hailfinger | c244138 | 2010-11-09 22:00:31 +0000 | [diff] [blame] | 237 | voltage_selector = 0x0; |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 238 | break; |
Carl-Daniel Hailfinger | c244138 | 2010-11-09 22:00:31 +0000 | [diff] [blame] | 239 | case 1800: |
| 240 | voltage_selector = 0x12; |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 241 | break; |
Carl-Daniel Hailfinger | c244138 | 2010-11-09 22:00:31 +0000 | [diff] [blame] | 242 | case 2500: |
| 243 | voltage_selector = 0x11; |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 244 | break; |
Carl-Daniel Hailfinger | c244138 | 2010-11-09 22:00:31 +0000 | [diff] [blame] | 245 | case 3500: |
| 246 | voltage_selector = 0x10; |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 247 | break; |
| 248 | default: |
Carl-Daniel Hailfinger | c244138 | 2010-11-09 22:00:31 +0000 | [diff] [blame] | 249 | msg_perr("Unknown voltage %i mV! Aborting.\n", millivolt); |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 250 | return 1; |
| 251 | } |
Carl-Daniel Hailfinger | c244138 | 2010-11-09 22:00:31 +0000 | [diff] [blame] | 252 | msg_pdbg("Setting SPI voltage to %u.%03u V\n", millivolt / 1000, |
| 253 | millivolt % 1000); |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 254 | |
Nico Huber | 4099a8a | 2012-06-16 00:02:27 +0000 | [diff] [blame] | 255 | if (voltage_selector == 0) { |
| 256 | /* Wait some time as the original driver does. */ |
| 257 | programmer_delay(200 * 1000); |
| 258 | } |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 259 | ret = dediprog_write(CMD_SET_VCC, voltage_selector, 0, NULL, 0); |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 260 | if (ret != 0x0) { |
Uwe Hermann | 91f4afa | 2011-07-28 08:13:25 +0000 | [diff] [blame] | 261 | msg_perr("Command Set SPI Voltage 0x%x failed!\n", |
| 262 | voltage_selector); |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 263 | return 1; |
| 264 | } |
Nico Huber | 4099a8a | 2012-06-16 00:02:27 +0000 | [diff] [blame] | 265 | if (voltage_selector != 0) { |
| 266 | /* Wait some time as the original driver does. */ |
| 267 | programmer_delay(200 * 1000); |
| 268 | } |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 269 | return 0; |
| 270 | } |
| 271 | |
Nico Huber | 77fa67d | 2013-02-20 18:03:36 +0000 | [diff] [blame] | 272 | struct dediprog_spispeeds { |
| 273 | const char *const name; |
| 274 | const int speed; |
| 275 | }; |
| 276 | |
| 277 | static const struct dediprog_spispeeds spispeeds[] = { |
| 278 | { "24M", 0x0 }, |
| 279 | { "12M", 0x2 }, |
| 280 | { "8M", 0x1 }, |
| 281 | { "3M", 0x3 }, |
| 282 | { "2.18M", 0x4 }, |
| 283 | { "1.5M", 0x5 }, |
| 284 | { "750k", 0x6 }, |
| 285 | { "375k", 0x7 }, |
| 286 | { NULL, 0x0 }, |
| 287 | }; |
| 288 | |
Nico Huber | 77fa67d | 2013-02-20 18:03:36 +0000 | [diff] [blame] | 289 | static int dediprog_set_spi_speed(unsigned int spispeed_idx) |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 290 | { |
Patrick Georgi | efe2d43 | 2013-05-23 21:47:46 +0000 | [diff] [blame] | 291 | if (dediprog_firmwareversion < FIRMWARE_VERSION(5, 0, 0)) { |
| 292 | msg_pwarn("Skipping to set SPI speed because firmware is too old.\n"); |
| 293 | return 0; |
| 294 | } |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 295 | |
Simon Glass | 557eb4f | 2015-07-05 16:53:22 +0000 | [diff] [blame] | 296 | const struct dediprog_spispeeds *spispeed = &spispeeds[spispeed_idx]; |
| 297 | msg_pdbg("SPI speed is %sHz\n", spispeed->name); |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 298 | |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 299 | int ret = dediprog_write(CMD_SET_SPI_CLK, spispeed->speed, 0, NULL, 0); |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 300 | if (ret != 0x0) { |
Simon Glass | 557eb4f | 2015-07-05 16:53:22 +0000 | [diff] [blame] | 301 | msg_perr("Command Set SPI Speed 0x%x failed!\n", spispeed->speed); |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 302 | return 1; |
| 303 | } |
| 304 | return 0; |
| 305 | } |
| 306 | |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 307 | static void fill_rw_cmd_payload(uint8_t *data_packet, unsigned int count, uint8_t dedi_spi_cmd, unsigned int *value, unsigned int *idx, unsigned int start) { |
| 308 | /* First 5 bytes are common in both generations. */ |
| 309 | data_packet[0] = count & 0xff; |
| 310 | data_packet[1] = (count >> 8) & 0xff; |
| 311 | data_packet[2] = 0; /* RFU */ |
| 312 | data_packet[3] = dedi_spi_cmd; /* Read/Write Mode (currently READ_MODE_STD, WRITE_MODE_PAGE_PGM or WRITE_MODE_2B_AAI) */ |
| 313 | data_packet[4] = 0; /* "Opcode". Specs imply necessity only for READ_MODE_4B_ADDR_FAST and WRITE_MODE_4B_ADDR_256B_PAGE_PGM */ |
| 314 | |
| 315 | if (is_new_prot()) { |
| 316 | *value = *idx = 0; |
| 317 | data_packet[5] = 0; /* RFU */ |
| 318 | data_packet[6] = (start >> 0) & 0xff; |
| 319 | data_packet[7] = (start >> 8) & 0xff; |
| 320 | data_packet[8] = (start >> 16) & 0xff; |
| 321 | data_packet[9] = (start >> 24) & 0xff; |
| 322 | } else { |
| 323 | *value = start % 0x10000; |
| 324 | *idx = start / 0x10000; |
| 325 | } |
| 326 | } |
| 327 | |
Carl-Daniel Hailfinger | 482e974 | 2010-11-16 21:25:29 +0000 | [diff] [blame] | 328 | /* Bulk read interface, will read multiple 512 byte chunks aligned to 512 bytes. |
| 329 | * @start start address |
| 330 | * @len length |
| 331 | * @return 0 on success, 1 on failure |
| 332 | */ |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 333 | static int dediprog_spi_bulk_read(struct flashctx *flash, uint8_t *buf, unsigned int start, unsigned int len) |
Carl-Daniel Hailfinger | 482e974 | 2010-11-16 21:25:29 +0000 | [diff] [blame] | 334 | { |
Carl-Daniel Hailfinger | 482e974 | 2010-11-16 21:25:29 +0000 | [diff] [blame] | 335 | /* chunksize must be 512, other sizes will NOT work at all. */ |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 336 | const unsigned int chunksize = 512; |
Stefan Tauner | c69c9c8 | 2011-11-23 09:13:48 +0000 | [diff] [blame] | 337 | const unsigned int count = len / chunksize; |
Carl-Daniel Hailfinger | 482e974 | 2010-11-16 21:25:29 +0000 | [diff] [blame] | 338 | |
| 339 | if ((start % chunksize) || (len % chunksize)) { |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 340 | msg_perr("%s: Unaligned start=%i, len=%i! Please report a bug at flashrom@flashrom.org\n", |
| 341 | __func__, start, len); |
Carl-Daniel Hailfinger | 482e974 | 2010-11-16 21:25:29 +0000 | [diff] [blame] | 342 | return 1; |
| 343 | } |
| 344 | |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 345 | if (len == 0) |
Carl-Daniel Hailfinger | 482e974 | 2010-11-16 21:25:29 +0000 | [diff] [blame] | 346 | return 0; |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 347 | |
| 348 | /* Command packet size of protocols: new 10 B, old 5 B. */ |
| 349 | uint8_t data_packet[is_new_prot() ? 10 : 5]; |
| 350 | unsigned int value, idx; |
| 351 | fill_rw_cmd_payload(data_packet, count, READ_MODE_STD, &value, &idx, start); |
| 352 | |
| 353 | int ret = dediprog_write(CMD_READ, value, idx, data_packet, sizeof(data_packet)); |
| 354 | if (ret != sizeof(data_packet)) { |
| 355 | msg_perr("Command Read SPI Bulk failed, %i %s!\n", ret, usb_strerror()); |
Carl-Daniel Hailfinger | 482e974 | 2010-11-16 21:25:29 +0000 | [diff] [blame] | 356 | return 1; |
| 357 | } |
| 358 | |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 359 | unsigned int i; |
Carl-Daniel Hailfinger | 482e974 | 2010-11-16 21:25:29 +0000 | [diff] [blame] | 360 | for (i = 0; i < count; i++) { |
David Woodhouse | 7f3b89f | 2016-02-18 21:42:15 +0000 | [diff] [blame] | 361 | ret = usb_bulk_read(dediprog_handle, 0x80 | dediprog_in_endpoint, |
Carl-Daniel Hailfinger | 482e974 | 2010-11-16 21:25:29 +0000 | [diff] [blame] | 362 | (char *)buf + i * chunksize, chunksize, |
| 363 | DEFAULT_TIMEOUT); |
| 364 | if (ret != chunksize) { |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 365 | msg_perr("SPI bulk read %i failed, expected %i, got %i %s!\n", |
| 366 | i, chunksize, ret, usb_strerror()); |
Carl-Daniel Hailfinger | 482e974 | 2010-11-16 21:25:29 +0000 | [diff] [blame] | 367 | return 1; |
| 368 | } |
| 369 | } |
| 370 | |
| 371 | return 0; |
| 372 | } |
| 373 | |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 374 | static int dediprog_spi_read(struct flashctx *flash, uint8_t *buf, unsigned int start, unsigned int len) |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 375 | { |
Carl-Daniel Hailfinger | 482e974 | 2010-11-16 21:25:29 +0000 | [diff] [blame] | 376 | int ret; |
| 377 | /* chunksize must be 512, other sizes will NOT work at all. */ |
Stefan Tauner | c69c9c8 | 2011-11-23 09:13:48 +0000 | [diff] [blame] | 378 | const unsigned int chunksize = 0x200; |
| 379 | unsigned int residue = start % chunksize ? chunksize - start % chunksize : 0; |
| 380 | unsigned int bulklen; |
Carl-Daniel Hailfinger | 482e974 | 2010-11-16 21:25:29 +0000 | [diff] [blame] | 381 | |
Simon Glass | 25e9f40 | 2015-06-28 13:31:19 +0000 | [diff] [blame] | 382 | dediprog_set_leds(LED_BUSY); |
Stefan Reinauer | 915b840 | 2011-01-28 09:00:15 +0000 | [diff] [blame] | 383 | |
Carl-Daniel Hailfinger | 482e974 | 2010-11-16 21:25:29 +0000 | [diff] [blame] | 384 | if (residue) { |
| 385 | msg_pdbg("Slow read for partial block from 0x%x, length 0x%x\n", |
| 386 | start, residue); |
| 387 | ret = spi_read_chunked(flash, buf, start, residue, 16); |
Simon Glass | 25e9f40 | 2015-06-28 13:31:19 +0000 | [diff] [blame] | 388 | if (ret) |
| 389 | goto err; |
Carl-Daniel Hailfinger | 482e974 | 2010-11-16 21:25:29 +0000 | [diff] [blame] | 390 | } |
| 391 | |
| 392 | /* Round down. */ |
| 393 | bulklen = (len - residue) / chunksize * chunksize; |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 394 | ret = dediprog_spi_bulk_read(flash, buf + residue, start + residue, bulklen); |
Simon Glass | 25e9f40 | 2015-06-28 13:31:19 +0000 | [diff] [blame] | 395 | if (ret) |
| 396 | goto err; |
Carl-Daniel Hailfinger | 482e974 | 2010-11-16 21:25:29 +0000 | [diff] [blame] | 397 | |
| 398 | len -= residue + bulklen; |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 399 | if (len != 0) { |
Carl-Daniel Hailfinger | 482e974 | 2010-11-16 21:25:29 +0000 | [diff] [blame] | 400 | msg_pdbg("Slow read for partial block from 0x%x, length 0x%x\n", |
| 401 | start, len); |
| 402 | ret = spi_read_chunked(flash, buf + residue + bulklen, |
| 403 | start + residue + bulklen, len, 16); |
Simon Glass | 25e9f40 | 2015-06-28 13:31:19 +0000 | [diff] [blame] | 404 | if (ret) |
| 405 | goto err; |
Carl-Daniel Hailfinger | 482e974 | 2010-11-16 21:25:29 +0000 | [diff] [blame] | 406 | } |
| 407 | |
Simon Glass | 25e9f40 | 2015-06-28 13:31:19 +0000 | [diff] [blame] | 408 | dediprog_set_leds(LED_PASS); |
Carl-Daniel Hailfinger | 482e974 | 2010-11-16 21:25:29 +0000 | [diff] [blame] | 409 | return 0; |
Simon Glass | 25e9f40 | 2015-06-28 13:31:19 +0000 | [diff] [blame] | 410 | err: |
| 411 | dediprog_set_leds(LED_ERROR); |
| 412 | return ret; |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 413 | } |
| 414 | |
Nico Huber | a4b14f7 | 2012-06-19 12:06:53 +0000 | [diff] [blame] | 415 | /* Bulk write interface, will write multiple chunksize byte chunks aligned to chunksize bytes. |
| 416 | * @chunksize length of data chunks, only 256 supported by now |
| 417 | * @start start address |
| 418 | * @len length |
| 419 | * @dedi_spi_cmd dediprog specific write command for spi bus |
| 420 | * @return 0 on success, 1 on failure |
Carl-Daniel Hailfinger | 64204b5 | 2011-12-20 01:54:19 +0000 | [diff] [blame] | 421 | */ |
Stefan Tauner | ffb0cf6 | 2014-05-25 07:47:47 +0000 | [diff] [blame] | 422 | static int dediprog_spi_bulk_write(struct flashctx *flash, const uint8_t *buf, unsigned int chunksize, |
Nico Huber | a4b14f7 | 2012-06-19 12:06:53 +0000 | [diff] [blame] | 423 | unsigned int start, unsigned int len, uint8_t dedi_spi_cmd) |
Carl-Daniel Hailfinger | 64204b5 | 2011-12-20 01:54:19 +0000 | [diff] [blame] | 424 | { |
Carl-Daniel Hailfinger | 64204b5 | 2011-12-20 01:54:19 +0000 | [diff] [blame] | 425 | /* USB transfer size must be 512, other sizes will NOT work at all. |
| 426 | * chunksize is the real data size per USB bulk transfer. The remaining |
| 427 | * space in a USB bulk transfer must be filled with 0xff padding. |
| 428 | */ |
Carl-Daniel Hailfinger | 64204b5 | 2011-12-20 01:54:19 +0000 | [diff] [blame] | 429 | const unsigned int count = len / chunksize; |
Carl-Daniel Hailfinger | 64204b5 | 2011-12-20 01:54:19 +0000 | [diff] [blame] | 430 | |
Nico Huber | a4b14f7 | 2012-06-19 12:06:53 +0000 | [diff] [blame] | 431 | /* |
| 432 | * We should change this check to |
| 433 | * chunksize > 512 |
| 434 | * once we know how to handle different chunk sizes. |
| 435 | */ |
| 436 | if (chunksize != 256) { |
| 437 | msg_perr("%s: Chunk sizes other than 256 bytes are unsupported, chunksize=%u!\n" |
| 438 | "Please report a bug at flashrom@flashrom.org\n", __func__, chunksize); |
| 439 | return 1; |
| 440 | } |
| 441 | |
Carl-Daniel Hailfinger | 64204b5 | 2011-12-20 01:54:19 +0000 | [diff] [blame] | 442 | if ((start % chunksize) || (len % chunksize)) { |
| 443 | msg_perr("%s: Unaligned start=%i, len=%i! Please report a bug " |
| 444 | "at flashrom@flashrom.org\n", __func__, start, len); |
| 445 | return 1; |
| 446 | } |
| 447 | |
| 448 | /* No idea if the hardware can handle empty writes, so chicken out. */ |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 449 | if (len == 0) |
Carl-Daniel Hailfinger | 64204b5 | 2011-12-20 01:54:19 +0000 | [diff] [blame] | 450 | return 0; |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 451 | |
| 452 | /* Command packet size of protocols: new 10 B, old 5 B. */ |
| 453 | uint8_t data_packet[is_new_prot() ? 10 : 5]; |
| 454 | unsigned int value, idx; |
| 455 | fill_rw_cmd_payload(data_packet, count, dedi_spi_cmd, &value, &idx, start); |
| 456 | int ret = dediprog_write(CMD_WRITE, value, idx, data_packet, sizeof(data_packet)); |
| 457 | if (ret != sizeof(data_packet)) { |
Carl-Daniel Hailfinger | 64204b5 | 2011-12-20 01:54:19 +0000 | [diff] [blame] | 458 | msg_perr("Command Write SPI Bulk failed, %i %s!\n", ret, |
| 459 | usb_strerror()); |
| 460 | return 1; |
| 461 | } |
| 462 | |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 463 | unsigned int i; |
Carl-Daniel Hailfinger | 64204b5 | 2011-12-20 01:54:19 +0000 | [diff] [blame] | 464 | for (i = 0; i < count; i++) { |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 465 | char usbbuf[512]; |
Carl-Daniel Hailfinger | 64204b5 | 2011-12-20 01:54:19 +0000 | [diff] [blame] | 466 | memcpy(usbbuf, buf + i * chunksize, chunksize); |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 467 | memset(usbbuf + chunksize, 0xff, sizeof(usbbuf) - chunksize); // fill up with 0xFF |
David Woodhouse | 7f3b89f | 2016-02-18 21:42:15 +0000 | [diff] [blame] | 468 | ret = usb_bulk_write(dediprog_handle, dediprog_out_endpoint, usbbuf, 512, DEFAULT_TIMEOUT); |
Carl-Daniel Hailfinger | 64204b5 | 2011-12-20 01:54:19 +0000 | [diff] [blame] | 469 | if (ret != 512) { |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 470 | msg_perr("SPI bulk write failed, expected %i, got %i %s!\n", 512, ret, usb_strerror()); |
Carl-Daniel Hailfinger | 64204b5 | 2011-12-20 01:54:19 +0000 | [diff] [blame] | 471 | return 1; |
| 472 | } |
| 473 | } |
| 474 | |
| 475 | return 0; |
| 476 | } |
| 477 | |
Stefan Tauner | ffb0cf6 | 2014-05-25 07:47:47 +0000 | [diff] [blame] | 478 | static int dediprog_spi_write(struct flashctx *flash, const uint8_t *buf, |
Nico Huber | a4b14f7 | 2012-06-19 12:06:53 +0000 | [diff] [blame] | 479 | unsigned int start, unsigned int len, uint8_t dedi_spi_cmd) |
Carl-Daniel Hailfinger | 306b818 | 2010-11-23 21:28:16 +0000 | [diff] [blame] | 480 | { |
Stefan Reinauer | 915b840 | 2011-01-28 09:00:15 +0000 | [diff] [blame] | 481 | int ret; |
Carl-Daniel Hailfinger | 5a7cb84 | 2012-08-25 01:17:58 +0000 | [diff] [blame] | 482 | const unsigned int chunksize = flash->chip->page_size; |
Carl-Daniel Hailfinger | 64204b5 | 2011-12-20 01:54:19 +0000 | [diff] [blame] | 483 | unsigned int residue = start % chunksize ? chunksize - start % chunksize : 0; |
| 484 | unsigned int bulklen; |
Stefan Reinauer | 915b840 | 2011-01-28 09:00:15 +0000 | [diff] [blame] | 485 | |
Simon Glass | 25e9f40 | 2015-06-28 13:31:19 +0000 | [diff] [blame] | 486 | dediprog_set_leds(LED_BUSY); |
Stefan Reinauer | 915b840 | 2011-01-28 09:00:15 +0000 | [diff] [blame] | 487 | |
Nico Huber | a4b14f7 | 2012-06-19 12:06:53 +0000 | [diff] [blame] | 488 | if (chunksize != 256) { |
| 489 | msg_pdbg("Page sizes other than 256 bytes are unsupported as " |
| 490 | "we don't know how dediprog\nhandles them.\n"); |
| 491 | /* Write everything like it was residue. */ |
| 492 | residue = len; |
| 493 | } |
| 494 | |
Carl-Daniel Hailfinger | 64204b5 | 2011-12-20 01:54:19 +0000 | [diff] [blame] | 495 | if (residue) { |
| 496 | msg_pdbg("Slow write for partial block from 0x%x, length 0x%x\n", |
| 497 | start, residue); |
| 498 | /* No idea about the real limit. Maybe 12, maybe more. */ |
| 499 | ret = spi_write_chunked(flash, buf, start, residue, 12); |
| 500 | if (ret) { |
Simon Glass | 25e9f40 | 2015-06-28 13:31:19 +0000 | [diff] [blame] | 501 | dediprog_set_leds(LED_ERROR); |
Carl-Daniel Hailfinger | 64204b5 | 2011-12-20 01:54:19 +0000 | [diff] [blame] | 502 | return ret; |
| 503 | } |
| 504 | } |
Stefan Reinauer | 915b840 | 2011-01-28 09:00:15 +0000 | [diff] [blame] | 505 | |
Carl-Daniel Hailfinger | 64204b5 | 2011-12-20 01:54:19 +0000 | [diff] [blame] | 506 | /* Round down. */ |
| 507 | bulklen = (len - residue) / chunksize * chunksize; |
Nico Huber | a4b14f7 | 2012-06-19 12:06:53 +0000 | [diff] [blame] | 508 | ret = dediprog_spi_bulk_write(flash, buf + residue, chunksize, start + residue, bulklen, dedi_spi_cmd); |
Carl-Daniel Hailfinger | 64204b5 | 2011-12-20 01:54:19 +0000 | [diff] [blame] | 509 | if (ret) { |
Simon Glass | 25e9f40 | 2015-06-28 13:31:19 +0000 | [diff] [blame] | 510 | dediprog_set_leds(LED_ERROR); |
Carl-Daniel Hailfinger | 64204b5 | 2011-12-20 01:54:19 +0000 | [diff] [blame] | 511 | return ret; |
| 512 | } |
Stefan Reinauer | 915b840 | 2011-01-28 09:00:15 +0000 | [diff] [blame] | 513 | |
Carl-Daniel Hailfinger | 64204b5 | 2011-12-20 01:54:19 +0000 | [diff] [blame] | 514 | len -= residue + bulklen; |
| 515 | if (len) { |
| 516 | msg_pdbg("Slow write for partial block from 0x%x, length 0x%x\n", |
| 517 | start, len); |
| 518 | ret = spi_write_chunked(flash, buf + residue + bulklen, |
| 519 | start + residue + bulklen, len, 12); |
| 520 | if (ret) { |
Simon Glass | 25e9f40 | 2015-06-28 13:31:19 +0000 | [diff] [blame] | 521 | dediprog_set_leds(LED_ERROR); |
Carl-Daniel Hailfinger | 64204b5 | 2011-12-20 01:54:19 +0000 | [diff] [blame] | 522 | return ret; |
| 523 | } |
| 524 | } |
| 525 | |
Simon Glass | 25e9f40 | 2015-06-28 13:31:19 +0000 | [diff] [blame] | 526 | dediprog_set_leds(LED_PASS); |
Carl-Daniel Hailfinger | 64204b5 | 2011-12-20 01:54:19 +0000 | [diff] [blame] | 527 | return 0; |
Carl-Daniel Hailfinger | 306b818 | 2010-11-23 21:28:16 +0000 | [diff] [blame] | 528 | } |
| 529 | |
Stefan Tauner | ffb0cf6 | 2014-05-25 07:47:47 +0000 | [diff] [blame] | 530 | static int dediprog_spi_write_256(struct flashctx *flash, const uint8_t *buf, unsigned int start, unsigned int len) |
Nico Huber | a4b14f7 | 2012-06-19 12:06:53 +0000 | [diff] [blame] | 531 | { |
Simon Glass | 557eb4f | 2015-07-05 16:53:22 +0000 | [diff] [blame] | 532 | return dediprog_spi_write(flash, buf, start, len, WRITE_MODE_PAGE_PGM); |
Nico Huber | a4b14f7 | 2012-06-19 12:06:53 +0000 | [diff] [blame] | 533 | } |
| 534 | |
Stefan Tauner | ffb0cf6 | 2014-05-25 07:47:47 +0000 | [diff] [blame] | 535 | static int dediprog_spi_write_aai(struct flashctx *flash, const uint8_t *buf, unsigned int start, unsigned int len) |
Nico Huber | a4b14f7 | 2012-06-19 12:06:53 +0000 | [diff] [blame] | 536 | { |
Simon Glass | 557eb4f | 2015-07-05 16:53:22 +0000 | [diff] [blame] | 537 | return dediprog_spi_write(flash, buf, start, len, WRITE_MODE_2B_AAI); |
Nico Huber | a4b14f7 | 2012-06-19 12:06:53 +0000 | [diff] [blame] | 538 | } |
| 539 | |
Carl-Daniel Hailfinger | 8a3c60c | 2011-12-18 15:01:24 +0000 | [diff] [blame] | 540 | static int dediprog_spi_send_command(struct flashctx *flash, |
| 541 | unsigned int writecnt, |
| 542 | unsigned int readcnt, |
| 543 | const unsigned char *writearr, |
| 544 | unsigned char *readarr) |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 545 | { |
| 546 | int ret; |
| 547 | |
Carl-Daniel Hailfinger | eac6579 | 2010-01-22 02:53:30 +0000 | [diff] [blame] | 548 | msg_pspew("%s, writecnt=%i, readcnt=%i\n", __func__, writecnt, readcnt); |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 549 | if (writecnt > flash->mst->spi.max_data_write) { |
Simon Glass | 557eb4f | 2015-07-05 16:53:22 +0000 | [diff] [blame] | 550 | msg_perr("Invalid writecnt=%i, aborting.\n", writecnt); |
Carl-Daniel Hailfinger | eac6579 | 2010-01-22 02:53:30 +0000 | [diff] [blame] | 551 | return 1; |
| 552 | } |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 553 | if (readcnt > flash->mst->spi.max_data_read) { |
Simon Glass | 557eb4f | 2015-07-05 16:53:22 +0000 | [diff] [blame] | 554 | msg_perr("Invalid readcnt=%i, aborting.\n", readcnt); |
Carl-Daniel Hailfinger | eac6579 | 2010-01-22 02:53:30 +0000 | [diff] [blame] | 555 | return 1; |
| 556 | } |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 557 | |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 558 | unsigned int idx, value; |
| 559 | /* New protocol has options and timeout combined as value while the old one used the value field for |
| 560 | * timeout and the index field for options. */ |
| 561 | if (is_new_prot()) { |
| 562 | idx = 0; |
| 563 | value = readcnt ? 0x1 : 0x0; // Indicate if we require a read |
| 564 | } else { |
| 565 | idx = readcnt ? 0x1 : 0x0; // Indicate if we require a read |
| 566 | value = 0; |
| 567 | } |
| 568 | ret = dediprog_write(CMD_TRANSCEIVE, value, idx, writearr, writecnt); |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 569 | if (ret != writecnt) { |
Carl-Daniel Hailfinger | eac6579 | 2010-01-22 02:53:30 +0000 | [diff] [blame] | 570 | msg_perr("Send SPI failed, expected %i, got %i %s!\n", |
| 571 | writecnt, ret, usb_strerror()); |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 572 | return 1; |
| 573 | } |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 574 | if (readcnt == 0) // If we don't require a response, we are done here |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 575 | return 0; |
Simon Glass | 557eb4f | 2015-07-05 16:53:22 +0000 | [diff] [blame] | 576 | |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 577 | const uint8_t read_timeout = 10 + readcnt/512; |
| 578 | if (is_new_prot()) { |
| 579 | idx = 0; |
| 580 | value = min(read_timeout, 0xFF) | (0 << 8) ; // Timeout in lower byte, option in upper byte |
| 581 | } else { |
| 582 | idx = (0 & 0xFF); // Lower byte is option (0x01 = require SR, 0x02 keep CS low) |
| 583 | value = min(read_timeout, 0xFF); // Possibly two bytes but we play safe here |
| 584 | } |
| 585 | ret = dediprog_read(CMD_TRANSCEIVE, value, idx, readarr, readcnt); |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 586 | if (ret != readcnt) { |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 587 | msg_perr("Receive SPI failed, expected %i, got %i %s!\n", readcnt, ret, usb_strerror()); |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 588 | return 1; |
| 589 | } |
| 590 | return 0; |
| 591 | } |
| 592 | |
Carl-Daniel Hailfinger | ad3cc55 | 2010-07-03 11:02:10 +0000 | [diff] [blame] | 593 | static int dediprog_check_devicestring(void) |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 594 | { |
| 595 | int ret; |
| 596 | char buf[0x11]; |
| 597 | |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 598 | /* Command Receive Device String. */ |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 599 | ret = dediprog_read(CMD_READ_PROG_INFO, 0, 0, (uint8_t *)buf, 0x10); |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 600 | if (ret != 0x10) { |
| 601 | msg_perr("Incomplete/failed Command Receive Device String!\n"); |
| 602 | return 1; |
| 603 | } |
| 604 | buf[0x10] = '\0'; |
| 605 | msg_pdbg("Found a %s\n", buf); |
David Woodhouse | 7f3b89f | 2016-02-18 21:42:15 +0000 | [diff] [blame] | 606 | if (memcmp(buf, "SF100", 0x5) == 0) |
| 607 | dediprog_devicetype = DEV_SF100; |
| 608 | else if (memcmp(buf, "SF600", 0x5) == 0) |
| 609 | dediprog_devicetype = DEV_SF600; |
| 610 | else { |
| 611 | msg_perr("Device not a SF100 or SF600!\n"); |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 612 | return 1; |
| 613 | } |
David Woodhouse | 7f3b89f | 2016-02-18 21:42:15 +0000 | [diff] [blame] | 614 | |
| 615 | int sfnum; |
| 616 | int fw[3]; |
| 617 | if (sscanf(buf, "SF%d V:%d.%d.%d ", &sfnum, &fw[0], &fw[1], &fw[2]) != 4 || |
| 618 | sfnum != dediprog_devicetype) { |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 619 | msg_perr("Unexpected firmware version string '%s'\n", buf); |
Mathias Krause | db7afc5 | 2010-11-09 23:30:43 +0000 | [diff] [blame] | 620 | return 1; |
| 621 | } |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 622 | /* Only these major versions were tested. */ |
David Woodhouse | 7f3b89f | 2016-02-18 21:42:15 +0000 | [diff] [blame] | 623 | if (fw[0] < 2 || fw[0] > 7) { |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 624 | msg_perr("Unexpected firmware version %d.%d.%d!\n", fw[0], fw[1], fw[2]); |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 625 | return 1; |
| 626 | } |
Stefan Reinauer | 915b840 | 2011-01-28 09:00:15 +0000 | [diff] [blame] | 627 | dediprog_firmwareversion = FIRMWARE_VERSION(fw[0], fw[1], fw[2]); |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 628 | |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 629 | return 0; |
| 630 | } |
| 631 | |
David Hendricks | c05900f | 2016-02-18 21:42:41 +0000 | [diff] [blame^] | 632 | /* |
| 633 | * This command presumably sets the voltage for the SF100 itself (not the |
| 634 | * SPI flash). Only use this command with firmware older than V6.0.0. Newer |
| 635 | * (including all SF600s) do not support it. |
| 636 | */ |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 637 | |
David Hendricks | c05900f | 2016-02-18 21:42:41 +0000 | [diff] [blame^] | 638 | /* This command presumably sets the voltage for the SF100 itself (not the SPI flash). |
| 639 | * Only use dediprog_set_voltage on SF100 programmers with firmware older |
| 640 | * than V6.0.0. Newer programmers (including all SF600s) do not support it. */ |
| 641 | static int dediprog_set_voltage(void) |
| 642 | { |
| 643 | char buf[1] = {0}; |
| 644 | int ret = usb_control_msg(dediprog_handle, REQTYPE_OTHER_IN, CMD_SET_VOLTAGE, 0x0, 0x0, |
Simon Glass | 557eb4f | 2015-07-05 16:53:22 +0000 | [diff] [blame] | 645 | buf, 0x1, DEFAULT_TIMEOUT); |
Mathias Krause | db7afc5 | 2010-11-09 23:30:43 +0000 | [diff] [blame] | 646 | if (ret < 0) { |
David Hendricks | c05900f | 2016-02-18 21:42:41 +0000 | [diff] [blame^] | 647 | msg_perr("Command Set Voltage failed (%s)!\n", usb_strerror()); |
Mathias Krause | db7afc5 | 2010-11-09 23:30:43 +0000 | [diff] [blame] | 648 | return 1; |
| 649 | } |
David Hendricks | c05900f | 2016-02-18 21:42:41 +0000 | [diff] [blame^] | 650 | if ((ret != 1) || (buf[0] != 0x6f)) { |
Simon Glass | 557eb4f | 2015-07-05 16:53:22 +0000 | [diff] [blame] | 651 | msg_perr("Unexpected response to init!\n"); |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 652 | return 1; |
| 653 | } |
David Hendricks | c05900f | 2016-02-18 21:42:41 +0000 | [diff] [blame^] | 654 | |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 655 | return 0; |
| 656 | } |
| 657 | |
David Woodhouse | 7f3b89f | 2016-02-18 21:42:15 +0000 | [diff] [blame] | 658 | static int dediprog_standalone_mode(void) |
| 659 | { |
| 660 | int ret; |
| 661 | |
| 662 | if (dediprog_devicetype != DEV_SF600) |
| 663 | return 0; |
| 664 | |
| 665 | msg_pdbg2("Disabling standalone mode.\n"); |
| 666 | ret = dediprog_write(CMD_SET_STANDALONE, LEAVE_STANDALONE_MODE, 0, NULL, 0); |
| 667 | if (ret) { |
| 668 | msg_perr("Failed to disable standalone mode: %s\n", usb_strerror()); |
| 669 | return 1; |
| 670 | } |
| 671 | |
| 672 | return 0; |
| 673 | } |
| 674 | |
Carl-Daniel Hailfinger | ff30d8a | 2011-01-20 21:05:15 +0000 | [diff] [blame] | 675 | #if 0 |
| 676 | /* Something. |
| 677 | * Present in eng_detect_blink.log with firmware 3.1.8 |
| 678 | * Always preceded by Command Receive Device String |
| 679 | */ |
| 680 | static int dediprog_command_b(void) |
| 681 | { |
| 682 | int ret; |
| 683 | char buf[0x3]; |
| 684 | |
Simon Glass | 557eb4f | 2015-07-05 16:53:22 +0000 | [diff] [blame] | 685 | ret = usb_control_msg(dediprog_handle, REQTYPE_OTHER_IN, 0x7, 0x0, 0xef00, |
| 686 | buf, 0x3, DEFAULT_TIMEOUT); |
Carl-Daniel Hailfinger | ff30d8a | 2011-01-20 21:05:15 +0000 | [diff] [blame] | 687 | if (ret < 0) { |
| 688 | msg_perr("Command B failed (%s)!\n", usb_strerror()); |
| 689 | return 1; |
| 690 | } |
| 691 | if ((ret != 0x3) || (buf[0] != 0xff) || (buf[1] != 0xff) || |
| 692 | (buf[2] != 0xff)) { |
| 693 | msg_perr("Unexpected response to Command B!\n"); |
| 694 | return 1; |
| 695 | } |
| 696 | |
| 697 | return 0; |
| 698 | } |
| 699 | #endif |
| 700 | |
Simon Glass | 557eb4f | 2015-07-05 16:53:22 +0000 | [diff] [blame] | 701 | static int set_target_flash(enum dediprog_target target) |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 702 | { |
Simon Glass | 557eb4f | 2015-07-05 16:53:22 +0000 | [diff] [blame] | 703 | int ret = usb_control_msg(dediprog_handle, REQTYPE_EP_OUT, CMD_SET_TARGET, target, 0, |
| 704 | NULL, 0, DEFAULT_TIMEOUT); |
| 705 | if (ret != 0) { |
| 706 | msg_perr("set_target_flash failed (%s)!\n", usb_strerror()); |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 707 | return 1; |
| 708 | } |
| 709 | return 0; |
| 710 | } |
| 711 | |
Carl-Daniel Hailfinger | ad3cc55 | 2010-07-03 11:02:10 +0000 | [diff] [blame] | 712 | #if 0 |
Simon Glass | 557eb4f | 2015-07-05 16:53:22 +0000 | [diff] [blame] | 713 | /* Returns true if the button is currently pressed. */ |
| 714 | static bool dediprog_get_button(void) |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 715 | { |
Simon Glass | 557eb4f | 2015-07-05 16:53:22 +0000 | [diff] [blame] | 716 | char buf[1]; |
| 717 | int ret = usb_control_msg(dediprog_handle, REQTYPE_EP_IN, CMD_GET_BUTTON, 0, 0, |
| 718 | buf, 0x1, DEFAULT_TIMEOUT); |
| 719 | if (ret != 0) { |
| 720 | msg_perr("Could not get button state (%s)!\n", usb_strerror()); |
Carl-Daniel Hailfinger | ff30d8a | 2011-01-20 21:05:15 +0000 | [diff] [blame] | 721 | return 1; |
| 722 | } |
Simon Glass | 557eb4f | 2015-07-05 16:53:22 +0000 | [diff] [blame] | 723 | return buf[0] != 1; |
Carl-Daniel Hailfinger | 64204b5 | 2011-12-20 01:54:19 +0000 | [diff] [blame] | 724 | } |
Carl-Daniel Hailfinger | ad3cc55 | 2010-07-03 11:02:10 +0000 | [diff] [blame] | 725 | #endif |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 726 | |
Carl-Daniel Hailfinger | c244138 | 2010-11-09 22:00:31 +0000 | [diff] [blame] | 727 | static int parse_voltage(char *voltage) |
| 728 | { |
| 729 | char *tmp = NULL; |
Carl-Daniel Hailfinger | 082c8b5 | 2011-08-15 19:54:20 +0000 | [diff] [blame] | 730 | int i; |
| 731 | int millivolt = 0, fraction = 0; |
Carl-Daniel Hailfinger | c244138 | 2010-11-09 22:00:31 +0000 | [diff] [blame] | 732 | |
| 733 | if (!voltage || !strlen(voltage)) { |
| 734 | msg_perr("Empty voltage= specified.\n"); |
| 735 | return -1; |
| 736 | } |
| 737 | millivolt = (int)strtol(voltage, &tmp, 0); |
| 738 | voltage = tmp; |
| 739 | /* Handle "," and "." as decimal point. Everything after it is assumed |
| 740 | * to be in decimal notation. |
| 741 | */ |
| 742 | if ((*voltage == '.') || (*voltage == ',')) { |
| 743 | voltage++; |
| 744 | for (i = 0; i < 3; i++) { |
| 745 | fraction *= 10; |
| 746 | /* Don't advance if the current character is invalid, |
| 747 | * but continue multiplying. |
| 748 | */ |
| 749 | if ((*voltage < '0') || (*voltage > '9')) |
| 750 | continue; |
| 751 | fraction += *voltage - '0'; |
| 752 | voltage++; |
| 753 | } |
| 754 | /* Throw away remaining digits. */ |
| 755 | voltage += strspn(voltage, "0123456789"); |
| 756 | } |
| 757 | /* The remaining string must be empty or "mV" or "V". */ |
| 758 | tolower_string(voltage); |
| 759 | |
| 760 | /* No unit or "V". */ |
| 761 | if ((*voltage == '\0') || !strncmp(voltage, "v", 1)) { |
| 762 | millivolt *= 1000; |
| 763 | millivolt += fraction; |
| 764 | } else if (!strncmp(voltage, "mv", 2) || |
| 765 | !strncmp(voltage, "milliv", 6)) { |
| 766 | /* No adjustment. fraction is discarded. */ |
| 767 | } else { |
| 768 | /* Garbage at the end of the string. */ |
| 769 | msg_perr("Garbage voltage= specified.\n"); |
| 770 | return -1; |
| 771 | } |
| 772 | return millivolt; |
| 773 | } |
| 774 | |
Carl-Daniel Hailfinger | a5bcbce | 2014-07-19 22:03:29 +0000 | [diff] [blame] | 775 | static const struct spi_master spi_master_dediprog = { |
Uwe Hermann | 91f4afa | 2011-07-28 08:13:25 +0000 | [diff] [blame] | 776 | .type = SPI_CONTROLLER_DEDIPROG, |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 777 | .max_data_read = 16, /* 18 seems to work fine as well, but 19 times out sometimes with FW 5.15. */ |
| 778 | .max_data_write = 16, |
Uwe Hermann | 91f4afa | 2011-07-28 08:13:25 +0000 | [diff] [blame] | 779 | .command = dediprog_spi_send_command, |
| 780 | .multicommand = default_spi_send_multicommand, |
| 781 | .read = dediprog_spi_read, |
| 782 | .write_256 = dediprog_spi_write_256, |
Nico Huber | a4b14f7 | 2012-06-19 12:06:53 +0000 | [diff] [blame] | 783 | .write_aai = dediprog_spi_write_aai, |
Michael Karcher | b9dbe48 | 2011-05-11 17:07:07 +0000 | [diff] [blame] | 784 | }; |
| 785 | |
David Hendricks | 8bb2021 | 2011-06-14 01:35:36 +0000 | [diff] [blame] | 786 | static int dediprog_shutdown(void *data) |
| 787 | { |
Simon Glass | 557eb4f | 2015-07-05 16:53:22 +0000 | [diff] [blame] | 788 | dediprog_firmwareversion = FIRMWARE_VERSION(0, 0, 0); |
David Woodhouse | 7f3b89f | 2016-02-18 21:42:15 +0000 | [diff] [blame] | 789 | dediprog_devicetype = DEV_UNKNOWN; |
Carl-Daniel Hailfinger | 64204b5 | 2011-12-20 01:54:19 +0000 | [diff] [blame] | 790 | |
David Hendricks | 8bb2021 | 2011-06-14 01:35:36 +0000 | [diff] [blame] | 791 | /* URB 28. Command Set SPI Voltage to 0. */ |
| 792 | if (dediprog_set_spi_voltage(0x0)) |
| 793 | return 1; |
| 794 | |
| 795 | if (usb_release_interface(dediprog_handle, 0)) { |
| 796 | msg_perr("Could not release USB interface!\n"); |
| 797 | return 1; |
| 798 | } |
| 799 | if (usb_close(dediprog_handle)) { |
| 800 | msg_perr("Could not close USB device!\n"); |
| 801 | return 1; |
| 802 | } |
| 803 | return 0; |
| 804 | } |
| 805 | |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 806 | int dediprog_init(void) |
| 807 | { |
| 808 | struct usb_device *dev; |
Stefan Tauner | e659d2d | 2013-05-03 21:58:28 +0000 | [diff] [blame] | 809 | char *voltage, *device, *spispeed, *target_str; |
Patrick Georgi | efe2d43 | 2013-05-23 21:47:46 +0000 | [diff] [blame] | 810 | int spispeed_idx = 1; |
Carl-Daniel Hailfinger | 082c8b5 | 2011-08-15 19:54:20 +0000 | [diff] [blame] | 811 | int millivolt = 3500; |
Nathan Laredo | 21541a6 | 2012-12-24 22:07:36 +0000 | [diff] [blame] | 812 | long usedevice = 0; |
Stefan Tauner | e659d2d | 2013-05-03 21:58:28 +0000 | [diff] [blame] | 813 | long target = 1; |
Nico Huber | 77fa67d | 2013-02-20 18:03:36 +0000 | [diff] [blame] | 814 | int i, ret; |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 815 | |
Nico Huber | 77fa67d | 2013-02-20 18:03:36 +0000 | [diff] [blame] | 816 | spispeed = extract_programmer_param("spispeed"); |
| 817 | if (spispeed) { |
| 818 | for (i = 0; spispeeds[i].name; ++i) { |
| 819 | if (!strcasecmp(spispeeds[i].name, spispeed)) { |
| 820 | spispeed_idx = i; |
| 821 | break; |
| 822 | } |
| 823 | } |
| 824 | if (!spispeeds[i].name) { |
Patrick Georgi | efe2d43 | 2013-05-23 21:47:46 +0000 | [diff] [blame] | 825 | msg_perr("Error: Invalid spispeed value: '%s'.\n", spispeed); |
Nico Huber | 77fa67d | 2013-02-20 18:03:36 +0000 | [diff] [blame] | 826 | free(spispeed); |
| 827 | return 1; |
| 828 | } |
| 829 | free(spispeed); |
| 830 | } |
Simon Glass | 557eb4f | 2015-07-05 16:53:22 +0000 | [diff] [blame] | 831 | |
Carl-Daniel Hailfinger | c244138 | 2010-11-09 22:00:31 +0000 | [diff] [blame] | 832 | voltage = extract_programmer_param("voltage"); |
| 833 | if (voltage) { |
| 834 | millivolt = parse_voltage(voltage); |
| 835 | free(voltage); |
Uwe Hermann | 91f4afa | 2011-07-28 08:13:25 +0000 | [diff] [blame] | 836 | if (millivolt < 0) |
Carl-Daniel Hailfinger | c244138 | 2010-11-09 22:00:31 +0000 | [diff] [blame] | 837 | return 1; |
Carl-Daniel Hailfinger | c244138 | 2010-11-09 22:00:31 +0000 | [diff] [blame] | 838 | msg_pinfo("Setting voltage to %i mV\n", millivolt); |
| 839 | } |
| 840 | |
Nathan Laredo | 21541a6 | 2012-12-24 22:07:36 +0000 | [diff] [blame] | 841 | device = extract_programmer_param("device"); |
| 842 | if (device) { |
| 843 | char *dev_suffix; |
| 844 | errno = 0; |
| 845 | usedevice = strtol(device, &dev_suffix, 10); |
| 846 | if (errno != 0 || device == dev_suffix) { |
| 847 | msg_perr("Error: Could not convert 'device'.\n"); |
| 848 | free(device); |
| 849 | return 1; |
| 850 | } |
| 851 | if (usedevice < 0 || usedevice > UINT_MAX) { |
| 852 | msg_perr("Error: Value for 'device' is out of range.\n"); |
| 853 | free(device); |
| 854 | return 1; |
| 855 | } |
| 856 | if (strlen(dev_suffix) > 0) { |
| 857 | msg_perr("Error: Garbage following 'device' value.\n"); |
| 858 | free(device); |
| 859 | return 1; |
| 860 | } |
| 861 | msg_pinfo("Using device %li.\n", usedevice); |
| 862 | } |
| 863 | free(device); |
| 864 | |
Stefan Tauner | e659d2d | 2013-05-03 21:58:28 +0000 | [diff] [blame] | 865 | target_str = extract_programmer_param("target"); |
| 866 | if (target_str) { |
| 867 | char *target_suffix; |
| 868 | errno = 0; |
| 869 | target = strtol(target_str, &target_suffix, 10); |
| 870 | if (errno != 0 || target_str == target_suffix) { |
| 871 | msg_perr("Error: Could not convert 'target'.\n"); |
| 872 | free(target_str); |
| 873 | return 1; |
| 874 | } |
| 875 | if (target < 1 || target > 2) { |
| 876 | msg_perr("Error: Value for 'target' is out of range.\n"); |
| 877 | free(target_str); |
| 878 | return 1; |
| 879 | } |
| 880 | if (strlen(target_suffix) > 0) { |
| 881 | msg_perr("Error: Garbage following 'target' value.\n"); |
| 882 | free(target_str); |
| 883 | return 1; |
| 884 | } |
| 885 | msg_pinfo("Using target %li.\n", target); |
| 886 | } |
| 887 | free(target_str); |
| 888 | |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 889 | /* Here comes the USB stuff. */ |
| 890 | usb_init(); |
| 891 | usb_find_busses(); |
| 892 | usb_find_devices(); |
Nathan Laredo | 21541a6 | 2012-12-24 22:07:36 +0000 | [diff] [blame] | 893 | dev = get_device_by_vid_pid(0x0483, 0xdada, (unsigned int) usedevice); |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 894 | if (!dev) { |
| 895 | msg_perr("Could not find a Dediprog SF100 on USB!\n"); |
| 896 | return 1; |
| 897 | } |
| 898 | msg_pdbg("Found USB device (%04x:%04x).\n", |
Uwe Hermann | 91f4afa | 2011-07-28 08:13:25 +0000 | [diff] [blame] | 899 | dev->descriptor.idVendor, dev->descriptor.idProduct); |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 900 | dediprog_handle = usb_open(dev); |
David Woodhouse | d2a7e87 | 2013-07-30 09:34:44 +0000 | [diff] [blame] | 901 | if (!dediprog_handle) { |
David Woodhouse | 7f3b89f | 2016-02-18 21:42:15 +0000 | [diff] [blame] | 902 | msg_perr("Could not find a Dediprog programmer on USB: %s\n", usb_strerror()); |
David Woodhouse | d2a7e87 | 2013-07-30 09:34:44 +0000 | [diff] [blame] | 903 | return 1; |
| 904 | } |
Carl-Daniel Hailfinger | 482e974 | 2010-11-16 21:25:29 +0000 | [diff] [blame] | 905 | ret = usb_set_configuration(dediprog_handle, 1); |
| 906 | if (ret < 0) { |
| 907 | msg_perr("Could not set USB device configuration: %i %s\n", |
| 908 | ret, usb_strerror()); |
| 909 | if (usb_close(dediprog_handle)) |
| 910 | msg_perr("Could not close USB device!\n"); |
| 911 | return 1; |
| 912 | } |
| 913 | ret = usb_claim_interface(dediprog_handle, 0); |
| 914 | if (ret < 0) { |
| 915 | msg_perr("Could not claim USB device interface %i: %i %s\n", |
| 916 | 0, ret, usb_strerror()); |
| 917 | if (usb_close(dediprog_handle)) |
| 918 | msg_perr("Could not close USB device!\n"); |
| 919 | return 1; |
| 920 | } |
Nico Huber | 77fa67d | 2013-02-20 18:03:36 +0000 | [diff] [blame] | 921 | |
David Hendricks | 8bb2021 | 2011-06-14 01:35:36 +0000 | [diff] [blame] | 922 | if (register_shutdown(dediprog_shutdown, NULL)) |
| 923 | return 1; |
| 924 | |
David Hendricks | c05900f | 2016-02-18 21:42:41 +0000 | [diff] [blame^] | 925 | /* Try reading the devicestring. If that fails and the device is old (FW < 6.0.0, which we can not know) |
| 926 | * then we need to try the "set voltage" command and then attempt to read the devicestring again. */ |
| 927 | if (dediprog_check_devicestring()) { |
| 928 | if (dediprog_set_voltage()) |
| 929 | return 1; |
| 930 | if (dediprog_check_devicestring()) |
| 931 | return 1; |
| 932 | } |
Nico Huber | 77fa67d | 2013-02-20 18:03:36 +0000 | [diff] [blame] | 933 | |
David Woodhouse | 7f3b89f | 2016-02-18 21:42:15 +0000 | [diff] [blame] | 934 | /* SF100 only has 1 endpoint for in/out, SF600 uses two separate endpoints instead. */ |
| 935 | dediprog_in_endpoint = 2; |
| 936 | if (dediprog_devicetype == DEV_SF100) |
| 937 | dediprog_out_endpoint = 2; |
| 938 | else |
| 939 | dediprog_out_endpoint = 1; |
| 940 | |
Simon Glass | 25e9f40 | 2015-06-28 13:31:19 +0000 | [diff] [blame] | 941 | /* Set all possible LEDs as soon as possible to indicate activity. |
| 942 | * Because knowing the firmware version is required to set the LEDs correctly we need to this after |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 943 | * dediprog_check_devicestring() has queried the device and set dediprog_firmwareversion. */ |
Simon Glass | 25e9f40 | 2015-06-28 13:31:19 +0000 | [diff] [blame] | 944 | dediprog_set_leds(LED_ALL); |
| 945 | |
Simon Glass | 557eb4f | 2015-07-05 16:53:22 +0000 | [diff] [blame] | 946 | /* Select target/socket, frequency and VCC. */ |
| 947 | if (set_target_flash(FLASH_TYPE_APPLICATION_FLASH_1) || |
| 948 | dediprog_set_spi_speed(spispeed_idx) || |
| 949 | dediprog_set_spi_voltage(millivolt)) { |
Simon Glass | 25e9f40 | 2015-06-28 13:31:19 +0000 | [diff] [blame] | 950 | dediprog_set_leds(LED_ERROR); |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 951 | return 1; |
Stefan Reinauer | 915b840 | 2011-01-28 09:00:15 +0000 | [diff] [blame] | 952 | } |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 953 | |
David Woodhouse | 7f3b89f | 2016-02-18 21:42:15 +0000 | [diff] [blame] | 954 | if (dediprog_standalone_mode()) |
| 955 | return 1; |
| 956 | |
Simon Glass | ae61651 | 2016-01-23 23:27:58 +0000 | [diff] [blame] | 957 | if (register_spi_master(&spi_master_dediprog) || dediprog_set_leds(LED_NONE)) |
| 958 | return 1; |
Stefan Reinauer | 915b840 | 2011-01-28 09:00:15 +0000 | [diff] [blame] | 959 | |
Carl-Daniel Hailfinger | d38fac8 | 2010-01-19 11:15:48 +0000 | [diff] [blame] | 960 | return 0; |
| 961 | } |
| 962 | |