openwrt/upstream - upstream openwrt

diff options

author	Felix Fietkau <nbd@openwrt.org>	2005-04-18 19:51:42 +0000
committer	Felix Fietkau <nbd@openwrt.org>	2005-04-18 19:51:42 +0000
commit	e3b86ee3fb6960dbd2503a4ac01659c8e907b21e (patch)
tree	a6f87fac16d22ed13dfdc4793a87128c29095b91 /package/busybox/config
parent	26afbfb9fffedf03bbc0d3aaa937786b08270b77 (diff)
download	upstream-e3b86ee3fb6960dbd2503a4ac01659c8e907b21e.tar.gz upstream-e3b86ee3fb6960dbd2503a4ac01659c8e907b21e.tar.bz2 upstream-e3b86ee3fb6960dbd2503a4ac01659c8e907b21e.zip

enable dirname and id by default (needed by openswan)

git-svn-id: svn://svn.openwrt.org/openwrt/trunk/openwrt@676 3c298f89-4303-0410-b956-a3cf2f4a3e73

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

-rw-r--r--

package/busybox/config/coreutils/Config.in

1 files changed, 2 insertions, 2 deletions

/* * This file is part of the flashrom project. * * Copyright (C) 2011-2012 Stefan Tauner * * 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 */ #include <stdint.h> #include <stdlib.h> #include <string.h> #include "flash.h" #include "spi.h" #include "chipdrivers.h" static int spi_sfdp_read_sfdp_chunk(struct flashctx *flash, uint32_t address, uint8_t *buf, int len) { int i, ret; uint8_t *newbuf; const unsigned char cmd[JEDEC_SFDP_OUTSIZE] = { JEDEC_SFDP, (address >> 16) & 0xff, (address >> 8) & 0xff, (address >> 0) & 0xff, /* FIXME: the following dummy byte explodes on some programmers. * One workaround is to read the dummy byte * instead and discard its value. */ 0 }; msg_cspew("%s: addr=0x%x, len=%d, data:\n", __func__, address, len); newbuf = malloc(len + 1); if (!newbuf) return SPI_PROGRAMMER_ERROR; ret = spi_send_command(flash, sizeof(cmd) - 1, len + 1, cmd, newbuf); memmove(buf, newbuf + 1, len); free(newbuf); if (ret) return ret; for (i = 0; i < len; i++) msg_cspew(" 0x%02x", buf[i]); msg_cspew("\n"); return 0; } static int spi_sfdp_read_sfdp(struct flashctx *flash, uint32_t address, uint8_t *buf, int len) { /* FIXME: There are different upper bounds for the number of bytes to * read on the various programmers (even depending on the rest of the * structure of the transaction). 2 is a safe bet. */ int maxstep = 2; int ret = 0; while (len > 0) { int step = min(len, maxstep); ret = spi_sfdp_read_sfdp_chunk(flash, address, buf, step); if (ret) return ret; address += step; buf += step; len -= step; } return ret; } struct sfdp_tbl_hdr { uint8_t id; uint8_t v_minor; uint8_t v_major; uint8_t len; uint32_t ptp; /* 24b pointer */ }; static int sfdp_add_uniform_eraser(struct flashchip *chip, uint8_t opcode, uint32_t block_size) { int i; uint32_t total_size = chip->total_size * 1024; erasefunc_t *erasefn = spi_get_erasefn_from_opcode(opcode); if (erasefn == NULL || total_size == 0 || block_size == 0 || total_size % block_size != 0) { msg_cdbg("%s: invalid input, please report to " "flashrom@flashrom.org\n", __func__); return 1; } for (i = 0; i < NUM_ERASEFUNCTIONS; i++) { struct block_eraser *eraser = &chip->block_erasers[i]; /* Check for duplicates (including (some) non-uniform ones). */ if (eraser->eraseblocks[0].size == block_size && eraser->block_erase == erasefn) { msg_cdbg2(" Tried to add a duplicate block eraser: " "%d x %d B with opcode 0x%02x.\n", total_size/block_size, block_size, opcode); return 1; } if (eraser->eraseblocks[0].size != 0 || eraser->block_erase != NULL) { msg_cspew(" Block Eraser %d is already occupied.\n", i); continue; } eraser->block_erase = erasefn; eraser->eraseblocks[0].size = block_size; eraser->eraseblocks[0].count = total_size/block_size; msg_cdbg2(" Block eraser %d: %d x %d B with opcode " "0x%02x\n", i, total_size/block_size, block_size, opcode); return 0; } msg_cinfo("%s: Not enough space to store another eraser (i=%d)." " Please report this at flashrom@flashrom.org\n", __func__, i); return 1; } static int sfdp_fill_flash(struct flashchip *chip, uint8_t *buf, uint16_t len) { uint8_t opcode_4k_erase = 0xFF; uint32_t tmp32; uint8_t tmp8; uint32_t total_size; /* in bytes */ uint32_t block_size; int j; msg_cdbg("Parsing JEDEC flash parameter table... "); if (len != 9 * 4 && len != 4 * 4) { msg_cdbg("%s: len out of spec\n", __func__); return 1; } msg_cdbg2("\n"); /* 1. double word */ tmp32 = ((unsigned int)buf[(4 * 0) + 0]); tmp32 |= ((unsigned int)buf[(4 * 0) + 1]) << 8; tmp32 |= ((unsigned int)buf[(4 * 0) + 2]) << 16; tmp32 |= ((unsigned int)buf[(4 * 0) + 3]) << 24; tmp8 = (tmp32 >> 17) & 0x3; switch (tmp8) { case 0x0: msg_cdbg2(" 3-Byte only addressing.\n"); break; case 0x1: msg_cdbg2(" 3-Byte (and optionally 4-Byte) addressing.\n"); break; case 0x2: msg_cdbg(" 4-Byte only addressing (not supported by " "flashrom).\n"); return 1; default: msg_cdbg(" Required addressing mode (0x%x) not supported.\n", tmp8); return 1; } msg_cdbg2(" Status register is "); if (tmp32 & (1 << 3)) { msg_cdbg2("volatile and writes to the status register have to " "be enabled with "); if (tmp32 & (1 << 4)) { chip->feature_bits = FEATURE_WRSR_WREN; msg_cdbg2("WREN (0x06).\n"); } else { chip->feature_bits = FEATURE_WRSR_EWSR; msg_cdbg2("EWSR (0x50).\n"); } } else { msg_cdbg2("non-volatile and the standard does not allow " "vendors to tell us whether EWSR/WREN is needed for " "status register writes - assuming EWSR.\n"); chip->feature_bits = FEATURE_WRSR_EWSR; } msg_cdbg2(" Write chunk size is "); if (tmp32 & (1 << 2)) { msg_cdbg2("at least 64 B.\n"); chip->page_size = 64; chip->write = spi_chip_write_256; } else { msg_cdbg2("1 B only.\n"); chip->page_size = 256; chip->write = spi_chip_write_1; } if ((tmp32 & 0x3) == 0x1) { opcode_4k_erase = (tmp32 >> 8) & 0xFF; msg_cspew(" 4kB erase opcode is 0x%02x.\n", opcode_4k_erase); /* add the eraser later, because we don't know total_size yet */ } else msg_cspew(" 4kB erase opcode is not defined.\n"); /* 2. double word */ tmp32 = ((unsigned int)buf[(4 * 1) + 0]); tmp32 |= ((unsigned int)buf[(4 * 1) + 1]) << 8; tmp32 |= ((unsigned int)buf[(4 * 1) + 2]) << 16; tmp32 |= ((unsigned int)buf[(4 * 1) + 3]) << 24; if (tmp32 & (1 << 31)) { msg_cdbg("Flash chip size >= 4 Gb/512 MB not supported.\n"); return 1; } total_size = ((tmp32 & 0x7FFFFFFF) + 1) / 8; chip->total_size = total_size / 1024; msg_cdbg2(" Flash chip size is %d kB.\n", chip->total_size); if (total_size > (1 << 24)) { msg_cdbg("Flash chip size is bigger than what 3-Byte addressing " "can access.\n"); return 1; } if (opcode_4k_erase != 0xFF) sfdp_add_uniform_eraser(chip, opcode_4k_erase, 4 * 1024); /* FIXME: double words 3-7 contain unused fast read information */ if (len == 4 * 4) { msg_cdbg(" It seems like this chip supports the preliminary " "Intel version of SFDP, skipping processing of double " "words 3-9.\n"); goto done; } /* 8. double word */ for (j = 0; j < 4; j++) { /* 7 double words from the start + 2 bytes for every eraser */ tmp8 = buf[(4 * 7) + (j * 2)]; msg_cspew(" Erase Sector Type %d Size: 0x%02x\n", j + 1, tmp8); if (tmp8 == 0) { msg_cspew(" Erase Sector Type %d is unused.\n", j); continue; } if (tmp8 >= 31) { msg_cdbg2(" Block size of erase Sector Type %d (2^%d) " "is too big for flashrom.\n", j, tmp8); continue; } block_size = 1 << (tmp8); /* block_size = 2 ^ field */ tmp8 = buf[(4 * 7) + (j * 2) + 1]; msg_cspew(" Erase Sector Type %d Opcode: 0x%02x\n", j + 1, tmp8);


context:
space:
mode: