by Jon Morby
hi …
I don't suppose anyone has any experience updating or fixing MAC addresses on Nvidea nVIDIA MCP55V-Pro (Supermicro H8DMT+) ?
Following an experimental reflash everything went well, except afterwards we noticed the mac address had been reset
link/ether 66:77:44:22:33:12 brd ff:ff:ff:ff:ff:ff
--
Jon Morby
FidoNet - the internet made simple!
10 - 16 Tiller Road, London, E14 8PX
tel: 0845 004 3050 / fax: 0845 004 3051
by Nico Huber
Rebased this one, following patches are based on it.
This adds a programmer parameter 'spispeed' to the dediprog driver to
control the transfer rate on the spi bus. The following rates are
available (in Hz):
375k, 750k, 1.5M, 2.18M, 3M, 8M, 12M and 24M
The original driver reinitializes the programmer after setting the
speed, so the initialization calls have moved into a new function
dediprog_setup() which is called twice.
Signed-off-by: Nico Huber <nico.huber(a)secunet.com>
diff --git a/dediprog.c b/dediprog.c
index a81cf83..60067a8 100644
--- a/dediprog.c
+++ b/dediprog.c
@@ -152,7 +152,23 @@ static int dediprog_set_spi_voltage(int millivolt)
return 0;
}
-#if 0
+struct dediprog_spispeeds {
+ const char *const name;
+ const int speed;
+};
+
+static const struct dediprog_spispeeds spispeeds[] = {
+ { "24M", 0x0 },
+ { "12M", 0x2 },
+ { "8M", 0x1 },
+ { "3M", 0x3 },
+ { "2.18M", 0x4 },
+ { "1.5M", 0x5 },
+ { "750k", 0x6 },
+ { "375k", 0x7 },
+ { NULL, 0x0 },
+};
+
/* After dediprog_set_spi_speed, the original app always calls
* dediprog_set_spi_voltage(0) and then
* dediprog_check_devicestring() four times in a row.
@@ -160,56 +176,20 @@ static int dediprog_set_spi_voltage(int millivolt)
* This looks suspiciously like the microprocessor in the SF100 has to be
* restarted/reinitialized in case the speed changes.
*/
-static int dediprog_set_spi_speed(uint16_t speed)
+static int dediprog_set_spi_speed(unsigned int spispeed_idx)
{
int ret;
- unsigned int khz;
- /* Case 1 and 2 are in weird order. Probably an organically "grown"
- * interface.
- * Base frequency is 24000 kHz, divisors are (in order)
- * 1, 3, 2, 8, 11, 16, 32, 64.
- */
- switch (speed) {
- case 0x0:
- khz = 24000;
- break;
- case 0x1:
- khz = 8000;
- break;
- case 0x2:
- khz = 12000;
- break;
- case 0x3:
- khz = 3000;
- break;
- case 0x4:
- khz = 2180;
- break;
- case 0x5:
- khz = 1500;
- break;
- case 0x6:
- khz = 750;
- break;
- case 0x7:
- khz = 375;
- break;
- default:
- msg_perr("Unknown frequency selector 0x%x! Aborting.\n", speed);
- return 1;
- }
- msg_pdbg("Setting SPI speed to %u kHz\n", khz);
+ msg_pdbg("SPI speed is %sHz\n", spispeeds[spispeed_idx].name);
- ret = usb_control_msg(dediprog_handle, 0x42, 0x61, speed, 0xff, NULL,
- 0x0, DEFAULT_TIMEOUT);
+ ret = usb_control_msg(dediprog_handle, 0x42, 0x61, spispeeds[spispeed_idx].speed, 0xff,
+ NULL, 0x0, DEFAULT_TIMEOUT);
if (ret != 0x0) {
- msg_perr("Command Set SPI Speed 0x%x failed!\n", speed);
+ msg_perr("Command Set SPI Speed 0x%x failed!\n", spispeeds[spispeed_idx].speed);
return 1;
}
return 0;
}
-#endif
/* Bulk read interface, will read multiple 512 byte chunks aligned to 512 bytes.
* @start start address
@@ -736,6 +716,28 @@ static int parse_voltage(char *voltage)
return millivolt;
}
+static int dediprog_setup(void)
+{
+ /* URB 6. Command A. */
+ if (dediprog_command_a()) {
+ return 1;
+ }
+ /* URB 7. Command A. */
+ if (dediprog_command_a()) {
+ return 1;
+ }
+ /* URB 8. Command Prepare Receive Device String. */
+ /* URB 9. Command Receive Device String. */
+ if (dediprog_check_devicestring()) {
+ return 1;
+ }
+ /* URB 10. Command C. */
+ if (dediprog_command_c()) {
+ return 1;
+ }
+ return 0;
+}
+
static const struct spi_programmer spi_programmer_dediprog = {
.type = SPI_CONTROLLER_DEDIPROG,
.max_data_read = MAX_DATA_UNSPECIFIED,
@@ -777,12 +779,21 @@ static int dediprog_shutdown(void *data)
int dediprog_init(void)
{
struct usb_device *dev;
- char *voltage;
- int millivolt = 3500;
- int ret;
+ char *voltage, *spispeed;
+ int spispeed_idx = 2, millivolt = 3500;
+ int i, ret;
msg_pspew("%s\n", __func__);
+ spispeed = extract_programmer_param("spispeed");
+ if (spispeed) {
+ for (i = 0; spispeeds[i].name; ++i) {
+ if (!strcasecmp(spispeeds[i].name, spispeed)) {
+ spispeed_idx = i;
+ break;
+ }
+ }
+ }
voltage = extract_programmer_param("voltage");
if (voltage) {
millivolt = parse_voltage(voltage);
@@ -821,33 +832,26 @@ int dediprog_init(void)
return 1;
}
dediprog_endpoint = 2;
-
+
if (register_shutdown(dediprog_shutdown, NULL))
return 1;
dediprog_set_leds(PASS_ON|BUSY_ON|ERROR_ON);
- /* URB 6. Command A. */
- if (dediprog_command_a()) {
+ /* Perform basic setup. */
+ if (dediprog_setup()) {
dediprog_set_leds(PASS_OFF|BUSY_OFF|ERROR_ON);
return 1;
}
- /* URB 7. Command A. */
- if (dediprog_command_a()) {
- dediprog_set_leds(PASS_OFF|BUSY_OFF|ERROR_ON);
- return 1;
- }
- /* URB 8. Command Prepare Receive Device String. */
- /* URB 9. Command Receive Device String. */
- if (dediprog_check_devicestring()) {
- dediprog_set_leds(PASS_OFF|BUSY_OFF|ERROR_ON);
- return 1;
- }
- /* URB 10. Command C. */
- if (dediprog_command_c()) {
+
+ /* After setting voltage and speed, perform setup again. */
+ if (dediprog_set_spi_voltage(0) ||
+ dediprog_set_spi_speed(spispeed_idx) ||
+ dediprog_setup()) {
dediprog_set_leds(PASS_OFF|BUSY_OFF|ERROR_ON);
return 1;
}
+
/* URB 11. Command Set SPI Voltage. */
if (dediprog_set_spi_voltage(millivolt)) {
dediprog_set_leds(PASS_OFF|BUSY_OFF|ERROR_ON);
diff --git a/flashrom.8 b/flashrom.8
index b054c28..99e064e 100644
--- a/flashrom.8
+++ b/flashrom.8
@@ -651,6 +651,18 @@ where
can be
.BR 0V ", " 1.8V ", " 2.5V ", " 3.5V
or the equivalent in mV.
+.sp
+An optional
+.B spispeed
+parameter specifies the frequency of the SPI bus. Syntax is
+.sp
+.B " flashrom \-p dediprog:spispeed=frequency"
+.sp
+where
+.B frequency
+can be
+.BR 375k ", " 750k ", " 1.5M ", " 2.18M ", " 3M ", " 8M ", " 12M " or " 24M
+(in Hz). The default is a frequency of 12 MHz.
.SS
.BR "rayer_spi " programmer
The default I/O base address used for the parallel port is 0x378 and you can use
by Nico Huber
This patch tracks the changes in the libusb interface. Nothing changed
in the behaviour of the driver, so far.
It will be used by a follow-up patch. It's based on "Enable spi clock
setting in dediprog driver".
Signed-off-by: Nico Huber <nico.huber(a)secunet.com>
diff --git a/Makefile b/Makefile
index b087b3d..6da7226 100644
--- a/Makefile
+++ b/Makefile
@@ -531,7 +531,7 @@ endif
ifeq ($(CONFIG_DEDIPROG), yes)
FEATURE_CFLAGS += -D'CONFIG_DEDIPROG=1'
-FEATURE_LIBS += -lusb
+FEATURE_LIBS += -lusb-1.0
PROGRAMMER_OBJS += dediprog.o
endif
diff --git a/dediprog.c b/dediprog.c
index 60067a8..a558285 100644
--- a/dediprog.c
+++ b/dediprog.c
@@ -2,6 +2,7 @@
* This file is part of the flashrom project.
*
* Copyright (C) 2010 Carl-Daniel Hailfinger
+ * 2012 secunet Security Networks AG
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -19,7 +20,8 @@
#include <stdio.h>
#include <string.h>
-#include <usb.h>
+#include <stdlib.h>
+#include <libusb-1.0/libusb.h>
#include "flash.h"
#include "chipdrivers.h"
#include "programmer.h"
@@ -27,7 +29,8 @@
#define FIRMWARE_VERSION(x,y,z) ((x << 16) | (y << 8) | z)
#define DEFAULT_TIMEOUT 3000
-static usb_dev_handle *dediprog_handle;
+static libusb_context *usb_ctx;
+static libusb_device_handle *dediprog_handle;
static int dediprog_firmwareversion;
static int dediprog_endpoint;
@@ -45,23 +48,6 @@ static void print_hex(void *buf, size_t len)
}
#endif
-/* Might be useful for other USB devices as well. static for now. */
-static struct usb_device *get_device_by_vid_pid(uint16_t vid, uint16_t pid)
-{
- struct usb_bus *bus;
- struct usb_device *dev;
-
- for (bus = usb_get_busses(); bus; bus = bus->next)
- for (dev = bus->devices; dev; dev = dev->next)
- if ((dev->descriptor.idVendor == vid) &&
- (dev->descriptor.idProduct == pid))
- return dev;
-
- return NULL;
-}
-
-//int usb_control_msg(usb_dev_handle *dev, int requesttype, int request, int value, int index, char *bytes, int size, int timeout);
-
/* Set/clear LEDs on dediprog */
#define PASS_ON (0 << 0)
#define PASS_OFF (1 << 0)
@@ -95,11 +81,10 @@ static int dediprog_set_leds(int leds)
target_leds = leds;
}
- ret = usb_control_msg(dediprog_handle, 0x42, 0x07, 0x09, target_leds,
- NULL, 0x0, DEFAULT_TIMEOUT);
+ ret = libusb_control_transfer(dediprog_handle, 0x42, 0x07, 0x09, target_leds,
+ NULL, 0x0, DEFAULT_TIMEOUT);
if (ret != 0x0) {
- msg_perr("Command Set LED 0x%x failed (%s)!\n",
- leds, usb_strerror());
+ msg_perr("Command Set LED 0x%x failed (%s)!\n", leds, libusb_error_name(ret));
return 1;
}
@@ -138,8 +123,8 @@ static int dediprog_set_spi_voltage(int millivolt)
/* Wait some time as the original driver does. */
programmer_delay(200 * 1000);
}
- ret = usb_control_msg(dediprog_handle, 0x42, 0x9, voltage_selector,
- 0xff, NULL, 0x0, DEFAULT_TIMEOUT);
+ ret = libusb_control_transfer(dediprog_handle, 0x42, 0x9, voltage_selector,
+ 0xff, NULL, 0x0, DEFAULT_TIMEOUT);
if (ret != 0x0) {
msg_perr("Command Set SPI Voltage 0x%x failed!\n",
voltage_selector);
@@ -182,8 +167,8 @@ static int dediprog_set_spi_speed(unsigned int spispeed_idx)
msg_pdbg("SPI speed is %sHz\n", spispeeds[spispeed_idx].name);
- ret = usb_control_msg(dediprog_handle, 0x42, 0x61, spispeeds[spispeed_idx].speed, 0xff,
- NULL, 0x0, DEFAULT_TIMEOUT);
+ ret = libusb_control_transfer(dediprog_handle, 0x42, 0x61, spispeeds[spispeed_idx].speed, 0xff,
+ NULL, 0x0, DEFAULT_TIMEOUT);
if (ret != 0x0) {
msg_perr("Command Set SPI Speed 0x%x failed!\n", spispeeds[spispeed_idx].speed);
return 1;
@@ -199,15 +184,15 @@ static int dediprog_set_spi_speed(unsigned int spispeed_idx)
static int dediprog_spi_bulk_read(struct flashctx *flash, uint8_t *buf,
unsigned int start, unsigned int len)
{
- int ret;
+ int ret, transferred;
unsigned int i;
/* chunksize must be 512, other sizes will NOT work at all. */
const unsigned int chunksize = 0x200;
const unsigned int count = len / chunksize;
- const char count_and_chunk[] = {count & 0xff,
- (count >> 8) & 0xff,
- chunksize & 0xff,
- (chunksize >> 8) & 0xff};
+ const unsigned char count_and_chunk[] = {
+ count & 0xff, (count >> 8) & 0xff,
+ chunksize & 0xff, (chunksize >> 8) & 0xff
+ };
if ((start % chunksize) || (len % chunksize)) {
msg_perr("%s: Unaligned start=%i, len=%i! Please report a bug "
@@ -221,22 +206,20 @@ static int dediprog_spi_bulk_read(struct flashctx *flash, uint8_t *buf,
/* Command Read SPI Bulk. No idea which read command is used on the
* SPI side.
*/
- ret = usb_control_msg(dediprog_handle, 0x42, 0x20, start % 0x10000,
- start / 0x10000, (char *)count_and_chunk,
- sizeof(count_and_chunk), DEFAULT_TIMEOUT);
+ ret = libusb_control_transfer(dediprog_handle, 0x42, 0x20, start % 0x10000, start / 0x10000,
+ (unsigned char *)count_and_chunk, sizeof(count_and_chunk),
+ DEFAULT_TIMEOUT);
if (ret != sizeof(count_and_chunk)) {
- msg_perr("Command Read SPI Bulk failed, %i %s!\n", ret,
- usb_strerror());
+ msg_perr("Command Read SPI Bulk failed, %i %s!\n", ret, libusb_error_name(ret));
return 1;
}
for (i = 0; i < count; i++) {
- ret = usb_bulk_read(dediprog_handle, 0x80 | dediprog_endpoint,
- (char *)buf + i * chunksize, chunksize,
- DEFAULT_TIMEOUT);
- if (ret != chunksize) {
- msg_perr("SPI bulk read %i failed, expected %i, got %i "
- "%s!\n", i, chunksize, ret, usb_strerror());
+ ret = libusb_bulk_transfer(dediprog_handle, 0x80 | dediprog_endpoint,
+ buf + i * chunksize, chunksize, &transferred, DEFAULT_TIMEOUT);
+ if ((ret < 0) || (transferred != chunksize)) {
+ msg_perr("SPI bulk read %i failed, expected %i, got %i %s!\n",
+ i, chunksize, ret, libusb_error_name(ret));
return 1;
}
}
@@ -300,7 +283,7 @@ static int dediprog_spi_read(struct flashctx *flash, uint8_t *buf,
static int dediprog_spi_bulk_write(struct flashctx *flash, uint8_t *buf, unsigned int chunksize,
unsigned int start, unsigned int len, uint8_t dedi_spi_cmd)
{
- int ret;
+ int ret, transferred;
unsigned int i;
/* USB transfer size must be 512, other sizes will NOT work at all.
* chunksize is the real data size per USB bulk transfer. The remaining
@@ -308,7 +291,7 @@ static int dediprog_spi_bulk_write(struct flashctx *flash, uint8_t *buf, unsigne
*/
const unsigned int count = len / chunksize;
const char count_and_cmd[] = {count & 0xff, (count >> 8) & 0xff, 0x00, dedi_spi_cmd};
- char usbbuf[512];
+ unsigned char usbbuf[512];
/*
* We should change this check to
@@ -333,23 +316,21 @@ static int dediprog_spi_bulk_write(struct flashctx *flash, uint8_t *buf, unsigne
/* Command Write SPI Bulk. No idea which write command is used on the
* SPI side.
*/
- ret = usb_control_msg(dediprog_handle, 0x42, 0x30, start % 0x10000, start / 0x10000,
- (char *)count_and_cmd, sizeof(count_and_cmd), DEFAULT_TIMEOUT);
+ ret = libusb_control_transfer(dediprog_handle, 0x42, 0x30, start % 0x10000, start / 0x10000,
+ (unsigned char *)count_and_cmd, sizeof(count_and_cmd), DEFAULT_TIMEOUT);
if (ret != sizeof(count_and_cmd)) {
- msg_perr("Command Write SPI Bulk failed, %i %s!\n", ret,
- usb_strerror());
+ msg_perr("Command Write SPI Bulk failed, %i %s!\n", ret, libusb_error_name(ret));
return 1;
}
for (i = 0; i < count; i++) {
memset(usbbuf, 0xff, sizeof(usbbuf));
memcpy(usbbuf, buf + i * chunksize, chunksize);
- ret = usb_bulk_write(dediprog_handle, dediprog_endpoint,
- usbbuf, 512,
- DEFAULT_TIMEOUT);
- if (ret != 512) {
- msg_perr("SPI bulk write failed, expected %i, got %i "
- "%s!\n", 512, ret, usb_strerror());
+ ret = libusb_bulk_transfer(dediprog_handle, dediprog_endpoint,
+ usbbuf, 512, &transferred, DEFAULT_TIMEOUT);
+ if ((ret < 0) || (transferred != 512)) {
+ msg_perr("SPI bulk write failed, expected %i, got %i %s!\n",
+ 512, ret, libusb_error_name(ret));
return 1;
}
}
@@ -438,23 +419,20 @@ static int dediprog_spi_send_command(struct flashctx *flash,
msg_perr("Untested readcnt=%i, aborting.\n", readcnt);
return 1;
}
-
- ret = usb_control_msg(dediprog_handle, 0x42, 0x1, 0xff,
- readcnt ? 0x1 : 0x0, (char *)writearr, writecnt,
- DEFAULT_TIMEOUT);
+
+ ret = libusb_control_transfer(dediprog_handle, 0x42, 0x1, 0xff, readcnt ? 0x1 : 0x0,
+ (unsigned char *)writearr, writecnt, DEFAULT_TIMEOUT);
if (ret != writecnt) {
- msg_perr("Send SPI failed, expected %i, got %i %s!\n",
- writecnt, ret, usb_strerror());
+ msg_perr("Send SPI failed, expected %i, got %i %s!\n", writecnt, ret, libusb_error_name(ret));
return 1;
}
if (!readcnt)
return 0;
memset(readarr, 0, readcnt);
- ret = usb_control_msg(dediprog_handle, 0xc2, 0x01, 0xbb8, 0x0000,
- (char *)readarr, readcnt, DEFAULT_TIMEOUT);
+ ret = libusb_control_transfer(dediprog_handle, 0xc2, 0x01, 0xbb8, 0x0000,
+ readarr, readcnt, DEFAULT_TIMEOUT);
if (ret != readcnt) {
- msg_perr("Receive SPI failed, expected %i, got %i %s!\n",
- readcnt, ret, usb_strerror());
+ msg_perr("Receive SPI failed, expected %i, got %i %s!\n", readcnt, ret, libusb_error_name(ret));
return 1;
}
return 0;
@@ -464,22 +442,18 @@ static int dediprog_check_devicestring(void)
{
int ret;
int fw[3];
- char buf[0x11];
+ unsigned char buf[0x11];
/* Command Prepare Receive Device String. */
memset(buf, 0, sizeof(buf));
- ret = usb_control_msg(dediprog_handle, 0xc3, 0x7, 0x0, 0xef03, buf,
- 0x1, DEFAULT_TIMEOUT);
- /* The char casting is needed to stop gcc complaining about an always true comparison. */
- if ((ret != 0x1) || (buf[0] != (char)0xff)) {
- msg_perr("Unexpected response to Command Prepare Receive Device"
- " String!\n");
+ ret = libusb_control_transfer(dediprog_handle, 0xc3, 0x7, 0x0, 0xef03, buf, 0x1, DEFAULT_TIMEOUT);
+ if ((ret != 0x1) || (buf[0] != 0xff)) {
+ msg_perr("Unexpected response to Command Prepare Receive Device String!\n");
return 1;
}
/* Command Receive Device String. */
memset(buf, 0, sizeof(buf));
- ret = usb_control_msg(dediprog_handle, 0xc2, 0x8, 0xff, 0xff, buf,
- 0x10, DEFAULT_TIMEOUT);
+ ret = libusb_control_transfer(dediprog_handle, 0xc2, 0x8, 0xff, 0xff, buf, 0x10, DEFAULT_TIMEOUT);
if (ret != 0x10) {
msg_perr("Incomplete/failed Command Receive Device String!\n");
return 1;
@@ -490,7 +464,7 @@ static int dediprog_check_devicestring(void)
msg_perr("Device not a SF100!\n");
return 1;
}
- if (sscanf(buf, "SF100 V:%d.%d.%d ", &fw[0], &fw[1], &fw[2]) != 3) {
+ if (sscanf((const char *)buf, "SF100 V:%d.%d.%d ", &fw[0], &fw[1], &fw[2]) != 3) {
msg_perr("Unexpected firmware version string!\n");
return 1;
}
@@ -511,13 +485,12 @@ static int dediprog_check_devicestring(void)
static int dediprog_command_a(void)
{
int ret;
- char buf[0x1];
+ unsigned char buf[0x1];
memset(buf, 0, sizeof(buf));
- ret = usb_control_msg(dediprog_handle, 0xc3, 0xb, 0x0, 0x0, buf,
- 0x1, DEFAULT_TIMEOUT);
+ ret = libusb_control_transfer(dediprog_handle, 0xc3, 0xb, 0x0, 0x0, buf, 0x1, DEFAULT_TIMEOUT);
if (ret < 0) {
- msg_perr("Command A failed (%s)!\n", usb_strerror());
+ msg_perr("Command A failed (%s)!\n", libusb_error_name(ret));
return 1;
}
if ((ret != 0x1) || (buf[0] != 0x6f)) {
@@ -535,13 +508,12 @@ static int dediprog_command_a(void)
static int dediprog_command_b(void)
{
int ret;
- char buf[0x3];
+ unsigned char buf[0x3];
memset(buf, 0, sizeof(buf));
- ret = usb_control_msg(dediprog_handle, 0xc3, 0x7, 0x0, 0xef00, buf,
- 0x3, DEFAULT_TIMEOUT);
+ ret = libusb_control_transfer(dediprog_handle, 0xc3, 0x7, 0x0, 0xef00, buf, 0x3, DEFAULT_TIMEOUT);
if (ret < 0) {
- msg_perr("Command B failed (%s)!\n", usb_strerror());
+ msg_perr("Command B failed (%s)!\n", libusb_error_name(ret));
return 1;
}
if ((ret != 0x3) || (buf[0] != 0xff) || (buf[1] != 0xff) ||
@@ -563,10 +535,9 @@ static int dediprog_command_c(void)
{
int ret;
- ret = usb_control_msg(dediprog_handle, 0x42, 0x4, 0x0, 0x0, NULL,
- 0x0, DEFAULT_TIMEOUT);
+ ret = libusb_control_transfer(dediprog_handle, 0x42, 0x4, 0x0, 0x0, NULL, 0x0, DEFAULT_TIMEOUT);
if (ret != 0x0) {
- msg_perr("Command C failed (%s)!\n", usb_strerror());
+ msg_perr("Command C failed (%s)!\n", libusb_error_name(ret));
return 1;
}
return 0;
@@ -581,17 +552,16 @@ static int dediprog_command_c(void)
static int dediprog_command_f(int timeout)
{
int ret;
- char buf[0x1];
+ unsigned char buf[0x1];
memset(buf, 0, sizeof(buf));
- ret = usb_control_msg(dediprog_handle, 0xc2, 0x11, 0xff, 0xff, buf,
- 0x1, timeout);
+ ret = libusb_control_transfer(dediprog_handle, 0xc2, 0x11, 0xff, 0xff, buf, 0x1, timeout);
/* This check is most probably wrong. Command F always causes a timeout
* in the logs, so we should check for timeout instead of checking for
* success.
*/
if (ret != 0x1) {
- msg_perr("Command F failed (%s)!\n", usb_strerror());
+ msg_perr("Command F failed (%s)!\n", libusb_error_name(ret));
return 1;
}
return 0;
@@ -605,9 +575,9 @@ static int dediprog_command_g(void)
{
int ret;
- ret = usb_control_msg(dediprog_handle, 0x42, 0x07, 0x09, 0x03, NULL, 0x0, DEFAULT_TIMEOUT);
+ ret = libusb_control_transfer(dediprog_handle, 0x42, 0x07, 0x09, 0x03, NULL, 0x0, DEFAULT_TIMEOUT);
if (ret != 0x0) {
- msg_perr("Command G failed (%s)!\n", usb_strerror());
+ msg_perr("Command G failed (%s)!\n", libusb_error_name(ret));
return 1;
}
return 0;
@@ -622,9 +592,9 @@ static int dediprog_command_h(void)
{
int ret;
- ret = usb_control_msg(dediprog_handle, 0x42, 0x07, 0x09, 0x05, NULL, 0x0, DEFAULT_TIMEOUT);
+ ret = libusb_control_transfer(dediprog_handle, 0x42, 0x07, 0x09, 0x05, NULL, 0x0, DEFAULT_TIMEOUT);
if (ret != 0x0) {
- msg_perr("Command H failed (%s)!\n", usb_strerror());
+ msg_perr("Command H failed (%s)!\n", libusb_error_name(ret));
return 1;
}
return 0;
@@ -639,9 +609,9 @@ static int dediprog_command_i(void)
{
int ret;
- ret = usb_control_msg(dediprog_handle, 0x42, 0x07, 0x09, 0x06, NULL, 0x0, DEFAULT_TIMEOUT);
+ ret = libusb_control_transfer(dediprog_handle, 0x42, 0x07, 0x09, 0x06, NULL, 0x0, DEFAULT_TIMEOUT);
if (ret != 0x0) {
- msg_perr("Command I failed (%s)!\n", usb_strerror());
+ msg_perr("Command I failed (%s)!\n", libusb_error_name(ret));
return 1;
}
return 0;
@@ -659,9 +629,9 @@ static int dediprog_command_j(void)
{
int ret;
- ret = usb_control_msg(dediprog_handle, 0x42, 0x07, 0x09, 0x07, NULL, 0x0, DEFAULT_TIMEOUT);
+ ret = libusb_control_transfer(dediprog_handle, 0x42, 0x07, 0x09, 0x07, NULL, 0x0, DEFAULT_TIMEOUT);
if (ret != 0x0) {
- msg_perr("Command J failed (%s)!\n", usb_strerror());
+ msg_perr("Command J failed (%s)!\n", libusb_error_name(ret));
return 1;
}
return 0;
@@ -764,24 +734,22 @@ static int dediprog_shutdown(void *data)
if (dediprog_set_spi_voltage(0x0))
return 1;
- if (usb_release_interface(dediprog_handle, 0)) {
+ if (libusb_release_interface(dediprog_handle, 0)) {
msg_perr("Could not release USB interface!\n");
return 1;
}
- if (usb_close(dediprog_handle)) {
- msg_perr("Could not close USB device!\n");
- return 1;
- }
+ libusb_close(dediprog_handle);
+ libusb_exit(usb_ctx);
return 0;
}
/* URB numbers refer to the first log ever captured. */
int dediprog_init(void)
{
- struct usb_device *dev;
char *voltage, *spispeed;
int spispeed_idx = 2, millivolt = 3500;
int i, ret;
+ struct libusb_device_descriptor usb_desc;
msg_pspew("%s\n", __func__);
@@ -804,31 +772,31 @@ int dediprog_init(void)
}
/* Here comes the USB stuff. */
- usb_init();
- usb_find_busses();
- usb_find_devices();
- dev = get_device_by_vid_pid(0x0483, 0xdada);
- if (!dev) {
+ libusb_init(&usb_ctx);
+ if (!usb_ctx) {
+ msg_perr("Could not open libusb interface!\n");
+ return 1;
+ }
+ dediprog_handle = libusb_open_device_with_vid_pid(usb_ctx, 0x0483, 0xdada);
+ if (!dediprog_handle) {
msg_perr("Could not find a Dediprog SF100 on USB!\n");
return 1;
}
- msg_pdbg("Found USB device (%04x:%04x).\n",
- dev->descriptor.idVendor, dev->descriptor.idProduct);
- dediprog_handle = usb_open(dev);
- ret = usb_set_configuration(dediprog_handle, 1);
- if (ret < 0) {
- msg_perr("Could not set USB device configuration: %i %s\n",
- ret, usb_strerror());
- if (usb_close(dediprog_handle))
- msg_perr("Could not close USB device!\n");
+ ret = libusb_get_device_descriptor(libusb_get_device(dediprog_handle), &usb_desc);
+ if (ret != 0)
+ msg_pinfo("Warning: Could not get usb device descriptor: %i %s\n", ret, libusb_error_name(ret));
+ else
+ msg_pdbg("Found USB device (%04hx:%04hx).\n", usb_desc.idVendor, usb_desc.idProduct);
+ ret = libusb_set_configuration(dediprog_handle, 1);
+ if (ret != 0) {
+ msg_perr("Could not set USB device configuration: %i %s\n", ret, libusb_error_name(ret));
+ libusb_close(dediprog_handle);
return 1;
}
- ret = usb_claim_interface(dediprog_handle, 0);
+ ret = libusb_claim_interface(dediprog_handle, 0);
if (ret < 0) {
- msg_perr("Could not claim USB device interface %i: %i %s\n",
- 0, ret, usb_strerror());
- if (usb_close(dediprog_handle))
- msg_perr("Could not close USB device!\n");
+ msg_perr("Could not claim USB device interface %i: %i %s\n", 0, ret, libusb_error_name(ret));
+ libusb_close(dediprog_handle);
return 1;
}
dediprog_endpoint = 2;
by Kyösti Mälkki
Rebased on Revision 1650.
There remains a minor glitch with Makefile: If one sets
CONFIG_FT2322_SPI=no, also USB-Blaster support will be disabled. In my
opinion fixing this is not within the scope of this patch.
Adds support for the Altera USB-Blaster programming dongle in
Active Serial (AS) mode.
Tested on both original product and a clone dongle.
Signed-off-by: James Laird <jhl(a)mafipulation.org>
Signed-off-by: Kyösti Mälkki <kyosti.malkki(a)gmail.com>
Signed-off-by: Stefan Tauner <stefan.tauner(a)student.tuwien.ac.at>
---
Makefile | 23 ++++++
README | 4 +-
flashrom.8 | 6 +-
flashrom.c | 12 +++
programmer.h | 12 +++
usbblaster_spi.c | 225 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
6 files changed, 278 insertions(+), 4 deletions(-)
create mode 100644 usbblaster_spi.c
diff --git a/Makefile b/Makefile
index b948996..f7aaf95 100644
--- a/Makefile
+++ b/Makefile
@@ -128,6 +128,11 @@ UNSUPPORTED_FEATURES += CONFIG_FT2232_SPI=yes
else
override CONFIG_FT2232_SPI = no
endif
+ifeq ($(CONFIG_USBBLASTER_SPI), yes)
+UNSUPPORTED_FEATURES += CONFIG_USBBLASTER_SPI=yes
+else
+override CONFIG_USBBLASTER_SPI = no
+endif
endif
# FIXME: Should we check for Cygwin/MSVC as well?
@@ -240,6 +245,11 @@ UNSUPPORTED_FEATURES += CONFIG_FT2232_SPI=yes
else
override CONFIG_FT2232_SPI = no
endif
+ifeq ($(CONFIG_USBBLASTER_SPI), yes)
+UNSUPPORTED_FEATURES += CONFIG_USBBLASTER_SPI=yes
+else
+override CONFIG_USBBLASTER_SPI = no
+endif
endif
ifneq ($(TARGET_OS), Linux)
@@ -349,6 +359,9 @@ CONFIG_ATAHPT ?= no
# Always enable FT2232 SPI dongles for now.
CONFIG_FT2232_SPI ?= yes
+# Always enable Altera USB-Blaster dongles for now.
+CONFIG_USBBLASTER_SPI ?= yes
+
# Always enable dummy tracing for now.
CONFIG_DUMMY ?= yes
@@ -484,6 +497,16 @@ PROGRAMMER_OBJS += ft2232_spi.o
# into a hard requirement for libusb, defeating the purpose of auto-enabling.
endif
+ifeq ($(CONFIG_USBBLASTER_SPI), yes)
+FTDILIBS := $(shell pkg-config --libs libftdi 2>/dev/null || printf "%s" "-lftdi -lusb")
+# This is a totally ugly hack.
+FEATURE_CFLAGS += $(shell LC_ALL=C grep -q "FTDISUPPORT := yes" .features && printf "%s" "-D'CONFIG_USBBLASTER_SPI=1'")
+FEATURE_LIBS += $(shell LC_ALL=C grep -q "FTDISUPPORT := yes" .features && printf "%s" "$(FTDILIBS)")
+PROGRAMMER_OBJS += usbblaster_spi.o
+# We can't set NEED_USB here because that would transform libftdi auto-enabling
+# into a hard requirement for libusb, defeating the purpose of auto-enabling.
+endif
+
ifeq ($(CONFIG_DUMMY), yes)
FEATURE_CFLAGS += -D'CONFIG_DUMMY=1'
PROGRAMMER_OBJS += dummyflasher.o
diff --git a/README b/README
index 8e812be..7f24cca 100644
--- a/README
+++ b/README
@@ -45,8 +45,8 @@ Build Instructions
To build flashrom you need to install the following software:
* pciutils+libpci (if you want support for mainboard or PCI device flashing)
- * libusb (if you want FT2232 or Dediprog support)
- * libftdi (if you want FT2232 support)
+ * libusb (if you want FT2232, Dediprog or USB-Blaster support)
+ * libftdi (if you want FT2232 or USB-Blaster support)
Linux et al:
diff --git a/flashrom.8 b/flashrom.8
index c6c518e..feb70d6 100644
--- a/flashrom.8
+++ b/flashrom.8
@@ -220,6 +220,8 @@ bitbanging adapter)
.sp
.BR "* linux_spi" " (for SPI flash ROMs accessible via /dev/spidevX.Y on Linux)"
.sp
+.BR "* usbblaster_spi" " (for SPI flash ROMs attached to an Altera USB-Blaster compatible cable)"
+.sp
Some programmers have optional or mandatory parameters which are described
in detail in the
.B PROGRAMMER SPECIFIC INFO
@@ -837,7 +839,7 @@ needs TCP access to the network or userspace access to a serial port.
.B buspirate_spi
needs userspace access to a serial port.
.sp
-.BR dediprog " and " ft2232_spi
+.BR dediprog ", " ft2232_spi " and " usbblaster_spi
need access to the USB device via libusb.
.sp
.B dummy
@@ -847,7 +849,7 @@ needs no access permissions at all.
.BR gfxnvidia ", " drkaiser ", " satasii ", " satamv " and " atahpt
have to be run as superuser/root, and need additional raw access permission.
.sp
-.BR serprog ", " buspirate_spi ", " dediprog " and " ft2232_spi
+.BR serprog ", " buspirate_spi ", " dediprog ", " usbblaster_spi " and " ft2232_spi
can be run as normal user on most operating systems if appropriate device
permissions are set.
.sp
diff --git a/flashrom.c b/flashrom.c
index e1be398..e787197 100644
--- a/flashrom.c
+++ b/flashrom.c
@@ -308,6 +308,18 @@ const struct programmer_entry programmer_table[] = {
},
#endif
+#if CONFIG_USBBLASTER_SPI == 1
+ {
+ .name = "usbblaster_spi",
+ .type = USB,
+ .devs.dev = devs_usbblasterspi,
+ .init = usbblaster_spi_init,
+ .map_flash_region = fallback_map,
+ .unmap_flash_region = fallback_unmap,
+ .delay = internal_delay,
+ },
+#endif
+
{0}, /* This entry corresponds to PROGRAMMER_INVALID. */
};
diff --git a/programmer.h b/programmer.h
index 51a8c80..dd2ba30 100644
--- a/programmer.h
+++ b/programmer.h
@@ -87,6 +87,9 @@ enum programmer {
#if CONFIG_LINUX_SPI == 1
PROGRAMMER_LINUX_SPI,
#endif
+#if CONFIG_USBBLASTER_SPI == 1
+ PROGRAMMER_USBBLASTER_SPI,
+#endif
PROGRAMMER_INVALID /* This must always be the last entry. */
};
@@ -431,6 +434,12 @@ int ft2232_spi_init(void);
extern const struct dev_entry devs_ft2232spi[];
#endif
+/* usbblaster_spi.c */
+#if CONFIG_USBBLASTER_SPI == 1
+int usbblaster_spi_init(void);
+extern const struct dev_entry devs_usbblasterspi[];
+#endif
+
/* rayer_spi.c */
#if CONFIG_RAYER_SPI == 1
int rayer_spi_init(void);
@@ -509,6 +518,9 @@ enum spi_controller {
#if CONFIG_SERPROG == 1
SPI_CONTROLLER_SERPROG,
#endif
+#if CONFIG_USBBLASTER_SPI == 1
+ SPI_CONTROLLER_USBBLASTER,
+#endif
};
#define MAX_DATA_UNSPECIFIED 0
diff --git a/usbblaster_spi.c b/usbblaster_spi.c
new file mode 100644
index 0000000..53eb7d5
--- /dev/null
+++ b/usbblaster_spi.c
@@ -0,0 +1,225 @@
+/*
+ * This file is part of the flashrom project.
+ *
+ * Copyright (C) 2012 James Laird <jhl(a)mafipulation.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/*
+ * Device should be connected as per "active serial" mode:
+ *
+ * +---------+------+-----------+
+ * | SPI | Pin | Altera |
+ * +---------+------+-----------+
+ * | SCLK | 1 | DCLK |
+ * | GND | 2,10 | GND |
+ * | VCC | 4 | VCC(TRGT) |
+ * | MISO | 7 | DATAOUT |
+ * | /CS | 8 | nCS |
+ * | MOSI | 9 | ASDI |
+ * +---------+------+-----------+
+ *
+ * See also the USB-Blaster Download Cable User Guide: http://www.altera.com/literature/ug/ug_usb_blstr.pdf
+ */
+
+#if CONFIG_USBBLASTER_SPI == 1
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <ftdi.h>
+#include "flash.h"
+#include "programmer.h"
+#include "spi.h"
+
+/* Please keep sorted by vendor ID, then device ID. */
+#define ALTERA_VID 0x09fb
+#define ALTERA_USBBLASTER_PID 0x6001
+
+const struct dev_entry devs_usbblasterspi[] = {
+ {ALTERA_VID, ALTERA_USBBLASTER_PID, OK, "Altera", "USB-Blaster"},
+
+ {}
+};
+
+static const struct spi_programmer spi_programmer_usbblaster;
+
+static struct ftdi_context ftdic;
+
+// command bytes
+#define BIT_BYTE (1<<7) // byte mode (rather than bitbang)
+#define BIT_READ (1<<6) // read request
+#define BIT_LED (1<<5)
+#define BIT_CS (1<<3)
+#define BIT_TMS (1<<1)
+#define BIT_CLK (1<<0)
+
+#define BUF_SIZE 64
+
+/* The programmer shifts bits in the wrong order for SPI, so we use this method to reverse the bits when needed.
+ * http://graphics.stanford.edu/~seander/bithacks.html#ReverseByteWith32Bits */
+uint8_t reverse(uint8_t b)
+{
+ return ((b * 0x0802LU & 0x22110LU) | (b * 0x8020LU & 0x88440LU)) * 0x10101LU >> 16;
+}
+
+
+/* Returns 0 upon success, a negative number upon errors. */
+int usbblaster_spi_init(void)
+{
+ uint8_t buf[BUF_SIZE + 1];
+
+ if (ftdi_init(&ftdic) < 0)
+ return -1;
+
+ if (ftdi_usb_open(&ftdic, ALTERA_VID, ALTERA_USBBLASTER_PID) < 0) {
+ msg_perr("Failed to open USB-Blaster: %s\n", ftdic.error_str);
+ return -1;
+ }
+
+ if (ftdi_usb_reset(&ftdic) < 0) {
+ msg_perr("USB-Blaster reset failed\n");
+ return -1;
+ }
+
+ if (ftdi_set_latency_timer(&ftdic, 2) < 0) {
+ msg_perr("USB-Blaster set latency timer failed\n");
+ return -1;
+ }
+
+ if (ftdi_write_data_set_chunksize(&ftdic, 4096) < 0 ||
+ ftdi_read_data_set_chunksize(&ftdic, BUF_SIZE) < 0) {
+ msg_perr("USB-Blaster set chunk size failed\n");
+ return -1;
+ }
+
+ memset(buf, 0, sizeof(buf));
+ buf[sizeof(buf)-1] = BIT_LED | BIT_CS;
+ if (ftdi_write_data(&ftdic, buf, sizeof(buf)) < 0) {
+ msg_perr("USB-Blaster reset write failed\n");
+ return -1;
+ }
+ if (ftdi_read_data(&ftdic, buf, sizeof(buf)) < 0) {
+ msg_perr("USB-Blaster reset read failed\n");
+ return -1;
+ }
+
+ register_spi_programmer(&spi_programmer_usbblaster);
+ return 0;
+}
+
+static int send_write(unsigned int writecnt, const unsigned char *writearr)
+{
+ int i;
+ uint8_t buf[BUF_SIZE];
+
+ memset(buf, 0, sizeof(buf));
+ while (writecnt) {
+ unsigned int n_write = min(writecnt, BUF_SIZE - 1);
+ msg_pspew("writing %d-byte packet\n", n_write);
+
+ buf[0] = BIT_BYTE | (uint8_t)n_write;
+ for (i = 0; i < n_write; i++) {
+ buf[i+1] = reverse(writearr[i]);
+ }
+ if (ftdi_write_data(&ftdic, buf, n_write + 1) < 0) {
+ msg_perr("USB-Blaster write failed\n");
+ return -1;
+ }
+
+ writearr += n_write;
+ writecnt -= n_write;
+ }
+ return 0;
+}
+
+static int send_read(unsigned int readcnt, unsigned char *readarr)
+{
+ int i;
+ unsigned int n_read;
+ uint8_t buf[BUF_SIZE];
+ memset(buf, 0, sizeof(buf));
+
+ n_read = readcnt;
+ while (n_read) {
+ unsigned int payload_size = min(n_read, BUF_SIZE - 1);
+ msg_pspew("reading %d-byte packet\n", payload_size);
+
+ buf[0] = BIT_BYTE | BIT_READ | (uint8_t)payload_size;
+ if (ftdi_write_data(&ftdic, buf, payload_size + 1) < 0) {
+ msg_perr("USB-Blaster write failed\n");
+ return -1;
+ }
+ n_read -= payload_size;
+ };
+
+ n_read = readcnt;
+ while (n_read) {
+ int ret = ftdi_read_data(&ftdic, readarr, n_read);
+ if (ret < 0) {
+ msg_perr("USB-Blaster read failed\n");
+ return -1;
+ }
+ for (i = 0; i < ret; i++) {
+ readarr[i] = reverse(readarr[i]);
+ }
+ n_read -= ret;
+ readarr += ret;
+ }
+ return 0;
+}
+
+/* Returns 0 upon success, a negative number upon errors. */
+static int usbblaster_spi_send_command(struct flashctx *flash, unsigned int writecnt, unsigned int readcnt,
+ const unsigned char *writearr, unsigned char *readarr)
+{
+ uint8_t cmd;
+ int ret = 0;
+
+ cmd = BIT_LED; // asserts /CS
+ if (ftdi_write_data(&ftdic, &cmd, 1) < 0) {
+ msg_perr("USB-Blaster enable chip select failed\n");
+ ret = -1;
+ }
+
+ if (!ret && writecnt)
+ ret = send_write(writecnt, writearr);
+
+ if (!ret && readcnt)
+ ret = send_read(readcnt, readarr);
+
+ cmd = BIT_CS;
+ if (ftdi_write_data(&ftdic, &cmd, 1) < 0) {
+ msg_perr("USB-Blaster disable chip select failed\n");
+ ret = -1;
+ }
+
+ return ret;
+}
+
+
+static const struct spi_programmer spi_programmer_usbblaster = {
+ .type = SPI_CONTROLLER_USBBLASTER,
+ .max_data_read = 256,
+ .max_data_write = 256,
+ .command = usbblaster_spi_send_command,
+ .multicommand = default_spi_send_multicommand,
+ .read = default_spi_read,
+ .write_256 = default_spi_write_256,
+ .write_aai = default_spi_write_aai,
+};
+
+#endif
--
1.8.1.1
by Alexander List
Hi,
according to your website my board (Supermicro X9SCM-F) is not supported
yet.
http://www.supermicro.com/products/motherboard/xeon/c202_c204/x9scm-f.cfm
I wonder what's faster - me figuring out how to get a PXE boot
environment up and running here at home so I can boot a FreeDOS HDD
image via the net, or me helping you support this type of board ;)
output of flashrom -V attached, as well as dmidecode.
cheers
Alex
PS: You can find me on freenode as #alexlist - around the ubuntu
channels ... just ping me if I can help you support this board.
by Bertho Grandpied
Testing Dell Dimension 4100 : Pentium III and Intel 815 (82815 + 82801BA, ICH2) based desktop machine from ca yr 2000.
This chipset should be supported IIUC, but flash chip is not detected :(
Flashrom was run under MS-DOS (log appended) - notice how I had to specify the "not-a-laptop" override because of insufficient DMI tables. Please notice also the "warning" about being unable to set Bios Control at 0x4e : thus the question arises, is that Intel chipset variant supported or is it not ?
Additionally I ran 'Linux/sensors-detct' FWIW : "probing for Super-I/O at 0x2e/2f", "SMSC LPC47M10x/112/13x" fan sensors were found.
Any further software probe I can try before opening up the box in the hope of finding what BIOS chip was used by visual inspection ?
Regards...
__________________________________________________________________
flashrom v0.9.6.1-r1624 on MS-DOS 7 (i686)
flashrom was built with libpci 3.1.5, GCC 4.4.4, little endian
Command line (7 args): c:/flashrom/flashrom.exe -p internal:laptop=this_is_not_a_laptop -V -r DELL.BIN -o READ.LOG
Calibrating delay loop... OS timer resolution is 50000 usecs, 486M loops per second, 10 myus = 0 us, 100 myus = 0 us, 1000 myus = 0 us, 10000 myus = 0 us, 200000 myus = 270000 us, OK.
Initializing internal programmer
No coreboot table found.
DMI string system-manufacturer: "Dell Computer Corporation "
DMI string system-product-name: "XPS-Z "
DMI string system-version: " "
DMI string baseboard-manufacturer: "Intel Corporation "
DMI string baseboard-product-name: "D815EEA "
DMI string baseboard-version: "AAA10383-402 "
DMI string chassis-type: "Unknown"
DMI chassis-type is not specific enough.
========================================================================
WARNING! You may be running flashrom on an unsupported laptop.(....)
You have been warned.
========================================================================
Proceeding anyway because user forced us to.
Found chipset "Intel ICH2" with PCI ID 8086:2440. Enabling flash write...
BIOS_CNTL = 0x02: BIOS Lock Enable: enabled, BIOS Write Enable: disabled
WARNING: Setting Bios Control at 0x4e from 0x02 to 0x03 on ICH2 failed.
New value is 0x02.
FAILED!
The following protocols are supported: FWH.
Probing for Atmel AT49LH002, 256 kB: probe_82802ab: id1 0x93, id2 0x26, id1 parity violation, id1 is normal flash content, id2 is normal flash content
Probing for Intel 82802AB, 512 kB: probe_82802ab: id1 0xff, id2 0xff, id1 parity violation, id1 is normal flash content, id2 is normal flash content
Probing for Intel 82802AC, 1024 kB: probe_82802ab: id1 0xff, id2 0xff, id1 parity violation, id1 is normal flash content, id2 is normal flash content
Probing for PMC Pm49FL002, 256 kB: probe_jedec_common: id1 0x93, id2 0x26, id1 parity violation, id1 is normal flash content, id2 is normal flash content
Probing for PMC Pm49FL004, 512 kB: probe_jedec_common: id1 0xff, id2 0xff, id1 parity violation, id1 is normal flash content, id2 is normal flash content
Probing for Sharp LHF00L04, 1024 kB: probe_82802ab: id1 0xff, id2 0xff, id1 parity violation, id1 is normal flash content, id2 is normal flash content
Probing for SST SST49LF002A/B, 256 kB: probe_jedec_common: id1 0x93, id2 0x26, id1 parity violation, id1 is normal flash content, id2 is normal flash content
Probing for SST SST49LF003A/B, 384 kB: probe_jedec_common: id1 0xb2, id2 0xf1, id1 parity violation, id1 is normal flash content, id2 is normal flash content
Probing for SST SST49LF004A/B, 512 kB: probe_jedec_common: id1 0xff, id2 0xff, id1 parity violation, id1 is normal flash content, id2 is normal flash content
Probing for SST SST49LF004C, 512 kB: probe_82802ab: id1 0xff, id2 0xff, id1 parity violation, id1 is normal flash content, id2 is normal flash content
Probing for SST SST49LF008A, 1024 kB: probe_jedec_common: id1 0xff, id2 0xff, id1 parity violation, id1 is normal flash content, id2 is normal flash content
Probing for SST SST49LF008C, 1024 kB: probe_82802ab: id1 0xff, id2 0xff, id1 parity violation, id1 is normal flash content, id2 is normal flash content
Probing for SST SST49LF016C, 2048 kB: probe_82802ab: id1 0xff, id2 0xff, id1 parity violation, id1 is normal flash content, id2 is normal flash content
Probing for ST M50FLW040A, 512 kB: probe_82802ab: id1 0xff, id2 0xff, id1 parity violation, id1 is normal flash content, id2 is normal flash content
Probing for ST M50FLW040B, 512 kB: probe_82802ab: id1 0xff, id2 0xff, id1 parity violation, id1 is normal flash content, id2 is normal flash content
Probing for ST M50FLW080A, 1024 kB: probe_82802ab: id1 0xff, id2 0xff, id1 parity violation, id1 is normal flash content, id2 is normal flash content
Probing for ST M50FLW080B, 1024 kB: probe_82802ab: id1 0xff, id2 0xff, id1 parity violation, id1 is normal flash content, id2 is normal flash content
Probing for ST M50FW002, 256 kB: probe_82802ab: id1 0x93, id2 0x26, id1 parity violation, id1 is normal flash content, id2 is normal flash content
Probing for ST M50FW016, 2048 kB: probe_82802ab: id1 0xff, id2 0xff, id1 parity violation, id1 is normal flash content, id2 is normal flash content
Probing for ST M50FW040, 512 kB: probe_82802ab: id1 0xff, id2 0xff, id1 parity violation, id1 is normal flash content, id2 is normal flash content
Probing for ST M50FW080, 1024 kB: probe_82802ab: id1 0xff, id2 0xff, id1 parity violation, id1 is normal flash content, id2 is normal flash content
Probing for Winbond W39V040FA, 512 kB: probe_jedec_common: id1 0xff, id2 0xff, id1 parity violation, id1 is normal flash content, id2 is normal flash content
Probing for Winbond W39V040FB, 512 kB: probe_jedec_common: id1 0xff, id2 0xff, id1 parity violation, id1 is normal flash content, id2 is normal flash content
Probing for Winbond W39V040FC, 512 kB: probe_jedec_common: id1 0xff, id2 0xff, id1 parity violation, id1 is normal flash content, id2 is normal flash content
Probing for Winbond W49V002FA, 256 kB: probe_jedec_common: id1 0x93, id2 0x26, id1 parity violation, id1 is normal flash content, id2 is normal flash content
Probing for Winbond W39V080FA, 1024 kB: probe_jedec_common: id1 0xff, id2 0xff, id1 parity violation, id1 is normal flash content, id2 is normal flash content
Probing for Winbond W39V080FA (dual mode), 512 kB: probe_jedec_common: id1 0xff, id2 0xff, id1 parity violation, id1 is normal flash content, id2 is normal flash content
No EEPROM/flash device found.
Note: flashrom can never write if the flash chip isn't found automatically.
Restoring PCI config space for 00:1f:0 reg 0x4e
_________________________________________________________________
--
Czerno
by Stefan Tauner
On Mon, 6 Aug 2012 12:07:47 -0700
Greg Schardt <gschardt(a)ddn.com> wrote:
> Can you explain why doing a read operation failed? I expected that reads would work and writes would fail.
each region can have 4 different access states: read/write, read-only,
write-only (never seen in practice), locked (neither read nor write
allowed) (see FREG in the public datasheets for any newer intel
southbridge >ICH8).
flashrom disables writes by default if it detects locked or read-only
regions as a safety measurement and still allows reads because they can
not lead to the same severe damage. in case of locked regions reads of
addresses inside those regions will of course fail.
there are some patches available that are not merged yet that allow to
specify the addresses to be read/written, which allow to read/write the
readable/writable address ranges.
--
Kind regards/Mit freundlichen Grüßen, Stefan Tauner
