#ifndef _PCI_I386_H_
#define _PCI_I386_H_ 1
+#define DEFINE_PCI_DEVICE_TABLE(_table) \
+ const struct pci_device_id _table[]
+
void pci_setup_type1(struct pci_controller* hose, u32 cfg_addr, u32 cfg_data);
int pci_enable_legacy_video_ports(struct pci_controller* hose);
int pci_shadow_rom(pci_dev_t dev, unsigned char *dest);
#define __ASM_REALMODE_H_
#include <asm/ptrace.h>
+extern ulong __realmode_start;
+extern ulong __realmode_size;
+extern char realmode_enter;
+
int bios_setup(void);
int enter_realmode(u16 seg, u16 off, struct pt_regs *in, struct pt_regs *out);
int enter_realmode_int(u8 lvl, struct pt_regs *in, struct pt_regs *out);
#ifndef _U_BOOT_I386_H_
#define _U_BOOT_I386_H_ 1
+/* Exports from the Linker Script */
+extern ulong __text_start;
+extern ulong __data_end;
+extern ulong __rel_dyn_start;
+extern ulong __rel_dyn_end;
+extern ulong __bss_start;
+extern ulong __bss_end;
+
/* cpu/.../cpu.c */
int x86_cpu_init_r(void);
int cpu_init_r(void);
#ifndef _BIOS_H_
#define _BIOS_H_
-#define OFFS_ES 0 /* 16bit */
-#define OFFS_GS 2 /* 16bit */
-#define OFFS_DS 4 /* 16bit */
-#define OFFS_EDI 6 /* 32bit */
-#define OFFS_DI 6 /* low 16 bits of EDI */
-#define OFFS_ESI 10 /* 32bit */
-#define OFFS_SI 10 /* low 16 bits of ESI */
-#define OFFS_EBP 14 /* 32bit */
-#define OFFS_BP 14 /* low 16 bits of EBP */
-#define OFFS_ESP 18 /* 32bit */
-#define OFFS_SP 18 /* low 16 bits of ESP */
-#define OFFS_EBX 22 /* 32bit */
-#define OFFS_BX 22 /* low 16 bits of EBX */
-#define OFFS_BL 22 /* low 8 bits of BX */
-#define OFFS_BH 23 /* high 8 bits of BX */
-#define OFFS_EDX 26 /* 32bit */
-#define OFFS_DX 26 /* low 16 bits of EBX */
-#define OFFS_DL 26 /* low 8 bits of BX */
-#define OFFS_DH 27 /* high 8 bits of BX */
-#define OFFS_ECX 30 /* 32bit */
-#define OFFS_CX 30 /* low 16 bits of EBX */
-#define OFFS_CL 30 /* low 8 bits of BX */
-#define OFFS_CH 31 /* high 8 bits of BX */
-#define OFFS_EAX 34 /* 32bit */
-#define OFFS_AX 34 /* low 16 bits of EBX */
-#define OFFS_AL 34 /* low 8 bits of BX */
-#define OFFS_AH 35 /* high 8 bits of BX */
-#define OFFS_VECTOR 38 /* 16bit */
-#define OFFS_IP 40 /* 16bit */
-#define OFFS_CS 42 /* 16bit */
-#define OFFS_FLAGS 44 /* 16bit */
+#define OFFS_ES 0 /* 16bit */
+#define OFFS_GS 2 /* 16bit */
+#define OFFS_DS 4 /* 16bit */
+#define OFFS_EDI 6 /* 32bit */
+#define OFFS_DI 6 /* low 16 bits of EDI */
+#define OFFS_ESI 10 /* 32bit */
+#define OFFS_SI 10 /* low 16 bits of ESI */
+#define OFFS_EBP 14 /* 32bit */
+#define OFFS_BP 14 /* low 16 bits of EBP */
+#define OFFS_ESP 18 /* 32bit */
+#define OFFS_SP 18 /* low 16 bits of ESP */
+#define OFFS_EBX 22 /* 32bit */
+#define OFFS_BX 22 /* low 16 bits of EBX */
+#define OFFS_BL 22 /* low 8 bits of BX */
+#define OFFS_BH 23 /* high 8 bits of BX */
+#define OFFS_EDX 26 /* 32bit */
+#define OFFS_DX 26 /* low 16 bits of EBX */
+#define OFFS_DL 26 /* low 8 bits of BX */
+#define OFFS_DH 27 /* high 8 bits of BX */
+#define OFFS_ECX 30 /* 32bit */
+#define OFFS_CX 30 /* low 16 bits of EBX */
+#define OFFS_CL 30 /* low 8 bits of BX */
+#define OFFS_CH 31 /* high 8 bits of BX */
+#define OFFS_EAX 34 /* 32bit */
+#define OFFS_AX 34 /* low 16 bits of EBX */
+#define OFFS_AL 34 /* low 8 bits of BX */
+#define OFFS_AH 35 /* high 8 bits of BX */
+#define OFFS_VECTOR 38 /* 16bit */
+#define OFFS_IP 40 /* 16bit */
+#define OFFS_CS 42 /* 16bit */
+#define OFFS_FLAGS 44 /* 16bit */
-#define SEGMENT 0x40
-#define STACK 0x800 /* stack at 0x40:0x800 -> 0x800 */
+/* stack at 0x40:0x800 -> 0x800 */
+#define SEGMENT 0x40
+#define STACK 0x800
-/* save general registers */
-/* save some segments */
-/* save callers stack segment .. */
-/* ... in gs */
- /* setup my segments */
- /* setup BIOS stackpointer */
-
-#define MAKE_BIOS_STACK \
- pushal; \
- pushw %ds; \
- pushw %gs; \
- pushw %es; \
- pushw %ss; \
- popw %gs; \
- movw $SEGMENT, %ax; \
- movw %ax, %ds; \
- movw %ax, %es; \
- movw %ax, %ss; \
- movw %sp, %bp; \
+/*
+ * save general registers
+ * save some segments
+ * save callers stack segment
+ * setup BIOS segments
+ * setup BIOS stackpointer
+ */
+#define MAKE_BIOS_STACK \
+ pushal; \
+ pushw %ds; \
+ pushw %gs; \
+ pushw %es; \
+ pushw %ss; \
+ popw %gs; \
+ movw $SEGMENT, %ax; \
+ movw %ax, %ds; \
+ movw %ax, %es; \
+ movw %ax, %ss; \
+ movw %sp, %bp; \
movw $STACK, %sp
-#define RESTORE_CALLERS_STACK \
- pushw %gs; /* restore callers stack segment */ \
- popw %ss; \
- movw %bp, %sp; /* restore stackpointer */ \
- popw %es; /* restore segment selectors */ \
- popw %gs; \
- popw %ds; \
- popal /* restore GP registers */
+/*
+ * restore callers stack segment
+ * restore some segments
+ * restore general registers
+ */
+#define RESTORE_CALLERS_STACK \
+ pushw %gs; \
+ popw %ss; \
+ movw %bp, %sp; \
+ popw %es; \
+ popw %gs; \
+ popw %ds; \
+ popal
+
+#ifndef __ASSEMBLY__
+#define BIOS_DATA ((char *)0x400)
+#define BIOS_DATA_SIZE 256
+#define BIOS_BASE ((char *)0xf0000)
+#define BIOS_CS 0xf000
+
+extern ulong __bios_start;
+extern ulong __bios_size;
+
+/* these are defined in a 16bit segment and needs
+ * to be accessed with the RELOC_16_xxxx() macros below
+ */
+extern u16 ram_in_64kb_chunks;
+extern u16 bios_equipment;
+extern u8 pci_last_bus;
+
+extern void *rm_int00;
+extern void *rm_int01;
+extern void *rm_int02;
+extern void *rm_int03;
+extern void *rm_int04;
+extern void *rm_int05;
+extern void *rm_int06;
+extern void *rm_int07;
+extern void *rm_int08;
+extern void *rm_int09;
+extern void *rm_int0a;
+extern void *rm_int0b;
+extern void *rm_int0c;
+extern void *rm_int0d;
+extern void *rm_int0e;
+extern void *rm_int0f;
+extern void *rm_int10;
+extern void *rm_int11;
+extern void *rm_int12;
+extern void *rm_int13;
+extern void *rm_int14;
+extern void *rm_int15;
+extern void *rm_int16;
+extern void *rm_int17;
+extern void *rm_int18;
+extern void *rm_int19;
+extern void *rm_int1a;
+extern void *rm_int1b;
+extern void *rm_int1c;
+extern void *rm_int1d;
+extern void *rm_int1e;
+extern void *rm_int1f;
+extern void *rm_def_int;
+
+extern void *realmode_reset;
+extern void *realmode_pci_bios_call_entry;
+
+#define RELOC_16_LONG(seg, off) (*(u32 *)(seg << 4 | (u32)&off))
+#define RELOC_16_WORD(seg, off) (*(u16 *)(seg << 4 | (u32)&off))
+#define RELOC_16_BYTE(seg, off) (*(u8 *)(seg << 4 | (u32)&off))
+
+#ifdef PCI_BIOS_DEBUG
+extern u32 num_pci_bios_present;
+extern u32 num_pci_bios_find_device;
+extern u32 num_pci_bios_find_class;
+extern u32 num_pci_bios_generate_special_cycle;
+extern u32 num_pci_bios_read_cfg_byte;
+extern u32 num_pci_bios_read_cfg_word;
+extern u32 num_pci_bios_read_cfg_dword;
+extern u32 num_pci_bios_write_cfg_byte;
+extern u32 num_pci_bios_write_cfg_word;
+extern u32 num_pci_bios_write_cfg_dword;
+extern u32 num_pci_bios_get_irq_routing;
+extern u32 num_pci_bios_set_irq;
+extern u32 num_pci_bios_unknown_function;
+#endif
+
+#endif
#endif
#endif
movl $0x20494350, %eax
gs movl %eax, OFFS_EDX(%bp)
+
+ /* We support cfg type 1 version 2.10 */
movb $0x01, %al
-gs movb %al, OFFS_AL(%bp) /* We support cfg type 1 */
- movw $0x0210, %ax /* version 2.10 */
+gs movb %al, OFFS_AL(%bp)
+ movw $0x0210, %ax
gs movw %ax, OFFS_BX(%bp)
-cs movb pci_last_bus, %al /* last bus number */
+
+ /* last bus number */
+cs movb pci_last_bus, %al
gs movb %al, OFFS_CL(%bp)
jmp clear_carry
#endif
gs movw OFFS_CX(%bp), %di
shll $16, %edi
-gs movw OFFS_DX(%bp), %di /* edi now holds device in upper 16
- * bits and vendor in lower 16 bits */
+gs movw OFFS_DX(%bp), %di
+ /* edi now holds device in upper 16 bits and vendor in lower 16 bits */
+
gs movw OFFS_SI(%bp), %si
- xorw %bx, %bx /* start at bus 0 dev 0 function 0 */
+
+ /* start at bus 0 dev 0 function 0 */
+ xorw %bx, %bx
pfd_loop:
- xorw %ax, %ax /* dword 0 is vendor/device */
+ /* dword 0 is vendor/device */
+ xorw %ax, %ax
call __pci_bios_select_register
movw $0xcfc, %dx
inl %dx, %eax
- cmpl %edi, %eax /* our device ? */
+
+ /* our device ? */
+ cmpl %edi, %eax
je pfd_found_one
pfd_next_dev:
/* check for multi function devices */
andb $0x80, %al
jz pfd_not_multi_function
pfd_function_not_zero:
- incw %bx /* next function, overflows in to
- * device number, then bus number */
+ /* next function, overflows in to device number, then bus number */
+ incw %bx
jmp pfd_check_bus
pfd_not_multi_function:
- andw $0xfff8, %bx /* remove function bits */
- addw $0x0008, %bx /* next device, overflows in to bus number */
+ /* remove function bits */
+ andw $0xfff8, %bx
+
+ /* next device, overflows in to bus number */
+ addw $0x0008, %bx
pfd_check_bus:
cs movb pci_last_bus, %ah
cmpb %ah, %bh
jmp clear_carry
pfd_not_found:
- movb $0x86, %ah /* device not found */
+ /* device not found */
+ movb $0x86, %ah
jmp set_carry
/*****************************************************************************/
cs incl num_pci_bios_find_class
#endif
gs movl OFFS_ECX(%bp), %edi
- andl $0x00ffffff, %edi /* edi now holds class-code in lower 24 bits */
+
+ /* edi now holds class-code in lower 24 bits */
+ andl $0x00ffffff, %edi
gs movw OFFS_SI(%bp), %si
- xorw %bx, %bx /* start at bus 0 dev 0 function 0 */
+
+ /* start at bus 0 dev 0 function 0 */
+ xorw %bx, %bx
pfc_loop:
- movw $8, %ax /* dword 8 is class-code high 24bits */
+ /* dword 8 is class-code high 24bits */
+ movw $8, %ax
call __pci_bios_select_register
movw $0xcfc, %dx
inl %dx, %eax
shrl $8, %eax
andl $0x00ffffff, %eax
- cmpl %edi, %eax /* our device ? */
+
+ /* our device ? */
+ cmpl %edi, %eax
je pfc_found_one
pfc_next_dev:
/* check for multi function devices */
andb $0x80, %al
jz pfc_not_multi_function
pfc_function_not_zero:
- incw %bx /* next function, overflows in to
- * device number, then bus number */
+ /* next function, overflows in to device number, then bus number */
+ incw %bx
jmp pfc_check_bus
pfc_not_multi_function:
- andw $0xfff8, %bx /* remove function bits */
- addw $0x0008, %bx /* next device, overflows in to bus number */
+ /* remove function bits */
+ andw $0xfff8, %bx
+
+ /* next device, overflows in to bus number */
+ addw $0x0008, %bx
pfc_check_bus:
cs movb pci_last_bus, %ah
cmpb %ah, %bh
jmp clear_carry
pfc_not_found:
- movb $0x86, %ah /* device not found */
+ /* device not found */
+ movb $0x86, %ah
jmp set_carry
/*****************************************************************************/
#ifdef PCI_BIOS_DEBUG
cs incl num_pci_bios_generate_special_cycle
#endif
- movb $0x81, %ah /* function not supported */
+ /* function not supported */
+ movb $0x81, %ah
jmp set_carry
/*****************************************************************************/
#ifdef PCI_BIOS_DEBUG
cs incl num_pci_bios_get_irq_routing
#endif
- movb $0x81, %ah /* function not supported */
+ /* function not supported */
+ movb $0x81, %ah
jmp set_carry
/*****************************************************************************/
#ifdef PCI_BIOS_DEBUG
cs incl num_pci_bios_set_irq
#endif
- movb $0x81, %ah /* function not supported */
+ /* function not supported */
+ movb $0x81, %ah
jmp set_carry
/*****************************************************************************/
#ifdef PCI_BIOS_DEBUG
cs incl num_pci_bios_unknown_function
#endif
- movb $0x81, %ah /* function not supported */
+ /* function not supported */
+ movb $0x81, %ah
jmp set_carry
/*****************************************************************************/
gs movw OFFS_BX(%bp), %bx
gs movw OFFS_DI(%bp), %ax
/* destroys eax, dx */
-__pci_bios_select_register: /* BX holds device id, AX holds register index */
+__pci_bios_select_register:
+ /* BX holds device id, AX holds register index */
pushl %ebx
andl $0xfc, %eax
andl $0xffff, %ebx
clear_carry:
gs movw OFFS_FLAGS(%bp), %ax
- andw $0xfffe, %ax /* clear carry -- function succeeded */
+
+ /* clear carry -- function succeeded */
+ andw $0xfffe, %ax
gs movw %ax, OFFS_FLAGS(%bp)
xorw %ax, %ax
gs movb %ah, OFFS_AH(%bp)
set_carry:
gs movb %ah, OFFS_AH(%bp)
gs movw OFFS_FLAGS(%bp), %ax
- orw $1, %ax /* return carry -- function not supported */
+
+ /* return carry -- function not supported */
+ orw $1, %ax
gs movw %ax, OFFS_FLAGS(%bp)
movw $-1, %ax
ret
#include <pci.h>
#include <asm/realmode.h>
#include <asm/io.h>
+#include "bios.h"
DECLARE_GLOBAL_DATA_PTR;
#define NUMVECTS 256
-#define BIOS_DATA ((char*)0x400)
-#define BIOS_DATA_SIZE 256
-#define BIOS_BASE ((char*)0xf0000)
-#define BIOS_CS 0xf000
-
-extern ulong __bios_start;
-extern ulong __bios_size;
-
-/* these are defined in a 16bit segment and needs
- * to be accessed with the RELOC_16_xxxx() macros below
- */
-extern u16 ram_in_64kb_chunks;
-extern u16 bios_equipment;
-extern u8 pci_last_bus;
-
-extern void *rm_int00;
-extern void *rm_int01;
-extern void *rm_int02;
-extern void *rm_int03;
-extern void *rm_int04;
-extern void *rm_int05;
-extern void *rm_int06;
-extern void *rm_int07;
-extern void *rm_int08;
-extern void *rm_int09;
-extern void *rm_int0a;
-extern void *rm_int0b;
-extern void *rm_int0c;
-extern void *rm_int0d;
-extern void *rm_int0e;
-extern void *rm_int0f;
-extern void *rm_int10;
-extern void *rm_int11;
-extern void *rm_int12;
-extern void *rm_int13;
-extern void *rm_int14;
-extern void *rm_int15;
-extern void *rm_int16;
-extern void *rm_int17;
-extern void *rm_int18;
-extern void *rm_int19;
-extern void *rm_int1a;
-extern void *rm_int1b;
-extern void *rm_int1c;
-extern void *rm_int1d;
-extern void *rm_int1e;
-extern void *rm_int1f;
-extern void *rm_def_int;
-
-extern void *realmode_reset;
-extern void *realmode_pci_bios_call_entry;
-
static int set_jmp_vector(int entry_point, void *target)
{
- if (entry_point & ~0xffff) {
+ if (entry_point & ~0xffff)
return -1;
- }
- if (((u32)target-0xf0000) & ~0xffff) {
+ if (((u32)target - 0xf0000) & ~0xffff)
return -1;
- }
+
printf("set_jmp_vector: 0xf000:%04x -> %p\n",
- entry_point, target);
+ entry_point, target);
/* jmp opcode */
writeb(0xea, 0xf0000 + entry_point);
return 0;
}
-
-/*
- ************************************************************
- * Install an interrupt vector
- ************************************************************
- */
-
+/* Install an interrupt vector */
static void setvector(int vector, u16 segment, void *handler)
{
- u16 *ptr = (u16*)(vector*4);
- ptr[0] = ((u32)handler - (segment << 4))&0xffff;
+ u16 *ptr = (u16 *)(vector * 4);
+ ptr[0] = ((u32)handler - (segment << 4)) & 0xffff;
ptr[1] = segment;
#if 0
printf("setvector: int%02x -> %04x:%04x\n",
- vector, ptr[1], ptr[0]);
+ vector, ptr[1], ptr[0]);
#endif
}
-#define RELOC_16_LONG(seg, off) *(u32*)(seg << 4 | (u32)&off)
-#define RELOC_16_WORD(seg, off) *(u16*)(seg << 4 | (u32)&off)
-#define RELOC_16_BYTE(seg, off) *(u8*)(seg << 4 | (u32)&off)
-
int bios_setup(void)
{
ulong bios_start = (ulong)&__bios_start + gd->reloc_off;
ulong bios_size = (ulong)&__bios_size;
- static int done=0;
+ static int done;
int vector;
#ifdef CONFIG_PCI
struct pci_controller *pri_hose;
#endif
- if (done) {
+ if (done)
return 0;
- }
+
done = 1;
if (bios_size > 65536) {
printf("BIOS too large (%ld bytes, max is 65536)\n",
- bios_size);
+ bios_size);
return -1;
}
- memcpy(BIOS_BASE, (void*)bios_start, bios_size);
+ memcpy(BIOS_BASE, (void *)bios_start, bios_size);
/* clear bda */
memset(BIOS_DATA, 0, BIOS_DATA_SIZE);
/* setup realmode interrupt vectors */
- for (vector = 0; vector < NUMVECTS; vector++) {
+ for (vector = 0; vector < NUMVECTS; vector++)
setvector(vector, BIOS_CS, &rm_def_int);
- }
setvector(0x00, BIOS_CS, &rm_int00);
setvector(0x01, BIOS_CS, &rm_int01);
#define XTRN_DECLARE_GLOBAL_DATA_PTR /* empty = allocate here */
DECLARE_GLOBAL_DATA_PTR = (gd_t *) (CONFIG_SYS_INIT_GD_ADDR);
-
-/* Exports from the Linker Script */
-extern ulong __text_start;
-extern ulong __data_end;
-extern ulong __rel_dyn_start;
-extern ulong __rel_dyn_end;
-extern ulong __bss_start;
-extern ulong __bss_end;
-
/************************************************************************
* Init Utilities *
************************************************************************
* or dropped completely,
* but let's get it working (again) first...
*/
-static int init_baudrate (void)
+static int init_baudrate(void)
{
gd->baudrate = getenv_ulong("baudrate", 10, CONFIG_BAUDRATE);
return 0;
}
-static int display_banner (void)
+static int display_banner(void)
{
- printf ("\n\n%s\n\n", version_string);
-/*
- printf ("U-Boot code: %08lX -> %08lX data: %08lX -> %08lX\n"
- " BSS: %08lX -> %08lX stack: %08lX -> %08lX\n",
- i386boot_start, i386boot_romdata_start-1,
- i386boot_romdata_dest, i386boot_romdata_dest+i386boot_romdata_size-1,
- i386boot_bss_start, i386boot_bss_start+i386boot_bss_size-1,
- i386boot_bss_start+i386boot_bss_size,
- i386boot_bss_start+i386boot_bss_size+CONFIG_SYS_STACK_SIZE-1);
-
-*/
+ printf("\n\n%s\n\n", version_string);
- return (0);
+ return 0;
}
-static int display_dram_config (void)
+static int display_dram_config(void)
{
int i;
- puts ("DRAM Configuration:\n");
+ puts("DRAM Configuration:\n");
- for (i=0; i<CONFIG_NR_DRAM_BANKS; i++) {
- printf ("Bank #%d: %08lx ", i, gd->bd->bi_dram[i].start);
- print_size (gd->bd->bi_dram[i].size, "\n");
+ for (i = 0; i < CONFIG_NR_DRAM_BANKS; i++) {
+ printf("Bank #%d: %08lx ", i, gd->bd->bi_dram[i].start);
+ print_size(gd->bd->bi_dram[i].size, "\n");
}
- return (0);
+ return 0;
}
-static void display_flash_config (ulong size)
+static void display_flash_config(ulong size)
{
- puts ("Flash: ");
- print_size (size, "\n");
+ puts("Flash: ");
+ print_size(size, "\n");
}
/*
void *bss_end = &__bss_end;
ulong *dst_addr = (ulong *)(bss_start + gd->reloc_off);
- ulong *end_addr = (ulong *)(bss_end + gd->reloc_off);;
+ ulong *end_addr = (ulong *)(bss_end + gd->reloc_off);
while (dst_addr < end_addr)
*dst_addr++ = 0x00000000;
Elf32_Rel *re_src = (Elf32_Rel *)(&__rel_dyn_start);
Elf32_Rel *re_end = (Elf32_Rel *)(&__rel_dyn_end);
+ Elf32_Addr *offset_ptr_rom;
+ Elf32_Addr *offset_ptr_ram;
+
do {
- if (re_src->r_offset >= CONFIG_SYS_TEXT_BASE)
- if (*(Elf32_Addr *)(re_src->r_offset + gd->reloc_off) >= CONFIG_SYS_TEXT_BASE)
- *(Elf32_Addr *)(re_src->r_offset + gd->reloc_off) += gd->reloc_off;
+ /* Get the location from the relocation entry */
+ offset_ptr_rom = (Elf32_Addr *)re_src->r_offset;
+
+ /* Check that the location of the relocation is in .text */
+ if (offset_ptr_rom >= (Elf32_Addr *)CONFIG_SYS_TEXT_BASE) {
+
+ /* Switch to the in-RAM version */
+ offset_ptr_ram = offset_ptr_rom + gd->reloc_off;
+
+ /* Check that the target points into .text */
+ if (*offset_ptr_ram >= CONFIG_SYS_TEXT_BASE)
+ *offset_ptr_ram += gd->reloc_off;
+ }
} while (re_src++ < re_end);
return 0;
relocate_code(gd->start_addr_sp, gd, gd->relocaddr);
/* NOTREACHED - relocate_code() does not return */
- while(1);
+ while (1)
+ ;
}
void board_init_r(gd_t *id, ulong dest_addr)
memcpy(gd, id, sizeof(gd_t));
/* compiler optimization barrier needed for GCC >= 3.4 */
- __asm__ __volatile__("": : :"memory");
+ __asm__ __volatile__("" : : : "memory");
gd->bd = &bd_data;
- memset (gd->bd, 0, sizeof (bd_t));
+ memset(gd->bd, 0, sizeof(bd_t));
show_boot_progress(0x22);
gd->baudrate = CONFIG_BAUDRATE;
for (init_fnc_ptr = init_sequence_r; *init_fnc_ptr; ++init_fnc_ptr) {
if ((*init_fnc_ptr)() != 0)
- hang ();
+ hang();
}
show_boot_progress(0x23);
show_boot_progress(0x25);
/* initialize environment */
- env_relocate ();
+ env_relocate();
show_boot_progress(0x26);
#ifdef CONFIG_CMD_NET
/* IP Address */
- bd_data.bi_ip_addr = getenv_IPaddr ("ipaddr");
+ bd_data.bi_ip_addr = getenv_IPaddr("ipaddr");
#endif
#if defined(CONFIG_PCI)
show_boot_progress(0x27);
- stdio_init ();
+ stdio_init();
- jumptable_init ();
+ jumptable_init();
/* Initialize the console (after the relocation and devices init) */
console_init_r();
#if defined(CONFIG_CMD_PCMCIA) && !defined(CONFIG_CMD_IDE)
WATCHDOG_RESET();
- puts ("PCMCIA:");
+ puts("PCMCIA:");
pcmcia_init();
#endif
show_boot_progress(0x28);
#ifdef CONFIG_STATUS_LED
- status_led_set (STATUS_LED_BOOT, STATUS_LED_BLINKING);
+ status_led_set(STATUS_LED_BOOT, STATUS_LED_BLINKING);
#endif
udelay(20);
/* Initialize from environment */
load_addr = getenv_ulong("loadaddr", 16, load_addr);
#if defined(CONFIG_CMD_NET)
- if ((s = getenv ("bootfile")) != NULL) {
- copy_filename (BootFile, s, sizeof (BootFile));
- }
+ s = getenv("bootfile");
+
+ if (s != NULL)
+ copy_filename(BootFile, s, sizeof(BootFile));
#endif
WATCHDOG_RESET();
eth_initialize(gd->bd);
#endif
-#if ( defined(CONFIG_CMD_NET)) && (0)
+#if (defined(CONFIG_CMD_NET)) && (0)
WATCHDOG_RESET();
# ifdef DEBUG
- puts ("Reset Ethernet PHY\n");
+ puts("Reset Ethernet PHY\n");
# endif
reset_phy();
#endif
#ifdef CONFIG_POST
- post_run (NULL, POST_RAM | post_bootmode_get(0));
+ post_run(NULL, POST_RAM | post_bootmode_get(0));
#endif
-
show_boot_progress(0x29);
/* main_loop() can return to retry autoboot, if so just run it again. */
- for (;;) {
+ for (;;)
main_loop();
- }
/* NOTREACHED - no way out of command loop except booting */
}
-void hang (void)
+void hang(void)
{
- puts ("### ERROR ### Please RESET the board ###\n");
- for (;;);
+ puts("### ERROR ### Please RESET the board ###\n");
+ for (;;)
+ ;
}
-unsigned long do_go_exec (ulong (*entry)(int, char * const []), int argc, char * const argv[])
+unsigned long do_go_exec(ulong (*entry)(int, char * const []),
+ int argc, char * const argv[])
{
unsigned long ret = 0;
char **argv_tmp;
#include <asm/zimage.h>
/*cmd_boot.c*/
-int do_bootm_linux(int flag, int argc, char * const argv[], bootm_headers_t *images)
+int do_bootm_linux(int flag, int argc, char * const argv[],
+ bootm_headers_t *images)
{
void *base_ptr;
ulong os_data, os_len;
if (images->legacy_hdr_valid) {
hdr = images->legacy_hdr_os;
- if (image_check_type (hdr, IH_TYPE_MULTI)) {
+ if (image_check_type(hdr, IH_TYPE_MULTI)) {
/* if multi-part image, we need to get first subimage */
- image_multi_getimg (hdr, 0, &os_data, &os_len);
+ image_multi_getimg(hdr, 0, &os_data, &os_len);
} else {
/* otherwise get image data */
- os_data = image_get_data (hdr);
- os_len = image_get_data_size (hdr);
+ os_data = image_get_data(hdr);
+ os_len = image_get_data_size(hdr);
}
#if defined(CONFIG_FIT)
} else if (images->fit_uname_os) {
- ret = fit_image_get_data (images->fit_hdr_os,
+ ret = fit_image_get_data(images->fit_hdr_os,
images->fit_noffset_os, &data, &len);
if (ret) {
- puts ("Can't get image data/size!\n");
+ puts("Can't get image data/size!\n");
goto error;
}
os_data = (ulong)data;
os_len = (ulong)len;
#endif
} else {
- puts ("Could not find kernel image!\n");
+ puts("Could not find kernel image!\n");
goto error;
}
- base_ptr = load_zimage ((void*)os_data, os_len,
+ base_ptr = load_zimage((void *)os_data, os_len,
images->rd_start, images->rd_end - images->rd_start, 0);
if (NULL == base_ptr) {
- printf ("## Kernel loading failed ...\n");
+ printf("## Kernel loading failed ...\n");
goto error;
}
#ifdef DEBUG
- printf ("## Transferring control to Linux (at address %08x) ...\n",
+ printf("## Transferring control to Linux (at address %08x) ...\n",
(u32)base_ptr);
#endif
};
static struct irq_action irq_handlers[CONFIG_SYS_NUM_IRQS] = { {0} };
-static int spurious_irq_cnt = 0;
-static int spurious_irq = 0;
+static int spurious_irq_cnt;
+static int spurious_irq;
void irq_install_handler(int irq, interrupt_handler_t *handler, void *arg)
{
if (irq_handlers[irq].handler != NULL)
printf("irq_install_handler: 0x%08lx replacing 0x%08lx\n",
- (ulong) handler,
- (ulong) irq_handlers[irq].handler);
+ (ulong) handler,
+ (ulong) irq_handlers[irq].handler);
- status = disable_interrupts ();
+ status = disable_interrupts();
irq_handlers[irq].handler = handler;
irq_handlers[irq].arg = arg;
return;
}
- status = disable_interrupts ();
+ status = disable_interrupts();
mask_irq(irq);
int irq;
printf("Spurious IRQ: %u, last unknown IRQ: %d\n",
- spurious_irq_cnt, spurious_irq);
+ spurious_irq_cnt, spurious_irq);
- printf ("Interrupt-Information:\n");
- printf ("Nr Routine Arg Count\n");
+ printf("Interrupt-Information:\n");
+ printf("Nr Routine Arg Count\n");
for (irq = 0; irq <= CONFIG_SYS_NUM_IRQS; irq++) {
if (irq_handlers[irq].handler != NULL) {
- printf ("%02d %08lx %08lx %d\n",
+ printf("%02d %08lx %08lx %d\n",
irq,
(ulong)irq_handlers[irq].handler,
(ulong)irq_handlers[irq].arg,
* Enable cascaded interrupts by unmasking the cascade IRQ pin of
* the master PIC
*/
- unmask_irq (2);
+ unmask_irq(2);
enable_interrupts();
#define TIMER0_VALUE 0x04aa /* 1kHz 1.9318MHz / 1000 */
#define TIMER2_VALUE 0x0a8e /* 440Hz */
-static int timer_init_done = 0;
+static int timer_init_done;
int timer_init(void)
{
* (to stasrt a beep: write 3 to port 0x61,
* to stop it again: write 0)
*/
- outb (PIT_CMD_CTR0 | PIT_CMD_BOTH | PIT_CMD_MODE2,
- PIT_BASE + PIT_COMMAND);
- outb (TIMER0_VALUE & 0xff, PIT_BASE + PIT_T0);
- outb (TIMER0_VALUE >> 8, PIT_BASE + PIT_T0);
+ outb(PIT_CMD_CTR0 | PIT_CMD_BOTH | PIT_CMD_MODE2,
+ PIT_BASE + PIT_COMMAND);
+ outb(TIMER0_VALUE & 0xff, PIT_BASE + PIT_T0);
+ outb(TIMER0_VALUE >> 8, PIT_BASE + PIT_T0);
- outb (PIT_CMD_CTR2 | PIT_CMD_BOTH | PIT_CMD_MODE3,
- PIT_BASE + PIT_COMMAND);
- outb (TIMER2_VALUE & 0xff, PIT_BASE + PIT_T2);
- outb (TIMER2_VALUE >> 8, PIT_BASE + PIT_T2);
+ outb(PIT_CMD_CTR2 | PIT_CMD_BOTH | PIT_CMD_MODE3,
+ PIT_BASE + PIT_COMMAND);
+ outb(TIMER2_VALUE & 0xff, PIT_BASE + PIT_T2);
+ outb(TIMER2_VALUE >> 8, PIT_BASE + PIT_T2);
- irq_install_handler (0, timer_isr, NULL);
- unmask_irq (0);
+ irq_install_handler(0, timer_isr, NULL);
+ unmask_irq(0);
timer_init_done = 1;
{
u8 low;
- outb (PIT_CMD_LATCH, PIT_BASE + PIT_COMMAND);
- low = inb (PIT_BASE + PIT_T0);
+ outb(PIT_CMD_LATCH, PIT_BASE + PIT_COMMAND);
+ low = inb(PIT_BASE + PIT_T0);
- return ((inb (PIT_BASE + PIT_T0) << 8) | low);
+ return (inb(PIT_BASE + PIT_T0) << 8) | low;
}
/* this is not very exact */
-void __udelay (unsigned long usec)
+void __udelay(unsigned long usec)
{
int counter;
int wraps;
- if (timer_init_done)
- {
- counter = read_pit ();
+ if (timer_init_done) {
+ counter = read_pit();
wraps = usec / 1000;
usec = usec % 1000;
}
while (1) {
- int new_count = read_pit ();
+ int new_count = read_pit();
if (((new_count < usec) && !wraps) || wraps < 0)
break;
u16 device;
u32 class_code;
+ u32 pci_data;
+
hose = pci_bus_to_hose(PCI_BUS(dev));
-#if 0
- printf("pci_shadow_rom() asked to shadow device %x to %x\n",
+
+ debug("pci_shadow_rom() asked to shadow device %x to %x\n",
dev, (u32)dest);
-#endif
+
pci_read_config_word(dev, PCI_VENDOR_ID, &vendor);
pci_read_config_word(dev, PCI_DEVICE_ID, &device);
pci_read_config_dword(dev, PCI_CLASS_REVISION, &class_code);
return -1;
}
- size = (~(addr_reg&PCI_ROM_ADDRESS_MASK))+1;
+ size = (~(addr_reg&PCI_ROM_ADDRESS_MASK)) + 1;
debug("ROM is %d bytes\n", size);
|PCI_ROM_ADDRESS_ENABLE);
- for (i=rom_addr;i<rom_addr+size; i+=512) {
-
-
+ for (i = rom_addr; i < rom_addr + size; i += 512) {
if (readw(i) == 0xaa55) {
- u32 pci_data;
#ifdef PCI_ROM_SCAN_VERBOSE
printf("ROM signature found\n");
#endif
- pci_data = readw(0x18+i);
+ pci_data = readw(0x18 + i);
pci_data += i;
- if (0==memcmp((void*)pci_data, "PCIR", 4)) {
+ if (0 == memcmp((void *)pci_data, "PCIR", 4)) {
#ifdef PCI_ROM_SCAN_VERBOSE
- printf("Fount PCI rom image at offset %d\n", i-rom_addr);
+ printf("Fount PCI rom image at offset %d\n",
+ i - rom_addr);
printf("Vendor %04x device %04x class %06x\n",
- readw(pci_data+4), readw(pci_data+6),
- readl(pci_data+0x0d)&0xffffff);
+ readw(pci_data + 4), readw(pci_data + 6),
+ readl(pci_data + 0x0d) & 0xffffff);
printf("%s\n",
- (readw(pci_data+0x15) &0x80)?
- "Last image":"More images follow");
- switch (readb(pci_data+0x14)) {
+ (readw(pci_data + 0x15) & 0x80) ?
+ "Last image" : "More images follow");
+ switch (readb(pci_data + 0x14)) {
case 0:
printf("X86 code\n");
break;
printf("PARISC code\n");
break;
}
- printf("Image size %d\n", readw(pci_data+0x10) * 512);
+ printf("Image size %d\n",
+ readw(pci_data + 0x10) * 512);
#endif
- /* FixMe: I think we should compare the class code
- * bytes as well but I have no reference on the
- * exact order of these bytes in the PCI ROM header */
- if (readw(pci_data+4) == vendor &&
- readw(pci_data+6) == device &&
- /* (readl(pci_data+0x0d)&0xffffff) == class_code && */
- readb(pci_data+0x14) == 0 /* x86 code image */ ) {
+ /*
+ * FixMe: I think we should compare the class
+ * code bytes as well but I have no reference
+ * on the exact order of these bytes in the PCI
+ * ROM header
+ */
+ if (readw(pci_data + 4) == vendor &&
+ readw(pci_data + 6) == device &&
+ readb(pci_data + 0x14) == 0) {
#ifdef PCI_ROM_SCAN_VERBOSE
- printf("Suitable ROM image found, copying\n");
+ printf("Suitable ROM image found\n");
#endif
- memmove(dest, (void*)rom_addr, readw(pci_data+0x10) * 512);
+ memmove(dest, (void *)rom_addr,
+ readw(pci_data + 0x10) * 512);
res = 0;
break;
}
- if (readw(pci_data+0x15) &0x80) {
+
+ if (readw(pci_data + 0x15) & 0x80)
break;
- }
}
}
}
#ifdef PCI_ROM_SCAN_VERBOSE
- if (res) {
+ if (res)
printf("No suitable image found\n");
- }
#endif
/* disable PAR register and PCI device ROM address devocer */
pci_remove_rom_window(hose, rom_addr);
#include <asm/io.h>
#include <pci.h>
-#define cfg_read(val, addr, op) *val = op((int)(addr))
+#define cfg_read(val, addr, op) (*val = op((int)(addr)))
#define cfg_write(val, addr, op) op((val), (int)(addr))
#define TYPE1_PCI_OP(rw, size, type, op, mask) \
return 0; \
}
-
TYPE1_PCI_OP(read, byte, u8 *, inb, 3)
TYPE1_PCI_OP(read, word, u16 *, inw, 2)
TYPE1_PCI_OP(read, dword, u32 *, inl, 0)
TYPE1_PCI_OP(write, word, u16, outw, 2)
TYPE1_PCI_OP(write, dword, u32, outl, 0)
-void pci_setup_type1(struct pci_controller* hose, u32 cfg_addr, u32 cfg_data)
+void pci_setup_type1(struct pci_controller *hose, u32 cfg_addr, u32 cfg_data)
{
pci_set_ops(hose,
type1_read_config_byte,
type1_write_config_word,
type1_write_config_dword);
- hose->cfg_addr = (unsigned int *) cfg_addr;
- hose->cfg_data = (unsigned char *) cfg_data;
+ hose->cfg_addr = (unsigned int *)cfg_addr;
+ hose->cfg_data = (unsigned char *)cfg_data;
}
#include <asm/ptrace.h>
#include <asm/realmode.h>
-#define REALMODE_MAILBOX ((char*)0xe00)
-
-extern ulong __realmode_start;
-extern ulong __realmode_size;
-extern char realmode_enter;
+#define REALMODE_MAILBOX ((char *)0xe00)
int realmode_setup(void)
{
in->eip = off;
in->xcs = seg;
- if (3>(in->esp & 0xffff)) {
+ if ((in->esp & 0xffff) < 4)
printf("Warning: entering realmode with sp < 4 will fail\n");
- }
memcpy(REALMODE_MAILBOX, in, sizeof(struct pt_regs));
asm("wbinvd\n");
__asm__ volatile (
- "lcall $0x20,%0\n" : : "i" (&realmode_enter) );
+ "lcall $0x20,%0\n" : : "i" (&realmode_enter));
asm("wbinvd\n");
memcpy(out, REALMODE_MAILBOX, sizeof(struct pt_regs));
return out->eax;
}
-
-/* This code is supposed to access a realmode interrupt
- * it does currently not work for me */
+/*
+ * This code is supposed to access a realmode interrupt
+ * it does currently not work for me
+ */
int enter_realmode_int(u8 lvl, struct pt_regs *in, struct pt_regs *out)
{
/* place two instructions at 0x700 */
enter_realmode(0x00, 0x700, in, out);
- return out->eflags&1;
+ return out->eflags & 0x00000001;
}
timer_fnc_t *isr_func;
};
-static struct timer_isr_function *first_timer_isr = NULL;
-static volatile unsigned long system_ticks = 0;
+static struct timer_isr_function *first_timer_isr;
+static unsigned long system_ticks;
/*
* register_timer_isr() allows multiple architecture and board specific
* functions to be called every millisecond. Keep the execution time of
* each function as low as possible
*/
-int register_timer_isr (timer_fnc_t *isr_func)
+int register_timer_isr(timer_fnc_t *isr_func)
{
struct timer_isr_function *new_func;
struct timer_isr_function *temp;
* Don't allow timer interrupts while the
* linked list is being modified
*/
- flag = disable_interrupts ();
+ flag = disable_interrupts();
if (first_timer_isr == NULL) {
first_timer_isr = new_func;
}
if (flag)
- enable_interrupts ();
+ enable_interrupts();
return 0;
}
/* Execute each registered function */
while (temp != NULL) {
- temp->isr_func ();
+ temp->isr_func();
temp = temp->next;
}
}
-ulong get_timer (ulong base)
+ulong get_timer(ulong base)
{
- return (system_ticks - base);
+ return system_ticks - base;
}
static void video_putc(const char c)
{
- int x,y,pos;
+ int x, y, pos;
x = orig_x;
y = orig_y;
static void video_puts(const char *s)
{
- int x,y,pos;
+ int x, y, pos;
char c;
x = orig_x;
printf("pos %x %d %d\n", pos, orig_x, orig_y);
#endif
if (orig_y > lines)
- orig_x = orig_y =0;
+ orig_x = orig_y = 0;
memset(&vga_dev, 0, sizeof(vga_dev));
strcpy(vga_dev.name, "vga");
#include <asm/realmode.h>
#include <asm/io.h>
#include <asm/pci.h>
+#include "bios.h"
#undef PCI_BIOS_DEBUG
#undef VGA_BIOS_DEBUG
#ifdef VGA_BIOS_DEBUG
-#define PRINTF(fmt,args...) printf (fmt ,##args)
+#define PRINTF(fmt, args...) printf(fmt, ##args)
#else
-#define PRINTF(fmt,args...)
+#define PRINTF(fmt, args...)
#endif
#ifdef CONFIG_PCI
#ifdef PCI_BIOS_DEBUG
-#define RELOC_16(seg, off) *(u32*)(seg << 4 | (u32)&off)
-extern u32 num_pci_bios_present;
-extern u32 num_pci_bios_find_device;
-extern u32 num_pci_bios_find_class;
-extern u32 num_pci_bios_generate_special_cycle;
-extern u32 num_pci_bios_read_cfg_byte;
-extern u32 num_pci_bios_read_cfg_word;
-extern u32 num_pci_bios_read_cfg_dword;
-extern u32 num_pci_bios_write_cfg_byte;
-extern u32 num_pci_bios_write_cfg_word;
-extern u32 num_pci_bios_write_cfg_dword;
-extern u32 num_pci_bios_get_irq_routing;
-extern u32 num_pci_bios_set_irq;
-extern u32 num_pci_bios_unknown_function;
-
void print_bios_bios_stat(void)
{
printf("16 bit functions:\n");
- printf("pci_bios_present: %d\n", RELOC_16(0xf000, num_pci_bios_present));
- printf("pci_bios_find_device: %d\n", RELOC_16(0xf000, num_pci_bios_find_device));
- printf("pci_bios_find_class: %d\n", RELOC_16(0xf000, num_pci_bios_find_class));
- printf("pci_bios_generate_special_cycle: %d\n", RELOC_16(0xf000, num_pci_bios_generate_special_cycle));
- printf("pci_bios_read_cfg_byte: %d\n", RELOC_16(0xf000, num_pci_bios_read_cfg_byte));
- printf("pci_bios_read_cfg_word: %d\n", RELOC_16(0xf000, num_pci_bios_read_cfg_word));
- printf("pci_bios_read_cfg_dword: %d\n", RELOC_16(0xf000, num_pci_bios_read_cfg_dword));
- printf("pci_bios_write_cfg_byte: %d\n", RELOC_16(0xf000, num_pci_bios_write_cfg_byte));
- printf("pci_bios_write_cfg_word: %d\n", RELOC_16(0xf000, num_pci_bios_write_cfg_word));
- printf("pci_bios_write_cfg_dword: %d\n", RELOC_16(0xf000, num_pci_bios_write_cfg_dword));
- printf("pci_bios_get_irq_routing: %d\n", RELOC_16(0xf000, num_pci_bios_get_irq_routing));
- printf("pci_bios_set_irq: %d\n", RELOC_16(0xf000, num_pci_bios_set_irq));
- printf("pci_bios_unknown_function: %d\n", RELOC_16(0xf000, num_pci_bios_unknown_function));
+ printf("pci_bios_present: %d\n",
+ RELOC_16_LONG(0xf000, num_pci_bios_present));
+ printf("pci_bios_find_device: %d\n",
+ RELOC_16_LONG(0xf000, num_pci_bios_find_device));
+ printf("pci_bios_find_class: %d\n",
+ RELOC_16_LONG(0xf000, num_pci_bios_find_class));
+ printf("pci_bios_generate_special_cycle: %d\n",
+ RELOC_16_LONG(0xf000,
+ num_pci_bios_generate_special_cycle));
+ printf("pci_bios_read_cfg_byte: %d\n",
+ RELOC_16_LONG(0xf000, num_pci_bios_read_cfg_byte));
+ printf("pci_bios_read_cfg_word: %d\n",
+ RELOC_16_LONG(0xf000, num_pci_bios_read_cfg_word));
+ printf("pci_bios_read_cfg_dword: %d\n",
+ RELOC_16_LONG(0xf000, num_pci_bios_read_cfg_dword));
+ printf("pci_bios_write_cfg_byte: %d\n",
+ RELOC_16_LONG(0xf000, num_pci_bios_write_cfg_byte));
+ printf("pci_bios_write_cfg_word: %d\n",
+ RELOC_16_LONG(0xf000, num_pci_bios_write_cfg_word));
+ printf("pci_bios_write_cfg_dword: %d\n",
+ RELOC_16_LONG(0xf000, num_pci_bios_write_cfg_dword));
+ printf("pci_bios_get_irq_routing: %d\n",
+ RELOC_16_LONG(0xf000, num_pci_bios_get_irq_routing));
+ printf("pci_bios_set_irq: %d\n",
+ RELOC_16_LONG(0xf000, num_pci_bios_set_irq));
+ printf("pci_bios_unknown_function: %d\n",
+ RELOC_16_LONG(0xf000, num_pci_bios_unknown_function));
}
#endif
#ifdef CONFIG_VIDEO
-#define PCI_CLASS_VIDEO 3
-#define PCI_CLASS_VIDEO_STD 0
-#define PCI_CLASS_VIDEO_PROG_IF_VGA 0
+#define PCI_CLASS_VIDEO 3
+#define PCI_CLASS_VIDEO_STD 0
+#define PCI_CLASS_VIDEO_PROG_IF_VGA 0
-static struct pci_device_id supported[] = {
+DEFINE_PCI_DEVICE_TABLE(supported) = {
{PCI_VIDEO_VENDOR_ID, PCI_VIDEO_DEVICE_ID},
{}
};
static u32 probe_pci_video(void)
{
- pci_dev_t devbusfn;
+ struct pci_controller *hose;
+ pci_dev_t devbusfn = pci_find_devices(supported, 0);
- if ((devbusfn = pci_find_devices(supported, 0) != -1)) {
+ if ((devbusfn != -1)) {
u32 old;
u32 addr;
/* PCI video device detected */
printf("Found PCI VGA device at %02x.%02x.%x\n",
- PCI_BUS(devbusfn), PCI_DEV(devbusfn), PCI_FUNC(devbusfn));
+ PCI_BUS(devbusfn),
+ PCI_DEV(devbusfn),
+ PCI_FUNC(devbusfn));
/* Enable I/O decoding as well, PCI viudeo boards
* support I/O accesses, but they provide no
* bar register for this since the ports are fixed.
*/
- pci_write_config_word(devbusfn, PCI_COMMAND, PCI_COMMAND_MEMORY | PCI_COMMAND_IO | PCI_COMMAND_MASTER);
+ pci_write_config_word(devbusfn,
+ PCI_COMMAND,
+ PCI_COMMAND_MEMORY |
+ PCI_COMMAND_IO |
+ PCI_COMMAND_MASTER);
/* Test the ROM decoder, do the device support a rom? */
pci_read_config_dword(devbusfn, PCI_ROM_ADDRESS, &old);
- pci_write_config_dword(devbusfn, PCI_ROM_ADDRESS, (u32)PCI_ROM_ADDRESS_MASK);
+ pci_write_config_dword(devbusfn, PCI_ROM_ADDRESS,
+ (u32)PCI_ROM_ADDRESS_MASK);
pci_read_config_dword(devbusfn, PCI_ROM_ADDRESS, &addr);
pci_write_config_dword(devbusfn, PCI_ROM_ADDRESS, old);
}
/* device have a rom */
- if (pci_shadow_rom(devbusfn, (void*)0xc0000)) {
+ if (pci_shadow_rom(devbusfn, (void *)0xc0000)) {
printf("Shadowing of PCI VGA BIOS failed\n");
return 0;
}
/* Now enable lagacy VGA port access */
- if (pci_enable_legacy_video_ports(pci_bus_to_hose(PCI_BUS(devbusfn)))) {
+ hose = pci_bus_to_hose(PCI_BUS(devbusfn));
+ if (pci_enable_legacy_video_ports(hose)) {
printf("PCI VGA enable failed\n");
return 0;
}
/* return the pci device info, that we'll need later */
return PCI_BUS(devbusfn) << 8 |
- PCI_DEV(devbusfn) << 3 | (PCI_FUNC(devbusfn)&7);
+ PCI_DEV(devbusfn) << 3 | (PCI_FUNC(devbusfn) & 7);
}
return 0;
u32 ptr;
char *buf;
- if (0 == (ptr = isa_map_rom(0xc0000, 0x8000))) {
+ ptr = isa_map_rom(0xc0000, 0x8000);
+
+ if (!ptr)
return -1;
- }
- if (NULL == (buf=malloc(0x8000))) {
+
+ buf = malloc(0x8000);
+ if (!buf) {
isa_unmap_rom(ptr);
return -1;
}
+
if (readw(ptr) != 0xaa55) {
free(buf);
isa_unmap_rom(ptr);
}
/* shadow the rom */
- memcpy(buf, (void*)ptr, 0x8000);
+ memcpy(buf, (void *)ptr, 0x8000);
isa_unmap_rom(ptr);
- memcpy((void*)0xc0000, buf, 0x8000);
+ memcpy((void *)0xc0000, buf, 0x8000);
free(buf);
int video_bios_init(void)
{
struct pt_regs regs;
+ int size;
+ int i;
+ u8 sum;
/* clear the video bios area in case we warmbooted */
- memset((void*)0xc0000, 0, 0x8000);
+ memset((void *)0xc0000, 0, 0x8000);
memset(®s, 0, sizeof(struct pt_regs));
- if (probe_isa_video()) {
+ if (probe_isa_video())
/* No ISA board found, try the PCI bus */
regs.eax = probe_pci_video();
- }
/* Did we succeed in mapping any video bios */
if (readw(0xc0000) == 0xaa55) {
- int size;
- int i;
- u8 sum;
-
PRINTF("Found video bios signature\n");
- size = 512*readb(0xc0002);
+ size = readb(0xc0002) * 512;
PRINTF("size %d\n", size);
- sum=0;
- for (i=0;i<size;i++) {
+ sum = 0;
+
+ for (i = 0; i < size; i++)
sum += readb(0xc0000 + i);
- }
- PRINTF("Checksum is %sOK\n",sum?"NOT ":"");
- if (sum) {
+
+ PRINTF("Checksum is %sOK\n", sum ? "NOT " : "");
+
+ if (sum)
return 1;
- }
- /* some video bioses (ATI Mach64) seem to think that
+ /*
+ * Some video bioses (ATI Mach64) seem to think that
* the original int 10 handler is always at
* 0xf000:0xf065 , place an iret instruction there
*/
regs.esp = 0x8000;
regs.xss = 0x2000;
enter_realmode(0xc000, 3, ®s, ®s);
+
PRINTF("INT 0x10 vector after: %04x:%04x\n",
readw(0x42), readw(0x40));
- PRINTF("BIOS returned %scarry\n", regs.eflags & 1?"":"NOT ");
+ PRINTF("BIOS returned %scarry\n",
+ regs.eflags & 0x00000001 ? "" : "NOT ");
#ifdef PCI_BIOS_DEBUG
print_bios_bios_stat();
#endif
- return (regs.eflags & 1);
+ return regs.eflags & 0x00000001;
}
* 0x8000-0x8FFF Stack and heap
* 0x9000-0x90FF Kernel command line
*/
-#define DEFAULT_SETUP_BASE 0x90000
-#define COMMAND_LINE_OFFSET 0x9000
-#define HEAP_END_OFFSET 0x8e00
+#define DEFAULT_SETUP_BASE 0x90000
+#define COMMAND_LINE_OFFSET 0x9000
+#define HEAP_END_OFFSET 0x8e00
-#define COMMAND_LINE_SIZE 2048
+#define COMMAND_LINE_SIZE 2048
static void build_command_line(char *command_line, int auto_boot)
{
env_command_line = getenv("bootargs");
/* set console= argument if we use a serial console */
- if (NULL == strstr(env_command_line, "console=")) {
- if (0==strcmp(getenv("stdout"), "serial")) {
+ if (!strstr(env_command_line, "console=")) {
+ if (!strcmp(getenv("stdout"), "serial")) {
/* We seem to use serial console */
sprintf(command_line, "console=ttyS0,%s ",
- getenv("baudrate"));
+ getenv("baudrate"));
}
}
- if (auto_boot) {
+ if (auto_boot)
strcat(command_line, "auto ");
- }
- if (NULL != env_command_line) {
+ if (env_command_line)
strcat(command_line, env_command_line);
- }
-
printf("Kernel command line: \"%s\"\n", command_line);
}
int bootproto;
int big_image;
void *load_address;
+ struct setup_header *hdr;
- struct setup_header *hdr = (struct setup_header *)(image + SETUP_SECTS_OFF);
+ hdr = (struct setup_header *)(image + SETUP_SECTS_OFF);
- setup_base = (void*)DEFAULT_SETUP_BASE; /* base address for real-mode segment */
+ /* base address for real-mode segment */
+ setup_base = (void *)DEFAULT_SETUP_BASE;
if (KERNEL_MAGIC != hdr->boot_flag) {
printf("Error: Invalid Boot Flag (found 0x%04x, expected 0x%04x)\n",
- hdr->boot_flag, KERNEL_MAGIC);
+ hdr->boot_flag, KERNEL_MAGIC);
return 0;
} else {
printf("Valid Boot Flag\n");
printf("Setup Size = 0x%8.8lx\n", (ulong)setup_size);
- if (setup_size > SETUP_MAX_SIZE) {
+ if (setup_size > SETUP_MAX_SIZE)
printf("Error: Setup is too large (%d bytes)\n", setup_size);
- }
/* Determine image type */
- big_image = (bootproto >= 0x0200) && (hdr->loadflags & BIG_KERNEL_FLAG);
+ big_image = (bootproto >= 0x0200) &&
+ (hdr->loadflags & BIG_KERNEL_FLAG);
/* Determine load address */
- load_address = (void*)(big_image ? BZIMAGE_LOAD_ADDR : ZIMAGE_LOAD_ADDR);
+ load_address = (void *)(big_image ?
+ BZIMAGE_LOAD_ADDR :
+ ZIMAGE_LOAD_ADDR);
/* load setup */
- printf("Moving Real-Mode Code to 0x%8.8lx (%d bytes)\n", (ulong)setup_base, setup_size);
+ printf("Moving Real-Mode Code to 0x%8.8lx (%d bytes)\n",
+ (ulong)setup_base, setup_size);
memmove(setup_base, image, setup_size);
printf("Using boot protocol version %x.%02x\n",
(bootproto & 0xff00) >> 8, bootproto & 0xff);
if (bootproto == 0x0100) {
+ *(u16 *)(setup_base + CMD_LINE_MAGIC_OFF) = COMMAND_LINE_MAGIC;
+ *(u16 *)(setup_base + CMD_LINE_OFFSET_OFF) = COMMAND_LINE_OFFSET;
- *(u16*)(setup_base + CMD_LINE_MAGIC_OFF) = COMMAND_LINE_MAGIC;
- *(u16*)(setup_base + CMD_LINE_OFFSET_OFF) = COMMAND_LINE_OFFSET;
-
- /* A very old kernel MUST have its real-mode code
- * loaded at 0x90000 */
-
+ /*
+ * A very old kernel MUST have its real-mode code
+ * loaded at 0x90000
+ */
if ((u32)setup_base != 0x90000) {
/* Copy the real-mode kernel */
- memmove((void*)0x90000, setup_base, setup_size);
+ memmove((void *)0x90000, setup_base, setup_size);
+
/* Copy the command line */
- memmove((void*)0x99000, setup_base+COMMAND_LINE_OFFSET,
- COMMAND_LINE_SIZE);
+ memmove((void *)0x99000,
+ setup_base + COMMAND_LINE_OFFSET,
+ COMMAND_LINE_SIZE);
- setup_base = (void*)0x90000; /* Relocated */
+ /* Relocated */
+ setup_base = (void *)0x90000;
}
/* It is recommended to clear memory up to the 32K mark */
- memset((void*)0x90000 + setup_size, 0, SETUP_MAX_SIZE-setup_size);
+ memset((void *)0x90000 + setup_size, 0,
+ SETUP_MAX_SIZE-setup_size);
}
/* We are now setting up the real-mode version of the header */
hdr->type_of_loader = 8;
if (hdr->setup_sects >= 15)
- printf("Linux kernel version %s\n", (char *)
- (setup_base + (hdr->kernel_version + 0x200)));
+ printf("Linux kernel version %s\n",
+ (char *)(setup_base +
+ (hdr->kernel_version + 0x200)));
else
printf("Setup Sectors < 15 - Cannot print kernel version.\n");
hdr->cmd_line_ptr = (u32)setup_base + COMMAND_LINE_OFFSET;
} else if (bootproto >= 0x0200) {
- *(u16*)(setup_base + CMD_LINE_MAGIC_OFF) = COMMAND_LINE_MAGIC;
- *(u16*)(setup_base + CMD_LINE_OFFSET_OFF) = COMMAND_LINE_OFFSET;
+ *(u16 *)(setup_base + CMD_LINE_MAGIC_OFF) = COMMAND_LINE_MAGIC;
+ *(u16 *)(setup_base + CMD_LINE_OFFSET_OFF) = COMMAND_LINE_OFFSET;
hdr->setup_move_size = 0x9100;
}
/* build command line at COMMAND_LINE_OFFSET */
build_command_line(setup_base + COMMAND_LINE_OFFSET, auto_boot);
- printf("Loading %czImage at address 0x%08x (%ld bytes)\n", big_image ? 'b' : ' ',
- (u32)load_address, kernel_size);
+ printf("Loading %czImage at address 0x%08x (%ld bytes)\n",
+ big_image ? 'b' : ' ', (u32)load_address, kernel_size);
memmove(load_address, image + setup_size, kernel_size);
regs.xss = regs.xds;
regs.esp = 0x9000;
regs.eflags = 0;
- enter_realmode(((u32)setup_base+SETUP_START_OFFSET)>>4, 0, ®s, ®s);
+ enter_realmode(((u32)setup_base+SETUP_START_OFFSET)>>4, 0, ®s,
+ ®s);
}
-int do_zboot (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_zboot(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
{
void *base_ptr;
void *bzImage_addr = NULL;
bzImage_size = simple_strtoul(argv[2], NULL, 16);
/* Lets look for*/
- base_ptr = load_zimage (bzImage_addr, bzImage_size, 0, 0, 0);
+ base_ptr = load_zimage(bzImage_addr, bzImage_size, 0, 0, 0);
- if (NULL == base_ptr) {
- printf ("## Kernel loading failed ...\n");
+ if (!base_ptr) {
+ printf("## Kernel loading failed ...\n");
} else {
- printf ("## Transferring control to Linux (at address %08x) ...\n",
+ printf("## Transferring control to Linux (at address %08x) ...\n",
(u32)base_ptr);
/* we assume that the kernel is in place */
projects / karo-tx-uboot.git / commitdiff