openwrt/flashrom
1
0
Fork 0
mirror of https://review.coreboot.org/flashrom.git synced 2025-07-02 06:23:18 +02:00
Code Issues Releases Wiki Activity

Refine physical address mapping of flash chips

Browse Source 
- Create distinct functions for mapping and unmapping for flash chips.
 - Map only when needed: map before probing and unmap immediately
   after it. Map again when a single chip was probed successfully before
   taking any actual actions and clean up afterwards.
 - Map special function chip registers centrally together with flash space
   instead of within (some) probing methods after successful probes.
 - Save the used base addresses of the mappings in struct flashctx as well.
 - Do not try to (un)map the zero-sized chip definitions that are merely hacks.
   This also fixes the printing of wrong warnings for these chip definitions
   introduced in r1765.

Corresponding to flashrom svn r1847.

Signed-off-by: Stefan Tauner <stefan.tauner@alumni.tuwien.ac.at>
Acked-by: Carl-Daniel Hailfinger <c-d.hailfinger.devel.2006@gmx.net>
This commit is contained in:
Stefan Tauner
2014-08-30 23:39:51 +00:00
parent 583ea32911
commit 4e32ec19b1
5 changed files with 98 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files

100
flashrom.c
View File

@ -479,6 +479,7 @@ void *programmer_map_flash_region(const char *descr, uintptr_t phys_addr, size_t
void programmer_unmap_flash_region(void *virt_addr, size_t len)
{
programmer_table[programmer].unmap_flash_region(virt_addr, len);
msg_gspew("%s: unmapped 0x%0*" PRIxPTR "\n", __func__, PRIxPTR_WIDTH, (uintptr_t)virt_addr);
}
void chip_writeb(const struct flashctx *flash, uint8_t val, chipaddr addr)
@ -528,14 +529,6 @@ void programmer_delay(unsigned int usecs)
programmer_table[programmer].delay(usecs);
}
void map_flash_registers(struct flashctx *flash)
{
size_t size = flash->chip->total_size * 1024;
/* Flash registers live 4 MByte below the flash. */
/* FIXME: This is incorrect for nonstandard flashbase. */
flash->virtual_registers = (chipaddr)programmer_map_flash_region("flash chip registers", (0xFFFFFFFF - 0x400000 - size + 1), size);
}
int read_memmapped(struct flashctx *flash, uint8_t *buf, unsigned int start,
int unsigned len)
{
@ -1052,12 +1045,64 @@ unsigned int count_max_decode_exceedings(const struct flashctx *flash)
return limitexceeded;
}
void unmap_flash(struct flashctx *flash)
{
if (flash->virtual_registers != (chipaddr)ERROR_PTR) {
programmer_unmap_flash_region((void *)flash->virtual_registers, flash->chip->total_size * 1024);
flash->physical_registers = 0;
flash->virtual_registers = (chipaddr)ERROR_PTR;
}
if (flash->virtual_memory != (chipaddr)ERROR_PTR) {
programmer_unmap_flash_region((void *)flash->virtual_memory, flash->chip->total_size * 1024);
flash->physical_memory = 0;
flash->virtual_memory = (chipaddr)ERROR_PTR;
}
}
int map_flash(struct flashctx *flash)
{
/* Init pointers to the fail-safe state to distinguish them later from legit values. */
flash->virtual_memory = (chipaddr)ERROR_PTR;
flash->virtual_registers = (chipaddr)ERROR_PTR;
/* FIXME: This avoids mapping (and unmapping) of flash chip definitions with size 0.
* These are used for various probing-related hacks that would not map successfully anyway and should be
* removed ASAP. */
if (flash->chip->total_size == 0)
return 0;
const chipsize_t size = flash->chip->total_size * 1024;
uintptr_t base = flashbase ? flashbase : (0xffffffff - size + 1);
void *addr = programmer_map_flash_region(flash->chip->name, base, size);
if (addr == ERROR_PTR) {
msg_perr("Could not map flash chip %s at 0x%0*" PRIxPTR ".\n",
flash->chip->name, PRIxPTR_WIDTH, base);
return 1;
}
flash->physical_memory = base;
flash->virtual_memory = (chipaddr)addr;
/* FIXME: Special function registers normally live 4 MByte below flash space, but it might be somewhere
* completely different on some chips and programmers, or not mappable at all.
* Ignore these problems for now and always report success. */
if (flash->chip->feature_bits & FEATURE_REGISTERMAP) {
base = 0xffffffff - size - 0x400000 + 1;
addr = programmer_map_flash_region("flash chip registers", base, size);
if (addr == ERROR_PTR) {
msg_pdbg2("Could not map flash chip registers %s at 0x%0*" PRIxPTR ".\n",
flash->chip->name, PRIxPTR_WIDTH, base);
return 0;
}
flash->physical_registers = base;
flash->virtual_registers = (chipaddr)addr;
}
return 0;
}
int probe_flash(struct registered_master *mst, int startchip, struct flashctx *flash, int force)
{
const struct flashchip *chip;
unsigned long base = 0;
char location[64];
uint32_t size;
enum chipbustype buses_common;
char *tmp;
@ -1082,9 +1127,8 @@ int probe_flash(struct registered_master *mst, int startchip, struct flashctx *f
memcpy(flash->chip, chip, sizeof(struct flashchip));
flash->mst = mst;
size = flash->chip->total_size * 1024;
base = flashbase ? flashbase : (0xffffffff - size + 1);
flash->virtual_memory = (chipaddr)programmer_map_flash_region("flash chip", base, size);
if (map_flash(flash) != 0)
return -1;
/* We handle a forced match like a real match, we just avoid probing. Note that probe_flash()
* is only called with force=1 after normal probing failed.
@ -1133,8 +1177,7 @@ int probe_flash(struct registered_master *mst, int startchip, struct flashctx *f
break;
/* Not the first flash chip detected on this bus, and it's just a generic match. Ignore it. */
notfound:
programmer_unmap_flash_region((void *)flash->virtual_memory, size);
flash->virtual_memory = (chipaddr)NULL;
unmap_flash(flash);
free(flash->chip);
flash->chip = NULL;
}
@ -1142,25 +1185,28 @@ notfound:
if (!flash->chip)
return -1;
#if CONFIG_INTERNAL == 1
if (programmer_table[programmer].map_flash_region == physmap)
snprintf(location, sizeof(location), "at physical address 0x%lx", base);
else
#endif
snprintf(location, sizeof(location), "on %s", programmer_table[programmer].name);
tmp = flashbuses_to_text(flash->chip->bustype);
msg_cinfo("%s %s flash chip \"%s\" (%d kB, %s) %s.\n", force ? "Assuming" : "Found",
flash->chip->vendor, flash->chip->name, flash->chip->total_size, tmp, location);
msg_cinfo("%s %s flash chip \"%s\" (%d kB, %s) ", force ? "Assuming" : "Found",
flash->chip->vendor, flash->chip->name, flash->chip->total_size, tmp);
free(tmp);
#if CONFIG_INTERNAL == 1
if (programmer_table[programmer].map_flash_region == physmap)
msg_cinfo("mapped at physical address 0x%0*" PRIxPTR ".\n",
PRIxPTR_WIDTH, flash->physical_memory);
else
#endif
msg_cinfo("on %s.\n", programmer_table[programmer].name);
/* Flash registers will not be mapped if the chip was forced. Lock info
* may be stored in registers, so avoid lock info printing.
*/
/* Flash registers may more likely not be mapped if the chip was forced.
* Lock info may be stored in registers, so avoid lock info printing. */
if (!force)
if (flash->chip->printlock)
flash->chip->printlock(flash);
/* Get out of the way for later runs. */
unmap_flash(flash);
/* Return position of matching chip. */
return chip - flashchips;
}