vbatts/grub
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

2005-08-21 Vincent Pelletier <subdino2004@yahoo.fr>

Browse source 
* configure.ac: Add support for sparc64 host with ieee1275
        firmware.
        * configure: Generated from configure.ac.
        * disk/ieee1275/ofdisk.c (grub_ofdisk_open): Use grub_ssize_t
        instead of int.
        (grub_ofdisk_read): Likewise.
        (grub_ofdisk_open): Use %p to print pointer values, and cast the
        pointers as (void *) to remove a warning.
        (grub_ofdisk_close): Likewise.
        (grub_ofdisk_read): Likewise.
        * kern/ieee1275/ieee1275.c (grub_ieee1275_exit): This never
        returns, so make it return void to remove a warning.
        * include/grub/ieee1275/ieee1275.h (grub_ieee1275_exit):
        Corresponding prototype change.
        * kern/mm.c (grub_mm_init_region): Use %p to print pointer
        values, and cast the pointers as (void *) to remove a warning.
        (grub_mm_dump): Likewise.
        * conf/sparc64-ieee1275.mk: New file.
        * conf/sparc64-ieee1275.rmk: Likewise.
        * include/grub/sparc64/setjmp.h: Likewise.
        * include/grub/sparc64/types.h: Likewise.
        * include/grub/sparc64/ieee1275/console.h: Likewise.
        * include/grub/sparc64/ieee1275/ieee1275.h: Likewise.
        * include/grub/sparc64/ieee1275/kernel.h: Likewise.
        * include/grub/sparc64/ieee1275/time.h: Likewise.
        * kern/sparc64/cache.c: Likewise.
        * kern/sparc64/dl.c: Likewise.
        * kern/sparc64/ieee1275/init.c: Likewise.
        * kern/sparc64/ieee1275/openfw.c: Likewise.
This commit is contained in:
subdino 2005-08-21 18:42:55 +00:00
parent 385c6a92a3
commit e9211b5d32
19 changed files with 1615 additions and 13 deletions
Download patch file Download diff file Expand all files Collapse all files

2
kern/ieee1275/ieee1275.c
View file

@ -393,7 +393,7 @@ grub_ieee1275_enter (void)
return 0;
}
int
void
grub_ieee1275_exit (void)
{
struct exit_args

6
kern/mm.c
View file

@ -137,7 +137,7 @@ grub_mm_init_region (void *addr, grub_size_t size)
grub_mm_header_t h;
grub_mm_region_t r, *p, q;
grub_dprintf ("mem", "Using memory for heap: addr=%p, size=%u\n", addr, size);
grub_dprintf ("mem", "Using memory for heap: addr=%p, size=%u\n", addr, (unsigned int) size);
/* If this region is too small, ignore it. */
if (size < GRUB_MM_ALIGN * 2)
@ -408,10 +408,10 @@ grub_mm_dump (unsigned lineno)
{
case GRUB_MM_FREE_MAGIC:
grub_printf ("F:%p:%u:%p\n",
p, p->size << GRUB_MM_ALIGN_LOG2, p->next);
p, (unsigned int) p->size << GRUB_MM_ALIGN_LOG2, p->next);
break;
case GRUB_MM_ALLOC_MAGIC:
grub_printf ("A:%p:%u\n", p, p->size << GRUB_MM_ALIGN_LOG2);
grub_printf ("A:%p:%u\n", p, (unsigned int) p->size << GRUB_MM_ALIGN_LOG2);
break;
}
}

9
kern/sparc64/cache.c Normal file
View file

@ -0,0 +1,9 @@
#include <grub/types.h>
void grub_arch_sync_caches(void *address __attribute__((unused)),
grub_size_t len __attribute__((unused)));
void grub_arch_sync_caches(void *address __attribute__((unused)),
grub_size_t len __attribute__((unused)))
{
return;
}

139
kern/sparc64/dl.c Normal file
View file

@ -0,0 +1,139 @@
/* dl.c - arch-dependent part of loadable module support */
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2002, 2004, 2005 Free Software Foundation, Inc.
*
* GRUB is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GRUB; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <grub/dl.h>
#include <grub/elf.h>
#include <grub/misc.h>
#include <grub/err.h>
/* Check if EHDR is a valid ELF header. */
grub_err_t
grub_arch_dl_check_header (void *ehdr)
{
Elf64_Ehdr *e = ehdr;
/* Check the magic numbers. */
if (e->e_ident[EI_CLASS] != ELFCLASS32
|| e->e_ident[EI_DATA] != ELFDATA2MSB
|| e->e_machine != EM_PPC)
return grub_error (GRUB_ERR_BAD_OS, "invalid arch specific ELF magic");
return GRUB_ERR_NONE;
}
/* Relocate symbols. */
grub_err_t
grub_arch_dl_relocate_symbols (grub_dl_t mod, void *ehdr)
{
Elf64_Ehdr *e = ehdr;
Elf64_Shdr *s;
Elf64_Sym *symtab;
Elf64_Word entsize;
unsigned i;
/* Find a symbol table. */
for (i = 0, s = (Elf64_Shdr *) ((char *) e + e->e_shoff);
i < e->e_shnum;
i++, s = (Elf64_Shdr *) ((char *) s + e->e_shentsize))
if (s->sh_type == SHT_SYMTAB)
break;
if (i == e->e_shnum)
return grub_error (GRUB_ERR_BAD_MODULE, "no symtab found");
symtab = (Elf64_Sym *) ((char *) e + s->sh_offset);
entsize = s->sh_entsize;
for (i = 0, s = (Elf64_Shdr *) ((char *) e + e->e_shoff);
i < e->e_shnum;
i++, s = (Elf64_Shdr *) ((char *) s + e->e_shentsize))
if (s->sh_type == SHT_RELA)
{
grub_dl_segment_t seg;
/* Find the target segment. */
for (seg = mod->segment; seg; seg = seg->next)
if (seg->section == s->sh_info)
break;
if (seg)
{
Elf64_Rela *rel, *max;
for (rel = (Elf64_Rela *) ((char *) e + s->sh_offset),
max = rel + s->sh_size / s->sh_entsize;
rel < max;
rel++)
{
Elf64_Xword *addr;
Elf64_Sym *sym;
grub_uint64_t value;
if (seg->size < rel->r_offset)
return grub_error (GRUB_ERR_BAD_MODULE,
"reloc offset is out of the segment");
addr = (Elf64_Xword *) ((char *) seg->addr + rel->r_offset);
sym = (Elf64_Sym *) ((char *) symtab
+ entsize * ELF32_R_SYM (rel->r_info));
/* On the PPC the value does not have an explicit
addend, add it. */
value = sym->st_value + rel->r_addend;
switch (ELF32_R_TYPE (rel->r_info))
{
case R_PPC_ADDR16_LO:
*(Elf64_Half *) addr = value;
break;
case R_PPC_REL24:
{
Elf64_Sxword delta = value - (Elf64_Xword) addr;
if (delta << 6 >> 6 != delta)
return grub_error (GRUB_ERR_BAD_MODULE, "Relocation overflow");
*addr = (*addr & 0xfc000003) | (delta & 0x3fffffc);
break;
}
case R_PPC_ADDR16_HA:
*(Elf64_Half *) addr = (value + 0x8000) >> 16;
break;
case R_PPC_ADDR32:
*addr = value;
break;
case R_PPC_REL32:
*addr = value - (Elf64_Xword) addr;
break;
default:
return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
"This relocation (%d) is not implemented yet",
ELF32_R_TYPE (rel->r_info));
}
}
}
}
return GRUB_ERR_NONE;
}

238
kern/sparc64/ieee1275/init.c Normal file
View file

@ -0,0 +1,238 @@
/* init.c -- Initialize GRUB on the Ultra Sprac (sparc64). */
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <grub/kernel.h>
#include <grub/dl.h>
#include <grub/disk.h>
#include <grub/mm.h>
#include <grub/partition.h>
#include <grub/normal.h>
#include <grub/fs.h>
#include <grub/setjmp.h>
#include <grub/env.h>
#include <grub/misc.h>
#include <grub/machine/console.h>
#include <grub/machine/time.h>
#include <grub/machine/kernel.h>
#include <grub/ieee1275/ofdisk.h>
#include <grub/ieee1275/ieee1275.h>
/* OpenBoot entry point. */
int (*grub_ieee1275_entry_fn) (void *);
grub_ieee1275_phandle_t grub_ieee1275_chosen;
static grub_uint32_t grub_ieee1275_flags;
/* FIXME (sparc64). */
static const grub_addr_t grub_heap_start = 0x40000;
static grub_addr_t grub_heap_len;
void
_start (uint64_t r0 __attribute__((unused)),
uint64_t r1 __attribute__((unused)),
uint64_t r2 __attribute__((unused)),
uint64_t r3 __attribute__((unused)),
uint64_t r4,
uint64_t r5 __attribute__((unused)));
void
_start (uint64_t r0 __attribute__((unused)),
uint64_t r1 __attribute__((unused)),
uint64_t r2 __attribute__((unused)),
uint64_t r3 __attribute__((unused)),
uint64_t r4,
uint64_t r5 __attribute__((unused)))
{
grub_ieee1275_entry_fn = (int (*)(void *)) r4;
grub_ieee1275_finddevice ("/chosen", &grub_ieee1275_chosen);
/* Now invoke the main function. */
grub_main ();
/* Never reached. */
}
int
grub_ieee1275_test_flag (enum grub_ieee1275_flag flag)
{
return (grub_ieee1275_flags & (1 << flag));
}
void
grub_ieee1275_set_flag (enum grub_ieee1275_flag flag)
{
grub_ieee1275_flags |= (1 << flag);
}
void
abort (void)
{
/* Trap to Open Firmware. */
grub_ieee1275_enter ();
}
/* Translate an OF filesystem path (separated by backslashes), into a GRUB
path (separated by forward slashes). */
static void
grub_translate_ieee1275_path (char *filepath)
{
char *backslash;
backslash = grub_strchr (filepath, '\\');
while (backslash != 0)
{
*backslash = '/';
backslash = grub_strchr (filepath, '\\');
}
}
static void
grub_set_prefix (void)
{
char bootpath[64]; /* XXX check length */
char *filename;
char *prefix;
if (grub_ieee1275_get_property (grub_ieee1275_chosen, "bootpath", bootpath,
sizeof (bootpath), 0))
{
/* Should never happen. */
grub_printf ("/chosen/bootpath property missing!\n");
grub_env_set ("prefix", "");
return;
}
/* Transform an OF device path to a GRUB path. */
prefix = grub_ieee1275_encode_devname (bootpath);
filename = grub_ieee1275_get_filename (bootpath);
if (filename)
{
char *newprefix;
char *lastslash = grub_strrchr (filename, '\\');
/* Truncate at last directory. */
if (lastslash)
{
*lastslash = '\0';
grub_translate_ieee1275_path (filename);
newprefix = grub_malloc (grub_strlen (prefix)
+ grub_strlen (filename));
grub_sprintf (newprefix, "%s%s", prefix, filename);
grub_free (prefix);
prefix = newprefix;
}
}
grub_env_set ("prefix", prefix);
grub_free (filename);
grub_free (prefix);
}
void
grub_machine_init (void)
{
char *args;
grub_ssize_t length;
grub_console_init ();
/* FIXME (sparc64). */
grub_heap_len = (grub_addr_t) &_start - 0x1000 - grub_heap_start;
if (grub_ieee1275_claim (grub_heap_start, grub_heap_len, 0, 0))
grub_fatal ("Failed to claim heap at %p, len 0x%x\n", grub_heap_start,
grub_heap_len);
grub_mm_init_region ((void *) grub_heap_start, grub_heap_len);
grub_set_prefix ();
grub_ofdisk_init ();
/* Process commandline. */
if (grub_ieee1275_get_property_length (grub_ieee1275_chosen, "bootargs",
&length) == 0 &&
length > 0)
{
grub_ssize_t i = 0;
args = grub_malloc (length);
grub_ieee1275_get_property (grub_ieee1275_chosen, "bootargs", args,
length, 0);
while (i < length)
{
char *command = &args[i];
char *end;
char *val;
end = grub_strchr (command, ';');
if (end == 0)
i = length; /* No more commands after this one. */
else
{
*end = '\0';
i += end - command + 1;
while (grub_isspace(args[i]))
i++;
}
/* Process command. */
val = grub_strchr (command, '=');
if (val)
{
*val = '\0';
grub_env_set (command, val + 1);
}
}
}
}
void
grub_machine_fini (void)
{
grub_ofdisk_fini ();
grub_console_fini ();
}
void
grub_stop (void)
{
grub_ieee1275_exit ();
}
grub_uint32_t
grub_get_rtc (void)
{
grub_uint32_t msecs;
if (grub_ieee1275_milliseconds (&msecs))
return 0;
return msecs;
}
grub_addr_t
grub_arch_modules_addr (void)
{
return GRUB_IEEE1275_MODULE_BASE;
}

374
kern/sparc64/ieee1275/openfw.c Normal file
View file

@ -0,0 +1,374 @@
/* openfw.c -- Open firmware support funtions. */
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2003, 2004, 2005 Free Software Foundation, Inc.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <grub/err.h>
#include <grub/misc.h>
#include <grub/mm.h>
#include <grub/machine/kernel.h> /* Needed ? */
#include <grub/ieee1275/ieee1275.h>
enum grub_ieee1275_parse_type
{
GRUB_PARSE_FILENAME,
GRUB_PARSE_PARTITION,
};
/* Walk children of 'devpath', calling hook for each. */
grub_err_t
grub_children_iterate (char *devpath,
int (*hook) (struct grub_ieee1275_devalias *alias))
{
grub_ieee1275_phandle_t dev;
grub_ieee1275_phandle_t child;
grub_ieee1275_finddevice (devpath, &dev);
if (((signed) dev) == -1)
return grub_error (GRUB_ERR_UNKNOWN_DEVICE, "Unknown device");
grub_ieee1275_child (dev, &child);
if (((signed) child) == -1)
return grub_error (GRUB_ERR_BAD_DEVICE, "Device has no children");
do
{
/* XXX: Don't use hardcoded path lengths. */
char childtype[64];
char childpath[64];
char childname[64];
char fullname[64];
struct grub_ieee1275_devalias alias;
grub_ssize_t actual;
grub_ieee1275_get_property (child, "device_type", childtype,
sizeof childtype, &actual);
if (actual == -1)
continue;
grub_ieee1275_package_to_path (child, childpath, sizeof childpath,
&actual);
if (actual == -1)
continue;
grub_ieee1275_get_property (child, "name", childname,
sizeof childname, &actual);
if (actual == -1)
continue;
grub_sprintf (fullname, "%s/%s", devpath, childname);
alias.type = childtype;
alias.path = childpath;
alias.name = fullname;
hook (&alias);
}
while (grub_ieee1275_peer (child, &child));
return 0;
}
/* Iterate through all device aliases. This function can be used to
find a device of a specific type. */
grub_err_t
grub_devalias_iterate (int (*hook) (struct grub_ieee1275_devalias *alias))
{
grub_ieee1275_phandle_t devalias;
char aliasname[32];
grub_ssize_t actual;
grub_ieee1275_cell_t flags;
struct grub_ieee1275_devalias alias;
if (grub_ieee1275_finddevice ("/aliases", &devalias))
return -1;
aliasname[0] = '\0';
while (grub_ieee1275_next_property (devalias, aliasname, aliasname, &flags) != -1
&& ((signed) flags) != -1 )
{
grub_ieee1275_phandle_t dev;
grub_ssize_t pathlen, typelen;
char *devpath, *devtype;
grub_dprintf ("devalias", "devalias name = %s\n", aliasname);
/* The property `name' is a special case we should skip. */
if (!grub_strcmp (aliasname, "name"))
continue;
grub_ieee1275_get_property_length (devalias, aliasname, &pathlen);
devpath = grub_malloc (pathlen);
if (! devpath)
return grub_errno;
if (grub_ieee1275_get_property (devalias, aliasname, devpath, pathlen,
&actual))
{
grub_dprintf ("devalias", "get_property (%s) failed\n", aliasname);
grub_free (devpath);
continue;
}
if (grub_ieee1275_finddevice (devpath, &dev) || ((signed) dev) == -1)
{
grub_dprintf ("devalias", "finddevice (%s) failed\n", devpath);
grub_free (devpath);
continue;
}
grub_ieee1275_get_property_length (dev, "device_type", &typelen);
devtype = grub_malloc (typelen);
if (! devtype)
{
grub_free (devpath);
return grub_errno;
}
if (grub_ieee1275_get_property (dev, "device_type", devtype, typelen, &actual))
{
grub_dprintf ("devalias", "get device type failed\n");
grub_free (devtype);
grub_free (devpath);
continue;
}
alias.name = aliasname;
alias.path= devpath;
alias.type = devtype;
if((*hook) (&alias))
{
grub_free (devtype);
grub_free (devpath);
break;
}
grub_free (devtype);
grub_free (devpath);
}
return 0;
}
/* FIXME (sparc64) */
#if 0
/* Call the "map" method of /chosen/mmu. */
static int
grub_map (grub_addr_t phys, grub_addr_t virt, grub_uint32_t size,
grub_uint8_t mode)
{
struct map_args {
struct grub_ieee1275_common_hdr common;
char *method;
grub_ieee1275_ihandle_t ihandle;
grub_uint32_t mode;
grub_uint32_t size;
grub_uint32_t virt;
grub_uint32_t phys;
int catch_result;
} args;
grub_ieee1275_ihandle_t mmu;
grub_ssize_t len;
grub_ieee1275_get_property (grub_ieee1275_chosen, "mmu", &mmu, sizeof mmu,
&len);
if (len != sizeof mmu)
return -1;
INIT_IEEE1275_COMMON (&args.common, "call-method", 6, 1);
args.method = "map";
args.ihandle = mmu;
args.phys = phys;
args.virt = virt;
args.size = size;
args.mode = mode; /* Format is WIMG0PP. */
if (IEEE1275_CALL_ENTRY_FN (&args) == -1)
return -1;
return args.catch_result;
}
#endif
int
grub_claimmap (grub_addr_t addr, grub_size_t size)
{
if (grub_ieee1275_claim (addr, size, 0, 0))
return -1;
return 0;
}
/* Get the device arguments of the Open Firmware node name `path'. */
static char *
grub_ieee1275_get_devargs (const char *path)
{
char *colon = grub_strchr (path, ':');
if (! colon)
return 0;
return grub_strdup (colon + 1);
}
/* Get the device path of the Open Firmware node name `path'. */
static char *
grub_ieee1275_get_devname (const char *path)
{
char *colon = grub_strchr (path, ':');
char *newpath = 0;
int pathlen = grub_strlen (path);
auto int match_alias (struct grub_ieee1275_devalias *alias);
int match_alias (struct grub_ieee1275_devalias *curalias)
{
/* briQ firmware can change capitalization in /chosen/bootpath. */
if (! grub_strncasecmp (curalias->path, path, pathlen))
{
newpath = grub_strndup (curalias->name, grub_strlen (curalias->name));
return 1;
}
return 0;
}
if (colon)
pathlen = (int)(colon - path);
/* Try to find an alias for this device. */
grub_devalias_iterate (match_alias);
if (! newpath)
newpath = grub_strdup (path);
return newpath;
}
static char *
grub_ieee1275_parse_args (const char *path, enum grub_ieee1275_parse_type ptype)
{
char type[64]; /* XXX check size. */
char *device = grub_ieee1275_get_devname (path);
char *args = grub_ieee1275_get_devargs (path);
char *ret = 0;
grub_ieee1275_phandle_t dev;
if (!args)
/* Shouldn't happen. */
return 0;
/* We need to know what type of device it is in order to parse the full
file path properly. */
if (grub_ieee1275_finddevice (device, &dev))
{
grub_error (GRUB_ERR_UNKNOWN_DEVICE, "Device %s not found\n", device);
goto fail;
}
if (grub_ieee1275_get_property (dev, "device_type", type, sizeof type, 0))
{
grub_error (GRUB_ERR_UNKNOWN_DEVICE,
"Device %s lacks a device_type property\n", device);
goto fail;
}
if (!grub_strcmp ("block", type))
{
/* The syntax of the device arguments is defined in the CHRP and PReP
IEEE1275 bindings: "[partition][,[filename]]". */
char *comma = grub_strchr (args, ',');
if (ptype == GRUB_PARSE_FILENAME)
{
if (comma)
{
char *filepath = comma + 1;
ret = grub_malloc (grub_strlen (filepath) + 1);
/* Make sure filepath has leading backslash. */
if (filepath[0] != '\\')
grub_sprintf (ret, "\\%s", filepath);
else
grub_strcpy (ret, filepath);
}
}
else if (ptype == GRUB_PARSE_PARTITION)
{
if (!comma)
ret = grub_strdup (args);
else
ret = grub_strndup (args, (grub_size_t)(comma - args));
}
}
else
{
/* XXX Handle net devices by configuring & registering a grub_net_dev
here, then return its name?
Example path: "net:<server ip>,<file name>,<client ip>,<gateway
ip>,<bootp retries>,<tftp retries>". */
grub_printf ("Unsupported type %s for device %s\n", type, device);
}
fail:
grub_free (device);
grub_free (args);
return ret;
}
char *
grub_ieee1275_get_filename (const char *path)
{
return grub_ieee1275_parse_args (path, GRUB_PARSE_FILENAME);
}
/* Convert a device name from IEEE1275 syntax to GRUB syntax. */
char *
grub_ieee1275_encode_devname (const char *path)
{
char *device = grub_ieee1275_get_devname (path);
char *partition = grub_ieee1275_parse_args (path, GRUB_PARSE_PARTITION);
char *encoding;
if (partition)
{
unsigned int partno = grub_strtoul (partition, 0, 0);
/* Assume partno will require less than five bytes to encode. */
encoding = grub_malloc (grub_strlen (device) + 3 + 5);
grub_sprintf (encoding, "(%s,%d)", device, partno);
}
else
{
encoding = grub_malloc (grub_strlen (device) + 2);
grub_sprintf (encoding, "(%s)", device);
}
grub_free (partition);
grub_free (device);
return encoding;
}
void
grub_reboot (void)
{
grub_ieee1275_interpret ("reset-all", 0);
}
void
grub_halt (void)
{
grub_ieee1275_interpret ("power-off", 0);
}