parent
873c1d746e
commit
658cc34395
|
@ -1,4 +1,10 @@
|
|||
|
||||
config TEXT_BASE
|
||||
string
|
||||
default "0x08f00000" if MACH_MX1ADS
|
||||
default "0x08f80000" if MACH_SCB9328
|
||||
default "0x21e00000" if MACH_ECO920
|
||||
|
||||
config ARM920T
|
||||
bool
|
||||
|
||||
|
@ -20,6 +26,14 @@ config MACH_MX1ADS
|
|||
help
|
||||
Say Y here if you are using the Motorola MX1ADS board
|
||||
|
||||
config MACH_SCB9328
|
||||
bool "Syntertronixx scb9328"
|
||||
select HAS_DM9000
|
||||
select HAS_CFI
|
||||
select ARCH_IMX
|
||||
help
|
||||
Say Y here if you are using the Synertronixx scb9328 board
|
||||
|
||||
config MACH_ECO920
|
||||
bool "eco920"
|
||||
select HAS_AT91_ETHER
|
||||
|
|
|
@ -8,9 +8,10 @@ machine-$(CONFIG_ARCH_IMX) := imx
|
|||
machine-$(CONFIG_ARCH_AT91RM9200) := at91rm9200
|
||||
board-$(CONFIG_MACH_MX1ADS) := mx1ads
|
||||
board-$(CONFIG_MACH_ECO920) := eco920
|
||||
board-$(CONFIG_MACH_SCB9328) := scb9328
|
||||
cpu-$(CONFIG_ARM920T) := arm920t
|
||||
|
||||
TEXT_BASE = 0x21e00000
|
||||
TEXT_BASE = $(CONFIG_TEXT_BASE)
|
||||
|
||||
CPPFLAGS += -mabi=apcs-gnu -DTEXT_BASE=$(TEXT_BASE)
|
||||
CFLAGS := -fno-common -msoft-float -Os
|
||||
|
|
|
@ -46,7 +46,7 @@
|
|||
#include <net.h>
|
||||
#include <cfi_flash.h>
|
||||
|
||||
ulong load_addr = CFG_LOAD_ADDR; /* Default Load Address */
|
||||
ulong load_addr = 0; /* Default Load Address */
|
||||
|
||||
DECLARE_GLOBAL_DATA_PTR;
|
||||
|
||||
|
@ -147,22 +147,6 @@ static int display_dram_config (void)
|
|||
return (0);
|
||||
}
|
||||
|
||||
#ifndef CFG_NO_FLASH
|
||||
extern flash_info_t flash_info[CFG_MAX_FLASH_BANKS];
|
||||
|
||||
static void display_flash_config (ulong size)
|
||||
{
|
||||
int i;
|
||||
|
||||
puts ("Flash Configuration:\n");
|
||||
for(i=0; i<CFG_MAX_FLASH_BANKS; i++) {
|
||||
printf ("Bank #%d: 0x%08lx ", i, flash_info[i].start[0]);
|
||||
print_size (flash_info[i].size, "\n");
|
||||
}
|
||||
}
|
||||
#endif /* CFG_NO_FLASH */
|
||||
|
||||
|
||||
/*
|
||||
* Breathe some life into the board...
|
||||
*
|
||||
|
@ -189,6 +173,7 @@ static void display_flash_config (ulong size)
|
|||
typedef int (init_fnc_t) (void);
|
||||
|
||||
extern int mem_init(void);
|
||||
extern int partition_init(void);
|
||||
|
||||
int print_cpuinfo (void); /* test-only */
|
||||
|
||||
|
@ -203,6 +188,7 @@ init_fnc_t *init_sequence[] = {
|
|||
#ifdef CONFIG_DRIVER_CFI
|
||||
flash_init,
|
||||
#endif
|
||||
partition_init,
|
||||
#ifdef CONFIG_CMD_MEMORY
|
||||
mem_init,
|
||||
#endif
|
||||
|
@ -221,15 +207,11 @@ init_fnc_t *init_sequence[] = {
|
|||
void start_armboot (void)
|
||||
{
|
||||
init_fnc_t **init_fnc_ptr;
|
||||
char *s;
|
||||
#ifndef CFG_NO_FLASH
|
||||
ulong size;
|
||||
#endif
|
||||
#if defined(CONFIG_VFD) || defined(CONFIG_LCD)
|
||||
unsigned long addr;
|
||||
#endif
|
||||
|
||||
/* Pointer is writable since we allocated a register for it */
|
||||
/* Pointer is writable since we allocated a register for it */
|
||||
gd = (gd_t*)(_armboot_start - CFG_MALLOC_LEN - sizeof(gd_t));
|
||||
/* compiler optimization barrier needed for GCC >= 3.4 */
|
||||
__asm__ __volatile__("": : :"memory");
|
||||
|
@ -240,46 +222,16 @@ void start_armboot (void)
|
|||
|
||||
monitor_flash_len = _bss_start - _armboot_start;
|
||||
|
||||
/* armboot_start is defined in the board-specific linker script */
|
||||
mem_malloc_init (_armboot_start - CFG_MALLOC_LEN);
|
||||
|
||||
for (init_fnc_ptr = init_sequence; *init_fnc_ptr; ++init_fnc_ptr) {
|
||||
if ((*init_fnc_ptr)() != 0) {
|
||||
// serial_putc(i++ + 'a');
|
||||
if ((*init_fnc_ptr)() != 0) {
|
||||
hang ();
|
||||
}
|
||||
}
|
||||
|
||||
#ifndef CFG_NO_FLASH
|
||||
/* configure available FLASH banks */
|
||||
// display_flash_config (size);
|
||||
#endif /* CFG_NO_FLASH */
|
||||
|
||||
#ifdef CONFIG_VFD
|
||||
# ifndef PAGE_SIZE
|
||||
# define PAGE_SIZE 4096
|
||||
# endif
|
||||
/*
|
||||
* reserve memory for VFD display (always full pages)
|
||||
*/
|
||||
/* bss_end is defined in the board-specific linker script */
|
||||
addr = (_bss_end + (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1);
|
||||
size = vfd_setmem (addr);
|
||||
gd->fb_base = addr;
|
||||
#endif /* CONFIG_VFD */
|
||||
|
||||
#ifdef CONFIG_LCD
|
||||
# ifndef PAGE_SIZE
|
||||
# define PAGE_SIZE 4096
|
||||
# endif
|
||||
/*
|
||||
* reserve memory for LCD display (always full pages)
|
||||
*/
|
||||
/* bss_end is defined in the board-specific linker script */
|
||||
addr = (_bss_end + (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1);
|
||||
size = lcd_setmem (addr);
|
||||
gd->fb_base = addr;
|
||||
#endif /* CONFIG_LCD */
|
||||
|
||||
/* armboot_start is defined in the board-specific linker script */
|
||||
mem_malloc_init (_armboot_start - CFG_MALLOC_LEN);
|
||||
|
||||
#if (CONFIG_COMMANDS & CFG_CMD_NAND)
|
||||
puts ("NAND: ");
|
||||
nand_init(); /* go init the NAND */
|
||||
|
@ -288,11 +240,6 @@ void start_armboot (void)
|
|||
/* initialize environment */
|
||||
env_relocate ();
|
||||
|
||||
#ifdef CONFIG_VFD
|
||||
/* must do this after the framebuffer is allocated */
|
||||
drv_vfd_init();
|
||||
#endif /* CONFIG_VFD */
|
||||
|
||||
jumptable_init ();
|
||||
|
||||
#if defined(CONFIG_MISC_INIT_R)
|
||||
|
@ -306,13 +253,10 @@ void start_armboot (void)
|
|||
#ifdef BOARD_LATE_INIT
|
||||
board_late_init ();
|
||||
#endif
|
||||
#if (CONFIG_COMMANDS & CFG_CMD_NET)
|
||||
#if defined(CONFIG_NET_MULTI)
|
||||
puts ("Net: ");
|
||||
#endif
|
||||
#ifdef CONFIG_NET
|
||||
eth_initialize(gd->bd);
|
||||
#endif
|
||||
/* main_loop() can return to retry autoboot, if so just run it again. */
|
||||
/* main_loop() can return to retry autoboot, if so just run it again. */
|
||||
for (;;) {
|
||||
main_loop ();
|
||||
}
|
||||
|
|
|
@ -74,7 +74,7 @@ obj-$(CONFIG_CMD_I2C) += cmd_i2c.o
|
|||
obj-y += dlmalloc.o
|
||||
#obj-y += env_nvram.o
|
||||
#obj-y += lynxkdi.o
|
||||
#obj-y += cmd_boot.o
|
||||
obj-y += cmd_boot.o
|
||||
#obj-y += cmd_eeprom.o
|
||||
#obj-y += cmd_immap.o
|
||||
#obj-y += cmd_nand.o
|
||||
|
|
|
@ -154,6 +154,7 @@ int do_bootm (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
|
|||
#if defined CONFIG_CMD_BOOTM_ZLIB || defined CONFIG_CMD_BOOTM_BZLIB
|
||||
uint unc_len = CFG_BOOTM_LEN;
|
||||
#endif
|
||||
char buf[32];
|
||||
int i, verify;
|
||||
char *name, *s;
|
||||
image_header_t *hdr = &header;
|
||||
|
@ -368,7 +369,6 @@ int do_bootm (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
|
|||
if (iflag)
|
||||
enable_interrupts();
|
||||
|
||||
char buf[32];
|
||||
sprintf(buf, "%lX", len);
|
||||
setenv("filesize", buf);
|
||||
return 0;
|
||||
|
@ -1110,8 +1110,6 @@ do_bootm_artos (cmd_tbl_t *cmdtp, int flag,
|
|||
}
|
||||
#endif
|
||||
|
||||
|
||||
#if (CONFIG_COMMANDS & CFG_CMD_BOOTD)
|
||||
int do_bootd (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
|
||||
{
|
||||
int rcode = 0;
|
||||
|
@ -1137,8 +1135,6 @@ U_BOOT_CMD(
|
|||
NULL
|
||||
);
|
||||
|
||||
#endif
|
||||
|
||||
#if (CONFIG_COMMANDS & CFG_CMD_IMI)
|
||||
int do_iminfo ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
|
||||
{
|
||||
|
|
|
@ -26,12 +26,7 @@
|
|||
*/
|
||||
#include <common.h>
|
||||
#include <command.h>
|
||||
|
||||
int do_flinfo ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
|
||||
{
|
||||
printf("%s is broken\n",__FUNCTION__);
|
||||
return 0;
|
||||
}
|
||||
#include <cfi_flash.h>
|
||||
|
||||
int do_flerase (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
|
||||
{
|
||||
|
@ -56,7 +51,8 @@ int do_flerase (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
|
|||
return 1;
|
||||
}
|
||||
|
||||
mem.device->driver->erase(mem.device, &mem);
|
||||
erase(mem.device, mem.size, mem.start);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -93,13 +89,6 @@ int do_protect (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
|
|||
|
||||
/**************************************************/
|
||||
|
||||
U_BOOT_CMD(
|
||||
flinfo, 2, 1, do_flinfo,
|
||||
"flinfo - print FLASH memory information\n",
|
||||
"\n - print information for all FLASH memory banks\n"
|
||||
"flinfo N\n - print information for FLASH memory bank # N\n"
|
||||
);
|
||||
|
||||
U_BOOT_CMD(
|
||||
erase, 2, 0, do_flerase,
|
||||
"erase - erase FLASH memory\n",
|
||||
|
|
373
common/cmd_mem.c
373
common/cmd_mem.c
|
@ -30,6 +30,7 @@
|
|||
#include <common.h>
|
||||
#include <command.h>
|
||||
#include <driver.h>
|
||||
#include <malloc.h>
|
||||
|
||||
#ifdef CMD_MEM_DEBUG
|
||||
#define PRINTF(fmt,args...) printf (fmt ,##args)
|
||||
|
@ -37,46 +38,20 @@
|
|||
#define PRINTF(fmt,args...)
|
||||
#endif
|
||||
|
||||
#define RW_BUF_SIZE (ulong)4096
|
||||
static char *rw_buf;
|
||||
|
||||
/* Memory Display
|
||||
*
|
||||
* Syntax:
|
||||
* md{.b, .w, .l} {addr} {len}
|
||||
*/
|
||||
#define DISP_LINE_LEN 16
|
||||
int do_mem_md ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
|
||||
|
||||
void memory_display(char *addr, ulong offs, ulong nbytes, int size)
|
||||
{
|
||||
ulong addr, offs;
|
||||
ulong i, nbytes = 0x100, linebytes;
|
||||
struct memarea_info mem;
|
||||
ulong linebytes, i;
|
||||
u_char *cp;
|
||||
int size;
|
||||
int rc = 0;
|
||||
|
||||
if (argc < 2) {
|
||||
printf ("Usage:\n%s\n", cmdtp->usage);
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (spec_str_to_info(argv[1], &mem)) {
|
||||
printf("-ENOPARSE\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
offs = mem.start;
|
||||
if (mem.device->map_flags & MAP_READ)
|
||||
addr = mem.device->map_base + offs;
|
||||
else {
|
||||
printf("cannot yet show unmapped devices\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (mem.flags & MEMAREA_SIZE_SPECIFIED)
|
||||
nbytes = mem.size;
|
||||
else
|
||||
nbytes = min(0x100, mem.size);
|
||||
|
||||
if ((size = cmd_get_data_size(argv[0], 4)) < 0)
|
||||
return 1;
|
||||
|
||||
/* Print the lines.
|
||||
*
|
||||
|
@ -116,19 +91,64 @@ int do_mem_md ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
|
|||
putc ('\n');
|
||||
nbytes -= linebytes;
|
||||
if (ctrlc()) {
|
||||
rc = 1;
|
||||
break;
|
||||
return;
|
||||
}
|
||||
} while (nbytes > 0);
|
||||
|
||||
}
|
||||
|
||||
int do_mem_md ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
|
||||
{
|
||||
ulong offs, now;
|
||||
ulong nbytes = 0x100;
|
||||
struct memarea_info mem;
|
||||
int size, r;
|
||||
int rc = 0;
|
||||
|
||||
if (argc < 2) {
|
||||
printf ("Usage:\n%s\n", cmdtp->usage);
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (spec_str_to_info(argv[1], &mem)) {
|
||||
printf("-ENOPARSE\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (mem.flags & MEMAREA_SIZE_SPECIFIED)
|
||||
nbytes = mem.size;
|
||||
else
|
||||
nbytes = min((ulong)0x100, mem.size);
|
||||
|
||||
if ((size = cmd_get_data_size(argv[0], 4)) < 0)
|
||||
return 1;
|
||||
|
||||
offs = mem.start;
|
||||
|
||||
do {
|
||||
now = min(RW_BUF_SIZE, nbytes);
|
||||
r = read(mem.device, rw_buf, now, offs, RW_SIZE(size));
|
||||
if (r <= 0)
|
||||
return r;
|
||||
|
||||
memory_display(rw_buf, offs, r, size);
|
||||
|
||||
if (r < now)
|
||||
return 0;
|
||||
|
||||
nbytes -= now;
|
||||
offs += now;
|
||||
} while (nbytes > 0);
|
||||
|
||||
return (rc);
|
||||
}
|
||||
|
||||
int do_mem_mw ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
|
||||
{
|
||||
ulong addr, writeval, count;
|
||||
|
||||
struct memarea_info mem;
|
||||
int size;
|
||||
ulong size;
|
||||
|
||||
if ((argc < 3) || (argc > 4)) {
|
||||
printf ("Usage:\n%s\n", cmdtp->usage);
|
||||
|
@ -146,96 +166,25 @@ int do_mem_mw ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
|
|||
}
|
||||
addr = mem.start;
|
||||
|
||||
if (mem.device->map_flags & MAP_WRITE)
|
||||
addr += mem.device->map_base;
|
||||
else {
|
||||
printf("cannot yet modify unmapped devices\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Get the value to write.
|
||||
*/
|
||||
writeval = simple_strtoul(argv[2], NULL, 16);
|
||||
|
||||
/* Count ? */
|
||||
if (argc == 4) {
|
||||
if (argc == 4)
|
||||
count = simple_strtoul(argv[3], NULL, 16);
|
||||
else
|
||||
count = size;
|
||||
|
||||
if (count == size) {
|
||||
return write(mem.device, (uchar *)&writeval, count, mem.start, RW_SIZE(size));
|
||||
} else {
|
||||
count = 1;
|
||||
}
|
||||
|
||||
while (count-- > 0) {
|
||||
if (size == 4)
|
||||
*((ulong *)addr) = (ulong )writeval;
|
||||
else if (size == 2)
|
||||
*((ushort *)addr) = (ushort)writeval;
|
||||
else
|
||||
*((u_char *)addr) = (u_char)writeval;
|
||||
addr += size;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_MX_CYCLIC
|
||||
int do_mem_mdc ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
|
||||
{
|
||||
int i;
|
||||
ulong count;
|
||||
|
||||
if (argc < 4) {
|
||||
printf ("Usage:\n%s\n", cmdtp->usage);
|
||||
return 1;
|
||||
}
|
||||
|
||||
count = simple_strtoul(argv[3], NULL, 10);
|
||||
|
||||
for (;;) {
|
||||
do_mem_md (NULL, 0, 3, argv);
|
||||
|
||||
/* delay for <count> ms... */
|
||||
for (i=0; i<count; i++)
|
||||
udelay (1000);
|
||||
|
||||
/* check for ctrl-c to abort... */
|
||||
if (ctrlc()) {
|
||||
puts("Abort\n");
|
||||
return 0;
|
||||
}
|
||||
printf("write multiple not yet implemented\n");
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int do_mem_mwc ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
|
||||
{
|
||||
int i;
|
||||
ulong count;
|
||||
|
||||
if (argc < 4) {
|
||||
printf ("Usage:\n%s\n", cmdtp->usage);
|
||||
return 1;
|
||||
}
|
||||
|
||||
count = simple_strtoul(argv[3], NULL, 10);
|
||||
|
||||
for (;;) {
|
||||
do_mem_mw (NULL, 0, 3, argv);
|
||||
|
||||
/* delay for <count> ms... */
|
||||
for (i=0; i<count; i++)
|
||||
udelay (1000);
|
||||
|
||||
/* check for ctrl-c to abort... */
|
||||
if (ctrlc()) {
|
||||
puts("Abort\n");
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
#endif /* CONFIG_MX_CYCLIC */
|
||||
|
||||
int do_mem_cmp (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
|
||||
{
|
||||
ulong addr1, addr2, count, ngood;
|
||||
|
@ -307,7 +256,8 @@ int do_mem_cmp (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
|
|||
|
||||
int do_mem_cp ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
|
||||
{
|
||||
ulong addr, dest, count;
|
||||
ulong count, offset, now;
|
||||
int ret;
|
||||
struct memarea_info dst, src;
|
||||
|
||||
int size;
|
||||
|
@ -332,117 +282,33 @@ int do_mem_cp ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
|
|||
return -1;
|
||||
}
|
||||
|
||||
if (!src.size && !dst.size) {
|
||||
printf("no size given. We should copy the whole device\n");
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (!src.size || !dst.size)
|
||||
count = dst.size | src.size;
|
||||
else
|
||||
count = min(src.size, dst.size);
|
||||
|
||||
count /= size;
|
||||
printf("copy from 0x%08x to 0x%08x count %d\n",src.start, dst.start, count);
|
||||
|
||||
if ((dst.device->map_flags & MAP_WRITE) &&
|
||||
(src.device->map_flags & MAP_READ)) {
|
||||
addr = src.device->map_base + src.start;
|
||||
dest = dst.device->map_base + dst.start;
|
||||
printf("copy from 0x%08x to 0x%08x count %d\n",addr, dest, count);
|
||||
offset = 0;
|
||||
while (count > 0) {
|
||||
now = min(RW_BUF_SIZE, count);
|
||||
|
||||
ret = read(src.device, rw_buf, now, src.start + offset, RW_SIZE(size));
|
||||
if (ret <= 0)
|
||||
return ret;
|
||||
|
||||
ret = write(dst.device, rw_buf, ret, dst.start + offset, RW_SIZE(size));
|
||||
if (ret <= 0)
|
||||
return ret;
|
||||
if (ret < now)
|
||||
return 0;
|
||||
offset += now;
|
||||
count -= now;
|
||||
}
|
||||
|
||||
while (count-- > 0) {
|
||||
if (size == 4)
|
||||
*((ulong *)dest) = *((ulong *)addr);
|
||||
else if (size == 2)
|
||||
*((ushort *)dest) = *((ushort *)addr);
|
||||
else
|
||||
*((u_char *)dest) = *((u_char *)addr);
|
||||
addr += size;
|
||||
dest += size;
|
||||
}
|
||||
return 0;
|
||||
} else {
|
||||
printf("can not yet copy to unmapped devices\n");
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_LOOPW
|
||||
int do_mem_loopw (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
|
||||
{
|
||||
ulong addr, length, i, data;
|
||||
int size;
|
||||
volatile uint *longp;
|
||||
volatile ushort *shortp;
|
||||
volatile u_char *cp;
|
||||
|
||||
if (argc < 4) {
|
||||
printf ("Usage:\n%s\n", cmdtp->usage);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* Check for a size spefication.
|
||||
* Defaults to long if no or incorrect specification.
|
||||
*/
|
||||
if ((size = cmd_get_data_size(argv[0], 4)) < 0)
|
||||
return 1;
|
||||
|
||||
/* Address is always specified.
|
||||
*/
|
||||
addr = simple_strtoul(argv[1], NULL, 16);
|
||||
|
||||
/* Length is the number of objects, not number of bytes.
|
||||
*/
|
||||
length = simple_strtoul(argv[2], NULL, 16);
|
||||
|
||||
/* data to write */
|
||||
data = simple_strtoul(argv[3], NULL, 16);
|
||||
|
||||
/* We want to optimize the loops to run as fast as possible.
|
||||
* If we have only one object, just run infinite loops.
|
||||
*/
|
||||
if (length == 1) {
|
||||
if (size == 4) {
|
||||
longp = (uint *)addr;
|
||||
for (;;)
|
||||
*longp = data;
|
||||
}
|
||||
if (size == 2) {
|
||||
shortp = (ushort *)addr;
|
||||
for (;;)
|
||||
*shortp = data;
|
||||
}
|
||||
cp = (u_char *)addr;
|
||||
for (;;)
|
||||
*cp = data;
|
||||
}
|
||||
|
||||
if (size == 4) {
|
||||
for (;;) {
|
||||
longp = (uint *)addr;
|
||||
i = length;
|
||||
while (i-- > 0)
|
||||
*longp++ = data;
|
||||
}
|
||||
}
|
||||
if (size == 2) {
|
||||
for (;;) {
|
||||
shortp = (ushort *)addr;
|
||||
i = length;
|
||||
while (i-- > 0)
|
||||
*shortp++ = data;
|
||||
}
|
||||
}
|
||||
for (;;) {
|
||||
cp = (u_char *)addr;
|
||||
i = length;
|
||||
while (i-- > 0)
|
||||
*cp++ = data;
|
||||
}
|
||||
}
|
||||
#endif /* CONFIG_LOOPW */
|
||||
|
||||
/*
|
||||
* Perform a memory test. A more complete alternative test can be
|
||||
* configured using CFG_ALT_MEMTEST. The complete test loops until
|
||||
|
@ -839,32 +705,79 @@ int do_mem_crc (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
|
|||
|
||||
int mem_probe(struct device_d *dev)
|
||||
{
|
||||
printf("mem_probe: %s base: 0x%08x size: 0x%08x\n", dev->name, dev->map_base, dev->size);
|
||||
|
||||
dev->map_flags = MAP_READ | MAP_WRITE;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void memcpy_sz(void *_dst, void *_src, ulong count, ulong rwsize)
|
||||
{
|
||||
ulong dst = (ulong)_dst;
|
||||
ulong src = (ulong)_src;
|
||||
|
||||
if (!rwsize) {
|
||||
memcpy(_dst, _src, count);
|
||||
return;
|
||||
}
|
||||
|
||||
count /= rwsize;
|
||||
|
||||
while (count-- > 0) {
|
||||
switch (rwsize) {
|
||||
case 1:
|
||||
*((u_char *)dst) = *((u_char *)src);
|
||||
break;
|
||||
case 2:
|
||||
*((ushort *)dst) = *((ushort *)src);
|
||||
break;
|
||||
case 4:
|
||||
*((ulong *)dst) = *((ulong *)src);
|
||||
break;
|
||||
}
|
||||
dst += rwsize;
|
||||
src += rwsize;
|
||||
}
|
||||
}
|
||||
|
||||
ssize_t mem_read(struct device_d *dev, void *buf, size_t count, ulong offset, ulong rwflags)
|
||||
{
|
||||
memcpy_sz(buf, (void *)(dev->map_base + offset), count, rwflags & RW_SIZE_MASK);
|
||||
return count;
|
||||
}
|
||||
|
||||
ssize_t mem_write(struct device_d *dev, void *buf, size_t count, ulong offset, ulong rwflags)
|
||||
{
|
||||
memcpy_sz((void *)(dev->map_base + offset), buf, count, rwflags & RW_SIZE_MASK);
|
||||
return count;
|
||||
}
|
||||
|
||||
struct device_d mem_dev = {
|
||||
.name = "mem",
|
||||
.id = "mem",
|
||||
.map_base = 0,
|
||||
.size = ~0, /* FIXME: should be 0x100000000, ahem... */
|
||||
.map_flags = MAP_READ | MAP_WRITE,
|
||||
};
|
||||
|
||||
struct driver_d mem_drv = {
|
||||
.name = "mem",
|
||||
.probe = mem_probe,
|
||||
.read = mem_read,
|
||||
.write = mem_write,
|
||||
};
|
||||
|
||||
struct driver_d ram_drv = {
|
||||
.name = "ram",
|
||||
.probe = mem_probe,
|
||||
.read = mem_read,
|
||||
.write = mem_write,
|
||||
};
|
||||
|
||||
int mem_init(void)
|
||||
{
|
||||
rw_buf = malloc(RW_BUF_SIZE);
|
||||
if(!rw_buf) {
|
||||
printf("Out of memory\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
register_device(&mem_dev);
|
||||
register_driver(&mem_drv);
|
||||
register_driver(&ram_drv);
|
||||
|
@ -872,25 +785,25 @@ int mem_init(void)
|
|||
}
|
||||
|
||||
U_BOOT_CMD(
|
||||
md, 3, 1, do_mem_md,
|
||||
md, 3, 0, do_mem_md,
|
||||
"md - memory display\n",
|
||||
"[.b, .w, .l] address [# of objects]\n - memory display\n"
|
||||
);
|
||||
|
||||
U_BOOT_CMD(
|
||||
mw, 4, 1, do_mem_mw,
|
||||
mw, 4, 0, do_mem_mw,
|
||||
"mw - memory write (fill)\n",
|
||||
"[.b, .w, .l] address value [count]\n - write memory\n"
|
||||
);
|
||||
|
||||
U_BOOT_CMD(
|
||||
cp, 4, 1, do_mem_cp,
|
||||
cp, 4, 0, do_mem_cp,
|
||||
"cp - memory copy\n",
|
||||
"[.b, .w, .l] source target count\n - copy memory\n"
|
||||
);
|
||||
|
||||
U_BOOT_CMD(
|
||||
cmp, 4, 1, do_mem_cmp,
|
||||
cmp, 4, 0, do_mem_cmp,
|
||||
"cmp - memory compare\n",
|
||||
"[.b, .w, .l] addr1 addr2 count\n - compare memory\n"
|
||||
);
|
||||
|
@ -898,7 +811,7 @@ U_BOOT_CMD(
|
|||
#ifndef CONFIG_CRC32_VERIFY
|
||||
|
||||
U_BOOT_CMD(
|
||||
crc32, 4, 1, do_mem_crc,
|
||||
crc32, 4, 0, do_mem_crc,
|
||||
"crc32 - checksum calculation\n",
|
||||
"address count [addr]\n - compute CRC32 checksum [save at addr]\n"
|
||||
);
|
||||
|
@ -906,7 +819,7 @@ U_BOOT_CMD(
|
|||
#else /* CONFIG_CRC32_VERIFY */
|
||||
|
||||
U_BOOT_CMD(
|
||||
crc32, 5, 1, do_mem_crc,
|
||||
crc32, 5, 0, do_mem_crc,
|
||||
"crc32 - checksum calculation\n",
|
||||
"address count [addr]\n - compute CRC32 checksum [save at addr]\n"
|
||||
"-v address count crc\n - verify crc of memory area\n"
|
||||
|
@ -916,7 +829,7 @@ U_BOOT_CMD(
|
|||
|
||||
#ifdef CONFIG_LOOPW
|
||||
U_BOOT_CMD(
|
||||
loopw, 4, 1, do_mem_loopw,
|
||||
loopw, 4, 0, do_mem_loopw,
|
||||
"loopw - infinite write loop on address range\n",
|
||||
"[.b, .w, .l] address number_of_objects data_to_write\n"
|
||||
" - loop on a set of addresses\n"
|
||||
|
@ -924,7 +837,7 @@ U_BOOT_CMD(
|
|||
#endif /* CONFIG_LOOPW */
|
||||
|
||||
U_BOOT_CMD(
|
||||
mtest, 4, 1, do_mem_mtest,
|
||||
mtest, 4, 0, do_mem_mtest,
|
||||
"mtest - simple RAM test\n",
|
||||
"[start [end [pattern]]]\n"
|
||||
" - simple RAM read/write test\n"
|
||||
|
@ -932,13 +845,13 @@ U_BOOT_CMD(
|
|||
|
||||
#ifdef CONFIG_MX_CYCLIC
|
||||
U_BOOT_CMD(
|
||||
mdc, 4, 1, do_mem_mdc,
|
||||
mdc, 4, 0, do_mem_mdc,
|
||||
"mdc - memory display cyclic\n",
|
||||
"[.b, .w, .l] address count delay(ms)\n - memory display cyclic\n"
|
||||
);
|
||||
|
||||
U_BOOT_CMD(
|
||||
mwc, 4, 1, do_mem_mwc,
|
||||
mwc, 4, 0, do_mem_mwc,
|
||||
"mwc - memory write cyclic\n",
|
||||
"[.b, .w, .l] address value delay(ms)\n - memory write cyclic\n"
|
||||
);
|
||||
|
|
|
@ -28,8 +28,6 @@
|
|||
#include <command.h>
|
||||
#include <clock.h>
|
||||
|
||||
#if (CONFIG_COMMANDS & CFG_CMD_MISC)
|
||||
|
||||
int do_sleep (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
|
||||
{
|
||||
uint64_t start;
|
||||
|
@ -65,5 +63,3 @@ U_BOOT_CMD(
|
|||
"N\n"
|
||||
" - delay execution for N seconds (N is _decimal_ !!!)\n"
|
||||
);
|
||||
|
||||
#endif /* CFG_CMD_MISC */
|
||||
|
|
|
@ -65,7 +65,7 @@ U_BOOT_CMD(
|
|||
"[loadAddress] [bootfilename]\n"
|
||||
);
|
||||
|
||||
#if (CONFIG_COMMANDS & CFG_CMD_DHCP)
|
||||
#ifdef CONFIG_NET_DHCP
|
||||
int do_dhcp (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
|
||||
{
|
||||
return netboot_common(DHCP, cmdtp, argc, argv);
|
||||
|
@ -76,9 +76,9 @@ U_BOOT_CMD(
|
|||
"dhcp\t- invoke DHCP client to obtain IP/boot params\n",
|
||||
"\n"
|
||||
);
|
||||
#endif /* CFG_CMD_DHCP */
|
||||
#endif /* CONFIG_NET_DHCP */
|
||||
|
||||
#if (CONFIG_COMMANDS & CFG_CMD_NFS)
|
||||
#ifdef CONFIG_NET_NFS
|
||||
int do_nfs (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
|
||||
{
|
||||
return netboot_common(NFS, cmdtp, argc, argv);
|
||||
|
@ -89,7 +89,7 @@ U_BOOT_CMD(
|
|||
"nfs\t- boot image via network using NFS protocol\n",
|
||||
"[loadAddress] [host ip addr:bootfilename]\n"
|
||||
);
|
||||
#endif /* CFG_CMD_NFS */
|
||||
#endif /* CONFIG_NET_NFS */
|
||||
|
||||
static void netboot_update_env (void)
|
||||
{
|
||||
|
@ -153,7 +153,7 @@ netboot_common (proto_t proto, cmd_tbl_t *cmdtp, int argc, char *argv[])
|
|||
{
|
||||
char *s;
|
||||
int rcode = 0;
|
||||
int size, i;
|
||||
int size;
|
||||
|
||||
/* pre-set load_addr */
|
||||
if ((s = getenv("loadaddr")) != NULL) {
|
||||
|
|
|
@ -557,7 +557,6 @@ U_BOOT_CMD(
|
|||
);
|
||||
#endif /* CFG_CMD_ASKENV */
|
||||
|
||||
#if (CONFIG_COMMANDS & CFG_CMD_RUN)
|
||||
int do_run (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[]);
|
||||
U_BOOT_CMD(
|
||||
run, CFG_MAXARGS, 1, do_run,
|
||||
|
@ -565,4 +564,3 @@ U_BOOT_CMD(
|
|||
"var [...]\n"
|
||||
" - run the commands in the environment variable(s) 'var'\n"
|
||||
);
|
||||
#endif /* CFG_CMD_RUN */
|
||||
|
|
|
@ -25,7 +25,6 @@
|
|||
|
||||
#include <common.h>
|
||||
#include <command.h>
|
||||
#include <flash.h>
|
||||
#include <cfi_flash.h>
|
||||
|
||||
extern flash_info_t flash_info[]; /* info for FLASH chips */
|
||||
|
|
|
@ -1370,7 +1370,6 @@ int run_command (const char *cmd, int flag)
|
|||
|
||||
/****************************************************************************/
|
||||
|
||||
#if (CONFIG_COMMANDS & CFG_CMD_RUN)
|
||||
int do_run (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
|
||||
{
|
||||
int i;
|
||||
|
@ -1398,4 +1397,3 @@ int do_run (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
|
|||
}
|
||||
return 0;
|
||||
}
|
||||
#endif /* CFG_CMD_RUN */
|
||||
|
|
115
common/mtdpart.c
115
common/mtdpart.c
|
@ -3,26 +3,17 @@
|
|||
#include <command.h>
|
||||
#include <driver.h>
|
||||
#include <malloc.h>
|
||||
#include <partition.h>
|
||||
|
||||
static int dev_add_partition(struct device_d *dev, struct partition *new_part)
|
||||
{
|
||||
struct partition *part = dev->part;
|
||||
struct partition {
|
||||
int num;
|
||||
|
||||
new_part->next = NULL;
|
||||
unsigned long offset;
|
||||
|
||||
if (!part) {
|
||||
dev->part = new_part;
|
||||
return 0;
|
||||
}
|
||||
|
||||
while (part->next)
|
||||
part = part->next;
|
||||
|
||||
part->next = new_part;
|
||||
return 0;
|
||||
}
|
||||
struct device_d *parent;
|
||||
struct device_d device;
|
||||
};
|
||||
|
||||
#if 0
|
||||
static void dev_del_partitions(struct device_d *dev)
|
||||
{
|
||||
struct partition *part = dev->part;
|
||||
|
@ -37,6 +28,7 @@ static void dev_del_partitions(struct device_d *dev)
|
|||
|
||||
dev->part = NULL;
|
||||
}
|
||||
#endif
|
||||
|
||||
int mtd_part_do_parse_one (struct partition *part, const char *str, char **endp)
|
||||
{
|
||||
|
@ -82,7 +74,7 @@ int mtd_part_do_parse_one (struct partition *part, const char *str, char **endp)
|
|||
if (endp)
|
||||
*endp = end;
|
||||
|
||||
sprintf(part->device.name, "%s.%d", part->parent->name, part->num);
|
||||
strcpy(part->device.name, "partition");
|
||||
part->device.size = size;
|
||||
|
||||
// printf("part: name=%10s size=0x%08x %s\n", part->device.name, size, ro ? "ro":"");
|
||||
|
@ -95,9 +87,9 @@ int do_addpart ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
|
|||
struct device_d *dev;
|
||||
char *endp;
|
||||
int num = 0;
|
||||
unsigned long base;
|
||||
unsigned long offset;
|
||||
|
||||
if (argc < 2) {
|
||||
if (argc != 2) {
|
||||
printf ("Usage:\n%s\n", cmdtp->usage);
|
||||
return 1;
|
||||
}
|
||||
|
@ -108,9 +100,9 @@ int do_addpart ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
|
|||
return 1;
|
||||
}
|
||||
|
||||
dev_del_partitions(dev);
|
||||
// dev_del_partitions(dev);
|
||||
|
||||
base = dev->map_base;
|
||||
offset = 0;
|
||||
|
||||
while (1) {
|
||||
part = malloc(sizeof(struct partition));
|
||||
|
@ -119,24 +111,24 @@ int do_addpart ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
|
|||
return 1;
|
||||
}
|
||||
|
||||
part->offset = offset;
|
||||
part->parent = dev;
|
||||
part->num = num++;
|
||||
part->device.map_base = base;
|
||||
part->device.map_flags = dev->map_flags;
|
||||
part->num = num;
|
||||
part->device.map_base = dev->map_base + offset;
|
||||
|
||||
if(mtd_part_do_parse_one(part, endp, &endp)) {
|
||||
dev_del_partitions(dev);
|
||||
// dev_del_partitions(dev);
|
||||
free(part);
|
||||
return 1;
|
||||
}
|
||||
|
||||
base += part->device.size;
|
||||
dev_add_partition(dev, part);
|
||||
offset += part->device.size;
|
||||
|
||||
/* FIXME: Frameork should handle this */
|
||||
part->device.driver = dev->driver;
|
||||
part->device.platform_data = part;
|
||||
|
||||
sprintf(part->device.id, "%s.%d", dev->id, num);
|
||||
register_device(&part->device);
|
||||
num++;
|
||||
|
||||
if(!*endp)
|
||||
break;
|
||||
|
@ -152,7 +144,14 @@ int do_addpart ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
|
|||
|
||||
int do_delpart ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
|
||||
{
|
||||
struct device_d *dev;
|
||||
struct device_d *dev, *p;
|
||||
int i = 0;
|
||||
char buf[MAX_DRIVER_NAME];
|
||||
|
||||
if (argc != 2) {
|
||||
printf ("Usage:\n%s\n", cmdtp->usage);
|
||||
return 1;
|
||||
}
|
||||
|
||||
dev = device_from_spec_str(argv[1], NULL);
|
||||
if (!dev) {
|
||||
|
@ -160,7 +159,16 @@ int do_delpart ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
|
|||
return 1;
|
||||
}
|
||||
|
||||
dev_del_partitions(dev);
|
||||
/* This is lame. Devices should to able to have children */
|
||||
while(1) {
|
||||
sprintf(buf, "%s.%d", dev->id, i);
|
||||
p = device_from_spec_str(buf, NULL);
|
||||
if (p)
|
||||
unregister_device(p);
|
||||
else
|
||||
break;
|
||||
i++;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
@ -173,7 +181,50 @@ U_BOOT_CMD(
|
|||
|
||||
U_BOOT_CMD(
|
||||
delpart, 2, 0, do_delpart,
|
||||
"addpart - delete a partition table from a device\n",
|
||||
"delpart - delete a partition table from a device\n",
|
||||
""
|
||||
);
|
||||
|
||||
int part_probe (struct device_d *dev)
|
||||
{
|
||||
// printf("%s: devname: %s devid: %s drvname: %s\n",__FUNCTION__, dev->name, dev->id, dev->driver->name);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int part_erase(struct device_d *dev, size_t count, unsigned long offset)
|
||||
{
|
||||
struct partition *part = dev->platform_data;
|
||||
|
||||
if (part->parent->driver->erase)
|
||||
return part->parent->driver->erase(part->parent, count, offset + part->offset);
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
ssize_t part_read(struct device_d *dev, void *buf, size_t count, unsigned long offset, ulong flags)
|
||||
{
|
||||
struct partition *part = dev->platform_data;
|
||||
|
||||
return read(part->parent, buf, count, offset + part->offset, flags);
|
||||
}
|
||||
|
||||
ssize_t part_write(struct device_d *dev, void *buf, size_t count, unsigned long offset, ulong flags)
|
||||
{
|
||||
struct partition *part = dev->platform_data;
|
||||
|
||||
return write(part->parent, buf, count, offset + part->offset, flags);
|
||||
}
|
||||
|
||||
static struct driver_d part_driver = {
|
||||
.name = "partition",
|
||||
.probe = part_probe,
|
||||
.read = part_read,
|
||||
.write = part_write,
|
||||
.erase = part_erase,
|
||||
};
|
||||
|
||||
int partition_init(void)
|
||||
{
|
||||
return register_driver(&part_driver);
|
||||
}
|
||||
|
||||
|
|
|
@ -185,9 +185,6 @@ static int flash_write_cfiword (flash_info_t * info, ulong dest, cfiword_t cword
|
|||
static int flash_full_status_check (flash_info_t * info, flash_sect_t sector,
|
||||
uint64_t tout, char *prompt);
|
||||
ulong flash_get_size (flash_info_t *info, ulong base);
|
||||
#if defined(CFG_ENV_IS_IN_FLASH) || defined(CFG_ENV_ADDR_REDUND) || (CFG_MONITOR_BASE >= CFG_FLASH_BASE)
|
||||
static flash_info_t *flash_get_info(ulong base);
|
||||
#endif
|
||||
#ifdef CFG_FLASH_USE_BUFFER_WRITE
|
||||
static int flash_write_cfibuffer (flash_info_t * info, ulong dest, uchar * cp, int len);
|
||||
#endif
|
||||
|
@ -328,9 +325,7 @@ int cfi_probe (struct device_d *dev)
|
|||
struct cfi_platform_data *pdev = (struct cfi_platform_data *)dev->platform_data;
|
||||
flash_info_t *info = &pdev->finfo;
|
||||
|
||||
dev->map_flags = MAP_READ;
|
||||
|
||||
printf("cfi_probe: %s base: 0x%08x size: 0x%08x\n", dev->name, dev->map_base, dev->size);
|
||||
// printf("cfi_probe: %s base: 0x%08x size: 0x%08x\n", dev->name, dev->map_base, dev->size);
|
||||
|
||||
/* Init: no FLASHes known */
|
||||
info->flash_id = FLASH_UNKNOWN;
|
||||
|
@ -396,43 +391,42 @@ int flash_erase_one (flash_info_t * info, long sect)
|
|||
return rcode;
|
||||
}
|
||||
|
||||
int cfi_erase(struct device_d *dev, struct memarea_info *mem)
|
||||
int cfi_erase(struct device_d *dev, size_t count, unsigned long offset)
|
||||
{
|
||||
struct cfi_platform_data *pdata = dev->platform_data;
|
||||
flash_info_t *finfo = &pdata->finfo;
|
||||
unsigned long start, end;
|
||||
int i, ret = 0;
|
||||
|
||||
printf("start: 0x%08x\n",mem->start);
|
||||
printf("end: 0x%08x\n",mem->end);
|
||||
printf("base: 0x%08x\n",mem->device->map_base);
|
||||
start = flash_find_sector(finfo, mem->start + mem->device->map_base);
|
||||
end = flash_find_sector(finfo, mem->end + mem->device->map_base);
|
||||
start = flash_find_sector(finfo, dev->map_base + offset);
|
||||
end = flash_find_sector(finfo, dev->map_base + offset + count - 1);
|
||||
|
||||
printf("would erase sectors %d to %d\n",start, end);
|
||||
return 0;
|
||||
for (i = start; i <= end; i++) {
|
||||
ret = flash_erase_one (finfo, i);
|
||||
if (ret)
|
||||
goto out;
|
||||
}
|
||||
out:
|
||||
putc('\n');
|
||||
return ret;
|
||||
}
|
||||
|
||||
static ssize_t cfi_write(struct device_d* dev, void* buf, size_t count, unsigned long offset) {
|
||||
printf("cfi_write: buf=0x%08x count=0x%08x offset=0x%08x\n",buf, count, offset);
|
||||
return count;
|
||||
}
|
||||
|
||||
static struct driver_d cfi_driver = {
|
||||
.name = "nor",
|
||||
.probe = cfi_probe,
|
||||
.write = cfi_write,
|
||||
.erase = cfi_erase,
|
||||
};
|
||||
|
||||
int flash_init(void)
|
||||
static ssize_t cfi_write(struct device_d* dev, void* buf, size_t count, unsigned long offset, ulong flags)
|
||||
{
|
||||
return register_driver(&cfi_driver);
|
||||
struct cfi_platform_data *pdata = dev->platform_data;
|
||||
flash_info_t *finfo = &pdata->finfo;
|
||||
int ret;
|
||||
|
||||
// printf("cfi_write: buf=0x%08x addr=0x%08x count=0x%08x\n",buf, dev->map_base + offset, count);
|
||||
|
||||
ret = write_buff (finfo, buf, dev->map_base + offset, count);
|
||||
return ret == 0 ? count : -1;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------------------
|
||||
*/
|
||||
void flash_print_info (flash_info_t * info)
|
||||
void cfi_info (struct device_d* dev)
|
||||
{
|
||||
struct cfi_platform_data *pdata = dev->platform_data;
|
||||
flash_info_t *info = &pdata->finfo;
|
||||
int i;
|
||||
|
||||
if (info->flash_id != FLASH_MAN_CFI) {
|
||||
|
@ -518,6 +512,20 @@ void flash_print_info (flash_info_t * info)
|
|||
return;
|
||||
}
|
||||
|
||||
static struct driver_d cfi_driver = {
|
||||
.name = "cfi_flash",
|
||||
.probe = cfi_probe,
|
||||
.read = mem_read,
|
||||
.write = cfi_write,
|
||||
.erase = cfi_erase,
|
||||
.info = cfi_info,
|
||||
};
|
||||
|
||||
int flash_init(void)
|
||||
{
|
||||
return register_driver(&cfi_driver);
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------------------
|
||||
* Copy memory to flash, returns:
|
||||
* 0 - OK
|
||||
|
@ -719,6 +727,8 @@ static int flash_status_check (flash_info_t * info, flash_sect_t sector,
|
|||
{
|
||||
uint64_t start;
|
||||
|
||||
tout *= 1000000;
|
||||
|
||||
/* Wait for command completion */
|
||||
start = get_time_ns();
|
||||
while (flash_is_busy (info, sector)) {
|
||||
|
|
|
@ -7,10 +7,8 @@
|
|||
*/
|
||||
|
||||
# ifndef __ASSEMBLY__
|
||||
# define __REG(x) (*((volatile u32 *)(x)))
|
||||
# define __REG2(x,y) \
|
||||
( __builtin_constant_p(y) ? (__REG((x) + (y))) \
|
||||
: (*(volatile u32 *)((u32)&__REG(x) + (y))) )
|
||||
# define __REG(x) (*((volatile u32 *)(x)))
|
||||
# define __REG2(x,y) (*(volatile u32 *)((u32)&__REG(x) + (y)))
|
||||
# else
|
||||
# define __REG(x) (x)
|
||||
# define __REG2(x,y) ((x)+(y))
|
||||
|
@ -430,123 +428,6 @@
|
|||
#define LCDISR_ERR_RES (1<<2)
|
||||
#define LCDISR_EOF (1<<1)
|
||||
#define LCDISR_BOF (1<<0)
|
||||
/*
|
||||
* UART Module
|
||||
*/
|
||||
#define URXD0(x) __REG2( IMX_UART1_BASE + 0x0, ((x) & 1) << 12) /* Receiver Register */
|
||||
#define URTX0(x) __REG2( IMX_UART1_BASE + 0x40, ((x) & 1) << 12) /* Transmitter Register */
|
||||
#define UCR1(x) __REG2( IMX_UART1_BASE + 0x80, ((x) & 1) << 12) /* Control Register 1 */
|
||||
#define UCR2(x) __REG2( IMX_UART1_BASE + 0x84, ((x) & 1) << 12) /* Control Register 2 */
|
||||
#define UCR3(x) __REG2( IMX_UART1_BASE + 0x88, ((x) & 1) << 12) /* Control Register 3 */
|
||||
#define UCR4(x) __REG2( IMX_UART1_BASE + 0x8c, ((x) & 1) << 12) /* Control Register 4 */
|
||||
#define UFCR(x) __REG2( IMX_UART1_BASE + 0x90, ((x) & 1) << 12) /* FIFO Control Register */
|
||||
#define USR1(x) __REG2( IMX_UART1_BASE + 0x94, ((x) & 1) << 12) /* Status Register 1 */
|
||||
#define USR2(x) __REG2( IMX_UART1_BASE + 0x98, ((x) & 1) << 12) /* Status Register 2 */
|
||||
#define UESC(x) __REG2( IMX_UART1_BASE + 0x9c, ((x) & 1) << 12) /* Escape Character Register */
|
||||
#define UTIM(x) __REG2( IMX_UART1_BASE + 0xa0, ((x) & 1) << 12) /* Escape Timer Register */
|
||||
#define UBIR(x) __REG2( IMX_UART1_BASE + 0xa4, ((x) & 1) << 12) /* BRM Incremental Register */
|
||||
#define UBMR(x) __REG2( IMX_UART1_BASE + 0xa8, ((x) & 1) << 12) /* BRM Modulator Register */
|
||||
#define UBRC(x) __REG2( IMX_UART1_BASE + 0xac, ((x) & 1) << 12) /* Baud Rate Count Register */
|
||||
#define BIPR1(x) __REG2( IMX_UART1_BASE + 0xb0, ((x) & 1) << 12) /* Incremental Preset Register 1 */
|
||||
#define BIPR2(x) __REG2( IMX_UART1_BASE + 0xb4, ((x) & 1) << 12) /* Incremental Preset Register 2 */
|
||||
#define BIPR3(x) __REG2( IMX_UART1_BASE + 0xb8, ((x) & 1) << 12) /* Incremental Preset Register 3 */
|
||||
#define BIPR4(x) __REG2( IMX_UART1_BASE + 0xbc, ((x) & 1) << 12) /* Incremental Preset Register 4 */
|
||||
#define BMPR1(x) __REG2( IMX_UART1_BASE + 0xc0, ((x) & 1) << 12) /* BRM Modulator Register 1 */
|
||||
#define BMPR2(x) __REG2( IMX_UART1_BASE + 0xc4, ((x) & 1) << 12) /* BRM Modulator Register 2 */
|
||||
#define BMPR3(x) __REG2( IMX_UART1_BASE + 0xc8, ((x) & 1) << 12) /* BRM Modulator Register 3 */
|
||||
#define BMPR4(x) __REG2( IMX_UART1_BASE + 0xcc, ((x) & 1) << 12) /* BRM Modulator Register 4 */
|
||||
#define UTS(x) __REG2( IMX_UART1_BASE + 0xd0, ((x) & 1) << 12) /* UART Test Register */
|
||||
|
||||
/* UART Control Register Bit Fields.*/
|
||||
#define URXD_CHARRDY (1<<15)
|
||||
#define URXD_ERR (1<<14)
|
||||
#define URXD_OVRRUN (1<<13)
|
||||
#define URXD_FRMERR (1<<12)
|
||||
#define URXD_BRK (1<<11)
|
||||
#define URXD_PRERR (1<<10)
|
||||
#define UCR1_ADEN (1<<15) /* Auto dectect interrupt */
|
||||
#define UCR1_ADBR (1<<14) /* Auto detect baud rate */
|
||||
#define UCR1_TRDYEN (1<<13) /* Transmitter ready interrupt enable */
|
||||
#define UCR1_IDEN (1<<12) /* Idle condition interrupt */
|
||||
#define UCR1_RRDYEN (1<<9) /* Recv ready interrupt enable */
|
||||
#define UCR1_RDMAEN (1<<8) /* Recv ready DMA enable */
|
||||
#define UCR1_IREN (1<<7) /* Infrared interface enable */
|
||||
#define UCR1_TXMPTYEN (1<<6) /* Transimitter empty interrupt enable */
|
||||
#define UCR1_RTSDEN (1<<5) /* RTS delta interrupt enable */
|
||||
#define UCR1_SNDBRK (1<<4) /* Send break */
|
||||
#define UCR1_TDMAEN (1<<3) /* Transmitter ready DMA enable */
|
||||
#define UCR1_UARTCLKEN (1<<2) /* UART clock enabled */
|
||||
#define UCR1_DOZE (1<<1) /* Doze */
|
||||
#define UCR1_UARTEN (1<<0) /* UART enabled */
|
||||
#define UCR2_ESCI (1<<15) /* Escape seq interrupt enable */
|
||||
#define UCR2_IRTS (1<<14) /* Ignore RTS pin */
|
||||
#define UCR2_CTSC (1<<13) /* CTS pin control */
|
||||
#define UCR2_CTS (1<<12) /* Clear to send */
|
||||
#define UCR2_ESCEN (1<<11) /* Escape enable */
|
||||
#define UCR2_PREN (1<<8) /* Parity enable */
|
||||
#define UCR2_PROE (1<<7) /* Parity odd/even */
|
||||
#define UCR2_STPB (1<<6) /* Stop */
|
||||
#define UCR2_WS (1<<5) /* Word size */
|
||||
#define UCR2_RTSEN (1<<4) /* Request to send interrupt enable */
|
||||
#define UCR2_TXEN (1<<2) /* Transmitter enabled */
|
||||
#define UCR2_RXEN (1<<1) /* Receiver enabled */
|
||||
#define UCR2_SRST (1<<0) /* SW reset */
|
||||
#define UCR3_DTREN (1<<13) /* DTR interrupt enable */
|
||||
#define UCR3_PARERREN (1<<12) /* Parity enable */
|
||||
#define UCR3_FRAERREN (1<<11) /* Frame error interrupt enable */
|
||||
#define UCR3_DSR (1<<10) /* Data set ready */
|
||||
#define UCR3_DCD (1<<9) /* Data carrier detect */
|
||||
#define UCR3_RI (1<<8) /* Ring indicator */
|
||||
#define UCR3_TIMEOUTEN (1<<7) /* Timeout interrupt enable */
|
||||
#define UCR3_RXDSEN (1<<6) /* Receive status interrupt enable */
|
||||
#define UCR3_AIRINTEN (1<<5) /* Async IR wake interrupt enable */
|
||||
#define UCR3_AWAKEN (1<<4) /* Async wake interrupt enable */
|
||||
#define UCR3_REF25 (1<<3) /* Ref freq 25 MHz */
|
||||
#define UCR3_REF30 (1<<2) /* Ref Freq 30 MHz */
|
||||
#define UCR3_INVT (1<<1) /* Inverted Infrared transmission */
|
||||
#define UCR3_BPEN (1<<0) /* Preset registers enable */
|
||||
#define UCR4_CTSTL_32 (32<<10) /* CTS trigger level (32 chars) */
|
||||
#define UCR4_INVR (1<<9) /* Inverted infrared reception */
|
||||
#define UCR4_ENIRI (1<<8) /* Serial infrared interrupt enable */
|
||||
#define UCR4_WKEN (1<<7) /* Wake interrupt enable */
|
||||
#define UCR4_REF16 (1<<6) /* Ref freq 16 MHz */
|
||||
#define UCR4_IRSC (1<<5) /* IR special case */
|
||||
#define UCR4_TCEN (1<<3) /* Transmit complete interrupt enable */
|
||||
#define UCR4_BKEN (1<<2) /* Break condition interrupt enable */
|
||||
#define UCR4_OREN (1<<1) /* Receiver overrun interrupt enable */
|
||||
#define UCR4_DREN (1<<0) /* Recv data ready interrupt enable */
|
||||
#define UFCR_RXTL_SHF 0 /* Receiver trigger level shift */
|
||||
#define UFCR_RFDIV (7<<7) /* Reference freq divider mask */
|
||||
#define UFCR_TXTL_SHF 10 /* Transmitter trigger level shift */
|
||||
#define USR1_PARITYERR (1<<15) /* Parity error interrupt flag */
|
||||
#define USR1_RTSS (1<<14) /* RTS pin status */
|
||||
#define USR1_TRDY (1<<13) /* Transmitter ready interrupt/dma flag */
|
||||
#define USR1_RTSD (1<<12) /* RTS delta */
|
||||
#define USR1_ESCF (1<<11) /* Escape seq interrupt flag */
|
||||
#define USR1_FRAMERR (1<<10) /* Frame error interrupt flag */
|
||||
#define USR1_RRDY (1<<9) /* Receiver ready interrupt/dma flag */
|
||||
#define USR1_TIMEOUT (1<<7) /* Receive timeout interrupt status */
|
||||
#define USR1_RXDS (1<<6) /* Receiver idle interrupt flag */
|
||||
#define USR1_AIRINT (1<<5) /* Async IR wake interrupt flag */
|
||||
#define USR1_AWAKE (1<<4) /* Aysnc wake interrupt flag */
|
||||
#define USR2_ADET (1<<15) /* Auto baud rate detect complete */
|
||||
#define USR2_TXFE (1<<14) /* Transmit buffer FIFO empty */
|
||||
#define USR2_DTRF (1<<13) /* DTR edge interrupt flag */
|
||||
#define USR2_IDLE (1<<12) /* Idle condition */
|
||||
#define USR2_IRINT (1<<8) /* Serial infrared interrupt flag */
|
||||
#define USR2_WAKE (1<<7) /* Wake */
|
||||
#define USR2_RTSF (1<<4) /* RTS edge interrupt flag */
|
||||
#define USR2_TXDC (1<<3) /* Transmitter complete */
|
||||
#define USR2_BRCD (1<<2) /* Break condition */
|
||||
#define USR2_ORE (1<<1) /* Overrun error */
|
||||
#define USR2_RDR (1<<0) /* Recv data ready */
|
||||
#define UTS_FRCPERR (1<<13) /* Force parity error */
|
||||
#define UTS_LOOP (1<<12) /* Loop tx and rx */
|
||||
#define UTS_TXEMPTY (1<<6) /* TxFIFO empty */
|
||||
#define UTS_RXEMPTY (1<<5) /* RxFIFO empty */
|
||||
#define UTS_TXFULL (1<<4) /* TxFIFO full */
|
||||
#define UTS_RXFULL (1<<3) /* RxFIFO full */
|
||||
#define UTS_SOFTRST (1<<0) /* Software reset */
|
||||
|
||||
/* General purpose timers registers */
|
||||
#define TCTL1 __REG(IMX_TIM1_BASE)
|
||||
|
|
|
@ -102,7 +102,6 @@ typedef volatile unsigned char vu_char;
|
|||
#endif
|
||||
|
||||
#include <part.h>
|
||||
#include <flash.h>
|
||||
#include <image.h>
|
||||
|
||||
#ifdef DEBUG
|
||||
|
|
|
@ -10,6 +10,7 @@ struct memarea_info;
|
|||
|
||||
struct device_d {
|
||||
char name[MAX_DRIVER_NAME];
|
||||
char id[MAX_DRIVER_NAME];
|
||||
|
||||
unsigned long size;
|
||||
|
||||
|
@ -17,36 +18,46 @@ struct device_d {
|
|||
* SDRAM.
|
||||
*/
|
||||
unsigned long map_base;
|
||||
unsigned long map_flags;
|
||||
|
||||
void *platform_data;
|
||||
void *priv;
|
||||
|
||||
/* The driver for this device */
|
||||
struct driver_d *driver;
|
||||
|
||||
struct device_d *next;
|
||||
|
||||
struct partition *part;
|
||||
};
|
||||
|
||||
struct driver_d {
|
||||
char name[MAX_DRIVER_NAME];
|
||||
|
||||
void *priv;
|
||||
|
||||
struct driver_d *next;
|
||||
|
||||
int (*probe) (struct device_d *);
|
||||
ssize_t (*read) (struct device_d*, void* buf, size_t count, unsigned long offset);
|
||||
ssize_t (*write) (struct device_d*, void* buf, size_t count, unsigned long offset);
|
||||
ssize_t (*erase) (struct device_d*, struct memarea_info *);
|
||||
ssize_t (*read) (struct device_d*, void* buf, size_t count, ulong offset, ulong flags);
|
||||
ssize_t (*write) (struct device_d*, void* buf, size_t count, ulong offset, ulong flags);
|
||||
ssize_t (*erase) (struct device_d*, size_t count, unsigned long offset);
|
||||
|
||||
void (*info) (struct device_d *);
|
||||
void (*shortinfo) (struct device_d *);
|
||||
};
|
||||
|
||||
#define RW_SIZE(x) (x)
|
||||
#define RW_SIZE_MASK 0x7
|
||||
|
||||
int register_driver(struct driver_d *);
|
||||
int register_device(struct device_d *);
|
||||
void unregister_device(struct device_d *);
|
||||
|
||||
struct device_d *device_from_spec_str(const char *str, char **endp);
|
||||
struct device_d *get_device_by_name(char *name);
|
||||
|
||||
ssize_t read(struct device_d *dev, void *buf, size_t count, ulong offset, ulong flags);
|
||||
ssize_t write(struct device_d *dev, void *buf, size_t count, ulong offset, ulong flags);
|
||||
ssize_t erase(struct device_d *dev, size_t count, unsigned long offset);
|
||||
|
||||
ssize_t mem_read(struct device_d *dev, void *buf, size_t count, ulong offset, ulong flags);
|
||||
ssize_t mem_write(struct device_d *dev, void *buf, size_t count, ulong offset, ulong flags);
|
||||
|
||||
#endif /* DRIVER_H */
|
||||
|
||||
|
|
|
@ -462,6 +462,7 @@ extern void copy_filename (char *dst, char *src, int size);
|
|||
extern void eth_set_current(struct eth_device *eth);
|
||||
extern struct eth_device *eth_get_current(void);
|
||||
|
||||
extern struct eth_device dm9000_eth;
|
||||
extern struct eth_device at91rm9200_eth;
|
||||
extern struct eth_device smc91111_eth;
|
||||
|
||||
|
|
|
@ -3,15 +3,5 @@
|
|||
|
||||
struct device_d;
|
||||
|
||||
struct partition {
|
||||
int num;
|
||||
|
||||
struct device_d *parent;
|
||||
|
||||
struct device_d device;
|
||||
|
||||
struct partition *next;
|
||||
};
|
||||
|
||||
#endif /* __PARTITION_H */
|
||||
|
||||
|
|
|
@ -29,58 +29,62 @@ int cmd_get_data_size(char* arg, int default_size)
|
|||
static struct device_d *first_device = NULL;
|
||||
static struct driver_d *first_driver = NULL;
|
||||
|
||||
struct device_d *get_device_by_id(char *id)
|
||||
{
|
||||
struct device_d *d;
|
||||
|
||||
d = first_device;
|
||||
|
||||
while(d) {
|
||||
if(!strcmp(id, d->id))
|
||||
break;
|
||||
d = d->next;
|
||||
}
|
||||
|
||||
return d;
|
||||
}
|
||||
|
||||
int do_devinfo ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
|
||||
{
|
||||
struct device_d *dev = first_device;
|
||||
struct driver_d *drv = first_driver;
|
||||
|
||||
printf("devices:\n");
|
||||
if (argc == 1) {
|
||||
printf("devices:\n");
|
||||
|
||||
while(dev) {
|
||||
printf("%10s: base=0x%08x size=0x%08x\n",dev->name, dev->map_base, dev->size);
|
||||
dev = dev->next;
|
||||
while(dev) {
|
||||
printf("%10s: base=0x%08x size=0x%08x (driver %s)\n",dev->id, dev->map_base, dev->size, dev->name);
|
||||
dev = dev->next;
|
||||
}
|
||||
|
||||
printf("drivers:\n");
|
||||
while(drv) {
|
||||
printf("%10s\n",drv->name);
|
||||
drv = drv->next;
|
||||
}
|
||||
} else {
|
||||
struct device_d *dev = get_device_by_id(argv[1]);
|
||||
|
||||
if (!dev) {
|
||||
printf("no such device: %s\n",argv[1]);
|
||||
return -1;
|
||||
}
|
||||
dev->driver->info(dev);
|
||||
}
|
||||
|
||||
printf("drivers:\n");
|
||||
while(drv) {
|
||||
printf("%10s\n",drv->name);
|
||||
drv = drv->next;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
U_BOOT_CMD(
|
||||
devinfo, 1, 0, do_devinfo,
|
||||
devinfo, 2, 0, do_devinfo,
|
||||
"devinfo - display info about devices and drivers\n",
|
||||
""
|
||||
);
|
||||
|
||||
static struct device_d *match_driver(struct driver_d *d, struct device_d *first_dev)
|
||||
static int match(struct driver_d *drv, struct device_d *dev)
|
||||
{
|
||||
struct device_d *device;
|
||||
|
||||
if (first_dev)
|
||||
device = first_dev->next;
|
||||
else
|
||||
device = first_device;
|
||||
|
||||
while (device) {
|
||||
if (!strcmp(device->name, d->name))
|
||||
return device;
|
||||
device = device->next;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct driver_d *match_device(struct device_d *d)
|
||||
{
|
||||
struct driver_d *driver = first_driver;
|
||||
|
||||
while (driver) {
|
||||
if (!strcmp(driver->name, d->name))
|
||||
return driver;
|
||||
driver = driver->next;
|
||||
}
|
||||
if (strcmp(dev->name, drv->name))
|
||||
return -1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
@ -91,7 +95,7 @@ int register_device(struct device_d *new_device)
|
|||
|
||||
dev = first_device;
|
||||
|
||||
printf("register_device: %s\n",new_device->name);
|
||||
// printf("register_device: %s\n",new_device->name);
|
||||
|
||||
if(!dev) {
|
||||
first_device = new_device;
|
||||
|
@ -103,12 +107,14 @@ int register_device(struct device_d *new_device)
|
|||
dev->next = new_device;
|
||||
new_device->next = 0;
|
||||
|
||||
drv = match_device(new_device);
|
||||
if (drv) {
|
||||
if (!drv->probe(new_device)) {
|
||||
printf("setting driver to 0x%08x\n",drv);
|
||||
drv = first_driver;
|
||||
|
||||
while(drv) {
|
||||
if (!match(drv, new_device) && !drv->probe(new_device)) {
|
||||
new_device->driver = drv;
|
||||
break;
|
||||
}
|
||||
drv = drv->next;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
@ -117,7 +123,7 @@ int register_device(struct device_d *new_device)
|
|||
void unregister_device(struct device_d *old_dev)
|
||||
{
|
||||
struct device_d *dev;
|
||||
printf("unregister_device: %s\n",old_dev->name);
|
||||
// printf("unregister_device: %s\n",old_dev->name);
|
||||
|
||||
dev = first_device;
|
||||
|
||||
|
@ -145,19 +151,13 @@ struct driver_d *get_driver_by_name(char *name)
|
|||
return d;
|
||||
}
|
||||
|
||||
struct device_d *get_device_by_name(char *name)
|
||||
static void noinfo(struct device_d *dev)
|
||||
{
|
||||
struct device_d *d;
|
||||
printf("no info available for %s\n", dev->id);
|
||||
}
|
||||
|
||||
d = first_device;
|
||||
|
||||
while(d) {
|
||||
if(!strcmp(name, d->name))
|
||||
break;
|
||||
d = d->next;
|
||||
}
|
||||
|
||||
return d;
|
||||
static void noshortinfo(struct device_d *dev)
|
||||
{
|
||||
}
|
||||
|
||||
int register_driver(struct driver_d *new_driver)
|
||||
|
@ -167,7 +167,7 @@ int register_driver(struct driver_d *new_driver)
|
|||
|
||||
drv = first_driver;
|
||||
|
||||
printf("register_driver: %s\n",new_driver->name);
|
||||
// printf("register_driver: %s\n",new_driver->name);
|
||||
|
||||
if(!drv) {
|
||||
first_driver = new_driver;
|
||||
|
@ -179,9 +179,16 @@ int register_driver(struct driver_d *new_driver)
|
|||
drv->next = new_driver;
|
||||
new_driver->next = 0;
|
||||
|
||||
while((dev = match_driver(new_driver, dev))) {
|
||||
if(!new_driver->probe(dev))
|
||||
if (!new_driver->info)
|
||||
new_driver->info = noinfo;
|
||||
if (!new_driver->shortinfo)
|
||||
new_driver->shortinfo = noshortinfo;
|
||||
|
||||
dev = first_device;
|
||||
while (dev) {
|
||||
if (!match(new_driver, dev) && !new_driver->probe(dev))
|
||||
dev->driver = new_driver;
|
||||
dev = dev->next;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
@ -189,7 +196,7 @@ int register_driver(struct driver_d *new_driver)
|
|||
|
||||
static char devicename_from_spec_str_buf[MAX_DRIVER_NAME];
|
||||
|
||||
char *devicename_from_spec_str(const char *str, char **endp)
|
||||
char *deviceid_from_spec_str(const char *str, char **endp)
|
||||
{
|
||||
char *buf = devicename_from_spec_str_buf;
|
||||
const char *end;
|
||||
|
@ -230,8 +237,8 @@ char *devicename_from_spec_str(const char *str, char **endp)
|
|||
struct device_d *device_from_spec_str(const char *str, char **endp)
|
||||
{
|
||||
char *name;
|
||||
name = devicename_from_spec_str(str, endp);
|
||||
return get_device_by_name(name);
|
||||
name = deviceid_from_spec_str(str, endp);
|
||||
return get_device_by_id(name);
|
||||
}
|
||||
|
||||
unsigned long strtoul_suffix(const char *str, char **endp, int base)
|
||||
|
@ -260,7 +267,6 @@ unsigned long strtoul_suffix(const char *str, char **endp, int base)
|
|||
|
||||
/*
|
||||
* Parse a string representing a memory area and fill in a struct memarea_info.
|
||||
* FIXME: Check for end of devices
|
||||
*/
|
||||
int spec_str_to_info(const char *str, struct memarea_info *info)
|
||||
{
|
||||
|
@ -270,7 +276,7 @@ int spec_str_to_info(const char *str, struct memarea_info *info)
|
|||
|
||||
info->device = device_from_spec_str(str, &endp);
|
||||
if (!info->device) {
|
||||
printf("unknown device: %s\n", devicename_from_spec_str(str, NULL));
|
||||
printf("unknown device: %s\n", deviceid_from_spec_str(str, NULL));
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
@ -341,7 +347,7 @@ out:
|
|||
info->end = info->device->size - 1;
|
||||
info->size = info->end - info->start + 1;
|
||||
}
|
||||
#if 1
|
||||
#if 0
|
||||
printf("start: 0x%08x\n",info->start);
|
||||
printf("size: 0x%08x\n",info->size);
|
||||
printf("end: 0x%08x\n",info->end);
|
||||
|
@ -349,3 +355,20 @@ out:
|
|||
return 0;
|
||||
}
|
||||
|
||||
ssize_t read(struct device_d *dev, void *buf, size_t count, unsigned long offset, ulong flags)
|
||||
{
|
||||
return dev->driver->read(dev, buf, count, offset, flags);
|
||||
}
|
||||
|
||||
ssize_t write(struct device_d *dev, void *buf, size_t count, unsigned long offset, ulong flags)
|
||||
{
|
||||
return dev->driver->write(dev, buf, count, offset, flags);
|
||||
}
|
||||
|
||||
ssize_t erase(struct device_d *dev, size_t count, unsigned long offset)
|
||||
{
|
||||
if (dev->driver->erase)
|
||||
return dev->driver->erase(dev, count, offset);
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
|
|
@ -128,7 +128,7 @@ static int truncate_sz (const char *name, int maxlen, int curlen)
|
|||
return (curlen);
|
||||
}
|
||||
|
||||
#if !(CONFIG_COMMANDS & CFG_CMD_DHCP)
|
||||
#ifndef CONFIG_NET_DHCP
|
||||
|
||||
static void BootpVendorFieldProcess (u8 * ext)
|
||||
{
|
||||
|
@ -285,6 +285,7 @@ static void BootpVendorProcess (u8 * ext, int size)
|
|||
/*
|
||||
* Handle a BOOTP received packet.
|
||||
*/
|
||||
|
||||
static void
|
||||
BootpHandler(uchar * pkt, unsigned dest, unsigned src, unsigned len)
|
||||
{
|
||||
|
@ -821,8 +822,6 @@ DhcpHandler(uchar * pkt, unsigned dest, unsigned src, unsigned len)
|
|||
debug ("DHCP State: REQUESTING\n");
|
||||
|
||||
if ( DhcpMessageType((u8 *)bp->bp_vend) == DHCP_ACK ) {
|
||||
char *s;
|
||||
|
||||
if (NetReadLong((ulong*)&bp->bp_vend[0]) == htonl(BOOTP_VENDOR_MAGIC))
|
||||
DhcpOptionsProcess((u8 *)&bp->bp_vend[4], bp);
|
||||
BootpCopyNetParams(bp); /* Store net params from reply */
|
||||
|
|
80
net/net.c
80
net/net.c
|
@ -134,11 +134,6 @@ uchar NetCDPAddr[6] = /* Ethernet bcast address */
|
|||
{ 0x01, 0x00, 0x0c, 0xcc, 0xcc, 0xcc };
|
||||
#endif
|
||||
int NetState; /* Network loop state */
|
||||
#ifdef CONFIG_NET_MULTI
|
||||
int NetRestartWrap = 0; /* Tried all network devices */
|
||||
static int NetRestarted = 0; /* Network loop restarted */
|
||||
static int NetDevExists = 0; /* At least one device configured */
|
||||
#endif
|
||||
|
||||
/* XXX in both little & big endian machines 0xFFFF == ntohs(-1) */
|
||||
ushort NetOurVLAN = 0xFFFF; /* default is without VLAN */
|
||||
|
@ -266,11 +261,6 @@ NetLoop(proto_t protocol)
|
|||
ip = getenv_IPaddr ("ipaddr");
|
||||
NetCopyIP(&NetOurIP, &ip);
|
||||
|
||||
#ifdef CONFIG_NET_MULTI
|
||||
NetRestarted = 0;
|
||||
NetDevExists = 0;
|
||||
#endif
|
||||
|
||||
/* XXX problem with bss workaround */
|
||||
NetArpWaitPacketMAC = NULL;
|
||||
NetArpWaitTxPacket = NULL;
|
||||
|
@ -297,21 +287,11 @@ NetLoop(proto_t protocol)
|
|||
NetArpWaitTxPacketSize = 0;
|
||||
}
|
||||
|
||||
eth_halt();
|
||||
#ifdef CONFIG_NET_MULTI
|
||||
eth_set_current();
|
||||
#endif
|
||||
if (eth_init(bd) < 0) {
|
||||
eth_halt();
|
||||
return(-1);
|
||||
}
|
||||
if (eth_init(bd) < 0)
|
||||
return -1;
|
||||
|
||||
restart:
|
||||
#ifdef CONFIG_NET_MULTI
|
||||
memcpy (NetOurEther, eth_get_dev()->enetaddr, 6);
|
||||
#else
|
||||
memcpy (NetOurEther, &(eth_get_current()->enetaddr), 6);
|
||||
#endif
|
||||
|
||||
NetState = NETLOOP_CONTINUE;
|
||||
|
||||
|
@ -383,18 +363,8 @@ restart:
|
|||
case 1:
|
||||
/* network not configured */
|
||||
eth_halt();
|
||||
return (-1);
|
||||
|
||||
#ifdef CONFIG_NET_MULTI
|
||||
case 2:
|
||||
/* network device not configured */
|
||||
break;
|
||||
#endif /* CONFIG_NET_MULTI */
|
||||
|
||||
return -1;
|
||||
case 0:
|
||||
#ifdef CONFIG_NET_MULTI
|
||||
NetDevExists = 1;
|
||||
#endif
|
||||
switch (protocol) {
|
||||
#ifdef CONFIG_NET_TFTP
|
||||
case TFTP:
|
||||
|
@ -527,9 +497,6 @@ restart:
|
|||
switch (NetState) {
|
||||
|
||||
case NETLOOP_RESTART:
|
||||
#ifdef CONFIG_NET_MULTI
|
||||
NetRestarted = 1;
|
||||
#endif
|
||||
goto restart;
|
||||
|
||||
case NETLOOP_SUCCESS:
|
||||
|
@ -581,25 +548,8 @@ void NetStartAgain (void)
|
|||
NetState = NETLOOP_FAIL;
|
||||
return;
|
||||
}
|
||||
#ifndef CONFIG_NET_MULTI
|
||||
NetSetTimeout (10 * SECOND, startAgainTimeout);
|
||||
NetSetHandler (startAgainHandler);
|
||||
#else /* !CONFIG_NET_MULTI*/
|
||||
eth_halt ();
|
||||
eth_try_another (!NetRestarted);
|
||||
eth_init (gd->bd);
|
||||
if (NetRestartWrap) {
|
||||
NetRestartWrap = 0;
|
||||
if (NetDevExists && !once) {
|
||||
NetSetTimeout (10 * SECOND, startAgainTimeout);
|
||||
NetSetHandler (startAgainHandler);
|
||||
} else {
|
||||
NetState = NETLOOP_FAIL;
|
||||
}
|
||||
} else {
|
||||
NetState = NETLOOP_RESTART;
|
||||
}
|
||||
#endif /* CONFIG_NET_MULTI */
|
||||
}
|
||||
|
||||
/**********************************************************************/
|
||||
|
@ -1021,9 +971,6 @@ CDPHandler(const uchar * pkt, unsigned len)
|
|||
|
||||
static void CDPStart(void)
|
||||
{
|
||||
#if defined(CONFIG_NET_MULTI)
|
||||
printf ("Using %s device\n", eth_get_name());
|
||||
#endif
|
||||
CDPSeq = 0;
|
||||
CDPOK = 0;
|
||||
|
||||
|
@ -1441,29 +1388,8 @@ static int net_check_prereq (proto_t protocol)
|
|||
case BOOTP:
|
||||
case CDP:
|
||||
if (memcmp (NetOurEther, "\0\0\0\0\0\0", 6) == 0) {
|
||||
#ifdef CONFIG_NET_MULTI
|
||||
extern int eth_get_dev_index (void);
|
||||
int num = eth_get_dev_index ();
|
||||
|
||||
switch (num) {
|
||||
case -1:
|
||||
puts ("*** ERROR: No ethernet found.\n");
|
||||
return (1);
|
||||
case 0:
|
||||
puts ("*** ERROR: `ethaddr' not set\n");
|
||||
break;
|
||||
default:
|
||||
printf ("*** ERROR: `eth%daddr' not set\n",
|
||||
num);
|
||||
break;
|
||||
}
|
||||
|
||||
NetStartAgain ();
|
||||
return (2);
|
||||
#else
|
||||
puts ("*** ERROR: `ethaddr' not set\n");
|
||||
return (1);
|
||||
#endif
|
||||
}
|
||||
/* Fall through */
|
||||
default:
|
||||
|
|
Loading…
Reference in New Issue