sysmo-bts
/
barebox
9
0
Fork 0
Code Releases Activity

svn_rev_118 

thousands of things
This commit is contained in:
Sascha Hauer 2007-07-05 18:01:24 +02:00 committed by Sascha Hauer
parent 873c1d746e
commit 658cc34395
22 changed files with 415 additions and 676 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
arch/arm/Kconfig
View File

@ -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

3
arch/arm/Makefile
View File

@ -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

78
arch/arm/lib/board.c
View File

@ -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 ();
}

2
common/Makefile
View File

@ -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

6
common/cmd_bootm.c
View File

@ -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[])
{

17
common/cmd_flash.c
View File

@ -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
View File

@ -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"
);

4
common/cmd_misc.c
View File

@ -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 */

10
common/cmd_net.c
View File

@ -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) {

2
common/cmd_nvedit.c
View File

@ -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 */

1
common/flash.c
View File

@ -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 */

2
common/main.c
View File

@ -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
View File

@ -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);
}

72
drivers/cfi_flash.c
View File

@ -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)) {

123
include/asm-arm/arch-imx/imx-regs.h
View File

@ -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)

1
include/common.h
View File

@ -102,7 +102,6 @@ typedef volatile unsigned char vu_char;
#endif
#include <part.h>
#include <flash.h>
#include <image.h>
#ifdef DEBUG

27
include/driver.h
View File

@ -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 */

1
include/net.h
View File

@ -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;

10
include/partition.h
View File

@ -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 */

145
lib_generic/misc.c
View File

@ -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;
}

5
net/bootp.c
View File

@ -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
View File

@ -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: