openwrt/upstream - upstream openwrt

diff options

author	Felix Fietkau <nbd@openwrt.org>	2013-01-28 20:35:55 +0000
committer	Felix Fietkau <nbd@openwrt.org>	2013-01-28 20:35:55 +0000
commit	6ea9abadebcddb605384dfc2e12687f29fc52f68 (patch)
tree	718894c9bfad76a286d0510cb67d8a409318c09d /package/network/config
parent	2d298b7b5e92e8cedd2beea861af0268294dccdf (diff)
download	upstream-6ea9abadebcddb605384dfc2e12687f29fc52f68.tar.gz upstream-6ea9abadebcddb605384dfc2e12687f29fc52f68.tar.bz2 upstream-6ea9abadebcddb605384dfc2e12687f29fc52f68.zip

netifd: update to latest version, fixes setting addresses/routes on alias interfaces

SVN-Revision: 35362

Diffstat (limited to 'package/network/config')

-rw-r--r--

package/network/config/netifd/Makefile

1 files changed, 2 insertions, 2 deletions

/* * This file is part of the flashrom project. * * Copyright (C) 2009, 2011 Urja Rannikko <urjaman@gmail.com> * Copyright (C) 2009 Carl-Daniel Hailfinger * * 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; either version 2 of the License, or * (at your option) any later version. * * 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. */ #include <stdbool.h> #include <stdio.h> #if ! IS_WINDOWS /* stuff (presumably) needed for sockets only */ #include <stdlib.h> #include <unistd.h> #include <fcntl.h> #include <sys/socket.h> #include <arpa/inet.h> #include <netinet/in.h> #include <netinet/tcp.h> #include <netdb.h> #endif #if IS_WINDOWS #include <conio.h> #else #include <termios.h> #endif #include <string.h> #include <errno.h> #include "flash.h" #include "programmer.h" #include "chipdrivers.h" /* According to Serial Flasher Protocol Specification - version 1 */ #define S_ACK 0x06 #define S_NAK 0x15 #define S_CMD_NOP 0x00 /* No operation */ #define S_CMD_Q_IFACE 0x01 /* Query interface version */ #define S_CMD_Q_CMDMAP 0x02 /* Query supported commands bitmap */ #define S_CMD_Q_PGMNAME 0x03 /* Query programmer name */ #define S_CMD_Q_SERBUF 0x04 /* Query Serial Buffer Size */ #define S_CMD_Q_BUSTYPE 0x05 /* Query supported bustypes */ #define S_CMD_Q_CHIPSIZE 0x06 /* Query supported chipsize (2^n format) */ #define S_CMD_Q_OPBUF 0x07 /* Query operation buffer size */ #define S_CMD_Q_WRNMAXLEN 0x08 /* Query Write to opbuf: Write-N maximum length */ #define S_CMD_R_BYTE 0x09 /* Read a single byte */ #define S_CMD_R_NBYTES 0x0A /* Read n bytes */ #define S_CMD_O_INIT 0x0B /* Initialize operation buffer */ #define S_CMD_O_WRITEB 0x0C /* Write opbuf: Write byte with address */ #define S_CMD_O_WRITEN 0x0D /* Write to opbuf: Write-N */ #define S_CMD_O_DELAY 0x0E /* Write opbuf: udelay */ #define S_CMD_O_EXEC 0x0F /* Execute operation buffer */ #define S_CMD_SYNCNOP 0x10 /* Special no-operation that returns NAK+ACK */ #define S_CMD_Q_RDNMAXLEN 0x11 /* Query read-n maximum length */ #define S_CMD_S_BUSTYPE 0x12 /* Set used bustype(s). */ #define S_CMD_O_SPIOP 0x13 /* Perform SPI operation. */ #define S_CMD_S_SPI_FREQ 0x14 /* Set SPI clock frequency */ #define S_CMD_S_PIN_STATE 0x15 /* Enable/disable output drivers */ #define MSGHEADER "serprog: " static uint16_t sp_device_serbuf_size = 16; static uint16_t sp_device_opbuf_size = 300; /* Bitmap of supported commands */ static uint8_t sp_cmdmap[32]; /* sp_prev_was_write used to detect writes with contiguous addresses and combine them to write-n's */ static int sp_prev_was_write = 0; /* sp_write_n_addr used as the starting addr of the currently combined write-n operation */ static uint32_t sp_write_n_addr; /* The maximum length of an write_n operation; 0 = write-n not supported */ static uint32_t sp_max_write_n = 0; /* The maximum length of a read_n operation; 0 = 2^24 */ static uint32_t sp_max_read_n = 0; /* A malloc'd buffer for combining the operation's data and a counter that tells how much data is there. */ static uint8_t *sp_write_n_buf; static uint32_t sp_write_n_bytes = 0; /* sp_streamed_* used for flow control checking */ static unsigned int sp_streamed_transmit_ops = 0; static unsigned int sp_streamed_transmit_bytes = 0; /* sp_opbuf_usage used for counting the amount of on-device operation buffer used */ static int sp_opbuf_usage = 0; /* if true causes sp_docommand to automatically check whether the command is supported before doing it */ static int sp_check_avail_automatic = 0; #if ! IS_WINDOWS static int sp_opensocket(char *ip, unsigned int port) { int flag = 1; struct hostent *hostPtr = NULL; union { struct sockaddr_in si; struct sockaddr s; } sp = {}; int sock; msg_pdbg(MSGHEADER "IP %s port %d\n", ip, port); sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP); if (sock < 0) { msg_perr("Error: serprog cannot open socket: %s\n", strerror(errno)); return -1; } hostPtr = gethostbyname(ip); if (NULL == hostPtr) { hostPtr = gethostbyaddr(ip, strlen(ip), AF_INET); if (NULL == hostPtr) { close(sock); msg_perr("Error: cannot resolve %s\n", ip); return -1; } } sp.si.sin_family = AF_INET; sp.si.sin_port = htons(port); (void)memcpy(&sp.si.sin_addr, hostPtr->h_addr_list[0], hostPtr->h_length); if (connect(sock, &sp.s, sizeof(sp.si)) < 0) { close(sock); msg_perr("Error: serprog cannot connect: %s\n", strerror(errno)); return -1; } /* We are latency limited, and sometimes do write-write-read * * (write-n) - so enable TCP_NODELAY. */ if (setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, &flag, sizeof(int))) { close(sock); msg_perr("Error: serprog cannot set socket options: %s\n", strerror(errno)); return -1; } return sock; } #endif /* Synchronize: a bit tricky algorithm that tries to (and in my tests has * * always succeeded in) bring the serial protocol to known waiting-for- * * command state - uses nonblocking I/O - rest of the driver uses * * blocking read - TODO: add an alarm() timer for the rest of the app on * * serial operations, though not such a big issue as the first thing to * * do is synchronize (eg. check that device is alive). */ static int sp_synchronize(void) { int i; unsigned char buf[8]; /* First sends 8 NOPs, then flushes the return data - should cause * * the device serial parser to get to a sane state, unless if it * * is waiting for a real long write-n. */ memset(buf, S_CMD_NOP, 8); if (serialport_write_nonblock(buf, 8, 1, NULL) != 0) { goto err_out; } /* A second should be enough to get all the answers to the buffer */ default_delay(1000 * 1000); sp_flush_incoming(); /* Then try up to 8 times to send syncnop and get the correct special * * return of NAK+ACK. Timing note: up to 10 characters, 10*50ms = * * up to 500ms per try, 8*0.5s = 4s; +1s (above) = up to 5s sync * * attempt, ~1s if immediate success. */ for (i = 0; i < 8; i++) { int n; unsigned char c = S_CMD_SYNCNOP; if (serialport_write_nonblock(&c, 1, 1, NULL) != 0) { goto err_out; } msg_pdbg("."); fflush(stdout); for (n = 0; n < 10; n++) { int ret = serialport_read_nonblock(&c, 1, 50, NULL); if (ret < 0) goto err_out; if (ret > 0 || c != S_NAK) continue; ret = serialport_read_nonblock(&c, 1, 20, NULL); if (ret < 0) goto err_out; if (ret > 0 || c != S_ACK) continue; c = S_CMD_SYNCNOP; if (serialport_write_nonblock(&c, 1, 1, NULL) != 0) { goto err_out; } ret = serialport_read_nonblock(&c, 1, 500, NULL); if (ret < 0) goto err_out; if (ret > 0 || c != S_NAK) break; /* fail */ ret = serialport_read_nonblock(&c, 1, 100, NULL); if (ret > 0 || ret < 0) goto err_out; if (c != S_ACK) break; /* fail */ msg_pdbg("\n"); return 0; } } err_out: msg_perr("Error: cannot synchronize protocol - check communications and reset device?\n"); return 1; } static int sp_check_commandavail(uint8_t command) { int byteoffs, bitoffs; byteoffs = command / 8; bitoffs = command % 8; return (sp_cmdmap[byteoffs] & (1 << bitoffs)) ? 1 : 0; } static int sp_automatic_cmdcheck(uint8_t cmd) { if ((sp_check_avail_automatic) && (sp_check_commandavail(cmd) == 0)) { msg_pdbg("Warning: Automatic command availability check failed " "for cmd 0x%02x - won't execute cmd\n", cmd); return 1; } return 0; } static int sp_docommand(uint8_t command, uint32_t parmlen, uint8_t *params, uint32_t retlen, void *retparms) { unsigned char c; if (sp_automatic_cmdcheck(command)) return 1; if (serialport_write(&command, 1) != 0) { msg_perr("Error: cannot write op code: %s\n", strerror(errno)); return 1; } if (serialport_write(params, parmlen) != 0) { msg_perr("Error: cannot write parameters: %s\n", strerror(errno)); return 1; } if (serialport_read(&c, 1) != 0) { msg_perr("Error: cannot read from device: %s\n", strerror(errno)); return 1; } if (c == S_NAK) return 1; if (c != S_ACK) { msg_perr("Error: invalid response 0x%02X from device (to command 0x%02X)\n", c, command); return 1; } if (retlen) { if (serialport_read(retparms, retlen) != 0) { msg_perr("Error: cannot read return parameters: %s\n", strerror(errno)); return 1; } } return 0; } static int sp_flush_stream(void) { if (sp_streamed_transmit_ops) do { unsigned char c; if (serialport_read(&c, 1) != 0) { msg_perr("Error: cannot read from device (flushing stream)"); return 1; } if (c == S_NAK) { msg_perr("Error: NAK to a stream buffer operation\n"); return 1; } if (c != S_ACK) { msg_perr("Error: Invalid reply 0x%02X from device\n", c); return 1; } } while (--sp_streamed_transmit_ops); sp_streamed_transmit_ops = 0; sp_streamed_transmit_bytes = 0; return 0; } static int sp_stream_buffer_op(uint8_t cmd, uint32_t parmlen, uint8_t *parms) { uint8_t *sp; if (sp_automatic_cmdcheck(cmd)) return 1; sp = malloc(1 + parmlen); if (!sp) { msg_perr("Error: cannot malloc command buffer\n"); return 1; } sp[0] = cmd; if (parms) memcpy(&(sp[1]), parms, parmlen); if (sp_streamed_transmit_bytes >= (1 + parmlen + sp_device_serbuf_size)) { if (sp_flush_stream() != 0) { free(sp); return 1; } } if (serialport_write(sp, 1 + parmlen) != 0) { msg_perr("Error: cannot write command\n"); free(sp); return 1; } sp_streamed_transmit_ops += 1; sp_streamed_transmit_bytes += 1 + parmlen; free(sp); return 0; } /* Move an in flashrom buffer existing write-n operation to the on-device operation buffer. */ static int sp_pass_writen(void) { unsigned char header[7]; msg_pspew(MSGHEADER "Passing write-n bytes=%d addr=0x%x\n", sp_write_n_bytes, sp_write_n_addr); if (sp_streamed_transmit_bytes >= (7 + sp_write_n_bytes + sp_device_serbuf_size)) { if (sp_flush_stream() != 0) { return 1; } } /* In case it's just a single byte send it as a single write. */ if (sp_write_n_bytes == 1) { sp_write_n_bytes = 0; header[0] = (sp_write_n_addr >> 0) & 0xFF; header[1] = (sp_write_n_addr >> 8) & 0xFF; header[2] = (sp_write_n_addr >> 16) & 0xFF; header[3] = sp_write_n_buf[0]; if (sp_stream_buffer_op(S_CMD_O_WRITEB, 4, header) != 0) return 1; sp_opbuf_usage += 5; return 0; } header[0] = S_CMD_O_WRITEN; header[1] = (sp_write_n_bytes >> 0) & 0xFF; header[2] = (sp_write_n_bytes >> 8) & 0xFF; header[3] = (sp_write_n_bytes >> 16) & 0xFF; header[4] = (sp_write_n_addr >> 0) & 0xFF; header[5] = (sp_write_n_addr >> 8) & 0xFF; header[6] = (sp_write_n_addr >> 16) & 0xFF; if (serialport_write(header, 7) != 0) { msg_perr(MSGHEADER "Error: cannot write write-n command\n"); return 1; } if (serialport_write(sp_write_n_buf, sp_write_n_bytes) != 0) { msg_perr(MSGHEADER "Error: cannot write write-n data"); return 1; } sp_streamed_transmit_bytes += 7 + sp_write_n_bytes; sp_streamed_transmit_ops += 1; sp_opbuf_usage += 7 + sp_write_n_bytes; sp_write_n_bytes = 0; sp_prev_was_write = 0; return 0; } static int sp_execute_opbuf_noflush(void) { if ((sp_max_write_n) && (sp_write_n_bytes)) { if (sp_pass_writen() != 0) { msg_perr("Error: could not transfer write buffer\n"); return 1; } } if (sp_stream_buffer_op(S_CMD_O_EXEC, 0, NULL) != 0) { msg_perr("Error: could not execute command buffer\n"); return 1; } msg_pspew(MSGHEADER "Executed operation buffer of %d bytes\n", sp_opbuf_usage); sp_opbuf_usage = 0; sp_prev_was_write = 0; return 0; } static int sp_execute_opbuf(void) { if (sp_execute_opbuf_noflush() != 0) return 1; if (sp_flush_stream() != 0) return 1; return 0; } static int serprog_spi_send_command(const struct flashctx *flash, unsigned int writecnt, unsigned int readcnt, const unsigned char *writearr, unsigned char *readarr) { unsigned char *parmbuf; int ret; msg_pspew("%s, writecnt=%i, readcnt=%i\n", __func__, writecnt, readcnt); if ((sp_opbuf_usage) || (sp_max_write_n && sp_write_n_bytes)) { if (sp_execute_opbuf() != 0) { msg_perr("Error: could not execute command buffer before sending SPI commands.\n"); return 1; } } parmbuf = malloc(writecnt + 6); if (!parmbuf) { msg_perr("Error: could not allocate SPI send param buffer.\n"); return 1; } parmbuf[0] = (writecnt >> 0) & 0xFF; parmbuf[1] = (writecnt >> 8) & 0xFF; parmbuf[2] = (writecnt >> 16) & 0xFF; parmbuf[3] = (readcnt >> 0) & 0xFF; parmbuf[4] = (readcnt >> 8) & 0xFF; parmbuf[5] = (readcnt >> 16) & 0xFF; memcpy(parmbuf + 6, writearr, writecnt); ret = sp_docommand(S_CMD_O_SPIOP, writecnt + 6, parmbuf, readcnt, readarr); free(parmbuf); return ret; } static int serprog_shutdown(void *data) { if ((sp_opbuf_usage) || (sp_max_write_n && sp_write_n_bytes)) if (sp_execute_opbuf() != 0) msg_pwarn("Could not flush command buffer.\n"); if (sp_check_commandavail(S_CMD_S_PIN_STATE)) { uint8_t dis = 0; if (sp_docommand(S_CMD_S_PIN_STATE, 1, &dis, 0, NULL) == 0) msg_pdbg(MSGHEADER "Output drivers disabled\n"); else msg_pwarn(MSGHEADER "%s: Warning: could not disable output buffers\n", __func__); } /* FIXME: fix sockets on windows(?), especially closing */ serialport_shutdown(&sp_fd); if (sp_max_write_n) free(sp_write_n_buf); return 0; } static void *serprog_map(const char *descr, uintptr_t phys_addr, size_t len) { /* Serprog transmits 24 bits only and assumes the underlying implementation handles any remaining bits * correctly (usually setting them to one either in software (for FWH/LPC) or relying on the fact that * the hardware observes a subset of the address bits only). Combined with the standard mapping of * flashrom this creates a 16 MB-wide window just below the 4 GB boundary where serprog can operate (as * needed for non-SPI chips). Below we make sure that the requested range is within this window. */ if ((phys_addr & 0xFF000000) == 0xFF000000) { return (void*)phys_addr; } msg_pwarn(MSGHEADER "requested mapping %s is incompatible: 0x%zx bytes at 0x%0*" PRIxPTR ".\n", descr, len, PRIxPTR_WIDTH, phys_addr); return NULL; } static void serprog_delay(const struct flashctx *flash, unsigned int usecs); static struct spi_master spi_master_serprog = { .map_flash_region = serprog_map, .features = SPI_MASTER_4BA, .max_data_read = MAX_DATA_READ_UNLIMITED, .max_data_write = MAX_DATA_WRITE_UNLIMITED, .command = serprog_spi_send_command, .multicommand = default_spi_send_multicommand, .read = default_spi_read, .write_256 = default_spi_write_256, .probe_opcode = default_spi_probe_opcode, .delay = serprog_delay, }; static int sp_check_opbuf_usage(int bytes_to_be_added) { if (sp_device_opbuf_size <= (sp_opbuf_usage + bytes_to_be_added)) { /* If this happens in the middle of a page load the page load will probably fail. */ msg_pwarn(MSGHEADER "Warning: executed operation buffer due to size reasons\n"); if (sp_execute_opbuf() != 0) return 1; } return 0; } static void serprog_chip_writeb(const struct flashctx *flash, uint8_t val, chipaddr addr) { msg_pspew("%s\n", __func__); if (sp_max_write_n) { if ((sp_prev_was_write) && (addr == (sp_write_n_addr + sp_write_n_bytes))) { sp_write_n_buf[sp_write_n_bytes++] = val; } else { if ((sp_prev_was_write) && (sp_write_n_bytes)) sp_pass_writen(); sp_prev_was_write = 1; sp_write_n_addr = addr; sp_write_n_bytes = 1; sp_write_n_buf[0] = val; } sp_check_opbuf_usage(7 + sp_write_n_bytes); if (sp_write_n_bytes >= sp_max_write_n) sp_pass_writen(); } else { /* We will have to do single writeb ops. */ unsigned char writeb_parm[4]; sp_check_opbuf_usage(6); writeb_parm[0] = (addr >> 0) & 0xFF; writeb_parm[1] = (addr >> 8) & 0xFF; writeb_parm[2] = (addr >> 16) & 0xFF; writeb_parm[3] = val; sp_stream_buffer_op(S_CMD_O_WRITEB, 4, writeb_parm); // FIXME: return error sp_opbuf_usage += 5; } } static uint8_t serprog_chip_readb(const struct flashctx *flash, const chipaddr addr) { unsigned char c; unsigned char buf[3]; /* Will stream the read operation - eg. add it to the stream buffer, * * then flush the buffer, then read the read answer. */ if ((sp_opbuf_usage) || (sp_max_write_n && sp_write_n_bytes)) sp_execute_opbuf_noflush(); buf[0] = ((addr >> 0) & 0xFF); buf[1] = ((addr >> 8) & 0xFF); buf[2] = ((addr >> 16) & 0xFF); sp_stream_buffer_op(S_CMD_R_BYTE, 3, buf); // FIXME: return error sp_flush_stream(); // FIXME: return error if (serialport_read(&c, 1) != 0) msg_perr(MSGHEADER "readb byteread"); // FIXME: return error msg_pspew("%s addr=0x%" PRIxPTR " returning 0x%02X\n", __func__, addr, c); return c; } /* Local version that really does the job, doesn't care of max_read_n. */ static int sp_do_read_n(uint8_t * buf, const chipaddr addr, size_t len) { unsigned char sbuf[6]; msg_pspew("%s: addr=0x%" PRIxPTR " len=%zu\n", __func__, addr, len); /* Stream the read-n -- as above. */ if ((sp_opbuf_usage) || (sp_max_write_n && sp_write_n_bytes)) sp_execute_opbuf_noflush(); sbuf[0] = ((addr >> 0) & 0xFF); sbuf[1] = ((addr >> 8) & 0xFF); sbuf[2] = ((addr >> 16) & 0xFF); sbuf[3] = ((len >> 0) & 0xFF); sbuf[4] = ((len >> 8) & 0xFF); sbuf[5] = ((len >> 16) & 0xFF); sp_stream_buffer_op(S_CMD_R_NBYTES, 6, sbuf); if (sp_flush_stream() != 0) return 1; if (serialport_read(buf, len) != 0) { msg_perr(MSGHEADER "Error: cannot read read-n data"); return 1; } return 0; } /* The externally called version that makes sure that max_read_n is obeyed. */ static void serprog_chip_readn(const struct flashctx *flash, uint8_t * buf, const chipaddr addr, size_t len) { size_t lenm = len; chipaddr addrm = addr; while ((sp_max_read_n != 0) && (lenm > sp_max_read_n)) { sp_do_read_n(&(buf[addrm-addr]), addrm, sp_max_read_n); // FIXME: return error addrm += sp_max_read_n; lenm -= sp_max_read_n; } if (lenm) sp_do_read_n(&(buf[addrm-addr]), addrm, lenm); // FIXME: return error } static void serprog_delay(const struct flashctx *flash, unsigned int usecs) { unsigned char buf[4]; msg_pspew("%s usecs=%d\n", __func__, usecs); if (!sp_check_commandavail(S_CMD_O_DELAY)) { msg_pdbg2("serprog_delay used, but programmer doesn't support delays natively - emulating\n"); default_delay(usecs); return; } if ((sp_max_write_n) && (sp_write_n_bytes)) sp_pass_writen(); sp_check_opbuf_usage(5); buf[0] = ((usecs >> 0) & 0xFF); buf[1] = ((usecs >> 8) & 0xFF); buf[2] = ((usecs >> 16) & 0xFF); buf[3] = ((usecs >> 24) & 0xFF); sp_stream_buffer_op(S_CMD_O_DELAY, 4, buf); sp_opbuf_usage += 5; sp_prev_was_write = 0; } static const struct par_master par_master_serprog = { .map_flash_region = serprog_map, .chip_readb = serprog_chip_readb, .chip_readn = serprog_chip_readn, .chip_writeb = serprog_chip_writeb, .delay = serprog_delay, }; static enum chipbustype serprog_buses_supported = BUS_NONE; static int serprog_init(const struct programmer_cfg *cfg) { uint16_t iface; unsigned char pgmname[17]; unsigned char rbuf[3]; unsigned char c; char *device; bool have_device = false; /* the parameter is either of format "dev=/dev/device[:baud]" or "ip=ip:port" */ device = extract_programmer_param_str(cfg, "dev"); if (device && strlen(device)) { char *baud_str = strstr(device, ":"); if (baud_str != NULL) { /* Split device from baudrate. */ *baud_str = '\0'; baud_str++; } int baud; /* Convert baud string to value. * baud_str is either NULL (if strstr can't find the colon), points to the \0 after the colon * if no characters where given after the colon, or a string to convert... */ if (baud_str == NULL || *baud_str == '\0') { baud = -1; msg_pdbg("No baudrate specified, using the hardware's defaults.\n"); } else { baud = atoi(baud_str); // FIXME: replace atoi with strtoul } if (strlen(device) > 0) { sp_fd = sp_openserport(device, baud); if (sp_fd == SER_INV_FD) { free(device); return 1; } have_device = true; } } #if !IS_WINDOWS if (device && !strlen(device)) { msg_perr("Error: No device specified.\n" "Use flashrom -p serprog:dev=/dev/device[:baud]\n"); free(device); return 1; } free(device); device = extract_programmer_param_str(cfg, "ip"); if (have_device && device) { msg_perr("Error: Both host and device specified.\n" "Please use either dev= or ip= but not both.\n"); free(device); return 1; } if (device && strlen(device)) { char *port = strstr(device, ":"); if (port != NULL) { /* Split host from port. */ *port = '\0'; port++; } if (!port || !strlen(port)) { msg_perr("Error: No port specified.\n" "Use flashrom -p serprog:ip=ipaddr:port\n"); free(device); return 1; } if (strlen(device)) { sp_fd = sp_opensocket(device, atoi(port)); // FIXME: replace atoi with strtoul if (sp_fd < 0) { free(device); return 1; } have_device = true; } } if (device && !strlen(device)) { msg_perr("Error: No host specified.\n" "Use flashrom -p serprog:ip=ipaddr:port\n"); free(device); return 1; } #endif free(device); if (!have_device) { #if IS_WINDOWS msg_perr("Error: No device specified.\n" "Use flashrom -p serprog:dev=comN[:baud]\n"); #else msg_perr("Error: Neither host nor device specified.\n" "Use flashrom -p serprog:dev=/dev/device:baud or " "flashrom -p serprog:ip=ipaddr:port\n"); #endif return 1; } msg_pdbg(MSGHEADER "connected - attempting to synchronize\n"); sp_check_avail_automatic = 0; if (sp_synchronize()) goto init_err_cleanup_exit; msg_pdbg(MSGHEADER "Synchronized\n"); if (sp_docommand(S_CMD_Q_IFACE, 0, NULL, 2, &iface)) { msg_perr("Error: NAK to query interface version\n"); goto init_err_cleanup_exit; } if (iface != 1) { msg_perr("Error: Unknown interface version: %d\n", iface);


context:
space:
mode: