automake commit without merge history

grub-core/Makefile.am

@@ -0,0 +1,155 @@
+AUTOMAKE_OPTIONS = subdir-objects
+SUBDIRS = po
+DEPDIR = .deps-core
+
+include $(top_srcdir)/Makefile.extra-dist
+include $(top_srcdir)/Makefile.vars
+
+LDADD_KERNEL = -lgcc
+CFLAGS_KERNEL = $(TARGET_CFLAGS) $(CFLAGS_CPU) $(CFLAGS_PLATFORM) -ffreestanding
+LDFLAGS_KERNEL = $(TARGET_LDFLAGS) $(LDFLAGS_CPU) $(LDFLAGS_PLATFORM) -nostdlib -Wl,-N -static-libgcc
+CPPFLAGS_KERNEL = $(TARGET_CPPFLAGS) $(CPPFLAGS_CPU) $(CPPFLAGS_PLATFORM)
+CCASFLAGS_KERNEL = $(TARGET_CCASFLAGS) $(CCASFLAGS_CPU) $(CCASFLAGS_PLATFORM)
+
+CFLAGS_MODULE = $(TARGET_CFLAGS) $(CFLAGS_CPU) $(CFLAGS_PLATFORM) -ffreestanding
+LDFLAGS_MODULE = $(TARGET_LDFLAGS) $(LDFLAGS_CPU) $(LDFLAGS_PLATFORM) -nostdlib -Wl,-N,-r,-d
+CPPFLAGS_MODULE = $(TARGET_CPPFLAGS) $(CPPFLAGS_CPU) $(CPPFLAGS_PLATFORM)
+CCASFLAGS_MODULE = $(TARGET_CCASFLAGS) $(CCASFLAGS_CPU) $(CCASFLAGS_PLATFORM)
+
+CFLAGS_IMAGE = $(TARGET_CFLAGS) $(CFLAGS_CPU) $(CFLAGS_PLATFORM) -fno-builtin
+LDFLAGS_IMAGE = $(TARGET_LDFLAGS) $(LDFLAGS_CPU) $(LDFLAGS_PLATFORM) -nostdlib -Wl,-N,-S
+CPPFLAGS_IMAGE = $(TARGET_CPPFLAGS) $(CPPFLAGS_CPU) $(CPPFLAGS_PLATFORM)
+CCASFLAGS_IMAGE = $(TARGET_CCASFLAGS) $(CCASFLAGS_CPU) $(CCASFLAGS_PLATFORM)
+
+CFLAGS_LIBRARY = $(TARGET_CFLAGS) $(CFLAGS_CPU) $(CFLAGS_PLATFORM) -fno-builtin
+CPPFLAGS_LIBRARY = $(TARGET_CPPFLAGS) $(CPPFLAGS_CPU) $(CPPFLAGS_PLATFORM)
+CCASFLAGS_LIBRARY = $(TARGET_CCASFLAGS) $(CCASFLAGS_CPU) $(CCASFLAGS_PLATFORM)
+
+CFLAGS_PROGRAM = $(TARGET_CFLAGS) $(CFLAGS_CPU) $(CFLAGS_PLATFORM)
+LDFLAGS_PROGRAM = $(TARGET_LDFLAGS) $(LDFLAGS_CPU) $(LDFLAGS_PLATFORM)
+CPPFLAGS_PROGRAM = $(TARGET_CPPFLAGS) $(CPPFLAGS_CPU) $(CPPFLAGS_PLATFORM)
+CCASFLAGS_PROGRAM = $(TARGET_CCASFLAGS) $(CCASFLAGS_CPU) $(CCASFLAGS_PLATFORM)
+
+AM_CFLAGS = 
+AM_LDFLAGS =
+AM_CPPFLAGS = $(CPPFLAGS_GRUB) -DGRUB_FILE=\"$(subst $(top_srcdir)/,,$<)\"
+AM_CCASFLAGS = -DASM_FILE=1
+
+# gentrigtables
+gentrigtables: $(top_srcdir)/gentrigtables.c
+	$(BUILD_CC) -o $@ -I$(top_srcdir)/include $(CPPFLAGS) -lm $<
+CLEANFILES += gentrigtables
+
+# trigtables.c
+trigtables.c: gentrigtables.c configure.ac
+	$(MAKE) $(AM_MAKEFLAGS) gentrigtables
+	$(top_builddir)/gentrigtables > $@
+CLEANFILES += trigtables.c
+
+# XXX Use Automake's LEX & YACC support
+# See Recording Dependencies Manually in automake doc for below rules
+script/sh_module-lexer.$(OBJEXT):grub_script.tab.h
+grub_script.tab.c grub_script.tab.h: $(top_srcdir)/script/parser.y
+	$(YACC) -d -p grub_script_yy -b grub_script $(top_srcdir)/script/parser.y
+CLEANFILES += grub_script.tab.c grub_script.tab.h
+
+# For the lexer.
+# See Recording Dependencies Manually in automake doc for below rules
+script/sh_module-lexer.$(OBJEXT):grub_script.yy.h
+grub_script.yy.c grub_script.yy.h: $(top_srcdir)/script/yylex.l
+	$(LEX) -o grub_script.yy.c --header-file=grub_script.yy.h $(top_srcdir)/script/yylex.l
+CLEANFILES += grub_script.yy.c grub_script.yy.h
+
+include $(srcdir)/modules.am
+include $(srcdir)/Makefile.kernel
+
+# .lst files
+platform_DATA += moddep.lst
+platform_DATA += fs.lst
+platform_DATA += command.lst
+platform_DATA += partmap.lst
+platform_DATA += handler.lst
+platform_DATA += terminal.lst
+platform_DATA += parttool.lst
+platform_DATA += video.lst
+platform_DATA += crypto.lst
+CLEANFILES += moddep.lst
+CLEANFILES += fs.lst
+CLEANFILES += command.lst
+CLEANFILES += partmap.lst
+CLEANFILES += handler.lst
+CLEANFILES += terminal.lst
+CLEANFILES += parttool.lst
+CLEANFILES += video.lst
+CLEANFILES += crypto.lst
+
+fs.lst: $(FS_FILES)
+	cat $^ /dev/null | sort | uniq > $@
+command.lst: $(COMMAND_FILES)
+	cat $^ /dev/null | sort | uniq > $@
+partmap.lst: $(PARTMAP_FILES)
+	cat $^ /dev/null | sort | uniq > $@
+handler.lst: $(HANDLER_FILES)
+	cat $^ /dev/null | sort | uniq > $@
+terminal.lst: $(TERMINAL_FILES)
+	cat $^ /dev/null | sort | uniq > $@
+parttool.lst: $(PARTTOOL_FILES)
+	cat $^ /dev/null | sort | uniq > $@
+video.lst: $(VIDEO_FILES)
+	cat $^ /dev/null | sort | uniq > $@
+
+# but, crypto.lst is simply copied
+crypto.lst: $(top_srcdir)/lib/libgcrypt-grub/cipher/crypto.lst
+	cp $^ $@
+
+# generate global module dependencies list
+moddep.lst: kernel_syms.lst genmoddep.awk $(DEF_FILES) $(UND_FILES)
+	cat $(DEF_FILES) kernel_syms.lst /dev/null \
+	  | $(AWK) -f $(top_srcdir)/genmoddep.awk $(UND_FILES) > $@ \
+	  || (rm -f $@; exit 1)
+
+if COND_i386_pc
+if COND_ENABLE_EFIEMU
+efiemu32.o: efiemu/runtime/efiemu.c $(TARGET_OBJ2ELF)
+	-rm -f $@; \
+	if test "x$(TARGET_APPLE_CC)" = x1; then \
+	  $(TARGET_CC) $(DEFS) $(INCLUDES) $(CPPFLAGS_EFIEMU) $(CPPFLAGS_GRUB) -DELF32 -DAPPLE_CC -m32 -Wall -Werror -nostdlib -O2 -c -o $@.bin $< || exit 1; \
+	  $(OBJCONV) -felf32 -nu -nd $@.bin $@ || exit 1; \
+	  rm -f $@.bin; \
+	else \
+	  $(TARGET_CC) $(DEFS) $(INCLUDES) $(CPPFLAGS_EFIEMU) $(CPPFLAGS_GRUB) -DELF32 -m32 -Wall -Werror -nostdlib -O2 -c -o $@ $< || exit 1; \
+	  if test ! -z "$(TARGET_OBJ2ELF)"; then $(TARGET_OBJ2ELF) $@ || (rm -f $@; exit 1); fi; \
+	fi
+
+efiemu64_c.o: efiemu/runtime/efiemu.c
+	if test "x$(TARGET_APPLE_CC)" = x1; then \
+	  $(TARGET_CC) $(DEFS) $(INCLUDES) $(CPPFLAGS_EFIEMU) $(CPPFLAGS_GRUB) -DELF64 -DAPPLE_CC=1 -m64 -nostdlib -Wall -Werror -mno-red-zone -c -o $@ $< || exit 1; \
+	else \
+	  $(TARGET_CC) $(DEFS) $(INCLUDES) $(CPPFLAGS_EFIEMU) $(CPPFLAGS_GRUB) -DELF64 -m64 -nostdlib -Wall -Werror -O2 -mcmodel=large -mno-red-zone -c -o $@ $< || exit 1; \
+	fi
+
+efiemu64_s.o: efiemu/runtime/efiemu.S
+	-rm -f $@
+	if test "x$(TARGET_APPLE_CC)" = x1; then \
+	  $(TARGET_CC) $(DEFS) $(INCLUDES) $(CPPFLAGS_EFIEMU) $(CPPFLAGS_GRUB) -DELF64 -DAPPLE_CC=1 -m64 -Wall -Werror -nostdlib -O2 -mno-red-zone -c -o $@ $< || exit 1; \
+	else \
+	  $(TARGET_CC) $(DEFS) $(INCLUDES) $(CPPFLAGS_EFIEMU) $(CPPFLAGS_GRUB) -DELF64 -m64 -Wall -Werror -nostdlib -O2 -mcmodel=large -mno-red-zone -c -o $@ $< || exit 1; \
+	fi
+
+efiemu64.o: efiemu64_c.o efiemu64_s.o $(TARGET_OBJ2ELEF)
+	-rm -f $@; \
+	if test "x$(TARGET_APPLE_CC)" = x1; then \
+	  rm -f $@.bin; \
+	  $(TARGET_CC) -m64 -Wl,-r -nostdlib -o $@.bin $^ || exit 1; \
+	  $(OBJCONV) -felf64 -nu -nd $@.bin $@ || exit 1; \
+	  rm -f $@.bin; \
+	else \
+	  $(TARGET_CC) -m64 -nostdlib -Wl,-r -o $@ $^ || exit 1; \
+	  if test ! -z "$(TARGET_OBJ2ELF)"; then $(TARGET_OBJ2ELF) $@ || (rm -f $@; exit 1); fi; \
+	fi
+
+platform_DATA += efiemu32.o efiemu64.o
+CLEANFILES += efiemu32.o efiemu64.o efiemu64_c.o efiemu64_s.o
+endif
+endif
+

grub-core/Makefile.extra-dist

@@ -0,0 +1,53 @@
+#
+# Extra files that need to be distributed (in .tar.gz) to build
+# successfully on user site.
+#
+# XXX Remove wildcards;  See 27.3 in automake.info
+#
+
+EXTRA_DIST =
+
+EXTRA_DIST += gentpl.py
+EXTRA_DIST += Makefile.tpl
+EXTRA_DIST += modules.def
+
+EXTRA_DIST += gentrigtables.c
+
+EXTRA_DIST += genmoddep.awk
+EXTRA_DIST += genmodsrc.sh
+EXTRA_DIST += gensymlist.sh
+
+EXTRA_DIST += genemuinit.sh
+EXTRA_DIST += genemuinitheader.sh
+
+EXTRA_DIST += genfslist.sh
+EXTRA_DIST += gencmdlist.sh
+EXTRA_DIST += genvideolist.sh
+EXTRA_DIST += genhandlerlist.sh
+EXTRA_DIST += genpartmaplist.sh
+EXTRA_DIST += genparttoollist.sh
+EXTRA_DIST += genterminallist.sh
+EXTRA_DIST += lib/libgcrypt-grub/cipher/crypto.lst
+
+EXTRA_DIST += script/yylex.l
+EXTRA_DIST += script/parser.y
+
+EXTRA_DIST += lib/relocator.c
+
+EXTRA_DIST += efiemu/loadcore.c
+EXTRA_DIST += efiemu/prepare.c
+
+EXTRA_DIST += loader/machoXX.c
+
+
+EXTRA_DIST += kern/i386/loader.S
+EXTRA_DIST += kern/i386/realmode.S
+EXTRA_DIST += loader/i386/bsdXX.c
+EXTRA_DIST += loader/i386/bsd_pagetable.c
+EXTRA_DIST += loader/i386/multiboot_elfxx.c
+EXTRA_DIST += commands/search.c
+
+EXTRA_DIST += kern/i386/pc/lzma_decode.S
+
+EXTRA_DIST += $(shell find $(top_srcdir) -name '*.h')
+

grub-core/Makefile.kernel

@@ -0,0 +1,192 @@
+# -*- makefile -*-
+
+KERNEL_HEADER_FILES =
+KERNEL_HEADER_FILES += include/grub/cache.h
+KERNEL_HEADER_FILES += include/grub/command.h
+KERNEL_HEADER_FILES += include/grub/device.h
+KERNEL_HEADER_FILES += include/grub/disk.h
+KERNEL_HEADER_FILES += include/grub/dl.h
+KERNEL_HEADER_FILES += include/grub/elf.h
+KERNEL_HEADER_FILES += include/grub/elfload.h
+KERNEL_HEADER_FILES += include/grub/env.h
+KERNEL_HEADER_FILES += include/grub/env_private.h
+KERNEL_HEADER_FILES += include/grub/err.h
+KERNEL_HEADER_FILES += include/grub/file.h
+KERNEL_HEADER_FILES += include/grub/fs.h
+KERNEL_HEADER_FILES += include/grub/handler.h
+KERNEL_HEADER_FILES += include/grub/i18n.h
+KERNEL_HEADER_FILES += include/grub/kernel.h
+KERNEL_HEADER_FILES += include/grub/list.h
+KERNEL_HEADER_FILES += include/grub/misc.h
+KERNEL_HEADER_FILES += include/grub/mm.h
+KERNEL_HEADER_FILES += include/grub/net.h
+KERNEL_HEADER_FILES += include/grub/parser.h
+KERNEL_HEADER_FILES += include/grub/partition.h
+KERNEL_HEADER_FILES += include/grub/reader.h
+KERNEL_HEADER_FILES += include/grub/symbol.h
+KERNEL_HEADER_FILES += include/grub/term.h
+KERNEL_HEADER_FILES += include/grub/time.h
+KERNEL_HEADER_FILES += include/grub/types.h
+
+if COND_i386_pc
+KERNEL_HEADER_FILES += include/grub/boot.h
+KERNEL_HEADER_FILES += include/grub/loader.h
+KERNEL_HEADER_FILES += include/grub/msdos_partition.h
+KERNEL_HEADER_FILES += include/grub/machine/biosdisk.h
+KERNEL_HEADER_FILES += include/grub/machine/boot.h
+KERNEL_HEADER_FILES += include/grub/machine/console.h
+KERNEL_HEADER_FILES += include/grub/machine/memory.h
+KERNEL_HEADER_FILES += include/grub/machine/loader.h
+KERNEL_HEADER_FILES += include/grub/machine/vga.h
+KERNEL_HEADER_FILES += include/grub/machine/vbe.h
+KERNEL_HEADER_FILES += include/grub/machine/kernel.h
+KERNEL_HEADER_FILES += include/grub/machine/pxe.h
+KERNEL_HEADER_FILES += include/grub/i386/pit.h
+endif
+
+if COND_i386_efi
+KERNEL_HEADER_FILES += include/grub/boot.h
+KERNEL_HEADER_FILES += include/grub/loader.h
+KERNEL_HEADER_FILES += include/grub/msdos_partition.h
+KERNEL_HEADER_FILES += include/grub/efi/efi.h
+KERNEL_HEADER_FILES += include/grub/efi/time.h
+KERNEL_HEADER_FILES += include/grub/efi/disk.h
+KERNEL_HEADER_FILES += include/grub/i386/pit.h
+endif
+
+if COND_i386_coreboot
+KERNEL_HEADER_FILES += include/grub/boot.h
+KERNEL_HEADER_FILES += include/grub/loader.h
+KERNEL_HEADER_FILES += include/grub/msdos_partition.h
+KERNEL_HEADER_FILES += include/grub/machine/boot.h
+KERNEL_HEADER_FILES += include/grub/machine/console.h
+KERNEL_HEADER_FILES += include/grub/machine/init.h
+KERNEL_HEADER_FILES += include/grub/machine/memory.h
+KERNEL_HEADER_FILES += include/grub/machine/loader.h
+endif
+
+if COND_i386_qemu
+KERNEL_HEADER_FILES += include/grub/boot.h
+KERNEL_HEADER_FILES += include/grub/loader.h
+KERNEL_HEADER_FILES += include/grub/msdos_partition.h
+KERNEL_HEADER_FILES += include/grub/machine/boot.h
+KERNEL_HEADER_FILES += include/grub/machine/console.h
+KERNEL_HEADER_FILES += include/grub/machine/init.h
+KERNEL_HEADER_FILES += include/grub/machine/memory.h
+KERNEL_HEADER_FILES += include/grub/machine/loader.h
+endif
+
+if COND_i386_ieee1275
+KERNEL_HEADER_FILES += include/grub/loader.h
+KERNEL_HEADER_FILES += include/grub/msdos_partition.h
+KERNEL_HEADER_FILES += include/grub/ieee1275/ieee1275.h
+KERNEL_HEADER_FILES += include/grub/machine/kernel.h
+KERNEL_HEADER_FILES += include/grub/machine/loader.h
+KERNEL_HEADER_FILES += include/grub/machine/memory.h
+endif
+
+if COND_x86_64_efi
+KERNEL_HEADER_FILES += include/grub/boot.h
+KERNEL_HEADER_FILES += include/grub/loader.h
+KERNEL_HEADER_FILES += include/grub/msdos_partition.h
+KERNEL_HEADER_FILES += include/grub/efi/efi.h
+KERNEL_HEADER_FILES += include/grub/efi/time.h
+KERNEL_HEADER_FILES += include/grub/efi/disk.h
+KERNEL_HEADER_FILES += include/grub/machine/loader.h
+KERNEL_HEADER_FILES += include/grub/i386/pit.h
+endif
+
+if COND_mips_yeeloong
+KERNEL_HEADER_FILES += include/grub/boot.h
+KERNEL_HEADER_FILES += include/grub/loader.h
+KERNEL_HEADER_FILES += include/grub/msdos_partition.h
+KERNEL_HEADER_FILES += include/grub/machine/kernel.h
+KERNEL_HEADER_FILES += include/grub/machine/memory.h
+KERNEL_HEADER_FILES += include/grub/cpu/cache.h
+KERNEL_HEADER_FILES += include/grub/bitmap.h
+KERNEL_HEADER_FILES += include/grub/video.h
+KERNEL_HEADER_FILES += include/grub/gfxterm.h
+KERNEL_HEADER_FILES += include/grub/font.h
+KERNEL_HEADER_FILES += include/grub/bitmap_scale.h
+KERNEL_HEADER_FILES += include/grub/bufio.h
+KERNEL_HEADER_FILES += include/grub/pci.h
+KERNEL_HEADER_FILES += include/grub/libgcc.h
+endif
+
+if COND_powerpc_ieee1275
+KERNEL_HEADER_FILES += include/grub/boot.h
+KERNEL_HEADER_FILES += include/grub/loader.h
+KERNEL_HEADER_FILES += include/grub/msdos_partition.h
+KERNEL_HEADER_FILES += include/grub/ieee1275/ieee1275.h
+KERNEL_HEADER_FILES += include/grub/machine/kernel.h
+KERNEL_HEADER_FILES += include/grub/libgcc.h
+endif
+
+if COND_sparc64_ieee1275
+KERNEL_HEADER_FILES += include/grub/boot.h
+KERNEL_HEADER_FILES += include/grub/loader.h
+KERNEL_HEADER_FILES += include/grub/msdos_partition.h
+KERNEL_HEADER_FILES += include/grub/libgcc.h
+KERNEL_HEADER_FILES += include/grub/ieee1275/ieee1275.h
+KERNEL_HEADER_FILES += include/grub/machine/kernel.h
+KERNEL_HEADER_FILES += include/grub/sparc64/ieee1275/ieee1275.h
+endif
+
+if COND_emu
+KERNEL_HEADER_FILES += include/grub/cpu/time.h
+KERNEL_HEADER_FILES += include/grub/cpu/types.h
+KERNEL_HEADER_FILES += include/grub/gzio.h
+KERNEL_HEADER_FILES += include/grub/menu.h
+KERNEL_HEADER_FILES += include/grub/datetime.h
+KERNEL_HEADER_FILES += include/grub/emu/misc.h
+if COND_GRUB_EMU_SDL
+KERNEL_HEADER_FILES += include/grub/sdl.h
+endif
+if COND_GRUB_EMU_USB
+KERNEL_HEADER_FILES += include/grub/libusb.h
+endif
+if COND_GRUB_EMU_PCI
+KERNEL_HEADER_FILES += include/grub/libpciaccess.h
+endif
+endif
+
+symlist.h: config.h $(KERNEL_HEADER_FILES)
+	@list='$^'; \
+	for p in $$list; do \
+	  echo "#include <$$p>" >> $@ || (rm -f $@; exit 1); \
+	done
+CLEANFILES += symlist.h
+BUILT_SOURCES += symlist.h
+
+symlist.c: symlist.h gensymlist.sh
+	$(TARGET_CPP) $(DEFS) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS_KERNEL) $(CPPFLAGS) -DGRUB_SYMBOL_GENERATOR=1 symlist.h > symlist.p || (rm -f symlist.p; exit 1)
+	cat symlist.p | /bin/sh $(srcdir)/gensymlist.sh config.h $(KERNEL_HEADER_FILES) >$@ || (rm -f $@; exit 1)
+	rm -f symlist.p
+CLEANFILES += symlist.c
+BUILT_SOURCES += symlist.c
+
+noinst_DATA += kernel_syms.lst
+kernel_syms.lst: $(KERNEL_HEADER_FILES) config.h
+	if grep "^#define HAVE_ASM_USCORE" config.h; then u="_"; else u=""; fi
+	$(TARGET_CPP) $(DEFS) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS_KERNEL) $(CPPFLAGS) $(CFLAGS) -DGRUB_SYMBOL_GENERATOR=1 $^ >kernel_syms.input
+	cat kernel_syms.input | grep -v '^#' | sed -n \
+	  -e '/EXPORT_FUNC *([a-zA-Z0-9_]*)/{s/.*EXPORT_FUNC *(\([a-zA-Z0-9_]*\)).*/'"$$u"'\1 kernel/;p;}' \
+	  -e '/EXPORT_VAR *([a-zA-Z0-9_]*)/{s/.*EXPORT_VAR *(\([a-zA-Z0-9_]*\)).*/'"$$u"'\1 kernel/;p;}' \
+	  | sort -u >$@
+	rm -f kernel_syms.input
+CLEANFILES += kernel_syms.lst
+
+if COND_emu
+kern/emu/grub_emu-main.$(OBJEXT):grub_emu_init.h
+grub_emu-grub_emu_init.$(OBJEXT):grub_emu_init.h
+kern/emu/grub_emu_dyn-main.$(OBJEXT):grub_emu_init.h
+grub_emu_dyn-grub_emu_init.$(OBJEXT):grub_emu_init.h
+
+grub_emu_init.h: genemuinitheader.sh $(MOD_FILES)
+	rm -f $@; echo $(MOD_FILES) | sh $(srcdir)/genemuinitheader.sh $(NM) > $@
+CLEANFILES += grub_emu_init.h
+
+grub_emu_init.c: grub_emu_init.h genemuinit.sh $(MOD_FILES)
+	rm -f $@; echo $(MOD_FILES) | sh $(srcdir)/genemuinit.sh $(NM) > $@
+CLEANFILES += grub_emu_init.c
+endif

grub-core/Makefile.vars

@@ -0,0 +1,80 @@
+# -*- makefile -*-
+
+# Platform specific options
+if COND_i386_pc
+  CFLAGS_PLATFORM = -mrtd -mregparm=3
+endif
+if COND_i386_efi
+  LDFLAGS_PLATFORM = -melf_i386
+endif
+if COND_x86_64_efi
+  LDFLAGS_PLATFORM = -melf_x86_64
+endif
+if COND_i386_qemu
+  CFLAGS_PLATFORM = -mrtd -mregparm=3
+endif
+if COND_i386_coreboot
+  CFLAGS_PLATFORM = -mrtd -mregparm=3
+endif
+if COND_i386_ieee1275
+  CFLAGS_PLATFORM = -mrtd -mregparm=3
+endif
+if COND_mips_yeeloong
+  CFLAGS_PLATFORM = -march=mips3 -mexplicit-relocs -mflush-func=grub_cpu_flush_cache
+  CCASFLAGS_PLATFORM = -march=mips3
+endif
+if COND_sparc64_ieee1275
+  CFLAGS_PLATFORM = -mno-app-regs
+  LDFLAGS_PLATFORM = -melf64_sparc -mno-relax
+endif
+
+CPPFLAGS_GRUB = -I$(builddir) -I$(srcdir) -I$(top_builddir) -I$(top_srcdir)
+CPPFLAGS_GRUB += -I$(top_srcdir)/include -I$(top_builddir)/include
+
+CFLAGS_GCRY = -Wno-error -Wno-missing-field-initializers
+CPPFLAGS_GCRY = -I$(top_srcdir)/lib/libgcrypt_wrap
+
+CFLAGS_GNULIB = -Wno-undef -Wno-sign-compare -Wno-unused -D_GL_UNUSED="__attribute__ ((unused))"
+CPPFLAGS_GNULIB = -I$(top_srcdir)/gnulib
+
+CFLAGS_MKISOFS = -Wno-all -Werror
+CPPFLAGS_MKISOFS = -D_FILE_OFFSET_BITS=64 -I$(top_srcdir)/util/mkisofs/include
+
+CFLAGS_POSIX = -fno-builtin
+CPPFLAGS_POSIX = -I$(top_srcdir)/lib/posix_wrap
+
+CPPFLAGS_EFIEMU = -I$(top_srcdir)/efiemu/runtime
+
+grubconfdir = $(sysconfdir)/grub.d
+platformdir = $(pkglibdir)/$(target_cpu)-$(platform)
+
+# to calm down automake
+BUILT_SOURCES =
+CLEANFILES =
+COMMAND_FILES =
+DEF_FILES =
+FS_FILES =
+HANDLER_FILES =
+IMG_FILES =
+MOD_FILES =
+MODULE_FILES =
+PARTMAP_FILES =
+PARTTOOL_FILES =
+TERMINAL_FILES =
+TESTS =
+UND_FILES =
+VIDEO_FILES =
+bin_PROGRAMS =
+bin_SCRIPTS =
+check_PROGRAMS =
+check_SCRIPTS =
+grubconf_DATA =
+grubconf_SCRIPTS =
+man_MANS =
+noinst_DATA =
+noinst_LIBRARIES =
+noinst_PROGRAMS =
+pkglib_SCRIPTS =
+platform_DATA =
+sbin_PROGRAMS =
+sbin_SCRIPTS =

grub-core/boot/i386/pc/boot.S

@@ -0,0 +1,479 @@
+/* -*-Asm-*- */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 1999,2000,2001,2002,2005,2006,2007,2008,2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/symbol.h>
+#include <grub/boot.h>
+#include <grub/machine/boot.h>
+
+/*
+ *  defines for the code go here
+ */
+
+	/* Print message string */
+#define MSG(x)	movw $x, %si; call LOCAL(message)
+#define ERR(x)	movw $x, %si; jmp LOCAL(error_message)
+
+	.file	"boot.S"
+
+	.text
+
+	/* Tell GAS to generate 16-bit instructions so that this code works
+	   in real mode. */
+	.code16
+
+.globl _start, start;
+_start:
+start:
+	/*
+	 * _start is loaded at 0x7c00 and is jumped to with CS:IP 0:0x7c00
+	 */
+
+	/*
+	 * Beginning of the sector is compatible with the FAT/HPFS BIOS
+	 * parameter block.
+	 */
+
+	jmp	LOCAL(after_BPB)
+	nop	/* do I care about this ??? */
+
+	/*
+	 * This space is for the BIOS parameter block!!!!  Don't change
+	 * the first jump, nor start the code anywhere but right after
+	 * this area.
+	 */
+
+	. = _start + GRUB_BOOT_MACHINE_BPB_START
+	. = _start + 4
+
+	/* scratch space */
+mode:
+	.byte	0
+disk_address_packet:
+sectors:
+	.long	0
+heads:
+	.long	0
+cylinders:
+	.word	0
+sector_start:
+	.byte	0
+head_start:
+	.byte	0
+cylinder_start:
+	.word	0
+	/* more space... */
+
+	. = _start + GRUB_BOOT_MACHINE_BPB_END
+
+	/*
+	 * End of BIOS parameter block.
+	 */
+
+kernel_address:
+	.word	GRUB_BOOT_MACHINE_KERNEL_ADDR
+
+	. = _start + GRUB_BOOT_MACHINE_KERNEL_SECTOR
+kernel_sector:
+	.long	1, 0
+
+	. = _start + GRUB_BOOT_MACHINE_BOOT_DRIVE
+boot_drive:
+	.byte 0xff	/* the disk to load kernel from */
+			/* 0xff means use the boot drive */
+
+LOCAL(after_BPB):
+
+/* general setup */
+	cli		/* we're not safe here! */
+
+        /*
+         * This is a workaround for buggy BIOSes which don't pass boot
+         * drive correctly. If GRUB is installed into a HDD, check if
+         * DL is masked correctly. If not, assume that the BIOS passed
+         * a bogus value and set DL to 0x80, since this is the only
+         * possible boot drive. If GRUB is installed into a floppy,
+         * this does nothing (only jump).
+         */
+	. = _start + GRUB_BOOT_MACHINE_DRIVE_CHECK
+boot_drive_check:
+        jmp     1f	/* grub-setup may overwrite this jump */
+        testb   $0x80, %dl
+        jnz     1f
+        movb    $0x80, %dl
+1:
+
+	/*
+	 * ljmp to the next instruction because some bogus BIOSes
+	 * jump to 07C0:0000 instead of 0000:7C00.
+	 */
+	ljmp	$0, $real_start
+
+real_start:
+
+	/* set up %ds and %ss as offset from 0 */
+	xorw	%ax, %ax
+	movw	%ax, %ds
+	movw	%ax, %ss
+
+	/* set up the REAL stack */
+	movw	$GRUB_BOOT_MACHINE_STACK_SEG, %sp
+
+	sti		/* we're safe again */
+
+	/*
+	 *  Check if we have a forced disk reference here
+	 */
+	movb   boot_drive, %al
+	cmpb	$0xff, %al
+	je	1f
+	movb	%al, %dl
+1:
+	/* save drive reference first thing! */
+	pushw	%dx
+
+	/* print a notification message on the screen */
+	MSG(notification_string)
+
+	/* set %si to the disk address packet */
+	movw	$disk_address_packet, %si
+
+	/* do not probe LBA if the drive is a floppy */
+	testb	$GRUB_BOOT_MACHINE_BIOS_HD_FLAG, %dl
+	jz	LOCAL(chs_mode)
+
+	/* check if LBA is supported */
+	movb	$0x41, %ah
+	movw	$0x55aa, %bx
+	int	$0x13
+
+	/*
+	 *  %dl may have been clobbered by INT 13, AH=41H.
+	 *  This happens, for example, with AST BIOS 1.04.
+	 */
+	popw	%dx
+	pushw	%dx
+
+	/* use CHS if fails */
+	jc	LOCAL(chs_mode)
+	cmpw	$0xaa55, %bx
+	jne	LOCAL(chs_mode)
+
+	andw	$1, %cx
+	jz	LOCAL(chs_mode)
+
+lba_mode:
+	xorw	%ax, %ax
+	movw	%ax, 4(%si)
+
+	incw	%ax
+	/* set the mode to non-zero */
+	movb	%al, -1(%si)
+
+	/* the blocks */
+	movw	%ax, 2(%si)
+
+	/* the size and the reserved byte */
+	movw	$0x0010, (%si)
+
+	/* the absolute address */
+	movl	kernel_sector, %ebx
+	movl	%ebx, 8(%si)
+	movl	kernel_sector + 4, %ebx
+	movl	%ebx, 12(%si)
+
+	/* the segment of buffer address */
+	movw	$GRUB_BOOT_MACHINE_BUFFER_SEG, 6(%si)
+
+/*
+ * BIOS call "INT 0x13 Function 0x42" to read sectors from disk into memory
+ *	Call with	%ah = 0x42
+ *			%dl = drive number
+ *			%ds:%si = segment:offset of disk address packet
+ *	Return:
+ *			%al = 0x0 on success; err code on failure
+ */
+
+	movb	$0x42, %ah
+	int	$0x13
+
+	/* LBA read is not supported, so fallback to CHS.  */
+	jc	LOCAL(chs_mode)
+
+	movw	$GRUB_BOOT_MACHINE_BUFFER_SEG, %bx
+	jmp	LOCAL(copy_buffer)
+
+LOCAL(chs_mode):
+	/*
+	 *  Determine the hard disk geometry from the BIOS!
+	 *  We do this first, so that LS-120 IDE floppies work correctly.
+	 */
+	movb	$8, %ah
+	int	$0x13
+	jnc	LOCAL(final_init)
+
+	/*
+	 *  The call failed, so maybe use the floppy probe instead.
+	 */
+	testb	$GRUB_BOOT_MACHINE_BIOS_HD_FLAG, %dl
+	jz	LOCAL(floppy_probe)
+
+	/* Nope, we definitely have a hard disk, and we're screwed. */
+	ERR(hd_probe_error_string)
+
+LOCAL(final_init):
+	/* set the mode to zero */
+	movzbl	%dh, %eax
+	movb	%ah, -1(%si)
+
+	/* save number of heads */
+	incw	%ax
+	movl	%eax, 4(%si)
+
+	movzbw	%cl, %dx
+	shlw	$2, %dx
+	movb	%ch, %al
+	movb	%dh, %ah
+
+	/* save number of cylinders */
+	incw	%ax
+	movw	%ax, 8(%si)
+
+	movzbw	%dl, %ax
+	shrb	$2, %al
+
+	/* save number of sectors */
+	movl	%eax, (%si)
+
+setup_sectors:
+	/* load logical sector start (top half) */
+	movl	kernel_sector + 4, %eax
+
+	orl	%eax, %eax
+	jnz	LOCAL(geometry_error)
+
+	/* load logical sector start (bottom half) */
+	movl	kernel_sector, %eax
+
+	/* zero %edx */
+	xorl	%edx, %edx
+
+	/* divide by number of sectors */
+	divl	(%si)
+
+	/* save sector start */
+	movb	%dl, %cl
+
+	xorw	%dx, %dx	/* zero %edx */
+	divl	4(%si)		/* divide by number of heads */
+
+	/* do we need too many cylinders? */
+	cmpw	8(%si), %ax
+	jge	LOCAL(geometry_error)
+
+	/* normalize sector start (1-based) */
+	incb	%cl
+
+	/* low bits of cylinder start */
+	movb	%al, %ch
+
+	/* high bits of cylinder start */
+	xorb	%al, %al
+	shrw	$2, %ax
+	orb	%al, %cl
+
+	/* save head start */
+	movb	%dl, %al
+
+	/* restore %dl */
+	popw	%dx
+
+	/* head start */
+	movb	%al, %dh
+
+/*
+ * BIOS call "INT 0x13 Function 0x2" to read sectors from disk into memory
+ *	Call with	%ah = 0x2
+ *			%al = number of sectors
+ *			%ch = cylinder
+ *			%cl = sector (bits 6-7 are high bits of "cylinder")
+ *			%dh = head
+ *			%dl = drive (0x80 for hard disk, 0x0 for floppy disk)
+ *			%es:%bx = segment:offset of buffer
+ *	Return:
+ *			%al = 0x0 on success; err code on failure
+ */
+
+	movw	$GRUB_BOOT_MACHINE_BUFFER_SEG, %bx
+	movw	%bx, %es	/* load %es segment with disk buffer */
+
+	xorw	%bx, %bx	/* %bx = 0, put it at 0 in the segment */
+	movw	$0x0201, %ax	/* function 2 */
+	int	$0x13
+
+	jc	LOCAL(read_error)
+
+	movw	%es, %bx
+
+LOCAL(copy_buffer):
+	/*
+	 * We need to save %cx and %si because the startup code in
+	 * kernel uses them without initializing them.
+	 */
+	pusha
+	pushw	%ds
+
+	movw	$0x100, %cx
+	movw	%bx, %ds
+	xorw	%si, %si
+	movw	$GRUB_BOOT_MACHINE_KERNEL_ADDR, %di
+	movw	%si, %es
+
+	cld
+
+	rep
+	movsw
+
+	popw	%ds
+	popa
+
+	/* boot kernel */
+	jmp	*(kernel_address)
+
+/* END OF MAIN LOOP */
+
+/*
+ * BIOS Geometry translation error (past the end of the disk geometry!).
+ */
+LOCAL(geometry_error):
+	ERR(geometry_error_string)
+
+/*
+ * Read error on the disk.
+ */
+LOCAL(read_error):
+	movw	$read_error_string, %si
+LOCAL(error_message):
+	call	LOCAL(message)
+LOCAL(general_error):
+	MSG(general_error_string)
+
+/* go here when you need to stop the machine hard after an error condition */
+        /* tell the BIOS a boot failure, which may result in no effect */
+        int	$0x18
+LOCAL(stop):
+	jmp	LOCAL(stop)
+
+notification_string:	.asciz "GRUB "
+geometry_error_string:	.asciz "Geom"
+hd_probe_error_string:	.asciz "Hard Disk"
+read_error_string:	.asciz "Read"
+general_error_string:	.asciz " Error\r\n"
+
+/*
+ * message: write the string pointed to by %si
+ *
+ *   WARNING: trashes %si, %ax, and %bx
+ */
+
+	/*
+	 * Use BIOS "int 10H Function 0Eh" to write character in teletype mode
+	 *	%ah = 0xe	%al = character
+	 *	%bh = page	%bl = foreground color (graphics modes)
+	 */
+1:
+	movw	$0x0001, %bx
+	movb	$0xe, %ah
+	int	$0x10		/* display a byte */
+LOCAL(message):
+	lodsb
+	cmpb	$0, %al
+	jne	1b	/* if not end of string, jmp to display */
+	ret
+
+	/*
+	 *  Windows NT breaks compatibility by embedding a magic
+	 *  number here.
+	 */
+
+	. = _start + GRUB_BOOT_MACHINE_WINDOWS_NT_MAGIC
+nt_magic:
+	.long 0
+	.word 0
+
+	/*
+	 *  This is where an MBR would go if on a hard disk.  The code
+	 *  here isn't even referenced unless we're on a floppy.  Kinda
+	 *  sneaky, huh?
+	 */
+
+	. = _start + GRUB_BOOT_MACHINE_PART_START
+part_start:
+
+probe_values:
+	.byte	36, 18, 15, 9, 0
+
+LOCAL(floppy_probe):
+/*
+ *  Perform floppy probe.
+ */
+
+	movw	$probe_values - 1, %si
+
+LOCAL(probe_loop):
+	/* reset floppy controller INT 13h AH=0 */
+	xorw	%ax, %ax
+	int	$0x13
+
+	incw	%si
+	movb	(%si), %cl
+
+	/* if number of sectors is 0, display error and die */
+	cmpb	$0, %cl
+	jne	1f
+
+/*
+ * Floppy disk probe failure.
+ */
+	MSG(fd_probe_error_string)
+	jmp	LOCAL(general_error)
+
+/* "Floppy" */
+fd_probe_error_string:	.asciz "Floppy"
+
+1:
+	/* perform read */
+	movw	$GRUB_BOOT_MACHINE_BUFFER_SEG, %bx
+	movw	$0x201, %ax
+	movb	$0, %ch
+	movb	$0, %dh
+	int	$0x13
+
+	/* if error, jump to "LOCAL(probe_loop)" */
+	jc	LOCAL(probe_loop)
+
+	/* %cl is already the correct value! */
+	movb	$1, %dh
+	movb	$79, %ch
+
+	jmp	LOCAL(final_init)
+
+	. = _start + GRUB_BOOT_MACHINE_PART_END
+
+/* the last 2 bytes in the sector 0 contain the signature */
+	.word	GRUB_BOOT_MACHINE_SIGNATURE

grub-core/boot/i386/pc/cdboot.S

@@ -0,0 +1,173 @@
+/* -*-Asm-*- */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008,2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/symbol.h>
+#include <grub/boot.h>
+#include <grub/machine/boot.h>
+#include <grub/machine/kernel.h>
+#include <multiboot.h>
+
+        .file   "cdboot.S"
+
+#define CODE_ADDR	0x6000
+#define DATA_ADDR	((GRUB_BOOT_MACHINE_KERNEL_ADDR) + 0x200)
+
+#define CDSEC_SHIFT	11
+#define CDBLK_LENG	16
+
+	.text
+
+        .code16
+
+        .globl  start, _start
+
+start:
+_start:
+	call	LOCAL(next)
+
+LOCAL(next):
+	jmp	1f
+
+	. = start + 8
+
+bi_pvd:
+	.long 0		/* LBA of primary volume descriptor.  */
+bi_file:
+	.long 0		/* LBA of boot file. */
+bi_length:
+	.long 0		/* Length of boot file. */
+bi_csum:
+	.long 0		/* Checksum of boot file */
+bi_reserved:
+	.space (10*4)	/* Reserved */
+
+1:
+	popw	%bx
+
+	/* Boot from CDROM.  */
+
+	xorw	%ax, %ax
+	movw	%ax, %ss
+	movw	$(CODE_ADDR), %sp
+	movw	%ax, %ds
+	movw	%ax, %es
+
+	movw	$(0x7C00 + err_noboot_msg - start), %si
+	movl	%cs: bi_length - LOCAL(next)(%bx), %ecx
+	orl	%ecx, %ecx
+	jz	LOCAL(fail)
+
+	addl	$((1 << CDSEC_SHIFT) - 1), %ecx
+	shrl	$CDSEC_SHIFT, %ecx
+
+	movl	%cs: bi_file - LOCAL(next)(%bx), %esi
+
+	call	LOCAL(read_cdrom)
+
+	ljmp	$(DATA_ADDR >> 4), $0
+
+/*
+ * Parameters:
+ *   esi: start sector
+ *   ecx: number of sectors
+ */
+LOCAL(read_cdrom):
+	xorl	%eax, %eax
+
+	/* Number of blocks to read.  */
+	pushw	$CDBLK_LENG
+
+	/* Block number.  */
+	pushl	%eax
+	pushl	%esi
+
+	/* Buffer address.  */
+	pushw	$((DATA_ADDR - 0x400)>> 4)
+	pushl	%eax
+	pushw	$0x10
+
+	xorl	%edi, %edi
+	movw	%sp, %si
+
+1:
+	movw	0x10(%si), %di
+	cmpl	%ecx, %edi
+	jbe	2f
+	movl	%ecx, %edi
+
+2:
+	mov	%di, 2(%si)
+
+	pushl	%ecx
+
+	movb	$0x42, %ah
+	int	$0x13
+
+	jnc	3f
+
+	movb	$0x42, %ah		/* Try again.  */
+	int	$0x13
+
+	jnc	3f
+
+2:
+	shrw	$1, %di			/* Reduce transfer size.  */
+	jz	LOCAL(cdrom_fail)
+	movw	%di, 0x10(%si)
+	movw	%di, 2(%si)
+	movb	$0x42, %ah
+	int	$0x13
+	jc	2b
+
+3:
+
+	movw	%di, %ax
+	shlw	$(CDSEC_SHIFT - 4), %ax
+	addw	%ax, 6(%si)
+	addl	%edi, 8(%si)
+
+	popl	%ecx
+	subl	%edi, %ecx
+	jnz	1b
+
+	addw	$0x12, %sp
+	ret
+
+LOCAL(cdrom_fail):
+	movw	$(0x7C00 + err_cdfail_msg - start), %si
+
+LOCAL(fail):
+	movb	$0x0e, %ah
+	xorw	%bx, %bx
+1:
+	lodsb	(%si), %al
+	int	$0x10
+	cmpb	$0, %al
+	jne	1b
+1:	jmp	1b
+
+err_noboot_msg:
+	.ascii	"no boot info\0"
+
+err_cdfail_msg:
+	.ascii	"cdrom read fails\0"
+
+	. = start + 0x1FF
+
+	.byte	0

grub-core/boot/i386/pc/diskboot.S

@@ -0,0 +1,380 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 1999,2000,2001,2002,2006,2007,2009,2010   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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/symbol.h>
+#include <grub/machine/boot.h>
+
+/*
+ *  defines for the code go here
+ */
+
+#define MSG(x)	movw $x, %si; call LOCAL(message)
+
+	.file	"diskboot.S"
+
+	.text
+
+	/* Tell GAS to generate 16-bit instructions so that this code works
+	   in real mode. */
+	.code16
+
+	.globl	start, _start
+start:
+_start:
+	/*
+	 * _start is loaded at 0x2000 and is jumped to with
+	 * CS:IP 0:0x2000 in kernel.
+	 */
+
+	/*
+	 * we continue to use the stack for boot.img and assume that
+	 * some registers are set to correct values. See boot.S
+	 * for more information.
+	 */
+
+	/* save drive reference first thing! */
+	pushw	%dx
+
+	/* print a notification message on the screen */
+	pushw	%si
+	MSG(notification_string)
+	popw	%si
+
+	/* this sets up for the first run through "bootloop" */
+	movw	$(firstlist - GRUB_BOOT_MACHINE_LIST_SIZE), %di
+
+	/* save the sector number of the second sector in %ebp */
+	movl	(%di), %ebp
+
+        /* this is the loop for reading the rest of the kernel in */
+LOCAL(bootloop):
+
+	/* check the number of sectors to read */
+	cmpw	$0, 8(%di)
+
+	/* if zero, go to the start function */
+	je	LOCAL(bootit)
+
+LOCAL(setup_sectors):
+	/* check if we use LBA or CHS */
+	cmpb	$0, -1(%si)
+
+	/* use CHS if zero, LBA otherwise */
+	je	LOCAL(chs_mode)
+
+	/* load logical sector start */
+	movl	(%di), %ebx
+	movl	4(%di), %ecx
+
+	/* the maximum is limited to 0x7f because of Phoenix EDD */
+	xorl	%eax, %eax
+	movb	$0x7f, %al
+
+	/* how many do we really want to read? */
+	cmpw	%ax, 8(%di)	/* compare against total number of sectors */
+
+	/* which is greater? */
+	jg	1f
+
+	/* if less than, set to total */
+	movw	8(%di), %ax
+
+1:
+	/* subtract from total */
+	subw	%ax, 8(%di)
+
+	/* add into logical sector start */
+	addl	%eax, (%di)
+	adcl	$0, 4(%di)
+
+	/* set up disk address packet */
+
+	/* the size and the reserved byte */
+	movw	$0x0010, (%si)
+
+	/* the number of sectors */
+	movw	%ax, 2(%si)
+
+	/* the absolute address */
+	movl	%ebx, 8(%si)
+	movl	%ecx, 12(%si)
+
+	/* the segment of buffer address */
+	movw	$GRUB_BOOT_MACHINE_BUFFER_SEG, 6(%si)
+
+	/* save %ax from destruction! */
+	pushw	%ax
+
+	/* the offset of buffer address */
+	movw	$0, 4(%si)
+
+/*
+ * BIOS call "INT 0x13 Function 0x42" to read sectors from disk into memory
+ *	Call with	%ah = 0x42
+ *			%dl = drive number
+ *			%ds:%si = segment:offset of disk address packet
+ *	Return:
+ *			%al = 0x0 on success; err code on failure
+ */
+
+	movb	$0x42, %ah
+	int	$0x13
+
+	jc	LOCAL(read_error)
+
+	movw	$GRUB_BOOT_MACHINE_BUFFER_SEG, %bx
+	jmp	LOCAL(copy_buffer)
+
+LOCAL(chs_mode):
+	/* load logical sector start (top half) */
+	movl	4(%di), %eax
+	orl	%eax, %eax
+	jnz	LOCAL(geometry_error)
+
+	/* load logical sector start (bottom half) */
+	movl	(%di), %eax
+
+	/* zero %edx */
+	xorl	%edx, %edx
+
+	/* divide by number of sectors */
+	divl	(%si)
+
+	/* save sector start */
+	movb	%dl, 10(%si)
+
+	xorl	%edx, %edx	/* zero %edx */
+	divl	4(%si)		/* divide by number of heads */
+
+	/* save head start */
+	movb	%dl, 11(%si)
+
+	/* save cylinder start */
+	movw	%ax, 12(%si)
+
+	/* do we need too many cylinders? */
+	cmpw	8(%si), %ax
+	jge	LOCAL(geometry_error)
+
+	/* determine the maximum sector length of this read */
+	movw	(%si), %ax	/* get number of sectors per track/head */
+
+	/* subtract sector start */
+	subb	10(%si), %al
+
+	/* how many do we really want to read? */
+	cmpw	%ax, 8(%di)	/* compare against total number of sectors */
+
+
+	/* which is greater? */
+	jg	2f
+
+	/* if less than, set to total */
+	movw	8(%di), %ax
+
+2:
+	/* subtract from total */
+	subw	%ax, 8(%di)
+
+	/* add into logical sector start */
+	addl	%eax, (%di)
+	adcl	$0, 4(%di)
+
+/*
+ *  This is the loop for taking care of BIOS geometry translation (ugh!)
+ */
+
+	/* get high bits of cylinder */
+	movb	13(%si), %dl
+
+	shlb	$6, %dl		/* shift left by 6 bits */
+	movb	10(%si), %cl	/* get sector */
+
+	incb	%cl		/* normalize sector (sectors go
+					from 1-N, not 0-(N-1) ) */
+	orb	%dl, %cl	/* composite together */
+	movb	12(%si), %ch	/* sector+hcyl in cl, cylinder in ch */
+
+	/* restore %dx */
+	popw	%dx
+	pushw	%dx
+
+	/* head number */
+	movb	11(%si), %dh
+
+	pushw	%ax	/* save %ax from destruction! */
+
+/*
+ * BIOS call "INT 0x13 Function 0x2" to read sectors from disk into memory
+ *	Call with	%ah = 0x2
+ *			%al = number of sectors
+ *			%ch = cylinder
+ *			%cl = sector (bits 6-7 are high bits of "cylinder")
+ *			%dh = head
+ *			%dl = drive (0x80 for hard disk, 0x0 for floppy disk)
+ *			%es:%bx = segment:offset of buffer
+ *	Return:
+ *			%al = 0x0 on success; err code on failure
+ */
+
+	movw	$GRUB_BOOT_MACHINE_BUFFER_SEG, %bx
+	movw	%bx, %es	/* load %es segment with disk buffer */
+
+	xorw	%bx, %bx	/* %bx = 0, put it at 0 in the segment */
+	movb	$0x2, %ah	/* function 2 */
+	int	$0x13
+
+	jc	LOCAL(read_error)
+
+	/* save source segment */
+	movw	%es, %bx
+
+LOCAL(copy_buffer):
+
+	/* load addresses for copy from disk buffer to destination */
+	movw	10(%di), %es	/* load destination segment */
+
+	/* restore %ax */
+	popw	%ax
+
+	/* determine the next possible destination address (presuming
+		512 byte sectors!) */
+	shlw	$5, %ax		/* shift %ax five bits to the left */
+	addw	%ax, 10(%di)	/* add the corrected value to the destination
+				   address for next time */
+
+	/* save addressing regs */
+	pusha
+	pushw	%ds
+
+	/* get the copy length */
+	shlw	$3, %ax
+	movw	%ax, %cx
+
+	xorw	%di, %di	/* zero offset of destination addresses */
+	xorw	%si, %si	/* zero offset of source addresses */
+	movw	%bx, %ds	/* restore the source segment */
+
+	cld		/* sets the copy direction to forward */
+
+	/* perform copy */
+	rep		/* sets a repeat */
+	movsw		/* this runs the actual copy */
+
+	/* restore addressing regs and print a dot with correct DS
+	   (MSG modifies SI, which is saved, and unused AX and BX) */
+	popw	%ds
+	MSG(notification_step)
+	popa
+
+	/* check if finished with this dataset */
+	cmpw	$0, 8(%di)
+	jne	LOCAL(setup_sectors)
+
+	/* update position to load from */
+	subw	$GRUB_BOOT_MACHINE_LIST_SIZE, %di
+
+	/* jump to bootloop */
+	jmp	LOCAL(bootloop)
+
+/* END OF MAIN LOOP */
+
+LOCAL(bootit):
+	/* print a newline */
+	MSG(notification_done)
+	popw	%dx	/* this makes sure %dl is our "boot" drive */
+	ljmp	$0, $(GRUB_BOOT_MACHINE_KERNEL_ADDR + 0x200)
+
+
+/*
+ * BIOS Geometry translation error (past the end of the disk geometry!).
+ */
+LOCAL(geometry_error):
+	MSG(geometry_error_string)
+	jmp	LOCAL(general_error)
+
+/*
+ * Read error on the disk.
+ */
+LOCAL(read_error):
+	MSG(read_error_string)
+
+LOCAL(general_error):
+	MSG(general_error_string)
+
+/* go here when you need to stop the machine hard after an error condition */
+LOCAL(stop):	jmp	LOCAL(stop)
+
+notification_string:	.asciz "loading"
+
+notification_step:	.asciz "."
+notification_done:	.asciz "\r\n"
+
+geometry_error_string:	.asciz "Geom"
+read_error_string:	.asciz "Read"
+general_error_string:	.asciz " Error"
+
+/*
+ * message: write the string pointed to by %si
+ *
+ *   WARNING: trashes %si, %ax, and %bx
+ */
+
+	/*
+	 * Use BIOS "int 10H Function 0Eh" to write character in teletype mode
+	 *	%ah = 0xe	%al = character
+	 *	%bh = page	%bl = foreground color (graphics modes)
+	 */
+1:
+	movw	$0x0001, %bx
+	movb	$0xe, %ah
+	int	$0x10		/* display a byte */
+
+	incw	%si
+LOCAL(message):
+	movb	(%si), %al
+	cmpb	$0, %al
+	jne	1b	/* if not end of string, jmp to display */
+	ret
+
+/*
+ *  This area is an empty space between the main body of code below which
+ *  grows up (fixed after compilation, but between releases it may change
+ *  in size easily), and the lists of sectors to read, which grows down
+ *  from a fixed top location.
+ */
+
+	.word 0
+	.word 0
+
+	. = _start + 0x200 - GRUB_BOOT_MACHINE_LIST_SIZE
+
+        /* fill the first data listing with the default */
+blocklist_default_start:
+	/* this is the sector start parameter, in logical sectors from
+	   the start of the disk, sector 0 */
+	.long 2, 0
+blocklist_default_len:
+	/* this is the number of sectors to read.  grub-mkimage
+	   will fill this up */
+	.word 0
+blocklist_default_seg:
+	/* this is the segment of the starting address to load the data into */
+	.word (GRUB_BOOT_MACHINE_KERNEL_SEG + 0x20)
+
+firstlist:	/* this label has to be after the list data!!! */

grub-core/boot/i386/pc/lnxboot.S

@@ -0,0 +1,290 @@
+/* -*-Asm-*- */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2007,2008,2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <config.h>
+#include <grub/symbol.h>
+#include <grub/boot.h>
+#include <grub/machine/boot.h>
+#include <grub/machine/kernel.h>
+#include <multiboot.h>
+
+        .file   "lnxboot.S"
+
+#define CODE_ADDR	0x6000
+#define CODE_SECTORS	1
+#define DATA_ADDR	((GRUB_BOOT_MACHINE_KERNEL_ADDR) + 0x200)
+
+#define BLCK_LENG	0x4000
+
+	.text
+
+        .code16
+
+        .globl  start, _start
+
+data_start:
+	xorl	%ebp, %ebp
+	jmp	LOCAL(linux_next)
+
+	. = data_start + 0x1F1
+
+setup_sects:
+	.byte	CODE_SECTORS
+root_flags:
+	.word	0
+syssize:
+	.word	0
+swap_dev:
+	.word	0
+ram_size:
+	.word	0
+vid_mode:
+	.word	0
+root_dev:
+	.word	0
+boot_flag:
+	.word	0xAA55
+
+start:
+_start:
+
+	jmp LOCAL(linux_init)
+
+	.ascii	"HdrS"			/* Header signature.  */
+	.word	0x0203			/* Header version number.  */
+
+realmode_swtch:
+	.word	0, 0			/* default_switch, SETUPSEG.  */
+start_sys_seg:
+	.word	0x1000			/* Obsolete.  */
+version_ptr:
+	.word	0			/* Version string ptr.  */
+type_of_loader:
+	.byte	0			/* Filled in by boot loader.  */
+loadflags:
+	.byte	1			/* Please load high.  */
+setup_move_size:
+	.word	0			/* Unused.  */
+code32_start:
+	.long	0x100000		/* 32-bit start address.  */
+ramdisk_image:
+	.long	0			/* Loaded ramdisk image address.  */
+ramdisk_size:
+	.long	0			/* Size of loaded ramdisk.  */
+bootsect_kludge:
+	.word	0, 0
+heap_end_ptr:
+	.word	0
+pad1:
+	.word	0
+cmd_line_ptr:
+	.long	0			/* Command line.  */
+ramdisk_max:
+	.long	0xffffffff		/* Highest allowed ramdisk address.  */
+
+gdt:
+	.long	0, 0, 0, 0		/* Must be zero.  */
+	.word	0xffff			/* 64 K segment size.  */
+gdt_src1:
+	.byte	0, 0 ,0			/* Low 24 bits of source address.  */
+	.byte	0x93			/* Access rights.  */
+	.byte	0			/* Extended access rights.  */
+gdt_src2:
+	.byte	0			/* High 8 bits of source address.  */
+	.word	0xffff			/* 64 K segment size.  */
+gdt_dst1:
+	.byte	0, 0, 0			/* Low 24 bits of target address.  */
+	.byte	0x93			/* Access rights.  */
+	.byte	0			/* Extended access rights.  */
+gdt_dst2:
+	.byte	0			/* High 8 bits of source address.  */
+	.long	0, 0, 0, 0		/* More space for the BIOS.  */
+
+reg_edx:
+	.byte	0x80, 0, 0xFF, 0xFF
+
+data_leng:
+	.long	0
+
+LOCAL(linux_init):
+	movw	%cs:(reg_edx - start), %dx
+	movl	%cs:(code32_start - start), %ebp
+
+LOCAL(linux_next):
+
+	call	LOCAL(normalize)
+
+LOCAL(normalize):
+	popw	%bx
+	subw	$(LOCAL(normalize) - start), %bx
+	shrw	$4, %bx
+	movw	%cs, %ax
+	addw	%bx, %ax
+	pushw	%ax
+	pushw	$(real_code - start)
+	lret				/* Jump to real_code.  */
+
+real_code:
+	subw	$0x20, %ax
+	movw	%ax, %ds
+	movw	(setup_sects - data_start), %cx
+	shlw	$7, %cx
+
+	/* Setup stack.  */
+
+	xorw	%si, %si
+	movw	%si, %ss
+	movw	$(CODE_ADDR), %sp
+
+	/* Move itself to 0:CODE_ADDR.  */
+
+	cld
+	movw	%cs, %ax
+	movw	%ax, %ds
+	movw	$(CODE_ADDR >> 4), %ax
+	movw	%ax, %es
+	movw	%si, %di
+
+	rep
+	movsl
+	ljmp	$(CODE_ADDR >> 4), $(real_code_2  - start)
+
+real_code_2:
+
+	xchgl	%ebp, %esi
+	orl	%esi, %esi
+	jnz	1f
+	movw	%ds, %si
+	shll	$4, %esi
+	addl	%ebp, %esi
+1:
+
+	pushw	%es
+	popw	%ds
+
+	movl	$0x200, %ecx
+	addl	%ecx, %esi
+	movl	$DATA_ADDR, %edi
+
+	call	LOCAL(move_memory)
+
+	/* Check for multiboot signature.  */
+	cmpl	$MULTIBOOT_HEADER_MAGIC, %ss:(DATA_ADDR + GRUB_KERNEL_MACHINE_DATA_END)
+	jz	1f
+
+	movl	(ramdisk_image - start), %esi
+	movl	(ramdisk_size - start), %ecx
+	movl	$(DATA_ADDR - 0x200), %edi
+	jmp	2f
+
+1:
+
+	movl	%ss:(DATA_ADDR + GRUB_KERNEL_MACHINE_COMPRESSED_SIZE), %ecx
+	addl	$(GRUB_KERNEL_MACHINE_RAW_SIZE - 0x200), %ecx
+
+2:
+	call	LOCAL(move_memory)
+
+	movsbl	%dh, %eax
+	movl	%eax, %ss:(DATA_ADDR + GRUB_KERNEL_MACHINE_INSTALL_DOS_PART)
+	movsbl	(reg_edx + 2 - start), %eax
+	movl	%eax, %ss:(DATA_ADDR + GRUB_KERNEL_MACHINE_INSTALL_BSD_PART)
+
+	movb	$0xFF, %dh
+
+	ljmp	$(DATA_ADDR >> 4), $0
+
+/*
+ * Parameters:
+ *   esi: source address
+ *   edi: target address
+ *   ecx: number of bytes
+ */
+
+LOCAL(move_memory):
+	incl	%ecx
+	andb	$0xFE, %cl
+	pushw	%dx
+1:
+	pushl	%esi
+	pushl	%edi
+	pushl	%ecx
+	cmpl	$BLCK_LENG, %ecx
+	jbe	2f
+	movl	$BLCK_LENG, %ecx
+2:
+	pushl	%ecx
+
+	movl	%esi, %eax
+	movw	%si, (gdt_src1 - start)
+	shrl	$16, %eax
+	movb	%al, (gdt_src1 + 2 - start)
+	movb	%ah, (gdt_src2 - start)
+
+	movl	%edi, %eax
+	movw	%di, (gdt_dst1 - start)
+	shrl	$16, %eax
+	movb	%al, (gdt_dst1 + 2 - start)
+	movb	%ah, (gdt_dst2 - start)
+
+	movw	$(gdt - start), %si
+	movb	$0x87, %ah
+	shrw	$1, %cx
+
+	int	$0x15
+
+	popl	%eax
+	popl	%ecx
+	popl	%edi
+	popl	%esi
+
+	jnc	2f
+	movw	$(err_int15_msg - start), %si
+	jmp	LOCAL(fail)
+
+2:
+
+	addl	%eax, %esi
+	addl	%eax, %edi
+	subl	%eax, %ecx
+	jnz	1b
+
+
+	popw	%dx
+	ret
+
+/*
+ * Parameters:
+ *   si: message
+ */
+
+LOCAL(fail):
+	movb	$0x0e, %ah
+	xorw	%bx, %bx
+1:
+	lodsb	(%si), %al
+	int	$0x10
+	cmpb	$0, %al
+	jne	1b
+1:	jmp	1b
+
+err_int15_msg:
+	.ascii	"move memory fails\0"
+
+	. = _start + CODE_SECTORS * 512

grub-core/boot/i386/pc/pxeboot.S

@@ -0,0 +1,42 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2000,2005,2007,2008,2009,2010   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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/machine/boot.h>
+
+	.file	"pxeboot.S"
+	.text
+
+	/* Start with the prehistoric environment... */
+	.code16
+
+	/* Let's go */
+.globl start, _start;
+_start:
+start:
+
+	/* Use drive number 0x7F for PXE */
+        movb	$GRUB_BOOT_MACHINE_PXE_DL, %dl
+
+	/* Jump to the real world */
+	ljmp	$0, $0x8200
+
+	/* This region is a junk. Do you say that this is wasteful?
+	   But I like that the memory layout of the body is consistent
+	   among different kernels rather than scamping just for 1.5KB. */
+	. = _start + 0x8200 - 0x7C00 - 0x200 - 1
+	.byte	0

grub-core/boot/i386/qemu/boot.S

@@ -0,0 +1,70 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 1999,2000,2001,2002,2003,2005,2006,2007,2008,2009 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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <config.h>
+#include <grub/symbol.h>
+#include <grub/machine/memory.h>
+#include <grub/machine/boot.h>
+#include <grub/machine/kernel.h>
+
+	.text
+	.code16
+	.globl _start
+_start:
+	/* Disable interrupts.  */
+	cli
+
+	jmp	1f
+
+	. = _start + GRUB_BOOT_MACHINE_CORE_ENTRY_ADDR
+VARIABLE(grub_core_entry_addr)
+	.long	0
+1:
+
+	/* Process VGA rom.  */
+	call	$0xc000, $0x3
+
+	/* Set up %ds, %ss, and %es.  */
+	xorw	%ax, %ax
+	movw	%ax, %ds
+	movw	%ax, %ss
+	movw	%ax, %es
+
+	/* Set up the real mode stack.  */
+	movl	$GRUB_MEMORY_MACHINE_REAL_STACK, %esp
+
+	/* Transition to protected mode.  We use pushl to force generation
+	   of a flat return address.  */
+	pushl	$1f
+	DATA32	jmp real_to_prot
+	.code32
+1:
+	movl	grub_core_entry_addr, %edx
+	jmp	*%edx
+
+#include "../../../kern/i386/realmode.S"
+
+	/* Intel, in its infinite wisdom, decided to put the i8086 entry point
+	   *right here* and this is why we need this kludge.  */
+
+	. = GRUB_BOOT_MACHINE_SIZE - 16
+
+       .code16
+       
+	jmp	_start
+	. = GRUB_BOOT_MACHINE_SIZE

grub-core/boot/sparc64/ieee1275/boot.S

@@ -0,0 +1,209 @@
+/* -*-Asm-*- */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/boot.h>
+#include <grub/machine/boot.h>
+
+	.text
+	.align	4
+	.globl	_start
+_start:
+	/* OF CIF entry point arrives in %o4 */
+pic_base:
+	call	boot_continue
+	 mov	%o4, CIF_REG
+
+	. = _start + GRUB_BOOT_MACHINE_VER_MAJ
+boot_version:		.byte	GRUB_BOOT_VERSION_MAJOR, GRUB_BOOT_VERSION_MINOR
+
+	/* The offsets to these locations are defined by the
+	 * GRUB_BOOT_MACHINE_foo macros in include/grub/sparc/ieee1275/boot.h,
+	 * and grub-setup uses this to patch these next three values as needed.
+	 *
+	 * The boot_path will be the OF device path of the partition where the
+	 * rest of the GRUB kernel image resides.  kernel_sector will be set to
+	 * the location of the first block of the GRUB kernel, and
+	 * kernel_address is the location where we should load that first block.
+	 *
+	 * After loading in that block we will execute it by jumping to the
+	 * load address plus the size of the prepended A.OUT header (32 bytes).
+	 */
+boot_path:
+	. = _start + GRUB_BOOT_MACHINE_KERNEL_BYTE
+boot_path_end:
+kernel_byte:		.xword (2 << 9)
+kernel_address:		.word  GRUB_BOOT_MACHINE_KERNEL_ADDR
+
+prom_finddev_name:	.asciz "finddevice"
+prom_chosen_path:	.asciz "/chosen"
+prom_getprop_name:	.asciz "getprop"
+prom_stdout_name:	.asciz "stdout"
+prom_write_name:	.asciz "write"
+prom_bootpath_name:	.asciz "bootpath"
+prom_open_name:		.asciz "open"
+prom_seek_name:		.asciz "seek"
+prom_read_name:		.asciz "read"
+prom_exit_name:		.asciz "exit"
+grub_name:		.asciz "GRUB "
+#define GRUB_NAME_LEN	5
+
+	.align	4
+
+prom_open_error:
+	GET_ABS(prom_open_name, %o2)
+	call	console_write
+	 mov	4, %o3
+	/* fallthru */
+
+prom_error:
+	GET_ABS(prom_exit_name, %o0)
+	/* fallthru */
+
+	/* %o0: OF call name
+	 * %o1: input arg 1
+	 */
+prom_call_1_1_o2:
+	clr	%o2
+	ba	prom_call_x_1
+	 mov	1, %g1
+
+prom_call_getprop:
+	mov	4, %g1
+	stx	%g1, [%l1 + 256]
+	mov	CHOSEN_NODE_REG, %o1
+	ba	prom_call_x_1
+	 GET_ABS(prom_getprop_name, %o0)
+
+prom_call_3_1_o1:
+	ba prom_call_3_1
+	 mov	BOOTDEV_REG, %o1
+
+	
+	/* %o2: message string
+	 * %o3: message length
+	 */
+console_write:
+	GET_ABS(prom_write_name, %o0)
+	mov	STDOUT_NODE_REG, %o1
+	/* fallthru */
+
+	/* %o0: OF call name
+	 * %o1: input arg 1
+	 * %o2: input arg 2
+	 * %o3: input arg 3
+	 */
+prom_call_3_1:	
+	mov	3, %g1
+prom_call_x_1:
+	mov	1, %o5
+	/* fallthru */
+
+	/* %o0: OF call name
+	 * %g1: num inputs
+	 * %o5: num outputs
+	 * %o1-%o4: inputs
+	 */
+prom_call:
+	stx	%o0, [%l1 + 0x00]
+	stx	%g1, [%l1 + 0x08]
+	stx	%o5, [%l1 + 0x10]
+	stx	%o1, [%l1 + 0x18]
+	stx	%o2, [%l1 + 0x20]
+	stx	%o3, [%l1 + 0x28]
+	stx	%o4, [%l1 + 0x30]
+	jmpl	CIF_REG, %g0
+	 mov	%l1, %o0
+
+boot_continue:
+	mov	%o7, PIC_REG		/* PIC base */
+	sethi	%hi(SCRATCH_PAD_BOOT), %l1	/* OF argument slots */
+
+	/* Find the /chosen node so we can fetch the stdout handle,
+	 * and thus perform console output.
+	 *
+	 * chosen_node = prom_finddevice("/chosen")
+	 */
+	GET_ABS(prom_finddev_name, %o0)
+	call	prom_call_1_1_o2
+	 GET_ABS(prom_chosen_path, %o1)
+
+	ldx	[%l1 + 0x20], CHOSEN_NODE_REG
+	brz	CHOSEN_NODE_REG, prom_error
+
+	/* getprop(chosen_node, "stdout", &buffer, buffer_size) */
+	 GET_ABS(prom_stdout_name, %o2)
+	add	%l1, 256, %o3
+	call	prom_call_getprop
+	 mov	1024, %o4
+
+	lduw	[%l1 + 256], STDOUT_NODE_REG
+	brz,pn	STDOUT_NODE_REG, prom_error
+
+	/* write(stdout_node, "GRUB ", strlen("GRUB ")) */
+	 GET_ABS(grub_name, %o2)
+	call	console_write
+	 mov	GRUB_NAME_LEN, %o3
+
+	GET_ABS(boot_path, %o3)
+	ldub	[%o3], %o1
+	brnz,pn	%o1, bootpath_known
+
+	/* getprop(chosen_node, "bootpath", &buffer, buffer_size) */
+	 GET_ABS(prom_bootpath_name, %o2)
+	call	prom_call_getprop
+	 mov	(boot_path_end - boot_path), %o4
+
+bootpath_known:	
+
+	/* Open up the boot_path, and use that handle to read the
+	 * first block of the GRUB kernel image.
+	 *
+	 * bootdev_handle = open(boot_path)
+	 */
+	GET_ABS(prom_open_name, %o0)
+	call	prom_call_1_1_o2
+	 GET_ABS(boot_path, %o1)
+
+	ldx	[%l1 + 0x20], BOOTDEV_REG
+	brz,pn	BOOTDEV_REG, prom_open_error
+
+	/* Since we have 64-bit cells, the high cell of the seek offset
+	 * is zero and the low cell is the entire value.
+	 *
+	 * seek(bootdev, 0, *kernel_byte)
+	 */
+	 GET_ABS(prom_seek_name, %o0)
+	clr	%o2
+	call	prom_call_3_1_o1
+	 LDX_ABS(kernel_byte, 0x00, %o3)
+
+	/* read(bootdev, *kernel_address, 512) */
+	GET_ABS(prom_read_name, %o0)
+	LDUW_ABS(kernel_address, 0x00, %o2)
+	call	prom_call_3_1_o1
+	 mov	512, %o3
+
+	LDUW_ABS(kernel_address, 0x00, %o2)
+	jmpl	%o2, %o7
+	 nop
+
+	. = _start + GRUB_BOOT_MACHINE_CODE_END
+
+/* the last 4 bytes in the sector 0 contain the signature */
+	.word	GRUB_BOOT_MACHINE_SIGNATURE

grub-core/boot/sparc64/ieee1275/diskboot.S

@@ -0,0 +1,145 @@
+/* -*-Asm-*- */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/boot.h>
+#include <grub/machine/boot.h>
+
+	.text
+	.align	4
+	.globl	_start
+_start:
+	/* First stage boot block jumps to us here.  */
+pic_base:
+	call	after_info_block
+	 mov	%o7, PIC_REG
+
+prom_write_name:		.asciz "write"
+prom_seek_name:			.asciz "seek"
+prom_read_name:			.asciz "read"
+prom_close_name:		.asciz "close"
+
+notification_string:		.asciz "Loading kernel"
+#define NOTIFICATION_STRING_LEN	14
+
+notification_step:		.asciz "."
+#define NOTIFICATION_STEP_LEN	1
+
+notification_done:		.asciz "\r\n"
+#define NOTIFICATION_DONE_LEN	2
+
+	.align	4
+
+	/* %o2: message string
+	 * %o3: message length
+	 */
+console_write:
+	GET_ABS(prom_write_name, %o0)
+	mov	STDOUT_NODE_REG, %o1
+	/* fallthru */
+
+	/* %o0: OF call name
+	 * %o1: input arg 1
+	 * %o2: input arg 2
+	 * %o3: input arg 3
+	 */
+prom_call_3_1:
+	mov	3, %g1
+	mov	1, %o5
+	/* fallthru */
+
+	/* %o0: OF call name
+	 * %g1: num inputs
+	 * %o5: num outputs
+	 * %o1-%o4: inputs
+	 */
+prom_call:
+	stx	%o0, [%l1 + 0x00]
+	stx	%g1, [%l1 + 0x08]
+	stx	%o5, [%l1 + 0x10]
+	stx	%o1, [%l1 + 0x18]
+	stx	%o2, [%l1 + 0x20]
+	stx	%o3, [%l1 + 0x28]
+	stx	%o4, [%l1 + 0x30]
+	jmpl	CIF_REG, %g0
+	 mov	%l1, %o0
+
+
+after_info_block:
+	sethi	%hi(SCRATCH_PAD_DISKBOOT), %l1	/* OF argument slots */
+
+	GET_ABS(notification_string, %o2)
+	call	console_write
+	 mov	NOTIFICATION_STRING_LEN, %o3
+
+	GET_ABS(firstlist - GRUB_BOOT_MACHINE_LIST_SIZE, %l2)
+	set	GRUB_BOOT_MACHINE_IMAGE_ADDRESS, %l3
+bootloop:
+	lduw	[%l2 + 0x08], %o0
+	brz	%o0, bootit
+	 lduw	[%l2 + 0x00], %o3
+	sllx	%o3, 32, %o3
+	lduw	[%l2 + 0x04], %o4
+	or	%o3, %o4, %o3
+	GET_ABS(prom_seek_name, %o0)
+	mov	BOOTDEV_REG, %o1
+	clr	%o2
+	call	prom_call_3_1
+	 sllx	%o3, 9, %o3
+
+	GET_ABS(prom_read_name, %o0)
+	mov	BOOTDEV_REG, %o1
+	lduw	[%l2 + 0x08], %o3
+	sllx	%o3, 9, %o3
+	mov	%l3, %o2
+	call	prom_call_3_1
+	 add	%l3, %o3, %l3
+
+	GET_ABS(notification_step, %o2)
+	call	console_write
+	 mov	NOTIFICATION_STEP_LEN, %o3
+
+	ba	bootloop
+	 sub	%l2, GRUB_BOOT_MACHINE_LIST_SIZE, %l2
+
+bootit:
+	GET_ABS(prom_close_name, %o0)
+	mov	1, %g1
+	mov	0, %o5
+	call	prom_call
+	 mov	BOOTDEV_REG, %o1
+
+	GET_ABS(notification_done, %o2)
+	call	console_write
+	 mov	NOTIFICATION_DONE_LEN, %o3
+	sethi	%hi(GRUB_BOOT_MACHINE_IMAGE_ADDRESS), %o2
+	jmpl	%o2 + %lo(GRUB_BOOT_MACHINE_IMAGE_ADDRESS), %o7
+	 mov	CIF_REG, %o4
+1:	ba,a	1b
+
+lastlist:
+	.word	0
+	.word	0
+
+	. = _start + (0x200 - GRUB_BOOT_MACHINE_LIST_SIZE)
+blocklist_default_start:
+	.word	0
+	.word	2
+blocklist_default_len:
+	.word	0
+firstlist:

grub-core/bus/bonito.c

@@ -0,0 +1,90 @@
+/* bonito.c - PCI bonito interface.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/pci.h>
+#include <grub/misc.h>
+
+static grub_uint32_t base_win[GRUB_MACHINE_PCI_NUM_WIN];
+static const grub_size_t sizes_win[GRUB_MACHINE_PCI_NUM_WIN] = 
+  {GRUB_MACHINE_PCI_WIN1_SIZE, GRUB_MACHINE_PCI_WIN_SIZE, 
+   GRUB_MACHINE_PCI_WIN_SIZE};
+/* Usage counters.  */
+static int usage_win[GRUB_MACHINE_PCI_NUM_WIN];
+static grub_addr_t addr_win[GRUB_MACHINE_PCI_NUM_WIN] = 
+  {GRUB_MACHINE_PCI_WIN1_ADDR, GRUB_MACHINE_PCI_WIN2_ADDR,
+   GRUB_MACHINE_PCI_WIN3_ADDR};
+
+static inline void
+write_bases (void)
+{
+  int i;
+  grub_uint32_t reg = 0;
+  for (i = 0; i < GRUB_MACHINE_PCI_NUM_WIN; i++) 
+    reg |= (((base_win[i] >> GRUB_MACHINE_PCI_WIN_SHIFT) 
+	     & GRUB_MACHINE_PCI_WIN_MASK) 
+	    >> (i * GRUB_MACHINE_PCI_WIN_MASK_SIZE));
+  GRUB_MACHINE_PCI_IO_CTRL_REG = reg;
+}
+
+volatile void *
+grub_pci_device_map_range (grub_pci_device_t dev __attribute__ ((unused)),
+			   grub_addr_t base, grub_size_t size)
+{
+  int i;
+  grub_addr_t newbase;
+
+  /* First try already used registers. */
+  for (i = 0; i < GRUB_MACHINE_PCI_NUM_WIN; i++)
+    if (usage_win[i] && base_win[i] <= base 
+	&& base_win[i] + sizes_win[i] > base + size)
+      {
+	usage_win[i]++;
+	return (void *) 
+	  (addr_win[i] | (base & GRUB_MACHINE_PCI_WIN_OFFSET_MASK));
+      }
+  /* Map new register.  */
+  newbase = base & ~GRUB_MACHINE_PCI_WIN_OFFSET_MASK;
+  for (i = 0; i < GRUB_MACHINE_PCI_NUM_WIN; i++)
+    if (!usage_win[i] && newbase <= base 
+	&& newbase + sizes_win[i] > base + size)
+      {
+	usage_win[i]++;
+	base_win[i] = newbase;
+	write_bases ();
+	return (void *) 
+	  (addr_win[i] | (base & GRUB_MACHINE_PCI_WIN_OFFSET_MASK));
+      }
+  grub_fatal ("Out of PCI windows.");
+}
+
+void
+grub_pci_device_unmap_range (grub_pci_device_t dev __attribute__ ((unused)),
+			     volatile void *mem __attribute__ ((unused)),
+			     grub_size_t size __attribute__ ((unused)))
+{
+  int i;
+  for (i = 0; i < GRUB_MACHINE_PCI_NUM_WIN; i++)
+    if (usage_win[i] && addr_win[i] 
+	== (((grub_addr_t) mem) & ~GRUB_MACHINE_PCI_WIN_OFFSET_MASK))
+      {
+	usage_win[i]--;
+	return;
+      }
+  grub_fatal ("Tried to unmap not mapped region");
+}

grub-core/bus/emu/pci.c

@@ -0,0 +1,77 @@
+/* pci.c - Generic PCI interfaces.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2007,2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/pci.h>
+#include <grub/dl.h>
+#include <grub/emu/misc.h>
+#include <grub/util/misc.h>
+
+grub_pci_address_t
+grub_pci_make_address (grub_pci_device_t dev, int reg)
+{
+  grub_pci_address_t ret;
+  ret.dev = dev;
+  ret.pos = reg;
+  return ret;
+}
+
+void
+grub_pci_iterate (grub_pci_iteratefunc_t hook)
+{
+  struct pci_device_iterator *iter;
+  struct pci_slot_match slot;
+  struct pci_device *dev;
+  slot.domain = PCI_MATCH_ANY;
+  slot.bus = PCI_MATCH_ANY;
+  slot.dev = PCI_MATCH_ANY;
+  slot.func = PCI_MATCH_ANY;
+  iter = pci_slot_match_iterator_create (&slot);
+  while ((dev = pci_device_next (iter)))
+    hook (dev, dev->vendor_id | (dev->device_id << 16));
+  pci_iterator_destroy (iter);
+}
+
+void *
+grub_pci_device_map_range (grub_pci_device_t dev, grub_addr_t base,
+			   grub_size_t size)
+{
+  void *addr;
+  int err;
+  err = pci_device_map_range (dev, base, size, PCI_DEV_MAP_FLAG_WRITABLE, &addr);
+  if (err)
+    grub_util_error ("mapping 0x%x failed (error %d)\n", base, err);
+  return addr;
+}
+
+void
+grub_pci_device_unmap_range (grub_pci_device_t dev, void *mem,
+			     grub_size_t size)
+{
+  pci_device_unmap_range (dev, mem, size);
+}
+
+GRUB_MOD_INIT (pci)
+{
+  pci_system_init ();
+}
+
+GRUB_MOD_FINI (pci)
+{
+  pci_system_cleanup ();
+}

grub-core/bus/pci.c

@@ -0,0 +1,65 @@
+/* pci.c - Generic PCI interfaces.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2007,2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/dl.h>
+#include <grub/pci.h>
+
+grub_pci_address_t
+grub_pci_make_address (grub_pci_device_t dev, int reg)
+{
+  return (1 << 31) | (dev.bus << 16) | (dev.device << 11)
+    | (dev.function << 8) | reg;
+}
+
+void
+grub_pci_iterate (grub_pci_iteratefunc_t hook)
+{
+  grub_pci_device_t dev;
+  grub_pci_address_t addr;
+  grub_pci_id_t id;
+  grub_uint32_t hdr;
+
+  for (dev.bus = 0; dev.bus < GRUB_PCI_NUM_BUS; dev.bus++)
+    {
+      for (dev.device = 0; dev.device < GRUB_PCI_NUM_DEVICES; dev.device++)
+	{
+	  for (dev.function = 0; dev.function < 8; dev.function++)
+	    {
+	      addr = grub_pci_make_address (dev, GRUB_PCI_REG_PCI_ID);
+	      id = grub_pci_read (addr);
+
+	      /* Check if there is a device present.  */
+	      if (id >> 16 == 0xFFFF)
+		continue;
+
+	      if (hook (dev, id))
+		return;
+
+	      /* Probe only func = 0 if the device if not multifunction */
+	      if (dev.function == 0)
+		{
+		  addr = grub_pci_make_address (dev, GRUB_PCI_REG_CACHELINE);
+		  hdr = grub_pci_read (addr);
+		  if (!(hdr & 0x800000))
+		    break;
+		}
+	    }
+	}
+    }
+}

grub-core/bus/usb/emu/usb.c

@@ -0,0 +1,195 @@
+/*  usb.c -- libusb USB support for GRUB.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <config.h>
+#include <grub/misc.h>
+#include <grub/mm.h>
+#include <usb.h>
+#include <grub/usb.h>
+#include <grub/dl.h>
+
+
+static struct grub_usb_controller_dev usb_controller =
+{
+  .name = "libusb"
+};
+
+static struct grub_usb_device *grub_usb_devs[128];
+
+struct usb_bus *busses;
+
+static grub_err_t
+grub_libusb_devices (void)
+
+{
+  struct usb_bus *bus;
+  int last = 0;
+
+  busses = usb_get_busses();
+
+  for (bus = busses; bus; bus = bus->next)
+    {
+      struct usb_device *usbdev;
+      struct grub_usb_device *dev;
+
+      for (usbdev = bus->devices; usbdev; usbdev = usbdev->next)
+	{
+	  struct usb_device_descriptor *desc = &usbdev->descriptor;
+	  grub_err_t err;
+
+	  if (! desc->bcdUSB)
+	    continue;
+
+	  dev = grub_malloc (sizeof (*dev));
+	  if (! dev)
+	    return grub_errno;
+
+	  dev->data = usbdev;
+
+	  /* Fill in all descriptors.  */
+	  err = grub_usb_device_initialize (dev);
+	  if (err)
+	    {
+	      grub_errno = GRUB_ERR_NONE;
+	      continue;
+	    }
+
+	  /* Register the device.  */
+	  grub_usb_devs[last++] = dev;
+	}
+    }
+
+  return GRUB_USB_ERR_NONE;
+}
+
+
+int
+grub_usb_iterate (int (*hook) (grub_usb_device_t dev))
+{
+  int i;
+
+  for (i = 0; i < 128; i++)
+    {
+      if (grub_usb_devs[i])
+	{
+	  if (hook (grub_usb_devs[i]))
+	      return 1;
+	}
+    }
+
+  return 0;
+}
+
+grub_usb_err_t
+grub_usb_root_hub (grub_usb_controller_t controller __attribute__((unused)))
+{
+  return GRUB_USB_ERR_NONE;
+}
+
+grub_usb_err_t
+grub_usb_control_msg (grub_usb_device_t dev, grub_uint8_t reqtype,
+		      grub_uint8_t request, grub_uint16_t value,
+		      grub_uint16_t index, grub_size_t size, char *data)
+{
+  usb_dev_handle *devh;
+  struct usb_device *d = dev->data;
+
+  devh = usb_open (d);
+  if (usb_control_msg (devh, reqtype, request,
+		       value, index, data, size, 20) < 0)
+    {
+      usb_close (devh);
+      return GRUB_USB_ERR_STALL;
+    }
+
+  usb_close (devh);
+
+  return GRUB_USB_ERR_NONE;
+}
+
+grub_usb_err_t
+grub_usb_bulk_read (grub_usb_device_t dev,
+		    int endpoint, grub_size_t size, char *data)
+{
+  usb_dev_handle *devh;
+  struct usb_device *d = dev->data;
+
+  devh = usb_open (d);
+  if (usb_claim_interface (devh, 0) < 1)
+    {
+      usb_close (devh);
+      return GRUB_USB_ERR_STALL;
+    }
+
+  if (usb_bulk_read (devh, endpoint, data, size, 20) < 1)
+    {
+      usb_close (devh);
+      return GRUB_USB_ERR_STALL;
+    }
+
+  usb_release_interface (devh, 0);
+  usb_close (devh);
+
+  return GRUB_USB_ERR_NONE;
+}
+
+grub_usb_err_t
+grub_usb_bulk_write (grub_usb_device_t dev,
+		     int endpoint, grub_size_t size, char *data)
+{
+  usb_dev_handle *devh;
+  struct usb_device *d = dev->data;
+
+  devh = usb_open (d);
+  if (usb_claim_interface (devh, 0) < 0)
+    goto fail;
+
+  if (usb_bulk_write (devh, endpoint, data, size, 20) < 0)
+    goto fail;
+
+  if (usb_release_interface (devh, 0) < 0)
+    goto fail;
+
+  usb_close (devh);
+
+  return GRUB_USB_ERR_NONE;
+
+ fail:
+  usb_close (devh);
+  return GRUB_USB_ERR_STALL;
+}
+
+GRUB_MOD_INIT (libusb)
+{
+  usb_init();
+  usb_find_busses();
+  usb_find_devices();
+
+  if (grub_libusb_devices ())
+    return;
+
+  grub_usb_controller_dev_register (&usb_controller);
+
+  return;
+}
+
+GRUB_MOD_FINI (libusb)
+{
+  return;
+}

grub-core/bus/usb/ohci.c

@@ -0,0 +1,611 @@
+/* ohci.c - OHCI Support.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/dl.h>
+#include <grub/mm.h>
+#include <grub/usb.h>
+#include <grub/usbtrans.h>
+#include <grub/misc.h>
+#include <grub/pci.h>
+#include <grub/cpu/pci.h>
+#include <grub/i386/io.h>
+#include <grub/time.h>
+
+struct grub_ohci_hcca
+{
+  /* Pointers to Interrupt Endpoint Descriptors.  Not used by
+     GRUB.  */
+  grub_uint32_t inttable[32];
+
+  /* Current frame number.  */
+  grub_uint16_t framenumber;
+
+  grub_uint16_t pad;
+
+  /* List of completed TDs.  */
+  grub_uint32_t donehead;
+
+  grub_uint8_t reserved[116];
+} __attribute__((packed));
+
+/* OHCI Endpoint Descriptor.  */
+struct grub_ohci_ed
+{
+  grub_uint32_t target;
+  grub_uint32_t td_tail;
+  grub_uint32_t td_head;
+  grub_uint32_t next_ed;
+} __attribute__((packed));
+
+struct grub_ohci_td
+{
+  /* Information used to construct the TOKEN packet.  */
+  grub_uint32_t token;
+
+  grub_uint32_t buffer;
+  grub_uint32_t next_td;
+  grub_uint32_t buffer_end;
+} __attribute__((packed));
+
+typedef struct grub_ohci_td *grub_ohci_td_t;
+typedef struct grub_ohci_ed *grub_ohci_ed_t;
+
+struct grub_ohci
+{
+  volatile grub_uint32_t *iobase;
+  volatile struct grub_ohci_hcca *hcca;
+  struct grub_ohci *next;
+};
+
+static struct grub_ohci *ohci;
+
+typedef enum
+{
+  GRUB_OHCI_REG_REVISION = 0x00,
+  GRUB_OHCI_REG_CONTROL,
+  GRUB_OHCI_REG_CMDSTATUS,
+  GRUB_OHCI_REG_INTSTATUS,
+  GRUB_OHCI_REG_INTENA,
+  GRUB_OHCI_REG_INTDIS,
+  GRUB_OHCI_REG_HCCA,
+  GRUB_OHCI_REG_PERIODIC,
+  GRUB_OHCI_REG_CONTROLHEAD,
+  GRUB_OHCI_REG_CONTROLCURR,
+  GRUB_OHCI_REG_BULKHEAD,
+  GRUB_OHCI_REG_BULKCURR,
+  GRUB_OHCI_REG_DONEHEAD,
+  GRUB_OHCI_REG_FRAME_INTERVAL,
+  GRUB_OHCI_REG_RHUBA = 18,
+  GRUB_OHCI_REG_RHUBPORT = 21
+} grub_ohci_reg_t;
+
+static grub_uint32_t
+grub_ohci_readreg32 (struct grub_ohci *o, grub_ohci_reg_t reg)
+{
+  return grub_le_to_cpu32 (*(o->iobase + reg));
+}
+
+static void
+grub_ohci_writereg32 (struct grub_ohci *o,
+		      grub_ohci_reg_t reg, grub_uint32_t val)
+{
+  *(o->iobase + reg) = grub_cpu_to_le32 (val);
+}
+
+
+
+/* Iterate over all PCI devices.  Determine if a device is an OHCI
+   controller.  If this is the case, initialize it.  */
+static int NESTED_FUNC_ATTR
+grub_ohci_pci_iter (grub_pci_device_t dev,
+		    grub_pci_id_t pciid __attribute__((unused)))
+{
+  grub_uint32_t class_code;
+  grub_uint32_t class;
+  grub_uint32_t subclass;
+  grub_uint32_t interf;
+  grub_uint32_t base;
+  grub_pci_address_t addr;
+  struct grub_ohci *o;
+  grub_uint32_t revision;
+  grub_uint32_t frame_interval;
+
+  addr = grub_pci_make_address (dev, GRUB_PCI_REG_CLASS);
+  class_code = grub_pci_read (addr) >> 8;
+
+  interf = class_code & 0xFF;
+  subclass = (class_code >> 8) & 0xFF;
+  class = class_code >> 16;
+
+  /* If this is not an OHCI controller, just return.  */
+  if (class != 0x0c || subclass != 0x03 || interf != 0x10)
+    return 0;
+
+  /* Determine IO base address.  */
+  addr = grub_pci_make_address (dev, GRUB_PCI_REG_ADDRESS_REG0);
+  base = grub_pci_read (addr);
+
+#if 0
+  /* Stop if there is no IO space base address defined.  */
+  if (! (base & 1))
+    return 0;
+#endif
+
+  /* Allocate memory for the controller and register it.  */
+  o = grub_malloc (sizeof (*o));
+  if (! o)
+    return 1;
+
+  o->iobase = (grub_uint32_t *) base;
+
+  /* Reserve memory for the HCCA.  */
+  o->hcca = (struct grub_ohci_hcca *) grub_memalign (256, 256);
+
+  grub_dprintf ("ohci", "class=0x%02x 0x%02x interface 0x%02x base=%p\n",
+ 		class, subclass, interf, o->iobase);
+
+  /* Check if the OHCI revision is actually 1.0 as supported.  */
+  revision = grub_ohci_readreg32 (o, GRUB_OHCI_REG_REVISION);
+  grub_dprintf ("ohci", "OHCI revision=0x%02x\n", revision & 0xFF);
+  if ((revision & 0xFF) != 0x10)
+    goto fail;
+
+  /* Backup the frame interval register.  */
+  frame_interval = grub_ohci_readreg32 (o, GRUB_OHCI_REG_FRAME_INTERVAL);
+
+  /* Suspend the OHCI by issuing a reset.  */
+  grub_ohci_writereg32 (o, GRUB_OHCI_REG_CMDSTATUS, 1); /* XXX: Magic.  */
+  grub_millisleep (1);
+  grub_dprintf ("ohci", "OHCI reset\n");
+
+  /* Restore the frame interval register.  */
+  grub_ohci_writereg32 (o, GRUB_OHCI_REG_FRAME_INTERVAL, frame_interval);
+
+  /* Setup the HCCA.  */
+  grub_ohci_writereg32 (o, GRUB_OHCI_REG_HCCA, (grub_uint32_t) o->hcca);
+  grub_dprintf ("ohci", "OHCI HCCA\n");
+
+  /* Enable the OHCI.  */
+  grub_ohci_writereg32 (o, GRUB_OHCI_REG_CONTROL,
+			(2 << 6));
+  grub_dprintf ("ohci", "OHCI enable: 0x%02x\n",
+		(grub_ohci_readreg32 (o, GRUB_OHCI_REG_CONTROL) >> 6) & 3);
+
+  /* Link to ohci now that initialisation is successful.  */
+  o->next = ohci;
+  ohci = o;
+
+  return 0;
+
+ fail:
+  if (o)
+    grub_free ((void *) o->hcca);
+  grub_free (o);
+
+  return 1;
+}
+
+
+static void
+grub_ohci_inithw (void)
+{
+  grub_pci_iterate (grub_ohci_pci_iter);
+}
+
+
+
+static int
+grub_ohci_iterate (int (*hook) (grub_usb_controller_t dev))
+{
+  struct grub_ohci *o;
+  struct grub_usb_controller dev;
+
+  for (o = ohci; o; o = o->next)
+    {
+      dev.data = o;
+      if (hook (&dev))
+	return 1;
+    }
+
+  return 0;
+}
+
+static void
+grub_ohci_transaction (grub_ohci_td_t td,
+		       grub_transfer_type_t type, unsigned int toggle,
+		       grub_size_t size, char *data)
+{
+  grub_uint32_t token;
+  grub_uint32_t buffer;
+  grub_uint32_t buffer_end;
+
+  grub_dprintf ("ohci", "OHCI transaction td=%p type=%d, toggle=%d, size=%d\n",
+		td, type, toggle, size);
+
+  switch (type)
+    {
+    case GRUB_USB_TRANSFER_TYPE_SETUP:
+      token = 0 << 19;
+      break;
+    case GRUB_USB_TRANSFER_TYPE_IN:
+      token = 2 << 19;
+      break;
+    case GRUB_USB_TRANSFER_TYPE_OUT:
+      token = 1 << 19;
+      break;
+    default:
+      token = 0;
+      break;
+    }
+
+  /* Generate no interrupts.  */
+  token |= 7 << 21;
+
+  /* Set the token.  */
+  token |= toggle << 24;
+  token |= 1 << 25;
+
+  buffer = (grub_uint32_t) data;
+  buffer_end = buffer + size - 1;
+
+  td->token = grub_cpu_to_le32 (token);
+  td->buffer = grub_cpu_to_le32 (buffer);
+  td->next_td = 0;
+  td->buffer_end = grub_cpu_to_le32 (buffer_end);
+}
+
+static grub_usb_err_t
+grub_ohci_transfer (grub_usb_controller_t dev,
+		    grub_usb_transfer_t transfer)
+{
+  struct grub_ohci *o = (struct grub_ohci *) dev->data;
+  grub_ohci_ed_t ed;
+  grub_ohci_td_t td_list;
+  grub_uint32_t target;
+  grub_uint32_t td_tail;
+  grub_uint32_t td_head;
+  grub_uint32_t status;
+  grub_uint32_t control;
+  grub_usb_err_t err;
+  int i;
+
+  /* Allocate an Endpoint Descriptor.  */
+  ed = grub_memalign (16, sizeof (*ed));
+  if (! ed)
+    return GRUB_USB_ERR_INTERNAL;
+
+  td_list = grub_memalign (16, sizeof (*td_list) * (transfer->transcnt + 1));
+  if (! td_list)
+    {
+      grub_free ((void *) ed);
+      return GRUB_USB_ERR_INTERNAL;
+    }
+
+  grub_dprintf ("ohci", "alloc=%p\n", td_list);
+
+  /* Setup all Transfer Descriptors.  */
+  for (i = 0; i < transfer->transcnt; i++)
+    {
+      grub_usb_transaction_t tr = &transfer->transactions[i];
+
+      grub_ohci_transaction (&td_list[i], tr->pid, tr->toggle,
+			     tr->size, tr->data);
+
+      td_list[i].next_td = grub_cpu_to_le32 (&td_list[i + 1]);
+    }
+
+  /* Setup the Endpoint Descriptor.  */
+
+  /* Set the device address.  */
+  target = transfer->devaddr;
+
+  /* Set the endpoint.  */
+  target |= transfer->endpoint << 7;
+
+  /* Set the device speed.  */
+  target |= (transfer->dev->speed == GRUB_USB_SPEED_LOW) << 13;
+
+  /* Set the maximum packet size.  */
+  target |= transfer->max << 16;
+
+  td_head = (grub_uint32_t) td_list;
+
+  td_tail = (grub_uint32_t) &td_list[transfer->transcnt];
+
+  ed->target = grub_cpu_to_le32 (target);
+  ed->td_head = grub_cpu_to_le32 (td_head);
+  ed->td_tail = grub_cpu_to_le32 (td_tail);
+  ed->next_ed = grub_cpu_to_le32 (0);
+
+  grub_dprintf ("ohci", "program OHCI\n");
+
+  /* Program the OHCI to actually transfer.  */
+  switch (transfer->type)
+    {
+    case GRUB_USB_TRANSACTION_TYPE_BULK:
+      {
+	grub_dprintf ("ohci", "add to bulk list\n");
+
+	status = grub_ohci_readreg32 (o, GRUB_OHCI_REG_CMDSTATUS);
+	control = grub_ohci_readreg32 (o, GRUB_OHCI_REG_CONTROL);
+
+	/* Disable the Control and Bulk lists.  */
+	control &= ~(3 << 4);
+	grub_ohci_writereg32 (o, GRUB_OHCI_REG_CONTROL, control);
+
+	/* Clear BulkListFilled.  */
+	status &= ~(1 << 2);
+	grub_ohci_writereg32 (o, GRUB_OHCI_REG_CMDSTATUS, status);
+
+	grub_ohci_writereg32 (o, GRUB_OHCI_REG_BULKHEAD, (grub_uint32_t) ed);
+
+	/* Enable the Bulk list.  */
+	control |= 1 << 5;
+	grub_ohci_writereg32 (o, GRUB_OHCI_REG_CONTROL, control);
+
+	/* Set BulkListFilled.  */
+	status |= 1 << 2;
+	grub_ohci_writereg32 (o, GRUB_OHCI_REG_CMDSTATUS, status);
+
+	break;
+      }
+
+    case GRUB_USB_TRANSACTION_TYPE_CONTROL:
+      {
+	grub_dprintf ("ohci", "add to control list\n");
+	status = grub_ohci_readreg32 (o, GRUB_OHCI_REG_CMDSTATUS);
+	control = grub_ohci_readreg32 (o, GRUB_OHCI_REG_CONTROL);
+
+	/* Disable the Control and Bulk lists.  */
+	control &= ~(3 << 4);
+	grub_ohci_writereg32 (o, GRUB_OHCI_REG_CONTROL, control);
+
+	/* Clear ControlListFilled.  */
+	status &= ~(1 << 1);
+	grub_ohci_writereg32 (o, GRUB_OHCI_REG_CMDSTATUS, status);
+
+	grub_ohci_writereg32 (o, GRUB_OHCI_REG_CONTROLHEAD,
+			      (grub_uint32_t) ed);
+	grub_ohci_writereg32 (o, GRUB_OHCI_REG_CONTROLHEAD+1,
+			      (grub_uint32_t) ed);
+
+	/* Enable the Control list.  */
+	control |= 1 << 4;
+	grub_ohci_writereg32 (o, GRUB_OHCI_REG_CONTROL, control);
+
+	/* Set ControlListFilled.  */
+	status |= 1 << 1;
+	grub_ohci_writereg32 (o, GRUB_OHCI_REG_CMDSTATUS, status);
+	break;
+      }
+    }
+
+  grub_dprintf ("ohci", "wait for completion\n");
+  grub_dprintf ("ohci", "control=0x%02x status=0x%02x\n",
+		grub_ohci_readreg32 (o, GRUB_OHCI_REG_CONTROL),
+		grub_ohci_readreg32 (o, GRUB_OHCI_REG_CMDSTATUS));
+
+  /* Wait until the transfer is completed or STALLs.  */
+  while ((ed->td_head & ~0xf) != (ed->td_tail & ~0xf))
+    {
+      grub_cpu_idle ();
+
+      grub_dprintf ("ohci", "head=0x%02x tail=0x%02x\n", ed->td_head, ed->td_tail);
+
+      /* Detected a STALL.  */
+      if (ed->td_head & 1)
+	break;
+    }
+
+  grub_dprintf ("ohci", "complete\n");
+
+/*   if (ed->td_head & 1) */
+/*     err = GRUB_USB_ERR_STALL; */
+/*   else if (ed->td */
+
+
+  if (ed->td_head & 1)
+    {
+      grub_uint8_t errcode;
+      grub_ohci_td_t tderr;
+
+      tderr = (grub_ohci_td_t) grub_ohci_readreg32 (o,
+						    GRUB_OHCI_REG_DONEHEAD);
+      errcode = tderr->token >> 28;
+
+      switch (errcode)
+	{
+	case 0:
+	  /* XXX: Should not happen!  */
+	  grub_error (GRUB_ERR_IO, "OHCI without reporting the reason");
+	  err = GRUB_USB_ERR_INTERNAL;
+	  break;
+
+	case 1:
+	  /* XXX: CRC error.  */
+	  err = GRUB_USB_ERR_TIMEOUT;
+	  break;
+
+	case 2:
+	  err = GRUB_USB_ERR_BITSTUFF;
+	  break;
+
+	case 3:
+	  /* XXX: Data Toggle error.  */
+	  err = GRUB_USB_ERR_DATA;
+	  break;
+
+	case 4:
+	  err = GRUB_USB_ERR_STALL;
+	  break;
+
+	case 5:
+	  /* XXX: Not responding.  */
+	  err = GRUB_USB_ERR_TIMEOUT;
+	  break;
+
+	case 6:
+	  /* XXX: PID Check bits failed.  */
+	  err = GRUB_USB_ERR_BABBLE;
+	  break;
+
+	case 7:
+	  /* XXX: PID unexpected failed.  */
+	  err = GRUB_USB_ERR_BABBLE;
+	  break;
+
+	case 8:
+	  /* XXX: Data overrun error.  */
+	  err = GRUB_USB_ERR_DATA;
+	  break;
+
+	case 9:
+	  /* XXX: Data underrun error.  */
+	  err = GRUB_USB_ERR_DATA;
+	  break;
+
+	case 10:
+	  /* XXX: Reserved.  */
+	  err = GRUB_USB_ERR_NAK;
+	  break;
+
+	case 11:
+	  /* XXX: Reserved.  */
+	  err = GRUB_USB_ERR_NAK;
+	  break;
+
+	case 12:
+	  /* XXX: Buffer overrun.  */
+	  err = GRUB_USB_ERR_DATA;
+	  break;
+
+	case 13:
+	  /* XXX: Buffer underrun.  */
+	  err = GRUB_USB_ERR_DATA;
+	  break;
+
+	default:
+	  err = GRUB_USB_ERR_NAK;
+	  break;
+	}
+    }
+  else
+    err = GRUB_USB_ERR_NONE;
+
+  /* Disable the Control and Bulk lists.  */
+  control = grub_ohci_readreg32 (o, GRUB_OHCI_REG_CONTROL);
+  control &= ~(3 << 4);
+  grub_ohci_writereg32 (o, GRUB_OHCI_REG_CONTROL, control);
+
+  /* Clear BulkListFilled and ControlListFilled.  */
+  status = grub_ohci_readreg32 (o, GRUB_OHCI_REG_CMDSTATUS);
+  status &= ~((1 << 2) | (1 << 3));
+  grub_ohci_writereg32 (o, GRUB_OHCI_REG_CMDSTATUS, status);
+
+  /* XXX */
+  grub_free (td_list);
+  grub_free (ed);
+
+  return err;
+}
+
+static grub_err_t
+grub_ohci_portstatus (grub_usb_controller_t dev,
+		      unsigned int port, unsigned int enable)
+{
+   struct grub_ohci *o = (struct grub_ohci *) dev->data;
+   grub_uint32_t status;
+
+   /* Reset the port.  */
+   status = grub_ohci_readreg32 (o, GRUB_OHCI_REG_RHUBPORT + port);
+   status |= (1 << 4); /* XXX: Magic.  */
+   grub_ohci_writereg32 (o, GRUB_OHCI_REG_RHUBPORT + port, status);
+   grub_millisleep (100);
+
+   /* End the reset signaling.  */
+   status = grub_ohci_readreg32 (o, GRUB_OHCI_REG_RHUBPORT + port);
+   status |= (1 << 20); /* XXX: Magic.  */
+   grub_ohci_writereg32 (o, GRUB_OHCI_REG_RHUBPORT + port, status);
+   grub_millisleep (10);
+
+   /* Enable the port.  */
+   status = grub_ohci_readreg32 (o, GRUB_OHCI_REG_RHUBPORT + port);
+   status |= (enable << 1); /* XXX: Magic.  */
+   grub_ohci_writereg32 (o, GRUB_OHCI_REG_RHUBPORT + port, status);
+
+   status = grub_ohci_readreg32 (o, GRUB_OHCI_REG_RHUBPORT + port);
+   grub_dprintf ("ohci", "portstatus=0x%02x\n", status);
+
+   return GRUB_ERR_NONE;
+}
+
+static grub_usb_speed_t
+grub_ohci_detect_dev (grub_usb_controller_t dev, int port)
+{
+   struct grub_ohci *o = (struct grub_ohci *) dev->data;
+   grub_uint32_t status;
+
+   status = grub_ohci_readreg32 (o, GRUB_OHCI_REG_RHUBPORT + port);
+
+   grub_dprintf ("ohci", "detect_dev status=0x%02x\n", status);
+
+   if (! (status & 1))
+     return GRUB_USB_SPEED_NONE;
+   else if (status & (1 << 9))
+     return GRUB_USB_SPEED_LOW;
+   else
+     return GRUB_USB_SPEED_FULL;
+}
+
+static int
+grub_ohci_hubports (grub_usb_controller_t dev)
+{
+  struct grub_ohci *o = (struct grub_ohci *) dev->data;
+  grub_uint32_t portinfo;
+
+  portinfo = grub_ohci_readreg32 (o, GRUB_OHCI_REG_RHUBA);
+
+  grub_dprintf ("ohci", "root hub ports=%d\n", portinfo & 0xFF);
+
+  /* The root hub has exactly two ports.  */
+  return portinfo & 0xFF;
+}
+
+
+
+static struct grub_usb_controller_dev usb_controller =
+{
+  .name = "ohci",
+  .iterate = grub_ohci_iterate,
+  .transfer = grub_ohci_transfer,
+  .hubports = grub_ohci_hubports,
+  .portstatus = grub_ohci_portstatus,
+  .detect_dev = grub_ohci_detect_dev
+};
+
+GRUB_MOD_INIT(ohci)
+{
+  grub_ohci_inithw ();
+  grub_usb_controller_dev_register (&usb_controller);
+}
+
+GRUB_MOD_FINI(ohci)
+{
+  grub_usb_controller_dev_unregister (&usb_controller);
+}

grub-core/bus/usb/uhci.c

@@ -0,0 +1,689 @@
+/* uhci.c - UHCI Support.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/dl.h>
+#include <grub/mm.h>
+#include <grub/misc.h>
+#include <grub/usb.h>
+#include <grub/usbtrans.h>
+#include <grub/pci.h>
+#include <grub/i386/io.h>
+#include <grub/time.h>
+
+#define GRUB_UHCI_IOMASK	(0x7FF << 5)
+
+typedef enum
+  {
+    GRUB_UHCI_REG_USBCMD = 0x00,
+    GRUB_UHCI_REG_FLBASEADD = 0x08,
+    GRUB_UHCI_REG_PORTSC1 = 0x10,
+    GRUB_UHCI_REG_PORTSC2 = 0x12
+  } grub_uhci_reg_t;
+
+#define GRUB_UHCI_LINK_TERMINATE	1
+#define GRUB_UHCI_LINK_QUEUE_HEAD	2
+
+
+/* UHCI Queue Head.  */
+struct grub_uhci_qh
+{
+  /* Queue head link pointer which points to the next queue head.  */
+  grub_uint32_t linkptr;
+
+  /* Queue element link pointer which points to the first data object
+     within the queue.  */
+  grub_uint32_t elinkptr;
+
+  /* Queue heads are aligned on 16 bytes, pad so a queue head is 16
+     bytes so we can store many in a 4K page.  */
+  grub_uint8_t pad[8];
+} __attribute__ ((packed));
+
+/* UHCI Transfer Descriptor.  */
+struct grub_uhci_td
+{
+  /* Pointer to the next TD in the list.  */
+  grub_uint32_t linkptr;
+
+  /* Control and status bits.  */
+  grub_uint32_t ctrl_status;
+
+  /* All information required to transfer the Token packet.  */
+  grub_uint32_t token;
+
+  /* A pointer to the data buffer, UHCI requires this pointer to be 32
+     bits.  */
+  grub_uint32_t buffer;
+
+  /* Another linkptr that is not overwritten by the Host Controller.
+     This is GRUB specific.  */
+  grub_uint32_t linkptr2;
+
+  /* 3 additional 32 bits words reserved for the Host Controller Driver.  */
+  grub_uint32_t data[3];
+} __attribute__ ((packed));
+
+typedef volatile struct grub_uhci_td *grub_uhci_td_t;
+typedef volatile struct grub_uhci_qh *grub_uhci_qh_t;
+
+struct grub_uhci
+{
+  int iobase;
+  grub_uint32_t *framelist;
+
+  /* 256 Queue Heads.  */
+  grub_uhci_qh_t qh;
+
+  /* 256 Transfer Descriptors.  */
+  grub_uhci_td_t td;
+
+  /* Free Transfer Descriptors.  */
+  grub_uhci_td_t tdfree;
+
+  struct grub_uhci *next;
+};
+
+static struct grub_uhci *uhci;
+
+static grub_uint16_t
+grub_uhci_readreg16 (struct grub_uhci *u, grub_uhci_reg_t reg)
+{
+  return grub_inw (u->iobase + reg);
+}
+
+#if 0
+static grub_uint32_t
+grub_uhci_readreg32 (struct grub_uhci *u, grub_uhci_reg_t reg)
+{
+  return grub_inl (u->iobase + reg);
+}
+#endif
+
+static void
+grub_uhci_writereg16 (struct grub_uhci *u,
+		      grub_uhci_reg_t reg, grub_uint16_t val)
+{
+  grub_outw (val, u->iobase + reg);
+}
+
+static void
+grub_uhci_writereg32 (struct grub_uhci *u,
+		    grub_uhci_reg_t reg, grub_uint32_t val)
+{
+  grub_outl (val, u->iobase + reg);
+}
+
+static grub_err_t
+grub_uhci_portstatus (grub_usb_controller_t dev,
+		      unsigned int port, unsigned int enable);
+
+
+/* Iterate over all PCI devices.  Determine if a device is an UHCI
+   controller.  If this is the case, initialize it.  */
+static int NESTED_FUNC_ATTR
+grub_uhci_pci_iter (grub_pci_device_t dev,
+		    grub_pci_id_t pciid __attribute__((unused)))
+{
+  grub_uint32_t class_code;
+  grub_uint32_t class;
+  grub_uint32_t subclass;
+  grub_uint32_t interf;
+  grub_uint32_t base;
+  grub_uint32_t fp;
+  grub_pci_address_t addr;
+  struct grub_uhci *u;
+  int i;
+
+  addr = grub_pci_make_address (dev, GRUB_PCI_REG_CLASS);
+  class_code = grub_pci_read (addr) >> 8;
+
+  interf = class_code & 0xFF;
+  subclass = (class_code >> 8) & 0xFF;
+  class = class_code >> 16;
+
+  /* If this is not an UHCI controller, just return.  */
+  if (class != 0x0c || subclass != 0x03 || interf != 0x00)
+    return 0;
+
+  /* Determine IO base address.  */
+  addr = grub_pci_make_address (dev, GRUB_PCI_REG_ADDRESS_REG4);
+  base = grub_pci_read (addr);
+  /* Stop if there is no IO space base address defined.  */
+  if (! (base & 1))
+    return 0;
+
+  /* Allocate memory for the controller and register it.  */
+  u = grub_zalloc (sizeof (*u));
+  if (! u)
+    return 1;
+
+  u->iobase = base & GRUB_UHCI_IOMASK;
+  grub_dprintf ("uhci", "class=0x%02x 0x%02x interface 0x%02x base=0x%x\n",
+		class, subclass, interf, u->iobase);
+
+  /* Reserve a page for the frame list.  */
+  u->framelist = grub_memalign (4096, 4096);
+  if (! u->framelist)
+    goto fail;
+
+  /* The framelist pointer of UHCI is only 32 bits, make sure this
+     code works on on 64 bits architectures.  */
+#if GRUB_CPU_SIZEOF_VOID_P == 8
+  if ((grub_uint64_t) u->framelist >> 32)
+    {
+      grub_error (GRUB_ERR_OUT_OF_MEMORY,
+		  "allocated frame list memory not <4GB");
+      goto fail;
+    }
+#endif
+
+  /* The QH pointer of UHCI is only 32 bits, make sure this
+     code works on on 64 bits architectures.  */
+  u->qh = (grub_uhci_qh_t) grub_memalign (4096, 4096);
+  if (! u->qh)
+    goto fail;
+
+#if GRUB_CPU_SIZEOF_VOID_P == 8
+  if ((grub_uint64_t) u->qh >> 32)
+    {
+      grub_error (GRUB_ERR_OUT_OF_MEMORY, "allocated QH memory not <4GB");
+      goto fail;
+    }
+#endif
+
+  /* The TD pointer of UHCI is only 32 bits, make sure this
+     code works on on 64 bits architectures.  */
+  u->td = (grub_uhci_td_t) grub_memalign (4096, 4096*2);
+  if (! u->td)
+    goto fail;
+
+#if GRUB_CPU_SIZEOF_VOID_P == 8
+  if ((grub_uint64_t) u->td >> 32)
+    {
+      grub_error (GRUB_ERR_OUT_OF_MEMORY, "allocated TD memory not <4GB");
+      goto fail;
+    }
+#endif
+
+  /* Link all Transfer Descriptors in a list of available Transfer
+     Descriptors.  */
+  for (i = 0; i < 256; i++)
+    u->td[i].linkptr = (grub_uint32_t) &u->td[i + 1];
+  u->td[255 - 1].linkptr = 0;
+  u->tdfree = u->td;
+
+  /* Make sure UHCI is disabled!  */
+  grub_uhci_writereg16 (u, GRUB_UHCI_REG_USBCMD, 0);
+
+  /* Setup the frame list pointers.  Since no isochronous transfers
+     are and will be supported, they all point to the (same!) queue
+     head.  */
+  fp = (grub_uint32_t) u->qh & (~15);
+  /* Mark this as a queue head.  */
+  fp |= 2;
+  for (i = 0; i < 1024; i++)
+    u->framelist[i] = fp;
+  /* Program the framelist address into the UHCI controller.  */
+  grub_uhci_writereg32 (u, GRUB_UHCI_REG_FLBASEADD,
+			(grub_uint32_t) u->framelist);
+
+  /* Make the Queue Heads point to each other.  */
+  for (i = 0; i < 256; i++)
+    {
+      /* Point to the next QH.  */
+      u->qh[i].linkptr = (grub_uint32_t) (&u->qh[i + 1]) & (~15);
+
+      /* This is a QH.  */
+      u->qh[i].linkptr |= GRUB_UHCI_LINK_QUEUE_HEAD;
+
+      /* For the moment, do not point to a Transfer Descriptor.  These
+	 are set at transfer time, so just terminate it.  */
+      u->qh[i].elinkptr = 1;
+    }
+
+  /* The last Queue Head should terminate.  256 are too many QHs so
+     just use 50.  */
+  u->qh[50 - 1].linkptr = 1;
+
+  /* Enable UHCI again.  */
+  grub_uhci_writereg16 (u, GRUB_UHCI_REG_USBCMD, 1 | (1 << 7));
+
+  /* UHCI is initialized and ready for transfers.  */
+  grub_dprintf ("uhci", "UHCI initialized\n");
+
+
+#if 0
+  {
+    int i;
+    for (i = 0; i < 10; i++)
+      {
+	grub_uint16_t frnum;
+
+	frnum = grub_uhci_readreg16 (u, 6);
+	grub_dprintf ("uhci", "Framenum=%d\n", frnum);
+	grub_millisleep (100);
+      }
+  }
+#endif
+
+  /* Link to uhci now that initialisation is successful.  */
+  u->next = uhci;
+  uhci = u;
+
+  return 0;
+
+ fail:
+  if (u)
+    {
+      grub_free ((void *) u->qh);
+      grub_free (u->framelist);
+    }
+  grub_free (u);
+
+  return 1;
+}
+
+static void
+grub_uhci_inithw (void)
+{
+  grub_pci_iterate (grub_uhci_pci_iter);
+}
+
+static grub_uhci_td_t
+grub_alloc_td (struct grub_uhci *u)
+{
+  grub_uhci_td_t ret;
+
+  /* Check if there is a Transfer Descriptor available.  */
+  if (! u->tdfree)
+    return NULL;
+
+  ret = u->tdfree;
+  u->tdfree = (grub_uhci_td_t) u->tdfree->linkptr;
+
+  return ret;
+}
+
+static void
+grub_free_td (struct grub_uhci *u, grub_uhci_td_t td)
+{
+  td->linkptr = (grub_uint32_t) u->tdfree;
+  u->tdfree = td;
+}
+
+static void
+grub_free_queue (struct grub_uhci *u, grub_uhci_td_t td)
+{
+  /* Free the TDs in this queue.  */
+  while (td)
+    {
+      grub_uhci_td_t tdprev;
+
+      /* Unlink the queue.  */
+      tdprev = td;
+      td = (grub_uhci_td_t) td->linkptr2;
+
+      /* Free the TD.  */
+      grub_free_td (u, tdprev);
+    }
+}
+
+static grub_uhci_qh_t
+grub_alloc_qh (struct grub_uhci *u,
+	       grub_transaction_type_t tr __attribute__((unused)))
+{
+  int i;
+  grub_uhci_qh_t qh;
+
+  /* Look for a Queue Head for this transfer.  Skip the first QH if
+     this is a Interrupt Transfer.  */
+#if 0
+  if (tr == GRUB_USB_TRANSACTION_TYPE_INTERRUPT)
+    i = 0;
+  else
+#endif
+    i = 1;
+
+  for (; i < 255; i++)
+    {
+      if (u->qh[i].elinkptr & 1)
+	break;
+    }
+  qh = &u->qh[i];
+  if (! (qh->elinkptr & 1))
+    {
+      grub_error (GRUB_ERR_OUT_OF_MEMORY,
+		  "no free queue heads available");
+      return NULL;
+    }
+
+  return qh;
+}
+
+static grub_uhci_td_t
+grub_uhci_transaction (struct grub_uhci *u, unsigned int endp,
+		       grub_transfer_type_t type, unsigned int addr,
+		       unsigned int toggle, grub_size_t size,
+		       char *data)
+{
+  grub_uhci_td_t td;
+  static const unsigned int tf[] = { 0x69, 0xE1, 0x2D };
+
+  /* XXX: Check if data is <4GB.  If it isn't, just copy stuff around.
+     This is only relevant for 64 bits architectures.  */
+
+  /* Grab a free Transfer Descriptor and initialize it.  */
+  td = grub_alloc_td (u);
+  if (! td)
+    {
+      grub_error (GRUB_ERR_OUT_OF_MEMORY,
+		  "no transfer descriptors available for UHCI transfer");
+      return 0;
+    }
+
+  grub_dprintf ("uhci",
+		"transaction: endp=%d, type=%d, addr=%d, toggle=%d, size=%d data=%p td=%p\n",
+		endp, type, addr, toggle, size, data, td);
+
+  /* Don't point to any TD, just terminate.  */
+  td->linkptr = 1;
+
+  /* Active!  Only retry a transfer 3 times.  */
+  td->ctrl_status = (1 << 23) | (3 << 27);
+
+  /* If zero bytes are transmitted, size is 0x7FF.  Otherwise size is
+     size-1.  */
+  if (size == 0)
+    size = 0x7FF;
+  else
+    size = size - 1;
+
+  /* Setup whatever is required for the token packet.  */
+  td->token = ((size << 21) | (toggle << 19) | (endp << 15)
+	       | (addr << 8) | tf[type]);
+
+  td->buffer = (grub_uint32_t) data;
+
+  return td;
+}
+
+static grub_usb_err_t
+grub_uhci_transfer (grub_usb_controller_t dev,
+		    grub_usb_transfer_t transfer)
+{
+  struct grub_uhci *u = (struct grub_uhci *) dev->data;
+  grub_uhci_qh_t qh;
+  grub_uhci_td_t td;
+  grub_uhci_td_t td_first = NULL;
+  grub_uhci_td_t td_prev = NULL;
+  grub_usb_err_t err = GRUB_USB_ERR_NONE;
+  int i;
+  grub_uint64_t endtime;
+
+  /* Allocate a queue head for the transfer queue.  */
+  qh = grub_alloc_qh (u, GRUB_USB_TRANSACTION_TYPE_CONTROL);
+  if (! qh)
+    return grub_errno;
+
+  for (i = 0; i < transfer->transcnt; i++)
+    {
+      grub_usb_transaction_t tr = &transfer->transactions[i];
+
+      td = grub_uhci_transaction (u, transfer->endpoint, tr->pid,
+				  transfer->devaddr, tr->toggle,
+				  tr->size, tr->data);
+      if (! td)
+	{
+	  /* Terminate and free.  */
+	  td_prev->linkptr2 = 0;
+	  td_prev->linkptr = 1;
+
+	  if (td_first)
+	    grub_free_queue (u, td_first);
+
+	  return GRUB_USB_ERR_INTERNAL;
+	}
+
+      if (! td_first)
+	td_first = td;
+      else
+	{
+	  td_prev->linkptr2 = (grub_uint32_t) td;
+	  td_prev->linkptr = (grub_uint32_t) td;
+	  td_prev->linkptr |= 4;
+	}
+      td_prev = td;
+    }
+  td_prev->linkptr2 = 0;
+  td_prev->linkptr = 1;
+
+  grub_dprintf ("uhci", "setup transaction %d\n", transfer->type);
+
+  /* Link it into the queue and terminate.  Now the transaction can
+     take place.  */
+  qh->elinkptr = (grub_uint32_t) td_first;
+
+  grub_dprintf ("uhci", "initiate transaction\n");
+
+  /* Wait until either the transaction completed or an error
+     occurred.  */
+  endtime = grub_get_time_ms () + 1000;
+  for (;;)
+    {
+      grub_uhci_td_t errtd;
+
+      errtd = (grub_uhci_td_t) (qh->elinkptr & ~0x0f);
+
+      grub_dprintf ("uhci", ">t status=0x%02x data=0x%02x td=%p\n",
+		    errtd->ctrl_status, errtd->buffer & (~15), errtd);
+
+      /* Check if the transaction completed.  */
+      if (qh->elinkptr & 1)
+	break;
+
+      grub_dprintf ("uhci", "t status=0x%02x\n", errtd->ctrl_status);
+
+      /* Check if the TD is not longer active.  */
+      if (! (errtd->ctrl_status & (1 << 23)))
+	{
+	  grub_dprintf ("uhci", ">>t status=0x%02x\n", errtd->ctrl_status);
+
+	  /* Check if the endpoint is stalled.  */
+	  if (errtd->ctrl_status & (1 << 22))
+	    err = GRUB_USB_ERR_STALL;
+
+	  /* Check if an error related to the data buffer occurred.  */
+	  if (errtd->ctrl_status & (1 << 21))
+	    err = GRUB_USB_ERR_DATA;
+
+	  /* Check if a babble error occurred.  */
+	  if (errtd->ctrl_status & (1 << 20))
+	    err = GRUB_USB_ERR_BABBLE;
+
+	  /* Check if a NAK occurred.  */
+	  if (errtd->ctrl_status & (1 << 19))
+	    err = GRUB_USB_ERR_NAK;
+
+	  /* Check if a timeout occurred.  */
+	  if (errtd->ctrl_status & (1 << 18))
+	    err = GRUB_USB_ERR_TIMEOUT;
+
+	  /* Check if a bitstuff error occurred.  */
+	  if (errtd->ctrl_status & (1 << 17))
+	    err = GRUB_USB_ERR_BITSTUFF;
+
+	  if (err)
+	    goto fail;
+
+	  /* Fall through, no errors occurred, so the QH might be
+	     updated.  */
+	  grub_dprintf ("uhci", "transaction fallthrough\n");
+	}
+      if (grub_get_time_ms () > endtime)
+	{
+	  err = GRUB_USB_ERR_STALL;
+	  grub_dprintf ("uhci", "transaction timed out\n");
+	  goto fail;
+	}
+      grub_cpu_idle ();
+    }
+
+  grub_dprintf ("uhci", "transaction complete\n");
+
+ fail:
+
+  grub_dprintf ("uhci", "transaction failed\n");
+
+  /* Place the QH back in the free list and deallocate the associated
+     TDs.  */
+  qh->elinkptr = 1;
+  grub_free_queue (u, td_first);
+
+  return err;
+}
+
+static int
+grub_uhci_iterate (int (*hook) (grub_usb_controller_t dev))
+{
+  struct grub_uhci *u;
+  struct grub_usb_controller dev;
+
+  for (u = uhci; u; u = u->next)
+    {
+      dev.data = u;
+      if (hook (&dev))
+	return 1;
+    }
+
+  return 0;
+}
+
+static grub_err_t
+grub_uhci_portstatus (grub_usb_controller_t dev,
+		      unsigned int port, unsigned int enable)
+{
+  struct grub_uhci *u = (struct grub_uhci *) dev->data;
+  int reg;
+  unsigned int status;
+  grub_uint64_t endtime;
+
+  grub_dprintf ("uhci", "enable=%d port=%d\n", enable, port);
+
+  if (port == 0)
+    reg = GRUB_UHCI_REG_PORTSC1;
+  else if (port == 1)
+    reg = GRUB_UHCI_REG_PORTSC2;
+  else
+    return grub_error (GRUB_ERR_OUT_OF_RANGE,
+		       "UHCI Root Hub port does not exist");
+
+  status = grub_uhci_readreg16 (u, reg);
+  grub_dprintf ("uhci", "detect=0x%02x\n", status);
+
+  /* Reset the port.  */
+  grub_uhci_writereg16 (u, reg, enable << 9);
+
+  /* Wait for the reset to complete.  XXX: How long exactly?  */
+  grub_millisleep (10);
+  status = grub_uhci_readreg16 (u, reg);
+  grub_uhci_writereg16 (u, reg, status & ~(1 << 9));
+  grub_dprintf ("uhci", "reset completed\n");
+  grub_millisleep (10);
+
+  /* Enable the port.  */
+  grub_uhci_writereg16 (u, reg, enable << 2);
+  grub_millisleep (10);
+
+  grub_dprintf ("uhci", "waiting for the port to be enabled\n");
+
+  endtime = grub_get_time_ms () + 1000;
+  while (! (grub_uhci_readreg16 (u, reg) & (1 << 2)))
+    if (grub_get_time_ms () > endtime)
+      return grub_error (GRUB_ERR_IO, "UHCI Timed out");
+
+  status = grub_uhci_readreg16 (u, reg);
+  grub_dprintf ("uhci", ">3detect=0x%02x\n", status);
+
+
+  return GRUB_ERR_NONE;
+}
+
+static grub_usb_speed_t
+grub_uhci_detect_dev (grub_usb_controller_t dev, int port)
+{
+  struct grub_uhci *u = (struct grub_uhci *) dev->data;
+  int reg;
+  unsigned int status;
+
+  if (port == 0)
+    reg = GRUB_UHCI_REG_PORTSC1;
+  else if (port == 1)
+    reg = GRUB_UHCI_REG_PORTSC2;
+  else
+    return grub_error (GRUB_ERR_OUT_OF_RANGE,
+		       "UHCI Root Hub port does not exist");
+
+  status = grub_uhci_readreg16 (u, reg);
+
+  grub_dprintf ("uhci", "detect=0x%02x port=%d\n", status, port);
+
+  if (! (status & 1))
+    return GRUB_USB_SPEED_NONE;
+  else if (status & (1 << 8))
+    return GRUB_USB_SPEED_LOW;
+  else
+    return GRUB_USB_SPEED_FULL;
+}
+
+static int
+grub_uhci_hubports (grub_usb_controller_t dev __attribute__((unused)))
+{
+  /* The root hub has exactly two ports.  */
+  return 2;
+}
+
+
+static struct grub_usb_controller_dev usb_controller =
+{
+  .name = "uhci",
+  .iterate = grub_uhci_iterate,
+  .transfer = grub_uhci_transfer,
+  .hubports = grub_uhci_hubports,
+  .portstatus = grub_uhci_portstatus,
+  .detect_dev = grub_uhci_detect_dev
+};
+
+GRUB_MOD_INIT(uhci)
+{
+  grub_uhci_inithw ();
+  grub_usb_controller_dev_register (&usb_controller);
+  grub_dprintf ("uhci", "registered\n");
+}
+
+GRUB_MOD_FINI(uhci)
+{
+  struct grub_uhci *u;
+
+  /* Disable all UHCI controllers.  */
+  for (u = uhci; u; u = u->next)
+    grub_uhci_writereg16 (u, GRUB_UHCI_REG_USBCMD, 0);
+
+  /* Unregister the controller.  */
+  grub_usb_controller_dev_unregister (&usb_controller);
+}

grub-core/bus/usb/usb.c

@@ -0,0 +1,227 @@
+/* usb.c - Generic USB interfaces.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/dl.h>
+#include <grub/mm.h>
+#include <grub/usb.h>
+#include <grub/misc.h>
+
+static grub_usb_controller_dev_t grub_usb_list;
+
+void
+grub_usb_controller_dev_register (grub_usb_controller_dev_t usb)
+{
+  auto int iterate_hook (grub_usb_controller_t dev);
+
+  /* Iterate over all controllers found by the driver.  */
+  int iterate_hook (grub_usb_controller_t dev)
+    {
+      dev->dev = usb;
+
+      /* Enable the ports of the USB Root Hub.  */
+      grub_usb_root_hub (dev);
+
+      return 0;
+    }
+
+  usb->next = grub_usb_list;
+  grub_usb_list = usb;
+
+  if (usb->iterate)
+    usb->iterate (iterate_hook);
+}
+
+void
+grub_usb_controller_dev_unregister (grub_usb_controller_dev_t usb)
+{
+  grub_usb_controller_dev_t *p, q;
+
+  for (p = &grub_usb_list, q = *p; q; p = &(q->next), q = q->next)
+    if (q == usb)
+      {
+	*p = q->next;
+	break;
+      }
+}
+
+#if 0
+int
+grub_usb_controller_iterate (int (*hook) (grub_usb_controller_t dev))
+{
+  grub_usb_controller_dev_t p;
+
+  auto int iterate_hook (grub_usb_controller_t dev);
+
+  int iterate_hook (grub_usb_controller_t dev)
+    {
+      dev->dev = p;
+      if (hook (dev))
+	return 1;
+      return 0;
+    }
+
+  /* Iterate over all controller drivers.  */
+  for (p = grub_usb_list; p; p = p->next)
+    {
+      /* Iterate over the busses of the controllers.  XXX: Actually, a
+	 hub driver should do this.  */
+      if (p->iterate (iterate_hook))
+	return 1;
+    }
+
+  return 0;
+}
+#endif
+
+
+grub_usb_err_t
+grub_usb_clear_halt (grub_usb_device_t dev, int endpoint)
+{
+  dev->toggle[endpoint] = 0;
+  return grub_usb_control_msg (dev, (GRUB_USB_REQTYPE_OUT
+				     | GRUB_USB_REQTYPE_STANDARD
+				     | GRUB_USB_REQTYPE_TARGET_ENDP),
+			       GRUB_USB_REQ_CLEAR_FEATURE,
+			       GRUB_USB_FEATURE_ENDP_HALT,
+			       endpoint, 0, 0);
+}
+
+grub_usb_err_t
+grub_usb_set_configuration (grub_usb_device_t dev, int configuration)
+{
+  int i;
+
+  for (i = 0; i < 16; i++)
+    dev->toggle[i] = 0;
+
+  return grub_usb_control_msg (dev, (GRUB_USB_REQTYPE_OUT
+				     | GRUB_USB_REQTYPE_STANDARD
+				     | GRUB_USB_REQTYPE_TARGET_DEV),
+			       GRUB_USB_REQ_SET_CONFIGURATION, configuration,
+			       0, 0, NULL);
+}
+
+grub_usb_err_t
+grub_usb_get_descriptor (grub_usb_device_t dev,
+			 grub_uint8_t type, grub_uint8_t index,
+			 grub_size_t size, char *data)
+{
+  return grub_usb_control_msg (dev, (GRUB_USB_REQTYPE_IN
+				     | GRUB_USB_REQTYPE_STANDARD
+				     | GRUB_USB_REQTYPE_TARGET_DEV),
+			       GRUB_USB_REQ_GET_DESCRIPTOR,
+			       (type << 8) | index,
+			       0, size, data);
+}
+
+struct grub_usb_desc_endp *
+grub_usb_get_endpdescriptor (grub_usb_device_t usbdev, int addr)
+{
+  int i;
+
+  for (i = 0; i < usbdev->config[0].descconf->numif; i++)
+    {
+      struct grub_usb_desc_if *interf;
+      int j;
+
+      interf = usbdev->config[0].interf[i].descif;
+
+      for (j = 0; j < interf->endpointcnt; j++)
+	{
+	  struct grub_usb_desc_endp *endp;
+	  endp = &usbdev->config[0].interf[i].descendp[j];
+
+	  if (endp->endp_addr == addr)
+	    return endp;
+	}
+    }
+
+  return NULL;
+}
+
+grub_usb_err_t
+grub_usb_device_initialize (grub_usb_device_t dev)
+{
+  struct grub_usb_desc_device *descdev;
+  struct grub_usb_desc_config config;
+  grub_usb_err_t err;
+  int i;
+
+  err = grub_usb_get_descriptor (dev, GRUB_USB_DESCRIPTOR_DEVICE,
+				 0, sizeof (struct grub_usb_desc_device),
+				 (char *) &dev->descdev);
+  if (err)
+    return err;
+  descdev = &dev->descdev;
+
+  for (i = 0; i < 8; i++)
+    dev->config[i].descconf = NULL;
+
+  for (i = 0; i < descdev->configcnt; i++)
+    {
+      int pos;
+      int currif;
+      char *data;
+
+      /* First just read the first 4 bytes of the configuration
+	 descriptor, after that it is known how many bytes really have
+	 to be read.  */
+      err = grub_usb_get_descriptor (dev, GRUB_USB_DESCRIPTOR_CONFIG, i, 4,
+				     (char *) &config);
+
+      data = grub_malloc (config.totallen);
+      if (! data)
+	{
+	  err = GRUB_USB_ERR_INTERNAL;
+	  goto fail;
+	}
+
+      dev->config[i].descconf = (struct grub_usb_desc_config *) data;
+      err = grub_usb_get_descriptor (dev, GRUB_USB_DESCRIPTOR_CONFIG, i,
+				     config.totallen, data);
+      if (err)
+	goto fail;
+
+      /* Skip the configuration descriptor.  */
+      pos = sizeof (struct grub_usb_desc_config);
+
+      /* Read all interfaces.  */
+      for (currif = 0; currif < dev->config[i].descconf->numif; currif++)
+	{
+	  dev->config[i].interf[currif].descif
+	    = (struct grub_usb_desc_if *) &data[pos];
+	  pos += sizeof (struct grub_usb_desc_if);
+
+	  /* Point to the first endpoint.  */
+	  dev->config[i].interf[currif].descendp
+	    = (struct grub_usb_desc_endp *) &data[pos];
+	  pos += (sizeof (struct grub_usb_desc_endp)
+		  * dev->config[i].interf[currif].descif->endpointcnt);
+	}
+    }
+
+  return GRUB_USB_ERR_NONE;
+
+ fail:
+
+  for (i = 0; i < 8; i++)
+    grub_free (dev->config[i].descconf);
+
+  return err;
+}

grub-core/bus/usb/usbhub.c

@@ -0,0 +1,192 @@
+/* usb.c - USB Hub Support.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/dl.h>
+#include <grub/mm.h>
+#include <grub/usb.h>
+#include <grub/misc.h>
+
+/* USB Supports 127 devices, with device 0 as special case.  */
+static struct grub_usb_device *grub_usb_devs[128];
+
+/* Add a device that currently has device number 0 and resides on
+   CONTROLLER, the Hub reported that the device speed is SPEED.  */
+static grub_usb_device_t
+grub_usb_hub_add_dev (grub_usb_controller_t controller, grub_usb_speed_t speed)
+{
+  grub_usb_device_t dev;
+  int i;
+
+  dev = grub_zalloc (sizeof (struct grub_usb_device));
+  if (! dev)
+    return NULL;
+
+  dev->controller = *controller;
+  dev->speed = speed;
+
+  grub_usb_device_initialize (dev);
+
+  /* Assign a new address to the device.  */
+  for (i = 1; i < 128; i++)
+    {
+      if (! grub_usb_devs[i])
+	break;
+    }
+  if (i == 128)
+    {
+      grub_error (GRUB_ERR_IO, "can't assign address to USB device");
+      return NULL;
+    }
+
+  grub_usb_control_msg (dev,
+			(GRUB_USB_REQTYPE_OUT
+			 | GRUB_USB_REQTYPE_STANDARD
+			 | GRUB_USB_REQTYPE_TARGET_DEV),
+			GRUB_USB_REQ_SET_ADDRESS,
+			i, 0, 0, NULL);
+
+  dev->addr = i;
+  dev->initialized = 1;
+  grub_usb_devs[i] = dev;
+
+  return dev;
+}
+
+
+static grub_err_t
+grub_usb_add_hub (grub_usb_device_t dev)
+{
+  struct grub_usb_usb_hubdesc hubdesc;
+  grub_err_t err;
+  int i;
+
+  grub_usb_control_msg (dev, (GRUB_USB_REQTYPE_IN
+			      | GRUB_USB_REQTYPE_CLASS
+			      | GRUB_USB_REQTYPE_TARGET_DEV),
+			GRUB_USB_REQ_GET_DESCRIPTOR,
+			(GRUB_USB_DESCRIPTOR_HUB << 8) | 0,
+			0, sizeof (hubdesc), (char *) &hubdesc);
+
+  /* Iterate over the Hub ports.  */
+  for (i = 1; i <= hubdesc.portcnt; i++)
+    {
+      grub_uint32_t status;
+
+      /* Get the port status.  */
+      err = grub_usb_control_msg (dev, (GRUB_USB_REQTYPE_IN
+					| GRUB_USB_REQTYPE_CLASS
+					| GRUB_USB_REQTYPE_TARGET_OTHER),
+				  GRUB_USB_REQ_HUB_GET_PORT_STATUS,
+				  0, i, sizeof (status), (char *) &status);
+
+      /* Just ignore the device if the Hub does not report the
+	 status.  */
+      if (err)
+	continue;
+
+      /* If connected, reset and enable the port.  */
+      if (status & GRUB_USB_HUB_STATUS_CONNECTED)
+	{
+	  grub_usb_speed_t speed;
+
+	  /* Determine the device speed.  */
+	  if (status & GRUB_USB_HUB_STATUS_LOWSPEED)
+	    speed = GRUB_USB_SPEED_LOW;
+	  else
+	    {
+	      if (status & GRUB_USB_HUB_STATUS_HIGHSPEED)
+		speed = GRUB_USB_SPEED_HIGH;
+	      else
+		speed = GRUB_USB_SPEED_FULL;
+	    }
+
+	  /* A device is actually connected to this port, not enable
+	     the port.  XXX: Why 0x03?  According to some docs it
+	     should be 0x0.  Check the specification!  */
+	  err = grub_usb_control_msg (dev, (GRUB_USB_REQTYPE_OUT
+					    | GRUB_USB_REQTYPE_CLASS
+					    | GRUB_USB_REQTYPE_TARGET_OTHER),
+				      0x3, 0x4, i, 0, 0);
+
+	  /* If the Hub does not cooperate for this port, just skip
+	     the port.  */
+	  if (err)
+	    continue;
+
+	  /* Add the device and assign a device address to it.  */
+	  grub_usb_hub_add_dev (&dev->controller, speed);
+	}
+    }
+
+  return GRUB_ERR_NONE;
+}
+
+grub_usb_err_t
+grub_usb_root_hub (grub_usb_controller_t controller)
+{
+  grub_err_t err;
+  int ports;
+  int i;
+
+  /* Query the number of ports the root Hub has.  */
+  ports = controller->dev->hubports (controller);
+
+  for (i = 0; i < ports; i++)
+    {
+      grub_usb_speed_t speed = controller->dev->detect_dev (controller, i);
+
+      if (speed != GRUB_USB_SPEED_NONE)
+	{
+	  grub_usb_device_t dev;
+
+	  /* Enable the port.  */
+	  err = controller->dev->portstatus (controller, i, 1);
+	  if (err)
+	    continue;
+
+	  /* Enable the port and create a device.  */
+	  dev = grub_usb_hub_add_dev (controller, speed);
+	  if (! dev)
+	    continue;
+
+	  /* If the device is a Hub, scan it for more devices.  */
+	  if (dev->descdev.class == 0x09)
+	    grub_usb_add_hub (dev);
+	}
+    }
+
+  return GRUB_USB_ERR_NONE;
+}
+
+int
+grub_usb_iterate (int (*hook) (grub_usb_device_t dev))
+{
+  int i;
+
+  for (i = 0; i < 128; i++)
+    {
+      if (grub_usb_devs[i])
+	{
+	  if (hook (grub_usb_devs[i]))
+	      return 1;
+	}
+    }
+
+  return 0;
+}

grub-core/bus/usb/usbtrans.c

@@ -0,0 +1,212 @@
+/* usbtrans.c - USB Transfers and Transactions.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/dl.h>
+#include <grub/mm.h>
+#include <grub/misc.h>
+#include <grub/usb.h>
+#include <grub/usbtrans.h>
+
+grub_usb_err_t
+grub_usb_control_msg (grub_usb_device_t dev,
+		      grub_uint8_t reqtype,
+		      grub_uint8_t request,
+		      grub_uint16_t value,
+		      grub_uint16_t index,
+		      grub_size_t size, char *data)
+{
+  int i;
+  grub_usb_transfer_t transfer;
+  int datablocks;
+  struct grub_usb_packet_setup setupdata;
+  grub_usb_err_t err;
+  unsigned int max;
+
+  grub_dprintf ("usb",
+		"control: reqtype=0x%02x req=0x%02x val=0x%02x idx=0x%02x size=%d\n",
+		reqtype, request,  value, index, size);
+
+  /* Create a transfer.  */
+  transfer = grub_malloc (sizeof (struct grub_usb_transfer));
+  if (! transfer)
+    return grub_errno;
+
+  /* Determine the maximum packet size.  */
+  if (dev->initialized)
+    max = dev->descdev.maxsize0;
+  else
+    max = 64;
+
+  datablocks = (size + max - 1) / max;
+
+  /* XXX: Discriminate between different types of control
+     messages.  */
+  transfer->transcnt = datablocks + 2;
+  transfer->size = size; /* XXX ? */
+  transfer->endpoint = 0;
+  transfer->devaddr = dev->addr;
+  transfer->type = GRUB_USB_TRANSACTION_TYPE_CONTROL;
+  transfer->max = max;
+  transfer->dev = dev;
+
+  /* Allocate an array of transfer data structures.  */
+  transfer->transactions = grub_malloc (transfer->transcnt
+					* sizeof (struct grub_usb_transfer));
+  if (! transfer->transactions)
+    {
+      grub_free (transfer);
+      return grub_errno;
+    }
+
+  /* Build a Setup packet.  XXX: Endianness.  */
+  setupdata.reqtype = reqtype;
+  setupdata.request = request;
+  setupdata.value = value;
+  setupdata.index = index;
+  setupdata.length = size;
+  transfer->transactions[0].size = sizeof (setupdata);
+  transfer->transactions[0].pid = GRUB_USB_TRANSFER_TYPE_SETUP;
+  transfer->transactions[0].data = (char *) &setupdata;
+  transfer->transactions[0].toggle = 0;
+
+  /* Now the data...  XXX: Is this the right way to transfer control
+     transfers?  */
+  for (i = 0; i < datablocks; i++)
+    {
+      grub_usb_transaction_t tr = &transfer->transactions[i + 1];
+
+      tr->size = (size > max) ? max : size;
+      /* Use the right most bit as the data toggle.  Simple and
+	 effective.  */
+      tr->toggle = !(i & 1);
+      if (reqtype & 128)
+	tr->pid = GRUB_USB_TRANSFER_TYPE_IN;
+      else
+	tr->pid = GRUB_USB_TRANSFER_TYPE_OUT;
+      tr->data = &data[i * max];
+      size -= max;
+    }
+
+  /* End with an empty OUT transaction.  */
+  transfer->transactions[datablocks + 1].size = 0;
+  transfer->transactions[datablocks + 1].data = NULL;
+  if (reqtype & 128)
+    transfer->transactions[datablocks + 1].pid = GRUB_USB_TRANSFER_TYPE_OUT;
+  else
+    transfer->transactions[datablocks + 1].pid = GRUB_USB_TRANSFER_TYPE_IN;
+
+  transfer->transactions[datablocks + 1].toggle = 1;
+
+  err = dev->controller.dev->transfer (&dev->controller, transfer);
+
+  grub_free (transfer->transactions);
+  grub_free (transfer);
+
+  return err;
+}
+
+static grub_usb_err_t
+grub_usb_bulk_readwrite (grub_usb_device_t dev,
+			 int endpoint, grub_size_t size, char *data,
+			 grub_transfer_type_t type)
+{
+  int i;
+  grub_usb_transfer_t transfer;
+  int datablocks;
+  unsigned int max;
+  grub_usb_err_t err;
+  int toggle = dev->toggle[endpoint];
+
+  /* Use the maximum packet size given in the endpoint descriptor.  */
+  if (dev->initialized)
+    {
+      struct grub_usb_desc_endp *endpdesc;
+      endpdesc = grub_usb_get_endpdescriptor (dev, 0);
+
+      if (endpdesc)
+	max = endpdesc->maxpacket;
+      else
+	max = 64;
+    }
+  else
+    max = 64;
+
+  /* Create a transfer.  */
+  transfer = grub_malloc (sizeof (struct grub_usb_transfer));
+  if (! transfer)
+    return grub_errno;
+
+  datablocks = ((size + max - 1) / max);
+  transfer->transcnt = datablocks;
+  transfer->size = size - 1;
+  transfer->endpoint = endpoint;
+  transfer->devaddr = dev->addr;
+  transfer->type = GRUB_USB_TRANSACTION_TYPE_BULK;
+  transfer->max = max;
+  transfer->dev = dev;
+
+  /* Allocate an array of transfer data structures.  */
+  transfer->transactions = grub_malloc (transfer->transcnt
+					* sizeof (struct grub_usb_transfer));
+  if (! transfer->transactions)
+    {
+      grub_free (transfer);
+      return grub_errno;
+    }
+
+  /* Set up all transfers.  */
+  for (i = 0; i < datablocks; i++)
+    {
+      grub_usb_transaction_t tr = &transfer->transactions[i];
+
+      tr->size = (size > max) ? max : size;
+      /* XXX: Use the right most bit as the data toggle.  Simple and
+	 effective.  */
+      tr->toggle = toggle;
+      toggle = toggle ? 0 : 1;
+      tr->pid = type;
+      tr->data = &data[i * max];
+      size -= tr->size;
+    }
+
+  err = dev->controller.dev->transfer (&dev->controller, transfer);
+  grub_dprintf ("usb", "toggle=%d\n", toggle);
+  dev->toggle[endpoint] = toggle;
+
+  grub_free (transfer->transactions);
+  grub_free (transfer);
+
+  return err;
+}
+
+grub_usb_err_t
+grub_usb_bulk_write (grub_usb_device_t dev,
+		     int endpoint, grub_size_t size, char *data)
+{
+  return grub_usb_bulk_readwrite (dev, endpoint, size, data,
+				  GRUB_USB_TRANSFER_TYPE_OUT);
+}
+
+grub_usb_err_t
+grub_usb_bulk_read (grub_usb_device_t dev,
+		    int endpoint, grub_size_t size, char *data)
+{
+  return grub_usb_bulk_readwrite (dev, endpoint, size, data,
+				  GRUB_USB_TRANSFER_TYPE_IN);
+}

grub-core/commands/acpi.c

@@ -0,0 +1,774 @@
+/* acpi.c - modify acpi tables. */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/dl.h>
+#include <grub/extcmd.h>
+#include <grub/file.h>
+#include <grub/disk.h>
+#include <grub/term.h>
+#include <grub/misc.h>
+#include <grub/gzio.h>
+#include <grub/acpi.h>
+#include <grub/mm.h>
+#include <grub/machine/memory.h>
+#include <grub/memory.h>
+#include <grub/i18n.h>
+
+#ifdef GRUB_MACHINE_EFI
+#include <grub/efi/efi.h>
+#include <grub/efi/api.h>
+#endif
+
+static const struct grub_arg_option options[] = {
+  {"exclude", 'x', 0,
+   N_("Don't load host tables specified by comma-separated list."),
+   0, ARG_TYPE_STRING},
+  {"load-only", 'n', 0,
+   N_("Load only tables specified by comma-separated list."), 0, ARG_TYPE_STRING},
+  {"v1", '1', 0, N_("Expose v1 tables."), 0, ARG_TYPE_NONE},
+  {"v2", '2', 0, N_("Expose v2 and v3 tables."), 0, ARG_TYPE_NONE},
+  {"oemid", 'o', 0, N_("Set OEMID of RSDP, XSDT and RSDT."), 0, ARG_TYPE_STRING},
+  {"oemtable", 't', 0,
+   N_("Set OEMTABLE ID of RSDP, XSDT and RSDT."), 0, ARG_TYPE_STRING},
+  {"oemtablerev", 'r', 0,
+   N_("Set OEMTABLE revision of RSDP, XSDT and RSDT."), 0, ARG_TYPE_INT},
+  {"oemtablecreator", 'c', 0,
+   N_("Set creator field of RSDP, XSDT and RSDT."), 0, ARG_TYPE_STRING},
+  {"oemtablecreatorrev", 'd', 0,
+   N_("Set creator revision of RSDP, XSDT and RSDT."), 0, ARG_TYPE_INT},
+  {"no-ebda", 'e', 0, N_("Don't update EBDA. May fix failures or hangs on some."
+   " BIOSes but makes it ineffective with OS not receiving RSDP from GRUB."),
+   0, ARG_TYPE_NONE},
+  {0, 0, 0, 0, 0, 0}
+};
+
+/* Simple checksum by summing all bytes. Used by ACPI and SMBIOS. */
+grub_uint8_t
+grub_byte_checksum (void *base, grub_size_t size)
+{
+  grub_uint8_t *ptr;
+  grub_uint8_t ret = 0;
+  for (ptr = (grub_uint8_t *) base; ptr < ((grub_uint8_t *) base) + size;
+       ptr++)
+    ret += *ptr;
+  return ret;
+}
+
+/* rev1 is 1 if ACPIv1 is to be generated, 0 otherwise.
+   rev2 contains the revision of ACPIv2+ to generate or 0 if none. */
+static int rev1, rev2;
+/* OEMID of RSDP, RSDT and XSDT. */
+static char root_oemid[6];
+/* OEMTABLE of the same tables. */
+static char root_oemtable[8];
+/* OEMREVISION of the same tables. */
+static grub_uint32_t root_oemrev;
+/* CreatorID of the same tables. */
+static char root_creator_id[4];
+/* CreatorRevision of the same tables. */
+static grub_uint32_t root_creator_rev;
+static struct grub_acpi_rsdp_v10 *rsdpv1_new = 0;
+static struct grub_acpi_rsdp_v20 *rsdpv2_new = 0;
+static char *playground = 0, *playground_ptr = 0;
+static int playground_size = 0;
+
+/* Linked list of ACPI tables. */
+struct efiemu_acpi_table
+{
+  void *addr;
+  grub_size_t size;
+  struct efiemu_acpi_table *next;
+};
+static struct efiemu_acpi_table *acpi_tables = 0;
+
+/* DSDT isn't in RSDT. So treat it specially. */
+static void *table_dsdt = 0;
+/* Pointer to recreated RSDT. */
+static void *rsdt_addr = 0;
+
+/* Allocation handles for different tables. */
+static grub_size_t dsdt_size = 0;
+
+/* Address of original FACS. */
+static grub_uint32_t facs_addr = 0;
+
+struct grub_acpi_rsdp_v20 *
+grub_acpi_get_rsdpv2 (void)
+{
+  if (rsdpv2_new)
+    return rsdpv2_new;
+  if (rsdpv1_new)
+    return 0;
+  return grub_machine_acpi_get_rsdpv2 ();
+}
+
+struct grub_acpi_rsdp_v10 *
+grub_acpi_get_rsdpv1 (void)
+{
+  if (rsdpv1_new)
+    return rsdpv1_new;
+  if (rsdpv2_new)
+    return 0;
+  return grub_machine_acpi_get_rsdpv1 ();
+}
+
+static inline int
+iszero (grub_uint8_t *reg, int size)
+{
+  int i;
+  for (i = 0; i < size; i++)
+    if (reg[i])
+      return 0;
+  return 1;
+}
+
+grub_err_t
+grub_acpi_create_ebda (void)
+{
+  int ebda_kb_len;
+  int ebda_len;
+  int mmapregion = 0;
+  grub_uint8_t *ebda, *v1inebda = 0, *v2inebda = 0;
+  grub_uint64_t highestlow = 0;
+  grub_uint8_t *targetebda, *target;
+  struct grub_acpi_rsdp_v10 *v1;
+  struct grub_acpi_rsdp_v20 *v2;
+  auto int NESTED_FUNC_ATTR find_hook (grub_uint64_t, grub_uint64_t,
+				       grub_uint32_t);
+  int NESTED_FUNC_ATTR find_hook (grub_uint64_t start, grub_uint64_t size,
+				  grub_uint32_t type)
+  {
+    grub_uint64_t end = start + size;
+    if (type != GRUB_MACHINE_MEMORY_AVAILABLE)
+      return 0;
+    if (end > 0x100000)
+      end = 0x100000;
+    if (end > start + ebda_len
+	&& highestlow < ((end - ebda_len) & (~0xf)) )
+      highestlow = (end - ebda_len) & (~0xf);
+    return 0;
+  }
+
+  ebda = (grub_uint8_t *) UINT_TO_PTR ((*((grub_uint16_t *)0x40e)) << 4);
+  ebda_kb_len = *(grub_uint16_t *) ebda;
+  if (! ebda || ebda_kb_len > 16)
+    ebda_kb_len = 0;
+  ebda_len = (ebda_kb_len + 1) << 10;
+
+  /* FIXME: use low-memory mm allocation once it's available. */
+  grub_mmap_iterate (find_hook);
+  targetebda = (grub_uint8_t *) UINT_TO_PTR (highestlow);
+  grub_dprintf ("acpi", "creating ebda @%llx\n",
+		(unsigned long long) highestlow);
+  if (! highestlow)
+    return grub_error (GRUB_ERR_OUT_OF_MEMORY,
+		       "couldn't find space for the new EBDA");
+
+  mmapregion = grub_mmap_register (PTR_TO_UINT64 (targetebda), ebda_len,
+				   GRUB_MACHINE_MEMORY_RESERVED);
+  if (! mmapregion)
+    return grub_errno;
+
+  /* XXX: EBDA is unstandardized, so this implementation is heuristical. */
+  if (ebda_kb_len)
+    grub_memcpy (targetebda, ebda, 0x400);
+  else
+    grub_memset (targetebda, 0, 0x400);
+  *((grub_uint16_t *) targetebda) = ebda_kb_len + 1;
+  target = targetebda;
+
+  v1 = grub_acpi_get_rsdpv1 ();
+  v2 = grub_acpi_get_rsdpv2 ();
+  if (v2 && v2->length > 40)
+    v2 = 0;
+
+  /* First try to replace already existing rsdp. */
+  if (v2)
+    {
+      grub_dprintf ("acpi", "Scanning EBDA for old rsdpv2\n");
+      for (; target < targetebda + 0x400 - v2->length; target += 0x10)
+	if (grub_memcmp (target, "RSD PTR ", 8) == 0
+	    && grub_byte_checksum (target,
+				   sizeof (struct grub_acpi_rsdp_v10)) == 0
+	    && ((struct grub_acpi_rsdp_v10 *) target)->revision != 0
+	    && ((struct grub_acpi_rsdp_v20 *) target)->length <= v2->length)
+	  {
+	    grub_memcpy (target, v2, v2->length);
+	    grub_dprintf ("acpi", "Copying rsdpv2 to %p\n", target);
+	    v2inebda = target;
+	    target += v2->length;
+	    target = (grub_uint8_t *) ((((long) target - 1) | 0xf) + 1);
+	    v2 = 0;
+	    break;
+	  }
+    }
+
+  if (v1)
+    {
+      grub_dprintf ("acpi", "Scanning EBDA for old rsdpv1\n");
+      for (; target < targetebda + 0x400 - sizeof (struct grub_acpi_rsdp_v10);
+	   target += 0x10)
+	if (grub_memcmp (target, "RSD PTR ", 8) == 0
+	    && grub_byte_checksum (target,
+				   sizeof (struct grub_acpi_rsdp_v10)) == 0)
+	  {
+	    grub_memcpy (target, v1, sizeof (struct grub_acpi_rsdp_v10));
+	    grub_dprintf ("acpi", "Copying rsdpv1 to %p\n", target);
+	    v1inebda = target;
+	    target += sizeof (struct grub_acpi_rsdp_v10);
+	    target = (grub_uint8_t *) ((((long) target - 1) | 0xf) + 1);
+	    v1 = 0;
+	    break;
+	  }
+    }
+
+  target = targetebda + 0x100;
+
+  /* Try contiguous zeros. */
+  if (v2)
+    {
+      grub_dprintf ("acpi", "Scanning EBDA for block of zeros\n");
+      for (; target < targetebda + 0x400 - v2->length; target += 0x10)
+	if (iszero (target, v2->length))
+	  {
+	    grub_dprintf ("acpi", "Copying rsdpv2 to %p\n", target);
+	    grub_memcpy (target, v2, v2->length);
+	    v2inebda = target;
+	    target += v2->length;
+	    target = (grub_uint8_t *) ((((long) target - 1) | 0xf) + 1);
+	    v2 = 0;
+	    break;
+	  }
+    }
+
+  if (v1)
+    {
+      grub_dprintf ("acpi", "Scanning EBDA for block of zeros\n");
+      for (; target < targetebda + 0x400 - sizeof (struct grub_acpi_rsdp_v10);
+	   target += 0x10)
+	if (iszero (target, sizeof (struct grub_acpi_rsdp_v10)))
+	  {
+	    grub_dprintf ("acpi", "Copying rsdpv1 to %p\n", target);
+	    grub_memcpy (target, v1, sizeof (struct grub_acpi_rsdp_v10));
+	    v1inebda = target;
+	    target += sizeof (struct grub_acpi_rsdp_v10);
+	    target = (grub_uint8_t *) ((((long) target - 1) | 0xf) + 1);
+	    v1 = 0;
+	    break;
+	  }
+    }
+
+  if (v1 || v2)
+    {
+      grub_mmap_unregister (mmapregion);
+      return grub_error (GRUB_ERR_OUT_OF_MEMORY,
+			 "couldn't find suitable spot in EBDA");
+    }
+
+  /* Remove any other RSDT. */
+  for (target = targetebda;
+       target < targetebda + 0x400 - sizeof (struct grub_acpi_rsdp_v10);
+       target += 0x10)
+    if (grub_memcmp (target, "RSD PTR ", 8) == 0
+	&& grub_byte_checksum (target,
+			       sizeof (struct grub_acpi_rsdp_v10)) == 0
+	&& target != v1inebda && target != v2inebda)
+      *target = 0;
+
+  grub_dprintf ("acpi", "Switching EBDA\n");
+  (*((grub_uint16_t *) 0x40e)) = ((long)targetebda) >> 4;
+  grub_dprintf ("acpi", "EBDA switched\n");
+
+  return GRUB_ERR_NONE;
+}
+
+/* Create tables common to ACPIv1 and ACPIv2+ */
+static void
+setup_common_tables (void)
+{
+  struct efiemu_acpi_table *cur;
+  struct grub_acpi_table_header *rsdt;
+  grub_uint32_t *rsdt_entry;
+  int numoftables;
+
+  /* Treat DSDT. */
+  grub_memcpy (playground_ptr, table_dsdt, dsdt_size);
+  grub_free (table_dsdt);
+  table_dsdt = playground_ptr;
+  playground_ptr += dsdt_size;
+
+  /* Treat other tables. */
+  for (cur = acpi_tables; cur; cur = cur->next)
+    {
+      struct grub_acpi_fadt *fadt;
+
+      grub_memcpy (playground_ptr, cur->addr, cur->size);
+      grub_free (cur->addr);
+      cur->addr = playground_ptr;
+      playground_ptr += cur->size;
+
+      /* If it's FADT correct DSDT and FACS addresses. */
+      fadt = (struct grub_acpi_fadt *) cur->addr;
+      if (grub_memcmp (fadt->hdr.signature, "FACP", 4) == 0)
+	{
+	  fadt->dsdt_addr = PTR_TO_UINT32 (table_dsdt);
+	  fadt->facs_addr = facs_addr;
+
+	  /* Does a revision 2 exist at all? */
+	  if (fadt->hdr.revision >= 3)
+	    {
+	      fadt->dsdt_xaddr = PTR_TO_UINT64 (table_dsdt);
+	      fadt->facs_xaddr = facs_addr;
+	    }
+
+	  /* Recompute checksum. */
+	  fadt->hdr.checksum = 0;
+	  fadt->hdr.checksum = 1 + ~grub_byte_checksum (fadt, fadt->hdr.length);
+	}
+    }
+
+  /* Fill RSDT entries. */
+  numoftables = 0;
+  for (cur = acpi_tables; cur; cur = cur->next)
+    numoftables++;
+
+  rsdt_addr = rsdt = (struct grub_acpi_table_header *) playground_ptr;
+  playground_ptr += sizeof (struct grub_acpi_table_header) + 4 * numoftables;
+
+  rsdt_entry = (grub_uint32_t *)(rsdt + 1);
+
+  /* Fill RSDT header. */
+  grub_memcpy (&(rsdt->signature), "RSDT", 4);
+  rsdt->length = sizeof (struct grub_acpi_table_header) + 4 * numoftables;
+  rsdt->revision = 1;
+  grub_memcpy (&(rsdt->oemid), root_oemid, 6);
+  grub_memcpy (&(rsdt->oemtable), root_oemtable, 4);
+  rsdt->oemrev = root_oemrev;
+  grub_memcpy (&(rsdt->creator_id), root_creator_id, 6);
+  rsdt->creator_rev = root_creator_rev;
+
+  for (cur = acpi_tables; cur; cur = cur->next)
+    *(rsdt_entry++) = PTR_TO_UINT32 (cur->addr);
+
+  /* Recompute checksum. */
+  rsdt->checksum = 0;
+  rsdt->checksum = 1 + ~grub_byte_checksum (rsdt, rsdt->length);
+}
+
+/* Regenerate ACPIv1 RSDP */
+static void
+setv1table (void)
+{
+  /* Create RSDP. */
+  rsdpv1_new = (struct grub_acpi_rsdp_v10 *) playground_ptr;
+  playground_ptr += sizeof (struct grub_acpi_rsdp_v10);
+  grub_memcpy (&(rsdpv1_new->signature), "RSD PTR ", 8);
+  grub_memcpy (&(rsdpv1_new->oemid), root_oemid, sizeof  (rsdpv1_new->oemid));
+  rsdpv1_new->revision = 0;
+  rsdpv1_new->rsdt_addr = PTR_TO_UINT32 (rsdt_addr);
+  rsdpv1_new->checksum = 0;
+  rsdpv1_new->checksum = 1 + ~grub_byte_checksum (rsdpv1_new,
+						  sizeof (*rsdpv1_new));
+  grub_dprintf ("acpi", "Generated ACPIv1 tables\n");
+}
+
+static void
+setv2table (void)
+{
+  struct grub_acpi_table_header *xsdt;
+  struct efiemu_acpi_table *cur;
+  grub_uint64_t *xsdt_entry;
+  int numoftables;
+
+  numoftables = 0;
+  for (cur = acpi_tables; cur; cur = cur->next)
+    numoftables++;
+
+  /* Create XSDT. */
+  xsdt = (struct grub_acpi_table_header *) playground_ptr;
+  playground_ptr += sizeof (struct grub_acpi_table_header) + 8 * numoftables;
+
+  xsdt_entry = (grub_uint64_t *)(xsdt + 1);
+  for (cur = acpi_tables; cur; cur = cur->next)
+    *(xsdt_entry++) = PTR_TO_UINT64 (cur->addr);
+  grub_memcpy (&(xsdt->signature), "XSDT", 4);
+  xsdt->length = sizeof (struct grub_acpi_table_header) + 8 * numoftables;
+  xsdt->revision = 1;
+  grub_memcpy (&(xsdt->oemid), root_oemid, sizeof (xsdt->oemid));
+  grub_memcpy (&(xsdt->oemtable), root_oemtable, sizeof (xsdt->oemtable));
+  xsdt->oemrev = root_oemrev;
+  grub_memcpy (&(xsdt->creator_id), root_creator_id, sizeof (xsdt->creator_id));
+  xsdt->creator_rev = root_creator_rev;
+  xsdt->checksum = 0;
+  xsdt->checksum = 1 + ~grub_byte_checksum (xsdt, xsdt->length);
+
+  /* Create RSDPv2. */
+  rsdpv2_new = (struct grub_acpi_rsdp_v20 *) playground_ptr;
+  playground_ptr += sizeof (struct grub_acpi_rsdp_v20);
+  grub_memcpy (&(rsdpv2_new->rsdpv1.signature), "RSD PTR ",
+	       sizeof (rsdpv2_new->rsdpv1.signature));
+  grub_memcpy (&(rsdpv2_new->rsdpv1.oemid), root_oemid,
+	       sizeof (rsdpv2_new->rsdpv1.oemid));
+  rsdpv2_new->rsdpv1.revision = rev2;
+  rsdpv2_new->rsdpv1.rsdt_addr = PTR_TO_UINT32 (rsdt_addr);
+  rsdpv2_new->rsdpv1.checksum = 0;
+  rsdpv2_new->rsdpv1.checksum = 1 + ~grub_byte_checksum
+    (&(rsdpv2_new->rsdpv1), sizeof (rsdpv2_new->rsdpv1));
+  rsdpv2_new->length = sizeof (*rsdpv2_new);
+  rsdpv2_new->xsdt_addr = PTR_TO_UINT64 (xsdt);
+  rsdpv2_new->checksum = 0;
+  rsdpv2_new->checksum = 1 + ~grub_byte_checksum (rsdpv2_new,
+						  rsdpv2_new->length);
+  grub_dprintf ("acpi", "Generated ACPIv2 tables\n");
+}
+
+static void
+free_tables (void)
+{
+  struct efiemu_acpi_table *cur, *t;
+  if (table_dsdt)
+    grub_free (table_dsdt);
+  for (cur = acpi_tables; cur;)
+    {
+      t = cur;
+      grub_free (cur->addr);
+      cur = cur->next;
+      grub_free (t);
+    }
+  acpi_tables = 0;
+  table_dsdt = 0;
+}
+
+static grub_err_t
+grub_cmd_acpi (struct grub_extcmd *cmd,
+		      int argc, char **args)
+{
+  struct grub_arg_list *state = cmd->state;
+  struct grub_acpi_rsdp_v10 *rsdp;
+  struct efiemu_acpi_table *cur, *t;
+  grub_err_t err;
+  int i, mmapregion;
+  int numoftables;
+
+  /* Default values if no RSDP is found. */
+  rev1 = 1;
+  rev2 = 3;
+
+  facs_addr = 0;
+  playground = playground_ptr = 0;
+  playground_size = 0;
+
+  rsdp = (struct grub_acpi_rsdp_v10 *) grub_machine_acpi_get_rsdpv2 ();
+
+  if (! rsdp)
+    rsdp = grub_machine_acpi_get_rsdpv1 ();
+
+  if (rsdp)
+    {
+      grub_uint32_t *entry_ptr;
+      char *exclude = 0;
+      char *load_only = 0;
+      char *ptr;
+      /* RSDT consists of header and an array of 32-bit pointers. */
+      struct grub_acpi_table_header *rsdt;
+
+      exclude = state[0].set ? grub_strdup (state[0].arg) : 0;
+      if (exclude)
+	{
+	  for (ptr = exclude; *ptr; ptr++)
+	    *ptr = grub_tolower (*ptr);
+	}
+
+      load_only = state[1].set ? grub_strdup (state[1].arg) : 0;
+      if (load_only)
+	{
+	  for (ptr = load_only; *ptr; ptr++)
+	    *ptr = grub_tolower (*ptr);
+	}
+
+      /* Set revision variables to replicate the same version as host. */
+      rev1 = ! rsdp->revision;
+      rev2 = rsdp->revision;
+      rsdt = (struct grub_acpi_table_header *) UINT_TO_PTR (rsdp->rsdt_addr);
+      /* Load host tables. */
+      for (entry_ptr = (grub_uint32_t *) (rsdt + 1);
+	   entry_ptr < (grub_uint32_t *) (((grub_uint8_t *) rsdt)
+					  + rsdt->length);
+	   entry_ptr++)
+	{
+	  char signature[5];
+	  struct efiemu_acpi_table *table;
+	  struct grub_acpi_table_header *curtable
+	    = (struct grub_acpi_table_header *) UINT_TO_PTR (*entry_ptr);
+	  signature[4] = 0;
+	  for (i = 0; i < 4;i++)
+	    signature[i] = grub_tolower (curtable->signature[i]);
+
+	  /* If it's FADT it contains addresses of DSDT and FACS. */
+	  if (grub_strcmp (signature, "facp") == 0)
+	    {
+	      struct grub_acpi_table_header *dsdt;
+	      struct grub_acpi_fadt *fadt = (struct grub_acpi_fadt *) curtable;
+
+	      /* Set root header variables to the same values
+		 as FACP by default. */
+	      grub_memcpy (&root_oemid, &(fadt->hdr.oemid),
+			   sizeof (root_oemid));
+	      grub_memcpy (&root_oemtable, &(fadt->hdr.oemtable),
+			   sizeof (root_oemtable));
+	      root_oemrev = fadt->hdr.oemrev;
+	      grub_memcpy (&root_creator_id, &(fadt->hdr.creator_id),
+			   sizeof (root_creator_id));
+	      root_creator_rev = fadt->hdr.creator_rev;
+
+	      /* Load DSDT if not excluded. */
+	      dsdt = (struct grub_acpi_table_header *)
+		UINT_TO_PTR (fadt->dsdt_addr);
+	      if (dsdt && (! exclude || ! grub_strword (exclude, "dsdt"))
+		  && (! load_only || grub_strword (load_only, "dsdt"))
+		  && dsdt->length >= sizeof (*dsdt))
+		{
+		  dsdt_size = dsdt->length;
+		  table_dsdt = grub_malloc (dsdt->length);
+		  if (! table_dsdt)
+		    {
+		      free_tables ();
+		      grub_free (exclude);
+		      grub_free (load_only);
+		      return grub_error (GRUB_ERR_OUT_OF_MEMORY,
+					 "couldn't allocate table");
+		    }
+		  grub_memcpy (table_dsdt, dsdt, dsdt->length);
+		}
+
+	      /* Save FACS address. FACS shouldn't be overridden. */
+	      facs_addr = fadt->facs_addr;
+	    }
+
+	  /* Skip excluded tables. */
+	  if (exclude && grub_strword (exclude, signature))
+	    continue;
+	  if (load_only && ! grub_strword (load_only, signature))
+	    continue;
+
+	  /* Sanity check. */
+	  if (curtable->length < sizeof (*curtable))
+	    continue;
+
+	  table = (struct efiemu_acpi_table *) grub_malloc
+	    (sizeof (struct efiemu_acpi_table));
+	  if (! table)
+	    {
+	      free_tables ();
+	      grub_free (exclude);
+	      grub_free (load_only);
+	      return grub_error (GRUB_ERR_OUT_OF_MEMORY,
+				 "couldn't allocate table structure");
+	    }
+	  table->size = curtable->length;
+	  table->addr = grub_malloc (table->size);
+	  playground_size += table->size;
+	  if (! table->addr)
+	    {
+	      free_tables ();
+	      return grub_error (GRUB_ERR_OUT_OF_MEMORY,
+				 "couldn't allocate table");
+	    }
+	  table->next = acpi_tables;
+	  acpi_tables = table;
+	  grub_memcpy (table->addr, curtable, table->size);
+	}
+      grub_free (exclude);
+      grub_free (load_only);
+    }
+
+  /* Does user specify versions to generate? */
+  if (state[2].set || state[3].set)
+    {
+      rev1 = state[2].set;
+      if (state[3].set)
+	rev2 = rev2 ? : 2;
+      else
+	rev2 = 0;
+    }
+
+  /* Does user override root header information? */
+  if (state[4].set)
+    grub_strncpy (root_oemid, state[4].arg, sizeof (root_oemid));
+  if (state[5].set)
+    grub_strncpy (root_oemtable, state[5].arg, sizeof (root_oemtable));
+  if (state[6].set)
+    root_oemrev = grub_strtoul (state[6].arg, 0, 0);
+  if (state[7].set)
+    grub_strncpy (root_creator_id, state[7].arg, sizeof (root_creator_id));
+  if (state[8].set)
+    root_creator_rev = grub_strtoul (state[8].arg, 0, 0);
+
+  /* Load user tables */
+  for (i = 0; i < argc; i++)
+    {
+      grub_file_t file;
+      grub_size_t size;
+      char *buf;
+
+      file = grub_gzfile_open (args[i], 1);
+      if (! file)
+	{
+	  free_tables ();
+	  return grub_error (GRUB_ERR_BAD_OS, "couldn't open file %s", args[i]);
+	}
+
+      size = grub_file_size (file);
+      if (size < sizeof (struct grub_acpi_table_header))
+	{
+	  grub_file_close (file);
+	  free_tables ();
+	  return grub_error (GRUB_ERR_BAD_OS, "file %s is too small", args[i]);
+	}
+
+      buf = (char *) grub_malloc (size);
+      if (! buf)
+	{
+	  grub_file_close (file);
+	  free_tables ();
+	  return grub_error (GRUB_ERR_OUT_OF_MEMORY,
+			     "couldn't read file %s", args[i]);
+	}
+
+      if (grub_file_read (file, buf, size) != (int) size)
+	{
+	  grub_file_close (file);
+	  free_tables ();
+	  return grub_error (GRUB_ERR_BAD_OS, "couldn't read file %s", args[i]);
+	}
+      grub_file_close (file);
+
+      if (grub_memcmp (((struct grub_acpi_table_header *) buf)->signature,
+		       "DSDT", 4) == 0)
+	{
+	  grub_free (table_dsdt);
+	  table_dsdt = buf;
+	  dsdt_size = size;
+	}
+      else
+	{
+	  struct efiemu_acpi_table *table;
+	  table = (struct efiemu_acpi_table *) grub_malloc
+	    (sizeof (struct efiemu_acpi_table));
+	  if (! table)
+	    {
+	      free_tables ();
+	      return grub_error (GRUB_ERR_OUT_OF_MEMORY,
+				 "couldn't allocate table structure");
+	    }
+
+	  table->size = size;
+	  table->addr = buf;
+	  playground_size += table->size;
+
+	  table->next = acpi_tables;
+	  acpi_tables = table;
+	}
+    }
+
+  numoftables = 0;
+  for (cur = acpi_tables; cur; cur = cur->next)
+    numoftables++;
+
+  /* DSDT. */
+  playground_size += dsdt_size;
+  /* RSDT. */
+  playground_size += sizeof (struct grub_acpi_table_header) + 4 * numoftables;
+  /* RSDPv1. */
+  playground_size += sizeof (struct grub_acpi_rsdp_v10);
+  /* XSDT. */
+  playground_size += sizeof (struct grub_acpi_table_header) + 8 * numoftables;
+  /* RSDPv2. */
+  playground_size += sizeof (struct grub_acpi_rsdp_v20);
+
+  playground = playground_ptr
+    = grub_mmap_malign_and_register (1, playground_size, &mmapregion,
+				     GRUB_MACHINE_MEMORY_ACPI, 0);
+
+  if (! playground)
+    {
+      free_tables ();
+      return grub_error (GRUB_ERR_OUT_OF_MEMORY,
+			 "couldn't allocate space for ACPI tables");
+    }
+
+  setup_common_tables ();
+
+  /* Request space for RSDPv1. */
+  if (rev1)
+    setv1table ();
+
+  /* Request space for RSDPv2+ and XSDT. */
+  if (rev2)
+    setv2table ();
+
+  for (cur = acpi_tables; cur;)
+    {
+      t = cur;
+      cur = cur->next;
+      grub_free (t);
+    }
+  acpi_tables = 0;
+
+  if (! state[9].set && (err = grub_acpi_create_ebda ()))
+    {
+      rsdpv1_new = 0;
+      rsdpv2_new = 0;
+      grub_mmap_free_and_unregister (mmapregion);
+      return err;
+    }
+
+#ifdef GRUB_MACHINE_EFI
+  {
+    struct grub_efi_guid acpi = GRUB_EFI_ACPI_TABLE_GUID;
+    struct grub_efi_guid acpi20 = GRUB_EFI_ACPI_20_TABLE_GUID;
+
+    grub_efi_system_table->boot_services->install_configuration_table
+      (&acpi20, grub_acpi_get_rsdpv2 ());
+    grub_efi_system_table->boot_services->install_configuration_table
+      (&acpi, grub_acpi_get_rsdpv1 ());
+  }
+#endif
+
+  return GRUB_ERR_NONE;
+}
+
+static grub_extcmd_t cmd;
+
+GRUB_MOD_INIT(acpi)
+{
+  cmd = grub_register_extcmd ("acpi", grub_cmd_acpi,
+			      GRUB_COMMAND_FLAG_BOTH,
+			      N_("[-1|-2] [--exclude=TABLE1,TABLE2|"
+			      "--load-only=table1,table2] FILE1"
+			      " [FILE2] [...]"),
+			      N_("Load host ACPI tables and tables "
+			      "specified by arguments."),
+			      options);
+}
+
+GRUB_MOD_FINI(acpi)
+{
+  grub_unregister_extcmd (cmd);
+}

grub-core/commands/blocklist.c

@@ -0,0 +1,119 @@
+/* blocklist.c - print the block list of a file */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2006,2007  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/dl.h>
+#include <grub/misc.h>
+#include <grub/file.h>
+#include <grub/mm.h>
+#include <grub/disk.h>
+#include <grub/partition.h>
+#include <grub/command.h>
+#include <grub/i18n.h>
+
+static grub_err_t
+grub_cmd_blocklist (grub_command_t cmd __attribute__ ((unused)),
+		    int argc, char **args)
+{
+  grub_file_t file;
+  char buf[GRUB_DISK_SECTOR_SIZE];
+  unsigned long start_sector = 0;
+  unsigned num_sectors = 0;
+  int num_entries = 0;
+  grub_disk_addr_t part_start = 0;
+  auto void NESTED_FUNC_ATTR read_blocklist (grub_disk_addr_t sector, unsigned offset,
+			    unsigned length);
+  auto void NESTED_FUNC_ATTR print_blocklist (grub_disk_addr_t sector, unsigned num,
+			     unsigned offset, unsigned length);
+
+  void NESTED_FUNC_ATTR read_blocklist (grub_disk_addr_t sector, unsigned offset,
+		       unsigned length)
+    {
+      if (num_sectors > 0)
+	{
+	  if (start_sector + num_sectors == sector
+	      && offset == 0 && length == GRUB_DISK_SECTOR_SIZE)
+	    {
+	      num_sectors++;
+	      return;
+	    }
+
+	  print_blocklist (start_sector, num_sectors, 0, 0);
+	  num_sectors = 0;
+	}
+
+      if (offset == 0 && length == GRUB_DISK_SECTOR_SIZE)
+	{
+	  start_sector = sector;
+	  num_sectors++;
+	}
+      else
+	print_blocklist (sector, 0, offset, length);
+    }
+
+  void NESTED_FUNC_ATTR print_blocklist (grub_disk_addr_t sector, unsigned num,
+			unsigned offset, unsigned length)
+    {
+      if (num_entries++)
+	grub_printf (",");
+
+      grub_printf ("%llu", (unsigned long long) (sector - part_start));
+      if (num > 0)
+	grub_printf ("+%u", num);
+      if (offset != 0 || length != 0)
+	grub_printf ("[%u-%u]", offset, offset + length);
+    }
+
+  if (argc < 1)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "no file specified");
+
+  file = grub_file_open (args[0]);
+  if (! file)
+    return grub_errno;
+
+  if (! file->device->disk)
+    return grub_error (GRUB_ERR_BAD_DEVICE,
+		       "this command is available only for disk devices");
+
+  part_start = grub_partition_get_start (file->device->disk->partition);
+
+  file->read_hook = read_blocklist;
+
+  while (grub_file_read (file, buf, sizeof (buf)) > 0)
+    ;
+
+  if (num_sectors > 0)
+    print_blocklist (start_sector, num_sectors, 0, 0);
+
+  grub_file_close (file);
+
+  return grub_errno;
+}
+
+static grub_command_t cmd;
+
+GRUB_MOD_INIT(blocklist)
+{
+  cmd = grub_register_command ("blocklist", grub_cmd_blocklist,
+			       N_("FILE"), N_("Print a block list."));
+}
+
+GRUB_MOD_FINI(blocklist)
+{
+  grub_unregister_command (cmd);
+}

grub-core/commands/boot.c

@@ -0,0 +1,196 @@
+/* boot.c - command to boot an operating system */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2002,2003,2004,2005,2007,2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/normal.h>
+#include <grub/dl.h>
+#include <grub/misc.h>
+#include <grub/loader.h>
+#include <grub/kernel.h>
+#include <grub/mm.h>
+#include <grub/i18n.h>
+
+static grub_err_t (*grub_loader_boot_func) (void);
+static grub_err_t (*grub_loader_unload_func) (void);
+static int grub_loader_noreturn;
+
+struct grub_preboot_t
+{
+  grub_err_t (*preboot_func) (int);
+  grub_err_t (*preboot_rest_func) (void);
+  grub_loader_preboot_hook_prio_t prio;
+  struct grub_preboot_t *next;
+  struct grub_preboot_t *prev;
+};
+
+static int grub_loader_loaded;
+static struct grub_preboot_t *preboots_head = 0,
+  *preboots_tail = 0;
+
+int
+grub_loader_is_loaded (void)
+{
+  return grub_loader_loaded;
+}
+
+/* Register a preboot hook. */
+void *
+grub_loader_register_preboot_hook (grub_err_t (*preboot_func) (int noreturn),
+				   grub_err_t (*preboot_rest_func) (void),
+				   grub_loader_preboot_hook_prio_t prio)
+{
+  struct grub_preboot_t *cur, *new_preboot;
+
+  if (! preboot_func && ! preboot_rest_func)
+    return 0;
+
+  new_preboot = (struct grub_preboot_t *)
+    grub_malloc (sizeof (struct grub_preboot_t));
+  if (! new_preboot)
+    {
+      grub_error (GRUB_ERR_OUT_OF_MEMORY, "hook not added");
+      return 0;
+    }
+
+  new_preboot->preboot_func = preboot_func;
+  new_preboot->preboot_rest_func = preboot_rest_func;
+  new_preboot->prio = prio;
+
+  for (cur = preboots_head; cur && cur->prio > prio; cur = cur->next);
+
+  if (cur)
+    {
+      new_preboot->next = cur;
+      new_preboot->prev = cur->prev;
+      cur->prev = new_preboot;
+    }
+  else
+    {
+      new_preboot->next = 0;
+      new_preboot->prev = preboots_tail;
+      preboots_tail = new_preboot;
+    }
+  if (new_preboot->prev)
+    new_preboot->prev->next = new_preboot;
+  else
+    preboots_head = new_preboot;
+
+  return new_preboot;
+}
+
+void
+grub_loader_unregister_preboot_hook (void *hnd)
+{
+  struct grub_preboot_t *preb = hnd;
+
+  if (preb->next)
+    preb->next->prev = preb->prev;
+  else
+    preboots_tail = preb->prev;
+  if (preb->prev)
+    preb->prev->next = preb->next;
+  else
+    preboots_head = preb->next;
+
+  grub_free (preb);
+}
+
+void
+grub_loader_set (grub_err_t (*boot) (void),
+		 grub_err_t (*unload) (void),
+		 int noreturn)
+{
+  if (grub_loader_loaded && grub_loader_unload_func)
+    grub_loader_unload_func ();
+
+  grub_loader_boot_func = boot;
+  grub_loader_unload_func = unload;
+  grub_loader_noreturn = noreturn;
+
+  grub_loader_loaded = 1;
+}
+
+void
+grub_loader_unset(void)
+{
+  if (grub_loader_loaded && grub_loader_unload_func)
+    grub_loader_unload_func ();
+
+  grub_loader_boot_func = 0;
+  grub_loader_unload_func = 0;
+
+  grub_loader_loaded = 0;
+}
+
+grub_err_t
+grub_loader_boot (void)
+{
+  grub_err_t err = GRUB_ERR_NONE;
+  struct grub_preboot_t *cur;
+
+  if (! grub_loader_loaded)
+    return grub_error (GRUB_ERR_NO_KERNEL, "no loaded kernel");
+
+  if (grub_loader_noreturn)
+    grub_machine_fini ();
+
+  for (cur = preboots_head; cur; cur = cur->next)
+    {
+      err = cur->preboot_func (grub_loader_noreturn);
+      if (err)
+	{
+	  for (cur = cur->prev; cur; cur = cur->prev)
+	    cur->preboot_rest_func ();
+	  return err;
+	}
+    }
+  err = (grub_loader_boot_func) ();
+
+  for (cur = preboots_tail; cur; cur = cur->prev)
+    if (! err)
+      err = cur->preboot_rest_func ();
+    else
+      cur->preboot_rest_func ();
+
+  return err;
+}
+
+/* boot */
+static grub_err_t
+grub_cmd_boot (struct grub_command *cmd __attribute__ ((unused)),
+		    int argc __attribute__ ((unused)),
+		    char *argv[] __attribute__ ((unused)))
+{
+  return grub_loader_boot ();
+}
+
+
+
+static grub_command_t cmd_boot;
+
+GRUB_MOD_INIT(boot)
+{
+  cmd_boot =
+    grub_register_command ("boot", grub_cmd_boot,
+			   0, N_("Boot an operating system."));
+}
+
+GRUB_MOD_FINI(boot)
+{
+  grub_unregister_command (cmd_boot);
+}

grub-core/commands/cat.c

@@ -0,0 +1,88 @@
+/* cat.c - command to show the contents of a file  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2003,2005,2007,2008  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/dl.h>
+#include <grub/file.h>
+#include <grub/disk.h>
+#include <grub/term.h>
+#include <grub/misc.h>
+#include <grub/gzio.h>
+#include <grub/command.h>
+#include <grub/i18n.h>
+
+static grub_err_t
+grub_cmd_cat (grub_command_t cmd __attribute__ ((unused)),
+	      int argc, char **args)
+
+{
+  grub_file_t file;
+  char buf[GRUB_DISK_SECTOR_SIZE];
+  grub_ssize_t size;
+  int key = 0;
+
+  if (argc != 1)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required");
+
+  file = grub_gzfile_open (args[0], 1);
+  if (! file)
+    return grub_errno;
+
+  while ((size = grub_file_read (file, buf, sizeof (buf))) > 0
+	 && key != GRUB_TERM_ESC)
+    {
+      int i;
+
+      for (i = 0; i < size; i++)
+	{
+	  unsigned char c = buf[i];
+
+	  if ((grub_isprint (c) || grub_isspace (c)) && c != '\r')
+	    grub_putchar (c);
+	  else
+	    {
+	      grub_setcolorstate (GRUB_TERM_COLOR_HIGHLIGHT);
+	      grub_printf ("<%x>", (int) c);
+	      grub_setcolorstate (GRUB_TERM_COLOR_STANDARD);
+	    }
+	}
+
+      while (grub_checkkey () >= 0 &&
+	     (key = GRUB_TERM_ASCII_CHAR (grub_getkey ())) != GRUB_TERM_ESC)
+	;
+    }
+
+  grub_putchar ('\n');
+  grub_refresh ();
+  grub_file_close (file);
+
+  return 0;
+}
+
+static grub_command_t cmd;
+
+GRUB_MOD_INIT(cat)
+{
+  cmd = grub_register_command_p1 ("cat", grub_cmd_cat,
+				  N_("FILE"), N_("Show the contents of a file."));
+}
+
+GRUB_MOD_FINI(cat)
+{
+  grub_unregister_command (cmd);
+}

grub-core/commands/cmp.c

@@ -0,0 +1,119 @@
+/* cmd.c - command to cmp an operating system */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2003,2005,2006,2007,2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/dl.h>
+#include <grub/misc.h>
+#include <grub/file.h>
+#include <grub/mm.h>
+#include <grub/gzio.h>
+#include <grub/command.h>
+#include <grub/i18n.h>
+
+#define BUFFER_SIZE 512
+
+static grub_err_t
+grub_cmd_cmp (grub_command_t cmd __attribute__ ((unused)),
+	      int argc, char **args)
+{
+  grub_ssize_t rd1, rd2;
+  grub_off_t pos;
+  grub_file_t file1 = 0;
+  grub_file_t file2 = 0;
+  char *buf1 = 0;
+  char *buf2 = 0;
+
+  if (argc != 2)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "two arguments required");
+
+  grub_printf ("Compare file `%s' with `%s':\n", args[0],
+	       args[1]);
+
+  file1 = grub_gzfile_open (args[0], 1);
+  file2 = grub_gzfile_open (args[1], 1);
+  if (! file1 || ! file2)
+    goto cleanup;
+
+  if (grub_file_size (file1) != grub_file_size (file2))
+    grub_printf ("Files differ in size: %llu [%s], %llu [%s]\n",
+		 (unsigned long long) grub_file_size (file1), args[0],
+		 (unsigned long long) grub_file_size (file2), args[1]);
+  else
+    {
+      pos = 0;
+
+      buf1 = grub_malloc (BUFFER_SIZE);
+      buf2 = grub_malloc (BUFFER_SIZE);
+
+      if (! buf1 || ! buf2)
+        goto cleanup;
+
+      do
+	{
+	  int i;
+
+	  rd1 = grub_file_read (file1, buf1, BUFFER_SIZE);
+	  rd2 = grub_file_read (file2, buf2, BUFFER_SIZE);
+
+	  if (rd1 != rd2)
+	    goto cleanup;
+
+	  for (i = 0; i < rd2; i++)
+	    {
+	      if (buf1[i] != buf2[i])
+		{
+		  grub_printf ("Files differ at the offset %llu: 0x%x [%s], 0x%x [%s]\n",
+			       (unsigned long long) (i + pos), buf1[i], args[0],
+			       buf2[i], args[1]);
+		  goto cleanup;
+		}
+	    }
+	  pos += BUFFER_SIZE;
+
+	}
+      while (rd2);
+
+      grub_printf ("The files are identical.\n");
+    }
+
+cleanup:
+
+  if (buf1)
+    grub_free (buf1);
+  if (buf2)
+    grub_free (buf2);
+  if (file1)
+    grub_file_close (file1);
+  if (file2)
+    grub_file_close (file2);
+
+  return grub_errno;
+}
+
+static grub_command_t cmd;
+
+GRUB_MOD_INIT(cmp)
+{
+  cmd = grub_register_command ("cmp", grub_cmd_cmp,
+			       N_("FILE1 FILE2"), N_("Compare two files."));
+}
+
+GRUB_MOD_FINI(cmp)
+{
+  grub_unregister_command (cmd);
+}

grub-core/commands/configfile.c

@@ -0,0 +1,75 @@
+/* configfile.c - command to manually load config file  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2005,2006,2007,2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/dl.h>
+#include <grub/term.h>
+#include <grub/env.h>
+#include <grub/normal.h>
+#include <grub/command.h>
+#include <grub/i18n.h>
+
+static grub_err_t
+grub_cmd_source (grub_command_t cmd, int argc, char **args)
+{
+  int new_env;
+
+  if (argc != 1)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required");
+
+  new_env = (cmd->name[0] == 'c');
+
+  if (new_env)
+    {
+      grub_cls ();
+      grub_env_context_open (1);
+    }
+
+  grub_normal_execute (args[0], 1, ! new_env);
+
+  if (new_env)
+    grub_env_context_close ();
+
+  return 0;
+}
+
+static grub_command_t cmd_configfile, cmd_source, cmd_dot;
+
+GRUB_MOD_INIT(configfile)
+{
+  cmd_configfile =
+    grub_register_command ("configfile", grub_cmd_source,
+			   N_("FILE"), N_("Load another config file."));
+  cmd_source =
+    grub_register_command ("source", grub_cmd_source,
+			   N_("FILE"),
+			   N_("Load another config file without changing context.")
+			   );
+  cmd_dot =
+    grub_register_command (".", grub_cmd_source,
+			   N_("FILE"),
+			   N_("Load another config file without changing context.")
+			   );
+}
+
+GRUB_MOD_FINI(configfile)
+{
+  grub_unregister_command (cmd_configfile);
+  grub_unregister_command (cmd_source);
+  grub_unregister_command (cmd_dot);
+}

grub-core/commands/crc.c

@@ -0,0 +1,71 @@
+/* crc.c - command to calculate the crc32 checksum of a file  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008,2010  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/dl.h>
+#include <grub/disk.h>
+#include <grub/file.h>
+#include <grub/misc.h>
+#include <grub/lib/crc.h>
+#include <grub/command.h>
+#include <grub/i18n.h>
+
+static grub_err_t
+grub_cmd_crc (grub_command_t cmd __attribute__ ((unused)),
+	      int argc, char **args)
+
+{
+  grub_file_t file;
+  char buf[GRUB_DISK_SECTOR_SIZE];
+  grub_ssize_t size;
+  grub_uint32_t crc;
+
+  if (argc != 1)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required");
+
+  file = grub_file_open (args[0]);
+  if (! file)
+    return 0;
+
+  crc = 0;
+  while ((size = grub_file_read (file, buf, sizeof (buf))) > 0)
+    crc = grub_getcrc32 (crc, buf, size);
+
+  if (grub_errno)
+    goto fail;
+
+  grub_printf ("%08x\n", crc);
+
+ fail:
+  grub_file_close (file);
+  return 0;
+}
+
+static grub_command_t cmd;
+
+GRUB_MOD_INIT(crc)
+{
+  cmd = grub_register_command ("crc", grub_cmd_crc,
+			       N_("FILE"),
+			       N_("Calculate the crc32 checksum of a file."));
+}
+
+GRUB_MOD_FINI(crc)
+{
+  grub_unregister_command (cmd);
+}

grub-core/commands/date.c

@@ -0,0 +1,146 @@
+/* date.c - command to display/set current datetime.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/dl.h>
+#include <grub/err.h>
+#include <grub/misc.h>
+#include <grub/datetime.h>
+#include <grub/command.h>
+#include <grub/i18n.h>
+
+#define GRUB_DATETIME_SET_YEAR		1
+#define GRUB_DATETIME_SET_MONTH		2
+#define GRUB_DATETIME_SET_DAY		4
+#define GRUB_DATETIME_SET_HOUR		8
+#define GRUB_DATETIME_SET_MINUTE	16
+#define GRUB_DATETIME_SET_SECOND	32
+
+static grub_err_t
+grub_cmd_date (grub_command_t cmd __attribute__ ((unused)),
+               int argc, char **args)
+{
+  struct grub_datetime datetime;
+  int limit[6][2] = {{1980, 2079}, {1, 12}, {1, 31}, {0, 23}, {0, 59}, {0, 59}};
+  int value[6], mask;
+
+  if (argc == 0)
+    {
+      if (grub_get_datetime (&datetime))
+        return grub_errno;
+
+      grub_printf ("%d-%02d-%02d %02d:%02d:%02d %s\n",
+                   datetime.year, datetime.month, datetime.day,
+                   datetime.hour, datetime.minute, datetime.second,
+                   grub_get_weekday_name (&datetime));
+
+      return 0;
+    }
+
+  grub_memset (&value, 0, sizeof (value));
+  mask = 0;
+
+  for (; argc; argc--, args++)
+    {
+      char *p, c;
+      int m1, ofs, n, cur_mask;
+
+      p = args[0];
+      m1 = grub_strtoul (p, &p, 10);
+
+      c = *p;
+      if (c == '-')
+        ofs = 0;
+      else if (c == ':')
+        ofs = 3;
+      else
+        goto fail;
+
+      value[ofs] = m1;
+      cur_mask = (1 << ofs);
+      mask &= ~(cur_mask * (1 + 2 + 4));
+
+      for (n = 1; (n < 3) && (*p); n++)
+        {
+          if (*p != c)
+            goto fail;
+
+          value[ofs + n] = grub_strtoul (p + 1, &p, 10);
+          cur_mask |= (1 << (ofs + n));
+        }
+
+      if (*p)
+        goto fail;
+
+      if ((ofs == 0) && (n == 2))
+        {
+          value[ofs + 2] = value[ofs + 1];
+          value[ofs + 1] = value[ofs];
+          ofs++;
+          cur_mask <<= 1;
+        }
+
+      for (; n; n--, ofs++)
+        if ((value [ofs] < limit[ofs][0]) ||
+            (value [ofs] > limit[ofs][1]))
+          goto fail;
+
+      mask |= cur_mask;
+    }
+
+  if (grub_get_datetime (&datetime))
+    return grub_errno;
+
+  if (mask & GRUB_DATETIME_SET_YEAR)
+    datetime.year = value[0];
+
+  if (mask & GRUB_DATETIME_SET_MONTH)
+    datetime.month = value[1];
+
+  if (mask & GRUB_DATETIME_SET_DAY)
+    datetime.day = value[2];
+
+  if (mask & GRUB_DATETIME_SET_HOUR)
+    datetime.hour = value[3];
+
+  if (mask & GRUB_DATETIME_SET_MINUTE)
+    datetime.minute = value[4];
+
+  if (mask & GRUB_DATETIME_SET_SECOND)
+    datetime.second = value[5];
+
+  return grub_set_datetime (&datetime);
+
+fail:
+  return grub_error (GRUB_ERR_BAD_ARGUMENT, "invalid datetime");
+}
+
+static grub_command_t cmd;
+
+GRUB_MOD_INIT(date)
+{
+  cmd =
+    grub_register_command ("date", grub_cmd_date,
+			   N_("[[year-]month-day] [hour:minute[:second]]"),
+			   N_("Command to display/set current datetime."));
+}
+
+GRUB_MOD_FINI(date)
+{
+  grub_unregister_command (cmd);
+}

grub-core/commands/echo.c

@@ -0,0 +1,124 @@
+/* echo.c - Command to display a line of text  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2006,2007  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/dl.h>
+#include <grub/misc.h>
+#include <grub/extcmd.h>
+#include <grub/i18n.h>
+
+static const struct grub_arg_option options[] =
+  {
+    {0, 'n', 0, N_("Do not output the trailing newline."), 0, 0},
+    {0, 'e', 0, N_("Enable interpretation of backslash escapes."), 0, 0},
+    {0, 0, 0, 0, 0, 0}
+  };
+
+static grub_err_t
+grub_cmd_echo (grub_extcmd_t cmd, int argc, char **args)
+{
+  struct grub_arg_list *state = cmd->state;
+  int newline = 1;
+  int i;
+
+  /* Check if `-n' was used.  */
+  if (state[0].set)
+    newline = 0;
+
+  for (i = 0; i < argc; i++)
+    {
+      char *arg = *args;
+      args++;
+
+      while (*arg)
+	{
+	  /* In case `-e' is used, parse backslashes.  */
+	  if (*arg == '\\' && state[1].set)
+	    {
+	      arg++;
+	      if (*arg == '\0')
+		break;
+
+	      switch (*arg)
+		{
+		case '\\':
+		  grub_printf ("\\");
+		  break;
+
+		case 'a':
+		  grub_printf ("\a");
+		  break;
+
+		case 'c':
+		  newline = 0;
+		  break;
+
+		case 'f':
+		  grub_printf ("\f");
+		  break;
+
+		case 'n':
+		  grub_printf ("\n");
+		  break;
+
+		case 'r':
+		  grub_printf ("\r");
+		  break;
+
+		case 't':
+		  grub_printf ("\t");
+		  break;
+
+		case 'v':
+		  grub_printf ("\v");
+		  break;
+		}
+	      arg++;
+	      continue;
+	    }
+
+	  /* This was not an escaped character, or escaping is not
+	     enabled.  */
+	  grub_printf ("%c", *arg);
+	  arg++;
+	}
+
+      /* If another argument follows, insert a space.  */
+      if (i != argc - 1)
+	grub_printf (" " );
+    }
+
+  if (newline)
+    grub_printf ("\n");
+
+  return 0;
+}
+
+static grub_extcmd_t cmd;
+
+GRUB_MOD_INIT(echo)
+{
+  cmd = grub_register_extcmd ("echo", grub_cmd_echo, GRUB_COMMAND_FLAG_BOTH,
+			      N_("[-e|-n] STRING"), N_("Display a line of text."),
+			      options);
+}
+
+GRUB_MOD_FINI(echo)
+{
+  grub_unregister_extcmd (cmd);
+}

grub-core/commands/efi/acpi.c

@@ -0,0 +1,59 @@
+/* acpi.c - get acpi tables. */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/acpi.h>
+#include <grub/misc.h>
+#include <grub/efi/efi.h>
+#include <grub/efi/api.h>
+
+struct grub_acpi_rsdp_v10 *
+grub_machine_acpi_get_rsdpv1 (void)
+{
+  unsigned i;
+  static grub_efi_guid_t acpi_guid = GRUB_EFI_ACPI_TABLE_GUID;
+
+  for (i = 0; i < grub_efi_system_table->num_table_entries; i++)
+    {
+      grub_efi_guid_t *guid =
+	&grub_efi_system_table->configuration_table[i].vendor_guid;
+
+      if (! grub_memcmp (guid, &acpi_guid, sizeof (grub_efi_guid_t)))
+	return (struct grub_acpi_rsdp_v10 *)
+	  grub_efi_system_table->configuration_table[i].vendor_table;
+    }
+  return 0;
+}
+
+struct grub_acpi_rsdp_v20 *
+grub_machine_acpi_get_rsdpv2 (void)
+{
+  unsigned i;
+  static grub_efi_guid_t acpi20_guid = GRUB_EFI_ACPI_20_TABLE_GUID;
+
+  for (i = 0; i < grub_efi_system_table->num_table_entries; i++)
+    {
+      grub_efi_guid_t *guid =
+	&grub_efi_system_table->configuration_table[i].vendor_guid;
+
+      if (! grub_memcmp (guid, &acpi20_guid, sizeof (grub_efi_guid_t)))
+	return (struct grub_acpi_rsdp_v20 *)
+	  grub_efi_system_table->configuration_table[i].vendor_table;
+    }
+  return 0;
+}

grub-core/commands/efi/fixvideo.c

@@ -0,0 +1,110 @@
+/* fixvideo.c - fix video problem in efi */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/dl.h>
+#include <grub/misc.h>
+#include <grub/file.h>
+#include <grub/pci.h>
+#include <grub/command.h>
+#include <grub/i18n.h>
+
+static struct grub_video_patch
+{
+  const char *name;
+  grub_uint32_t pci_id;
+  grub_uint32_t mmio_bar;
+  grub_uint32_t mmio_reg;
+  grub_uint32_t mmio_old;
+} video_patches[] =
+  {
+    {"Intel 945GM", 0x27a28086, 0, 0x71184, 0x1000000}, /* DSPBBASE  */
+    {"Intel 965GM", 0x2a028086, 0, 0x7119C, 0x1000000}, /* DSPBSURF  */
+    {0, 0, 0, 0, 0}
+  };
+
+static int NESTED_FUNC_ATTR
+scan_card (grub_pci_device_t dev, grub_pci_id_t pciid)
+{
+  grub_pci_address_t addr;
+
+  addr = grub_pci_make_address (dev, GRUB_PCI_REG_CLASS);
+  if (grub_pci_read_byte (addr + 3) == 0x3)
+    {
+      struct grub_video_patch *p = video_patches;
+
+      while (p->name)
+	{
+	  if (p->pci_id == pciid)
+	    {
+	      grub_target_addr_t base;
+
+	      grub_printf ("Found graphic card: %s\n", p->name);
+	      addr += 8 + p->mmio_bar * 4;
+	      base = grub_pci_read (addr);
+	      if ((! base) || (base & GRUB_PCI_ADDR_SPACE_IO) ||
+		  (base & GRUB_PCI_ADDR_MEM_PREFETCH))
+		grub_printf ("Invalid MMIO bar %d\n", p->mmio_bar);
+	      else
+		{
+		  base &= GRUB_PCI_ADDR_MEM_MASK;
+		  base += p->mmio_reg;
+
+		  if (*((volatile grub_uint32_t *) base) != p->mmio_old)
+		    grub_printf ("Old value don't match\n");
+		  else
+		    {
+		      *((volatile grub_uint32_t *) base) = 0;
+		      if (*((volatile grub_uint32_t *) base))
+			grub_printf ("Set MMIO fails\n");
+		    }
+		}
+
+	      return 1;
+	    }
+	  p++;
+	}
+
+      grub_printf ("Unknown graphic card: %x\n", pciid);
+    }
+
+  return 0;
+}
+
+static grub_err_t
+grub_cmd_fixvideo (grub_command_t cmd __attribute__ ((unused)),
+		   int argc __attribute__ ((unused)),
+		   char *argv[] __attribute__ ((unused)))
+{
+  grub_pci_iterate (scan_card);
+  return 0;
+}
+
+static grub_command_t cmd_fixvideo;
+
+GRUB_MOD_INIT(fixvideo)
+{
+  cmd_fixvideo = grub_register_command ("fix_video", grub_cmd_fixvideo,
+					0, N_("Fix video problem."));
+
+}
+
+GRUB_MOD_FINI(fixvideo)
+{
+  grub_unregister_command (cmd_fixvideo);
+}

grub-core/commands/efi/loadbios.c

@@ -0,0 +1,218 @@
+/* loadbios.c - command to load a bios dump  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/dl.h>
+#include <grub/misc.h>
+#include <grub/file.h>
+#include <grub/efi/efi.h>
+#include <grub/pci.h>
+#include <grub/command.h>
+#include <grub/i18n.h>
+
+static grub_efi_guid_t acpi_guid = GRUB_EFI_ACPI_TABLE_GUID;
+static grub_efi_guid_t acpi2_guid = GRUB_EFI_ACPI_20_TABLE_GUID;
+static grub_efi_guid_t smbios_guid = GRUB_EFI_SMBIOS_TABLE_GUID;
+
+#define EBDA_SEG_ADDR	0x40e
+#define LOW_MEM_ADDR	0x413
+#define FAKE_EBDA_SEG	0x9fc0
+
+#define BLANK_MEM	0xffffffff
+#define VBIOS_ADDR	0xc0000
+#define SBIOS_ADDR	0xf0000
+
+static int
+enable_rom_area (void)
+{
+  grub_pci_address_t addr;
+  grub_uint32_t *rom_ptr;
+  grub_pci_device_t dev = { .bus = 0, .device = 0, .function = 0};
+
+  rom_ptr = (grub_uint32_t *) VBIOS_ADDR;
+  if (*rom_ptr != BLANK_MEM)
+    {
+      grub_printf ("ROM image is present.\n");
+      return 0;
+    }
+
+  /* FIXME: should be macroified.  */
+  addr = grub_pci_make_address (dev, 144);
+  grub_pci_write_byte (addr++, 0x30);
+  grub_pci_write_byte (addr++, 0x33);
+  grub_pci_write_byte (addr++, 0x33);
+  grub_pci_write_byte (addr++, 0x33);
+  grub_pci_write_byte (addr++, 0x33);
+  grub_pci_write_byte (addr++, 0x33);
+  grub_pci_write_byte (addr++, 0x33);
+  grub_pci_write_byte (addr, 0);
+
+  *rom_ptr = 0;
+  if (*rom_ptr != 0)
+    {
+      grub_printf ("Can\'t enable ROM area.\n");
+      return 0;
+    }
+
+  return 1;
+}
+
+static void
+lock_rom_area (void)
+{
+  grub_pci_address_t addr;
+  grub_pci_device_t dev = { .bus = 0, .device = 0, .function = 0};
+
+  /* FIXME: should be macroified.  */
+  addr = grub_pci_make_address (dev, 144);
+  grub_pci_write_byte (addr++, 0x10);
+  grub_pci_write_byte (addr++, 0x11);
+  grub_pci_write_byte (addr++, 0x11);
+  grub_pci_write_byte (addr++, 0x11);
+  grub_pci_write_byte (addr, 0x11);
+}
+
+static void
+fake_bios_data (int use_rom)
+{
+  unsigned i;
+  void *acpi, *smbios;
+  grub_uint16_t *ebda_seg_ptr, *low_mem_ptr;
+
+  ebda_seg_ptr = (grub_uint16_t *) EBDA_SEG_ADDR;
+  low_mem_ptr = (grub_uint16_t *) LOW_MEM_ADDR;
+  if ((*ebda_seg_ptr) || (*low_mem_ptr))
+    return;
+
+  acpi = 0;
+  smbios = 0;
+  for (i = 0; i < grub_efi_system_table->num_table_entries; i++)
+    {
+      grub_efi_guid_t *guid =
+	&grub_efi_system_table->configuration_table[i].vendor_guid;
+
+      if (! grub_memcmp (guid, &acpi2_guid, sizeof (grub_efi_guid_t)))
+	{
+	  acpi = grub_efi_system_table->configuration_table[i].vendor_table;
+	  grub_dprintf ("efi", "ACPI2: %p\n", acpi);
+	}
+      else if (! grub_memcmp (guid, &acpi_guid, sizeof (grub_efi_guid_t)))
+	{
+	  void *t;
+
+	  t = grub_efi_system_table->configuration_table[i].vendor_table;
+	  if (! acpi)
+	    acpi = t;
+	  grub_dprintf ("efi", "ACPI: %p\n", t);
+	}
+      else if (! grub_memcmp (guid, &smbios_guid, sizeof (grub_efi_guid_t)))
+	{
+	  smbios = grub_efi_system_table->configuration_table[i].vendor_table;
+	  grub_dprintf ("efi", "SMBIOS: %p\n", smbios);
+	}
+    }
+
+  *ebda_seg_ptr = FAKE_EBDA_SEG;
+  *low_mem_ptr = (FAKE_EBDA_SEG >> 6);
+
+  *((grub_uint16_t *) (FAKE_EBDA_SEG << 4)) = 640 - *low_mem_ptr;
+
+  if (acpi)
+    grub_memcpy ((char *) ((FAKE_EBDA_SEG << 4) + 16), acpi, 1024 - 16);
+
+  if ((use_rom) && (smbios))
+    grub_memcpy ((char *) SBIOS_ADDR, (char *) smbios + 16, 16);
+}
+
+static grub_err_t
+grub_cmd_fakebios (struct grub_command *cmd __attribute__ ((unused)),
+		   int argc __attribute__ ((unused)),
+		   char *argv[] __attribute__ ((unused)))
+{
+  if (enable_rom_area ())
+    {
+      fake_bios_data (1);
+      lock_rom_area ();
+    }
+  else
+    fake_bios_data (0);
+
+  return 0;
+}
+
+static grub_err_t
+grub_cmd_loadbios (grub_command_t cmd __attribute__ ((unused)),
+		   int argc, char *argv[])
+{
+  grub_file_t file;
+  int size;
+
+  if (argc == 0)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "no ROM image specified");
+
+  if (argc > 1)
+    {
+      file = grub_file_open (argv[1]);
+      if (! file)
+	return grub_errno;
+
+      if (file->size != 4)
+	grub_error (GRUB_ERR_BAD_ARGUMENT, "invalid int10 dump size");
+      else
+	grub_file_read (file, (void *) 0x40, 4);
+
+      grub_file_close (file);
+      if (grub_errno)
+	return grub_errno;
+    }
+
+  file = grub_file_open (argv[0]);
+  if (! file)
+    return grub_errno;
+
+  size = file->size;
+  if ((size < 0x10000) || (size > 0x40000))
+    grub_error (GRUB_ERR_BAD_ARGUMENT, "invalid bios dump size");
+  else if (enable_rom_area ())
+    {
+      grub_file_read (file, (void *) VBIOS_ADDR, size);
+      fake_bios_data (size <= 0x40000);
+      lock_rom_area ();
+    }
+
+  grub_file_close (file);
+  return grub_errno;
+}
+
+static grub_command_t cmd_fakebios, cmd_loadbios;
+
+GRUB_MOD_INIT(loadbios)
+{
+  cmd_fakebios = grub_register_command ("fakebios", grub_cmd_fakebios,
+					0, N_("Fake BIOS."));
+
+  cmd_loadbios = grub_register_command ("loadbios", grub_cmd_loadbios,
+					"BIOS_DUMP [INT10_DUMP]",
+					N_("Load BIOS dump."));
+}
+
+GRUB_MOD_FINI(loadbios)
+{
+  grub_unregister_command (cmd_fakebios);
+  grub_unregister_command (cmd_loadbios);
+}

grub-core/commands/extcmd.c

@@ -0,0 +1,96 @@
+/* extcmd.c - support extended command */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/mm.h>
+#include <grub/list.h>
+#include <grub/misc.h>
+#include <grub/extcmd.h>
+
+static grub_err_t
+grub_extcmd_dispatcher (struct grub_command *cmd,
+			int argc, char **args)
+{
+  int new_argc;
+  char **new_args;
+  struct grub_arg_option *parser;
+  struct grub_arg_list *state;
+  int maxargs = 0;
+  grub_err_t ret;
+  grub_extcmd_t ext;
+
+  ext = cmd->data;
+  parser = (struct grub_arg_option *) ext->options;
+  while (parser && (parser++)->doc)
+    maxargs++;
+
+  /* Set up the option state.  */
+  state = grub_zalloc (sizeof (struct grub_arg_list) * maxargs);
+
+  if (grub_arg_parse (ext, argc, args, state, &new_args, &new_argc))
+    {
+      ext->state = state;
+      ret = (ext->func) (ext, new_argc, new_args);
+      grub_free (new_args);
+    }
+  else
+    ret = grub_errno;
+
+  grub_free (state);
+
+  return ret;
+}
+
+grub_extcmd_t
+grub_register_extcmd (const char *name, grub_extcmd_func_t func,
+		      unsigned flags, const char *summary,
+		      const char *description,
+		      const struct grub_arg_option *parser)
+{
+  grub_extcmd_t ext;
+  grub_command_t cmd;
+
+  ext = (grub_extcmd_t) grub_malloc (sizeof (*ext));
+  if (! ext)
+    return 0;
+
+  cmd = grub_register_command_prio (name, grub_extcmd_dispatcher,
+				    summary, description, 1);
+  if (! cmd)
+    {
+      grub_free (ext);
+      return 0;
+    }
+
+  cmd->flags = (flags | GRUB_COMMAND_FLAG_EXTCMD);
+  cmd->data = ext;
+
+  ext->cmd = cmd;
+  ext->func = func;
+  ext->options = parser;
+  ext->data = 0;
+
+  return ext;
+}
+
+void
+grub_unregister_extcmd (grub_extcmd_t ext)
+{
+  grub_unregister_command (ext->cmd);
+  grub_free (ext);
+}

grub-core/commands/gptsync.c

@@ -0,0 +1,256 @@
+/* gptsync.c - fill the mbr based on gpt entries  */
+/* XXX: I don't know what to do if sector size isn't 512 bytes */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/command.h>
+#include <grub/dl.h>
+#include <grub/device.h>
+#include <grub/disk.h>
+#include <grub/msdos_partition.h>
+#include <grub/partition.h>
+#include <grub/misc.h>
+#include <grub/mm.h>
+#include <grub/fs.h>
+#include <grub/i18n.h>
+
+/* Convert a LBA address to a CHS address in the INT 13 format.  */
+/* Taken from grub1. */
+/* XXX: use hardcoded geometry of C = 1024, H = 255, S = 63.
+   Is it a problem?
+*/
+static void
+lba_to_chs (int lba, grub_uint8_t *cl, grub_uint8_t *ch,
+	    grub_uint8_t *dh)
+{
+  int cylinder, head, sector;
+  int sectors = 63, heads = 255, cylinders = 1024;
+
+  sector = lba % sectors + 1;
+  head = (lba / sectors) % heads;
+  cylinder = lba / (sectors * heads);
+
+  if (cylinder >= cylinders)
+    {
+      *cl = *ch = *dh = 0xff;
+      return;
+    }
+
+  *cl = sector | ((cylinder & 0x300) >> 2);
+  *ch = cylinder & 0xFF;
+  *dh = head;
+}
+
+static grub_err_t
+grub_cmd_gptsync (grub_command_t cmd __attribute__ ((unused)),
+		  int argc, char **args)
+{
+  grub_device_t dev;
+  struct grub_msdos_partition_mbr mbr;
+  struct grub_partition *partition;
+  grub_disk_addr_t first_sector;
+  int numactive = 0;
+
+  if (argc < 1)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "device name required");
+  if (argc > 4)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "only 3 partitions can be "
+		       "in hybrid MBR");
+
+  if (args[0][0] == '(' && args[0][grub_strlen (args[0]) - 1] == ')')
+    {
+      args[0][grub_strlen (args[0]) - 1] = 0;
+      dev = grub_device_open (args[0] + 1);
+      args[0][grub_strlen (args[0])] = ')';
+    }
+  else
+    dev = grub_device_open (args[0]);
+
+  if (! dev)
+    return grub_errno;
+
+  if (! dev->disk)
+    {
+      grub_device_close (dev);
+      return grub_error (GRUB_ERR_BAD_ARGUMENT, "not a disk");
+    }
+
+  /* Read the protective MBR.  */
+  if (grub_disk_read (dev->disk, 0, 0, sizeof (mbr), &mbr))
+    {
+      grub_device_close (dev);
+      return grub_errno;
+    }
+
+  /* Check if it is valid.  */
+  if (mbr.signature != grub_cpu_to_le16 (GRUB_PC_PARTITION_SIGNATURE))
+    {
+      grub_device_close (dev);
+      return grub_error (GRUB_ERR_BAD_PART_TABLE, "no signature");
+    }
+
+  /* Make sure the MBR is a protective MBR and not a normal MBR.  */
+  if (mbr.entries[0].type != GRUB_PC_PARTITION_TYPE_GPT_DISK)
+    {
+      grub_device_close (dev);
+      return grub_error (GRUB_ERR_BAD_PART_TABLE, "no GPT partition map found");
+    }
+
+  int i;
+  first_sector = dev->disk->total_sectors;
+  for (i = 1; i < argc; i++)
+    {
+      char *separator, csep = 0;
+      grub_uint8_t type;
+      separator = grub_strchr (args[i], '+');
+      if (! separator)
+	separator = grub_strchr (args[i], '-');
+      if (separator)
+	{
+	  csep = *separator;
+	  *separator = 0;
+	}
+      partition = grub_partition_probe (dev->disk, args[i]);
+      if (separator)
+	*separator = csep;
+      if (! partition)
+	{
+	  grub_device_close (dev);
+	  return grub_error (GRUB_ERR_UNKNOWN_DEVICE, "no such partition");
+	}
+
+      if (partition->start + partition->len > 0xffffffff)
+	{
+	  grub_device_close (dev);
+	  return grub_error (GRUB_ERR_OUT_OF_RANGE,
+			     "only partitions resding in the first 2TB "
+			     "can be presen in hybrid MBR");
+	}
+
+
+      if (first_sector > partition->start)
+	first_sector = partition->start;
+
+      if (separator && *(separator + 1))
+	type = grub_strtoul (separator + 1, 0, 0);
+      else
+	{
+	  grub_fs_t fs = 0;
+	  dev->disk->partition = partition;
+	  fs = grub_fs_probe (dev);
+
+	  /* Unknown filesystem isn't fatal. */
+	  if (grub_errno == GRUB_ERR_UNKNOWN_FS)
+	    {
+	      fs = 0;
+	      grub_errno = GRUB_ERR_NONE;
+	    }
+
+	  if (fs && grub_strcmp (fs->name, "ntfs") == 0)
+	    type = GRUB_PC_PARTITION_TYPE_NTFS;
+	  else if (fs && grub_strcmp (fs->name, "fat") == 0)
+	    /* FIXME: detect FAT16. */
+	    type = GRUB_PC_PARTITION_TYPE_FAT32_LBA;
+	  else if (fs && (grub_strcmp (fs->name, "hfsplus") == 0
+			  || grub_strcmp (fs->name, "hfs") == 0))
+	    type = GRUB_PC_PARTITION_TYPE_HFS;
+	  else
+	    /* FIXME: detect more types. */
+	    type = GRUB_PC_PARTITION_TYPE_EXT2FS;
+
+	  dev->disk->partition = 0;
+	}
+
+      mbr.entries[i].flag = (csep == '+') ? 0x80 : 0;
+      if (csep == '+')
+	{
+	  numactive++;
+	  if (numactive == 2)
+	    {
+	      grub_device_close (dev);
+	      return grub_error (GRUB_ERR_BAD_ARGUMENT,
+				 "only one partition can be active");
+	    }
+	}
+      mbr.entries[i].type = type;
+      mbr.entries[i].start = grub_cpu_to_le32 (partition->start);
+      lba_to_chs (partition->start,
+		  &(mbr.entries[i].start_sector),
+		  &(mbr.entries[i].start_cylinder),
+		  &(mbr.entries[i].start_head));
+      lba_to_chs (partition->start + partition->len - 1,
+		  &(mbr.entries[i].end_sector),
+		  &(mbr.entries[i].end_cylinder),
+		  &(mbr.entries[i].end_head));
+      mbr.entries[i].length = grub_cpu_to_le32 (partition->len);
+      grub_free (partition);
+    }
+  for (; i < 4; i++)
+    grub_memset (&(mbr.entries[i]), 0, sizeof (mbr.entries[i]));
+
+  /* The protective partition. */
+  if (first_sector > 0xffffffff)
+    first_sector = 0xffffffff;
+  else
+    first_sector--;
+  mbr.entries[0].flag = 0;
+  mbr.entries[0].type = GRUB_PC_PARTITION_TYPE_GPT_DISK;
+  mbr.entries[0].start = grub_cpu_to_le32 (1);
+  lba_to_chs (1,
+	      &(mbr.entries[0].start_sector),
+	      &(mbr.entries[0].start_cylinder),
+	      &(mbr.entries[0].start_head));
+  lba_to_chs (first_sector,
+	      &(mbr.entries[0].end_sector),
+	      &(mbr.entries[0].end_cylinder),
+	      &(mbr.entries[0].end_head));
+  mbr.entries[0].length = grub_cpu_to_le32 (first_sector);
+
+  mbr.signature = grub_cpu_to_le16 (GRUB_PC_PARTITION_SIGNATURE);
+
+  if (grub_disk_write (dev->disk, 0, 0, sizeof (mbr), &mbr))
+    {
+      grub_device_close (dev);
+      return grub_errno;
+    }
+
+  grub_printf ("New MBR is written to '%s'\n", args[0]);
+
+  return GRUB_ERR_NONE;
+}
+
+
+static grub_command_t cmd;
+
+GRUB_MOD_INIT(gptsync)
+{
+  (void) mod;			/* To stop warning. */
+  cmd = grub_register_command ("gptsync", grub_cmd_gptsync,
+			       N_("DEVICE [PARTITION[+/-[TYPE]]] ..."),
+			       N_("Fill hybrid MBR of GPT drive DEVICE. "
+			       "specified partitions will be a part "
+			       "of hybrid mbr. Up to 3 partitions are "
+			       "allowed. TYPE is an MBR type. "
+			       "+ means that partition is active. "
+			       "Only one partition can be active."));
+}
+
+GRUB_MOD_FINI(gptsync)
+{
+  grub_unregister_command (cmd);
+}

grub-core/commands/halt.c

@@ -0,0 +1,46 @@
+/* halt.c - command to halt the computer.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2005,2007,2008  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/dl.h>
+#include <grub/command.h>
+#include <grub/misc.h>
+#include <grub/i18n.h>
+
+static grub_err_t
+grub_cmd_halt (grub_command_t cmd __attribute__ ((unused)),
+	       int argc __attribute__ ((unused)),
+	       char **args __attribute__ ((unused)))
+{
+  grub_halt ();
+  return 0;
+}
+
+static grub_command_t cmd;
+
+GRUB_MOD_INIT(halt)
+{
+  cmd = grub_register_command ("halt", grub_cmd_halt,
+			       0, N_("Halts the computer.  This command does" 
+			       " not work on all firmware implementations."));
+}
+
+GRUB_MOD_FINI(halt)
+{
+  grub_unregister_command (cmd);
+}

grub-core/commands/handler.c

@@ -0,0 +1,101 @@
+/* handler.c - commands to list or select handlers */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/dl.h>
+#include <grub/err.h>
+#include <grub/misc.h>
+#include <grub/term.h>
+#include <grub/handler.h>
+#include <grub/command.h>
+#include <grub/i18n.h>
+
+static grub_err_t
+grub_cmd_handler (struct grub_command *cmd __attribute__ ((unused)),
+		  int argc, char **args)
+{
+  void *curr_item = 0;
+  grub_handler_class_t head;
+
+  auto int list_item (grub_named_list_t item);
+  int list_item (grub_named_list_t item)
+    {
+      if (item == curr_item)
+	grub_putchar ('*');
+
+      grub_printf ("%s\n", item->name);
+
+      return 0;
+    }
+
+  head = grub_handler_class_list;
+  if (argc == 0)
+    {
+      grub_list_iterate (GRUB_AS_LIST (head), (grub_list_hook_t) list_item);
+    }
+  else
+    {
+      char *class_name;
+      grub_handler_class_t class;
+
+      class_name = args[0];
+      argc--;
+      args++;
+
+      class = grub_named_list_find (GRUB_AS_NAMED_LIST (head), class_name);
+      if (! class)
+	return grub_error (GRUB_ERR_FILE_NOT_FOUND, "class not found");
+
+      if (argc == 0)
+	{
+	  curr_item = class->cur_handler;
+	  grub_list_iterate (GRUB_AS_LIST (class->handler_list),
+			     (grub_list_hook_t) list_item);
+	}
+      else
+	{
+	  grub_handler_t handler;
+
+	  handler =
+	    grub_named_list_find (GRUB_AS_NAMED_LIST (class->handler_list),
+				  args[0]);
+
+	  if (! handler)
+	    return grub_error (GRUB_ERR_FILE_NOT_FOUND, "handler not found");
+
+	  grub_handler_set_current (class, handler);
+	}
+    }
+
+  return 0;
+}
+
+static grub_command_t cmd_handler;
+
+GRUB_MOD_INIT(handler)
+{
+  cmd_handler =
+    grub_register_command ("handler", grub_cmd_handler,
+			   N_("[class [handler]]"),
+			   N_("List or select a handler."));
+}
+
+GRUB_MOD_FINI(handler)
+{
+  grub_unregister_command (cmd_handler);
+}

grub-core/commands/hashsum.c

@@ -0,0 +1,277 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/dl.h>
+#include <grub/extcmd.h>
+#include <grub/file.h>
+#include <grub/disk.h>
+#include <grub/mm.h>
+#include <grub/misc.h>
+#include <grub/crypto.h>
+#include <grub/normal.h>
+#include <grub/i18n.h>
+
+static const struct grub_arg_option options[] = {
+  {"hash", 'h', 0, N_("Specify hash to use."), N_("HASH"), ARG_TYPE_STRING},
+  {"check", 'c', 0, N_("Check hash list file."), N_("FILE"), ARG_TYPE_STRING},
+  {"prefix", 'p', 0, N_("Base directory for hash list."), N_("DIRECTORY"),
+   ARG_TYPE_STRING},
+  {"keep-going", 'k', 0, N_("Don't stop after first error."), 0, 0},
+  {0, 0, 0, 0, 0, 0}
+};
+
+struct { const char *name; const char *hashname; } aliases[] = 
+  {
+    {"sha256sum", "sha256"},
+    {"sha512sum", "sha512"},
+    {"md5sum", "md5"},
+  };
+
+static inline int
+hextoval (char c)
+{
+  if (c >= '0' && c <= '9')
+    return c - '0';
+  if (c >= 'a' && c <= 'f')
+    return c - 'a' + 10;
+  if (c >= 'A' && c <= 'F')
+    return c - 'A' + 10;
+  return -1;
+}
+
+static grub_err_t
+hash_file (grub_file_t file, const gcry_md_spec_t *hash, void *result)
+{
+  grub_uint8_t context[hash->contextsize];
+  grub_uint8_t readbuf[4096];
+
+  grub_memset (context, 0, sizeof (context));
+  hash->init (context);
+  while (1)
+    {
+      grub_ssize_t r;
+      r = grub_file_read (file, readbuf, sizeof (readbuf));
+      if (r < 0)
+	return grub_errno;
+      if (r == 0)
+	break;
+      hash->write (context, readbuf, r);
+    }
+  hash->final (context);
+  grub_memcpy (result, hash->read (context), hash->mdlen);
+
+  return GRUB_ERR_NONE;
+}
+
+static grub_err_t
+check_list (const gcry_md_spec_t *hash, const char *hashfilename,
+	    const char *prefix, int keep)
+{
+  grub_file_t hashlist, file;
+  char *buf = NULL;
+  grub_uint8_t expected[hash->mdlen];
+  grub_uint8_t actual[hash->mdlen];
+  grub_err_t err;
+  unsigned i;
+  unsigned unread = 0, mismatch = 0;
+
+  hashlist = grub_file_open (hashfilename);
+  if (!hashlist)
+    return grub_errno;
+  
+  while (grub_free (buf), (buf = grub_file_getline (hashlist)))
+    {
+      const char *p = buf;
+      for (i = 0; i < hash->mdlen; i++)
+	{
+	  int high, low;
+	  high = hextoval (*p++);
+	  low = hextoval (*p++);
+	  if (high < 0 || low < 0)
+	    return grub_error (GRUB_ERR_BAD_FILE_TYPE, "invalid hash list");
+	  expected[i] = (high << 4) | low;
+	}
+      if (*p++ != ' ' || *p++ != ' ')
+	return grub_error (GRUB_ERR_BAD_FILE_TYPE, "invalid hash list");
+      if (prefix)
+	{
+	  char *filename;
+	  
+	  filename = grub_xasprintf ("%s/%s", prefix, p);
+	  if (!filename)
+	    return grub_errno;
+	  file = grub_file_open (filename);
+	  grub_free (filename);
+	}
+      else
+	file = grub_file_open (p);
+      if (!file)
+	{
+	  grub_file_close (hashlist);
+	  grub_free (buf);
+	  return grub_errno;
+	}
+      err = hash_file (file, hash, actual);
+      grub_file_close (file);
+      if (err)
+	{
+	  grub_printf ("%s: READ ERROR\n", p);
+	  if (!keep)
+	    {
+	      grub_file_close (hashlist);
+	      grub_free (buf);
+	      return err;
+	    }
+	  grub_print_error ();
+	  grub_errno = GRUB_ERR_NONE;
+	  unread++;
+	  continue;
+	}
+      if (grub_crypto_memcmp (expected, actual, hash->mdlen) != 0)
+	{
+	  grub_printf ("%s: HASH MISMATCH\n", p);
+	  if (!keep)
+	    {
+	      grub_file_close (hashlist);
+	      grub_free (buf);
+	      return grub_error (GRUB_ERR_TEST_FAILURE,
+				 "hash of '%s' mismatches", p);
+	    }
+	  mismatch++;
+	  continue;	  
+	}
+      grub_printf ("%s: OK\n", p);
+    }
+  if (mismatch || unread)
+    return grub_error (GRUB_ERR_TEST_FAILURE,
+		       "%d files couldn't be read and hash "
+		       "of %d files mismatches", unread, mismatch);
+  return GRUB_ERR_NONE;
+}
+
+static grub_err_t
+grub_cmd_hashsum (struct grub_extcmd *cmd,
+		  int argc, char **args)
+{
+  struct grub_arg_list *state = cmd->state;
+  const char *hashname = NULL;
+  const char *prefix = NULL;
+  const gcry_md_spec_t *hash;
+  unsigned i;
+  int keep = state[3].set;
+  unsigned unread = 0;
+
+  for (i = 0; i < ARRAY_SIZE (aliases); i++)
+    if (grub_strcmp (cmd->cmd->name, aliases[i].name) == 0)
+      hashname = aliases[i].hashname;
+  if (state[0].set)
+    hashname = state[0].arg;
+
+  if (!hashname)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "no hash specified");
+
+  hash = grub_crypto_lookup_md_by_name (hashname);
+  if (!hash)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "unknown hash");
+
+  if (state[2].set)
+    prefix = state[2].arg;
+
+  if (state[1].set)
+    {
+      if (argc != 0)
+	return grub_error (GRUB_ERR_BAD_ARGUMENT,
+			   "--check is incompatible with file list");
+      return check_list (hash, state[1].arg, prefix, keep);
+    }
+
+  for (i = 0; i < (unsigned) argc; i++)
+    {
+      grub_uint8_t result[hash->mdlen];
+      grub_file_t file;
+      grub_err_t err;
+      unsigned j;
+      file = grub_file_open (args[i]);
+      if (!file)
+	{
+	  if (!keep)
+	    return grub_errno;
+	  grub_print_error ();
+	  grub_errno = GRUB_ERR_NONE;
+	  unread++;
+	  continue;
+	}
+      err = hash_file (file, hash, result);
+      grub_file_close (file);
+      if (err)
+	{
+	  if (!keep)
+	    return err;
+	  grub_print_error ();
+	  grub_errno = GRUB_ERR_NONE;
+	  unread++;
+	  continue;
+	}
+      for (j = 0; j < hash->mdlen; j++)
+	grub_printf ("%02x", result[j]);
+      grub_printf ("  %s\n", args[i]);
+    }
+
+  if (unread)
+    return grub_error (GRUB_ERR_TEST_FAILURE, "%d files couldn't be read.",
+		       unread);
+  return GRUB_ERR_NONE;
+}
+
+static grub_extcmd_t cmd, cmd_md5, cmd_sha256, cmd_sha512;
+
+GRUB_MOD_INIT(hashsum)
+{
+  cmd = grub_register_extcmd ("hashsum", grub_cmd_hashsum,
+			      GRUB_COMMAND_FLAG_BOTH,
+			      "hashsum -h HASH [-c FILE [-p PREFIX]] "
+			      "[FILE1 [FILE2 ...]]",
+			      "Compute or check hash checksum.",
+			      options);
+  cmd_md5 = grub_register_extcmd ("md5sum", grub_cmd_hashsum,
+				  GRUB_COMMAND_FLAG_BOTH,
+				  N_("[-c FILE [-p PREFIX]] "
+				     "[FILE1 [FILE2 ...]]"),
+				  N_("Compute or check hash checksum."),
+				  options);
+  cmd_sha256 = grub_register_extcmd ("sha256sum", grub_cmd_hashsum,
+				     GRUB_COMMAND_FLAG_BOTH,
+				     N_("[-c FILE [-p PREFIX]] "
+					"[FILE1 [FILE2 ...]]"),
+				     "Compute or check hash checksum.",
+				     options);
+  cmd_sha512 = grub_register_extcmd ("sha512sum", grub_cmd_hashsum,
+				     GRUB_COMMAND_FLAG_BOTH,
+				     N_("[-c FILE [-p PREFIX]] "
+					"[FILE1 [FILE2 ...]]"),
+				     N_("Compute or check hash checksum."),
+				     options);
+}
+
+GRUB_MOD_FINI(hashsum)
+{
+  grub_unregister_extcmd (cmd);
+  grub_unregister_extcmd (cmd_md5);
+  grub_unregister_extcmd (cmd_sha256);
+  grub_unregister_extcmd (cmd_sha512);
+}

grub-core/commands/hdparm.c

@@ -0,0 +1,421 @@
+/* hdparm.c - command to get/set ATA disk parameters.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/ata.h>
+#include <grub/disk.h>
+#include <grub/dl.h>
+#include <grub/misc.h>
+#include <grub/mm.h>
+#include <grub/lib/hexdump.h>
+#include <grub/extcmd.h>
+#include <grub/i18n.h>
+
+static const struct grub_arg_option options[] = {
+  {"apm",             'B', 0, N_("Set Advanced Power Management\n"
+			      "(1=low, ..., 254=high, 255=off)."),
+			      0, ARG_TYPE_INT},
+  {"power",           'C', 0, N_("Check power mode."), 0, ARG_TYPE_NONE},
+  {"security-freeze", 'F', 0, N_("Freeze ATA security settings until reset."),
+			      0, ARG_TYPE_NONE},
+  {"health",          'H', 0, N_("Check SMART health status."), 0, ARG_TYPE_NONE},
+  {"aam",             'M', 0, N_("Set Automatic Acoustic Management\n"
+			      "(0=off, 128=quiet, ..., 254=fast)."),
+			      0, ARG_TYPE_INT},
+  {"standby-timeout", 'S', 0, N_("Set standby timeout\n"
+			      "(0=off, 1=5s, 2=10s, ..., 240=20m, 241=30m, ...)."),
+			      0, ARG_TYPE_INT},
+  {"standby",         'y', 0, N_("Set drive to standby mode."), 0, ARG_TYPE_NONE},
+  {"sleep",           'Y', 0, N_("Set drive to sleep mode."), 0, ARG_TYPE_NONE},
+  {"identify",        'i', 0, N_("Print drive identity and settings."),
+			      0, ARG_TYPE_NONE},
+  {"dumpid",          'I', 0, N_("Dump contents of ATA IDENTIFY sector."),
+			       0, ARG_TYPE_NONE},
+  {"smart",            -1, 0, N_("Disable/enable SMART (0/1)."), 0, ARG_TYPE_INT},
+  {"quiet",           'q', 0, N_("Do not print messages."), 0, ARG_TYPE_NONE},
+  {0, 0, 0, 0, 0, 0}
+};
+
+enum grub_ata_smart_commands
+  {
+    GRUB_ATA_FEAT_SMART_ENABLE  = 0xd8,
+    GRUB_ATA_FEAT_SMART_DISABLE = 0xd9,
+    GRUB_ATA_FEAT_SMART_STATUS  = 0xda,
+  };
+
+static int quiet = 0;
+
+static grub_err_t
+grub_hdparm_do_ata_cmd (grub_disk_t disk, grub_uint8_t cmd,
+			grub_uint8_t features, grub_uint8_t sectors,
+			void * buffer, int size)
+{
+  struct grub_disk_ata_pass_through_parms apt;
+  grub_memset (&apt, 0, sizeof (apt));
+
+  apt.taskfile[GRUB_ATA_REG_CMD] = cmd;
+  apt.taskfile[GRUB_ATA_REG_FEATURES] = features;
+  apt.taskfile[GRUB_ATA_REG_SECTORS] = sectors;
+  apt.buffer = buffer;
+  apt.size = size;
+
+  if (grub_disk_ata_pass_through (disk, &apt))
+    return grub_errno;
+
+  return GRUB_ERR_NONE;
+}
+
+static int
+grub_hdparm_do_check_powermode_cmd (grub_disk_t disk)
+{
+  struct grub_disk_ata_pass_through_parms apt;
+  grub_memset (&apt, 0, sizeof (apt));
+
+  apt.taskfile[GRUB_ATA_REG_CMD] = GRUB_ATA_CMD_CHECK_POWER_MODE;
+
+  if (grub_disk_ata_pass_through (disk, &apt))
+    return -1;
+
+  return apt.taskfile[GRUB_ATA_REG_SECTORS];
+}
+
+static int
+grub_hdparm_do_smart_cmd (grub_disk_t disk, grub_uint8_t features)
+{
+  struct grub_disk_ata_pass_through_parms apt;
+  grub_memset (&apt, 0, sizeof (apt));
+
+  apt.taskfile[GRUB_ATA_REG_CMD] = GRUB_ATA_CMD_SMART;
+  apt.taskfile[GRUB_ATA_REG_FEATURES] = features;
+  apt.taskfile[GRUB_ATA_REG_LBAMID]  = 0x4f;
+  apt.taskfile[GRUB_ATA_REG_LBAHIGH] = 0xc2;
+
+  if (grub_disk_ata_pass_through (disk, &apt))
+    return -1;
+
+  if (features == GRUB_ATA_FEAT_SMART_STATUS)
+    {
+      if (   apt.taskfile[GRUB_ATA_REG_LBAMID]  == 0x4f
+          && apt.taskfile[GRUB_ATA_REG_LBAHIGH] == 0xc2)
+	return 0; /* Good SMART status.  */
+      else if (   apt.taskfile[GRUB_ATA_REG_LBAMID]  == 0xf4
+	       && apt.taskfile[GRUB_ATA_REG_LBAHIGH] == 0x2c)
+	return 1; /* Bad SMART status.  */
+      else
+	return -1;
+    }
+  return 0;
+}
+
+static grub_err_t
+grub_hdparm_simple_cmd (const char * msg,
+			grub_disk_t disk, grub_uint8_t cmd)
+{
+  if (! quiet && msg)
+    grub_printf ("%s", msg);
+
+  grub_err_t err = grub_hdparm_do_ata_cmd (disk, cmd, 0, 0, NULL, 0);
+
+  if (! quiet && msg)
+    grub_printf ("%s\n", ! err ? "" : ": not supported");
+  return err;
+}
+
+static grub_err_t
+grub_hdparm_set_val_cmd (const char * msg, int val,
+			 grub_disk_t disk, grub_uint8_t cmd,
+			 grub_uint8_t features, grub_uint8_t sectors)
+{
+  if (! quiet && msg && *msg)
+    {
+      if (val >= 0)
+	grub_printf ("Set %s to %d", msg, val);
+      else
+	grub_printf ("Disable %s", msg);
+    }
+
+  grub_err_t err = grub_hdparm_do_ata_cmd (disk, cmd, features, sectors,
+					   NULL, 0);
+
+  if (! quiet && msg)
+    grub_printf ("%s\n", ! err ? "" : ": not supported");
+  return err;
+}
+
+static const char *
+le16_to_char (char *dest, const grub_uint16_t * src16, unsigned bytes)
+{
+  grub_uint16_t * dest16 = (grub_uint16_t *) dest;
+  unsigned i;
+  for (i = 0; i < bytes / 2; i++)
+    dest16[i] = grub_be_to_cpu16 (src16[i]);
+  return dest;
+}
+
+static void
+grub_hdparm_print_identify (const char * idbuf)
+{
+  const grub_uint16_t * idw = (const grub_uint16_t *) idbuf;
+
+  /* Print identity strings.  */
+  char tmp[40];
+  grub_printf ("Model:    \"%.40s\"\n", le16_to_char (tmp, &idw[27], 40));
+  grub_printf ("Firmware: \"%.8s\"\n",  le16_to_char (tmp, &idw[23], 8));
+  grub_printf ("Serial:   \"%.20s\"\n", le16_to_char (tmp, &idw[10], 20));
+
+  /* Print AAM, APM and SMART settings.  */
+  grub_uint16_t features1 = grub_le_to_cpu16 (idw[82]);
+  grub_uint16_t features2 = grub_le_to_cpu16 (idw[83]);
+  grub_uint16_t enabled1  = grub_le_to_cpu16 (idw[85]);
+  grub_uint16_t enabled2  = grub_le_to_cpu16 (idw[86]);
+
+  grub_printf ("Automatic Acoustic Management: ");
+  if (features2 & 0x0200)
+    {
+      if (enabled2 & 0x0200)
+	{
+	  grub_uint16_t aam = grub_le_to_cpu16 (idw[94]);
+	  grub_printf ("%u (128=quiet, ..., 254=fast, recommended=%u)\n",
+		       aam & 0xff, (aam >> 8) & 0xff);
+	}
+      else
+	grub_printf ("disabled\n");
+    }
+  else
+    grub_printf ("not supported\n");
+
+  grub_printf ("Advanced Power Management: ");
+  if (features2 & 0x0008)
+    {
+      if (enabled2 & 0x0008)
+	grub_printf ("%u (1=low, ..., 254=high)\n",
+		     grub_le_to_cpu16 (idw[91]) & 0xff);
+      else
+	grub_printf ("disabled\n");
+    }
+  else
+    grub_printf ("not supported\n");
+
+  grub_printf ("SMART Feature Set: ");
+  if (features1 & 0x0001)
+    grub_printf ("%sabled\n", (enabled1 & 0x0001 ? "en" : "dis"));
+  else
+    grub_printf ("not supported\n");
+
+  /* Print security settings.  */
+  grub_uint16_t security = grub_le_to_cpu16 (idw[128]);
+
+  grub_printf ("ATA Security: ");
+  if (security & 0x0001)
+    grub_printf ("%s, %s, %s, %s\n",
+		 (security & 0x0002 ? "ENABLED" : "disabled"),
+		 (security & 0x0004 ? "**LOCKED**"  : "not locked"),
+		 (security & 0x0008 ? "frozen" : "NOT FROZEN"),
+		 (security & 0x0010 ? "COUNT EXPIRED" : "count not expired"));
+  else
+    grub_printf ("not supported\n");
+}
+
+static void
+grub_hdparm_print_standby_tout (int timeout)
+{
+  if (timeout == 0)
+    grub_printf ("off");
+  else if (timeout <= 252 || timeout == 255)
+    {
+      int h = 0, m = 0 , s = 0;
+      if (timeout == 255)
+	{
+	  m = 21;
+	  s = 15;
+	}
+      else if (timeout == 252)
+	m = 21;
+      else if (timeout <= 240)
+	{
+	  s = timeout * 5;
+	  m = s / 60;
+	  s %= 60;
+	}
+      else
+	{
+	  m = (timeout - 240) * 30;
+	  h  = m / 60;
+	  m %= 60;
+	}
+      grub_printf ("%02d:%02d:%02d", h, m, s);
+    }
+  else
+    grub_printf ("invalid or vendor-specific");
+}
+
+static int get_int_arg (const struct grub_arg_list *state)
+{
+  return (state->set ? (int)grub_strtoul (state->arg, 0, 0) : -1);
+}
+
+static grub_err_t
+grub_cmd_hdparm (grub_extcmd_t cmd, int argc, char **args) // state????
+{
+  struct grub_arg_list *state = cmd->state;
+
+  /* Check command line.  */
+  if (argc != 1)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "missing device name argument");
+
+  grub_size_t len = grub_strlen (args[0]);
+  if (! (args[0][0] == '(' && args[0][len - 1] == ')'))
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "argument is not a device name");
+  args[0][len - 1] = 0;
+
+  if (! grub_disk_ata_pass_through)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "ATA pass through not available");
+
+  int i = 0;
+  int apm          = get_int_arg (&state[i++]);
+  int power        = state[i++].set;
+  int sec_freeze   = state[i++].set;
+  int health       = state[i++].set;
+  int aam          = get_int_arg (&state[i++]);
+  int standby_tout = get_int_arg (&state[i++]);
+  int standby_now  = state[i++].set;
+  int sleep_now    = state[i++].set;
+  int ident        = state[i++].set;
+  int dumpid       = state[i++].set;
+  int enable_smart = get_int_arg (&state[i++]);
+  quiet            = state[i++].set;
+
+  /* Open disk.  */
+  grub_disk_t disk = grub_disk_open (&args[0][1]);
+  if (! disk)
+    return grub_errno;
+
+  if (disk->partition)
+    {
+      grub_disk_close (disk);
+      return grub_error (GRUB_ERR_BAD_ARGUMENT, "partition not allowed");
+    }
+
+  /* Change settings.  */
+  if (aam >= 0)
+    grub_hdparm_set_val_cmd ("Automatic Acoustic Management", (aam ? aam : -1),
+      disk, GRUB_ATA_CMD_SET_FEATURES, (aam ? 0x42 : 0xc2), aam);
+
+  if (apm >= 0)
+    grub_hdparm_set_val_cmd ("Advanced Power Management",
+      (apm != 255 ? apm : -1), disk, GRUB_ATA_CMD_SET_FEATURES,
+      (apm != 255 ? 0x05 : 0x85), (apm != 255 ? apm : 0));
+
+  if (standby_tout >= 0)
+    {
+      if (! quiet)
+	{
+	  grub_printf ("Set standby timeout to %d (", standby_tout);
+	  grub_hdparm_print_standby_tout (standby_tout);
+	  grub_printf (")");
+	}
+      /* The IDLE cmd sets disk to idle mode and configures standby timer.  */
+      grub_hdparm_set_val_cmd ("", -1, disk, GRUB_ATA_CMD_IDLE, 0, standby_tout);
+    }
+
+  if (enable_smart >= 0)
+    {
+      if (! quiet)
+	grub_printf ("%sable SMART operations", (enable_smart ? "En" : "Dis"));
+      int err = grub_hdparm_do_smart_cmd (disk, (enable_smart ?
+	          GRUB_ATA_FEAT_SMART_ENABLE : GRUB_ATA_FEAT_SMART_DISABLE));
+      if (! quiet)
+	grub_printf ("%s\n", err ? ": not supported" : "");
+    }
+
+  if (sec_freeze)
+    grub_hdparm_simple_cmd ("Freeze security settings", disk,
+                            GRUB_ATA_CMD_SECURITY_FREEZE_LOCK);
+
+  /* Print/dump IDENTIFY.  */
+  if (ident || dumpid)
+    {
+      char buf[GRUB_DISK_SECTOR_SIZE];
+      if (grub_hdparm_do_ata_cmd (disk, GRUB_ATA_CMD_IDENTIFY_DEVICE,
+          0, 0, buf, sizeof (buf)))
+	grub_printf ("Cannot read ATA IDENTIFY data\n");
+      else
+	{
+	  if (ident)
+	    grub_hdparm_print_identify (buf);
+	  if (dumpid)
+	    hexdump (0, buf, sizeof (buf));
+	}
+    }
+
+  /* Check power mode.  */
+  if (power)
+    {
+      grub_printf ("Disk power mode is: ");
+      int mode = grub_hdparm_do_check_powermode_cmd (disk);
+      if (mode < 0)
+        grub_printf ("unknown\n");
+      else
+	grub_printf ("%s (0x%02x)\n",
+		     (mode == 0xff ? "active/idle" :
+		      mode == 0x80 ? "idle" :
+		      mode == 0x00 ? "standby" : "unknown"), mode);
+    }
+
+  /* Check health.  */
+  int status = 0;
+  if (health)
+    {
+      if (! quiet)
+	grub_printf ("SMART status is: ");
+      int err = grub_hdparm_do_smart_cmd (disk, GRUB_ATA_FEAT_SMART_STATUS);
+      if (! quiet)
+	grub_printf ("%s\n", (err  < 0 ? "unknown" :
+	                      err == 0 ? "OK" : "*BAD*"));
+      status = (err > 0);
+    }
+
+  /* Change power mode.  */
+  if (standby_now)
+    grub_hdparm_simple_cmd ("Set disk to standby mode", disk,
+			    GRUB_ATA_CMD_STANDBY_IMMEDIATE);
+
+  if (sleep_now)
+    grub_hdparm_simple_cmd ("Set disk to sleep mode", disk,
+			    GRUB_ATA_CMD_SLEEP);
+
+  grub_disk_close (disk);
+
+  grub_errno = GRUB_ERR_NONE;
+  return status;
+}
+
+static grub_extcmd_t cmd;
+
+GRUB_MOD_INIT(hdparm)
+{
+  cmd = grub_register_extcmd ("hdparm", grub_cmd_hdparm,
+			      GRUB_COMMAND_FLAG_BOTH,
+			      N_("[OPTIONS] DISK"),
+			      N_("Get/set ATA disk parameters."), options);
+}
+
+GRUB_MOD_FINI(hdparm)
+{
+  grub_unregister_extcmd (cmd);
+}

grub-core/commands/help.c

@@ -0,0 +1,143 @@
+/* help.c - command to show a help text.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2005,2007,2008,2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/dl.h>
+#include <grub/misc.h>
+#include <grub/term.h>
+#include <grub/extcmd.h>
+#include <grub/i18n.h>
+#include <grub/mm.h>
+#include <grub/normal.h>
+#include <grub/charset.h>
+
+static grub_err_t
+grub_cmd_help (grub_extcmd_t ext __attribute__ ((unused)), int argc,
+	       char **args)
+{
+  int cnt = 0;
+  char *currarg;
+
+  auto int print_command_info (grub_command_t cmd);
+  auto int print_command_help (grub_command_t cmd);
+
+  int print_command_info (grub_command_t cmd)
+    {
+      if ((cmd->prio & GRUB_PRIO_LIST_FLAG_ACTIVE) &&
+	  (cmd->flags & GRUB_COMMAND_FLAG_CMDLINE))
+	{
+	  struct grub_term_output *term;
+	  const char *summary_translated = _(cmd->summary);
+	  char *command_help;
+	  grub_uint32_t *unicode_command_help;
+	  grub_uint32_t *unicode_last_position;
+	  			      
+	  command_help = grub_xasprintf ("%s %s", cmd->name, summary_translated);
+	  if (!command_help)
+	    return 1;
+
+	  grub_utf8_to_ucs4_alloc (command_help, &unicode_command_help,
+	  			   &unicode_last_position);
+
+	  FOR_ACTIVE_TERM_OUTPUTS(term)
+	  {
+	    unsigned stringwidth;
+	    grub_uint32_t *unicode_last_screen_position;
+
+	    unicode_last_screen_position = unicode_command_help;
+
+	    stringwidth = 0;
+
+	    while (unicode_last_screen_position < unicode_last_position && 
+		   stringwidth < ((grub_term_width (term) / 2) - 2))
+	      {
+		stringwidth
+		  += grub_term_getcharwidth (term,
+					     *unicode_last_screen_position);
+		unicode_last_screen_position++;
+	      }
+
+	    grub_print_ucs4 (unicode_command_help,
+			     unicode_last_screen_position, term);
+	    if (!(cnt % 2))
+	      grub_print_spaces (term, grub_term_width (term) / 2
+				 - stringwidth);
+	  }
+	  if (cnt % 2)
+	    grub_printf ("\n");
+	  cnt++;
+	  
+	  grub_free (command_help);
+	  grub_free (unicode_command_help);
+	}
+      return 0;
+    }
+
+  int print_command_help (grub_command_t cmd)
+    {
+      if (cmd->prio & GRUB_PRIO_LIST_FLAG_ACTIVE)
+	{
+	  if (! grub_strncmp (cmd->name, currarg, grub_strlen (currarg)))
+	    {
+	      if (cnt++ > 0)
+		grub_printf ("\n\n");
+
+	      if (cmd->flags & GRUB_COMMAND_FLAG_EXTCMD)
+		grub_arg_show_help ((grub_extcmd_t) cmd->data);
+	      else
+		grub_printf ("%s %s %s\n%s\n", _("Usage:"), cmd->name, _(cmd->summary),
+			     _(cmd->description));
+	    }
+	}
+      return 0;
+    }
+
+  if (argc == 0)
+    {
+      grub_command_iterate (print_command_info);
+      if (!(cnt % 2))
+	grub_printf ("\n");
+    }
+  else
+    {
+      int i;
+
+      for (i = 0; i < argc; i++)
+	{
+	  currarg = args[i];
+	  grub_command_iterate (print_command_help);
+	}
+    }
+
+  return 0;
+}
+
+static grub_extcmd_t cmd;
+
+GRUB_MOD_INIT(help)
+{
+  cmd = grub_register_extcmd ("help", grub_cmd_help,
+			      GRUB_COMMAND_FLAG_CMDLINE,
+			      N_("[PATTERN ...]"),
+			      N_("Show a help message."), 0);
+}
+
+GRUB_MOD_FINI(help)
+{
+  grub_unregister_extcmd (cmd);
+}

grub-core/commands/hexdump.c

@@ -0,0 +1,133 @@
+/* hexdump.c - command to dump the contents of a file or memory */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2007,2008,2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/dl.h>
+#include <grub/file.h>
+#include <grub/disk.h>
+#include <grub/misc.h>
+#include <grub/gzio.h>
+#include <grub/lib/hexdump.h>
+#include <grub/extcmd.h>
+#include <grub/i18n.h>
+
+static const struct grub_arg_option options[] = {
+  {"skip", 's', 0, N_("Skip offset bytes from the beginning of file."), 0,
+   ARG_TYPE_INT},
+  {"length", 'n', 0, N_("Read only LENGTH bytes."), 0, ARG_TYPE_INT},
+  {0, 0, 0, 0, 0, 0}
+};
+
+static grub_err_t
+grub_cmd_hexdump (grub_extcmd_t cmd, int argc, char **args)
+{
+  struct grub_arg_list *state = cmd->state;
+  char buf[GRUB_DISK_SECTOR_SIZE * 4];
+  grub_ssize_t size, length;
+  grub_disk_addr_t skip;
+  int namelen;
+
+  if (argc != 1)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required");
+
+  namelen = grub_strlen (args[0]);
+  skip = (state[0].set) ? grub_strtoull (state[0].arg, 0, 0) : 0;
+  length = (state[1].set) ? grub_strtoul (state[1].arg, 0, 0) : 256;
+
+  if (!grub_strcmp (args[0], "(mem)"))
+    hexdump (skip, (char *) (grub_addr_t) skip, length);
+  else if ((args[0][0] == '(') && (args[0][namelen - 1] == ')'))
+    {
+      grub_disk_t disk;
+      grub_disk_addr_t sector;
+      grub_size_t ofs;
+
+      args[0][namelen - 1] = 0;
+      disk = grub_disk_open (&args[0][1]);
+      if (! disk)
+        return 0;
+
+      sector = (skip >> (GRUB_DISK_SECTOR_BITS + 2)) * 4;
+      ofs = skip & (GRUB_DISK_SECTOR_SIZE * 4 - 1);
+      while (length)
+        {
+          grub_size_t len;
+
+          len = length;
+          if (len > sizeof (buf))
+            len = sizeof (buf);
+
+          if (grub_disk_read (disk, sector, ofs, len, buf))
+            break;
+
+          hexdump (skip, buf, len);
+
+          ofs = 0;
+          skip += len;
+          length -= len;
+          sector += 4;
+        }
+
+      grub_disk_close (disk);
+    }
+  else
+    {
+      grub_file_t file;
+
+      file = grub_gzfile_open (args[0], 1);
+      if (! file)
+	return 0;
+
+      file->offset = skip;
+
+      while ((size = grub_file_read (file, buf, sizeof (buf))) > 0)
+	{
+	  unsigned long len;
+
+	  len = ((length) && (size > length)) ? length : size;
+	  hexdump (skip, buf, len);
+	  skip += len;
+	  if (length)
+	    {
+	      length -= len;
+	      if (!length)
+		break;
+	    }
+	}
+
+      grub_file_close (file);
+    }
+
+  return 0;
+}
+
+static grub_extcmd_t cmd;
+
+GRUB_MOD_INIT (hexdump)
+{
+  cmd = grub_register_extcmd ("hexdump", grub_cmd_hexdump,
+			      GRUB_COMMAND_FLAG_BOTH,
+			      N_("[OPTIONS] FILE_OR_DEVICE"),
+			      N_("Dump the contents of a file or memory."),
+			      options);
+}
+
+GRUB_MOD_FINI (hexdump)
+{
+  grub_unregister_extcmd (cmd);
+}

grub-core/commands/i386/cpuid.c

@@ -0,0 +1,98 @@
+/* cpuid.c - test for CPU features */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2006, 2007, 2009  Free Software Foundation, Inc.
+ *  Based on gcc/gcc/config/i386/driver-i386.c
+ *
+ *  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/dl.h>
+#include <grub/misc.h>
+#include <grub/mm.h>
+#include <grub/env.h>
+#include <grub/command.h>
+#include <grub/extcmd.h>
+#include <grub/i386/cpuid.h>
+#include <grub/i18n.h>
+
+#define cpuid(num,a,b,c,d) \
+  asm volatile ("xchgl %%ebx, %1; cpuid; xchgl %%ebx, %1" \
+		: "=a" (a), "=r" (b), "=c" (c), "=d" (d)  \
+		: "0" (num))
+
+static const struct grub_arg_option options[] =
+  {
+    {"long-mode", 'l', 0, N_("Check for long mode flag (default)."), 0, 0},
+    {0, 0, 0, 0, 0, 0}
+  };
+
+#define bit_LM (1 << 29)
+
+unsigned char grub_cpuid_has_longmode = 0;
+
+static grub_err_t
+grub_cmd_cpuid (grub_extcmd_t cmd __attribute__ ((unused)),
+		int argc __attribute__ ((unused)),
+		char **args __attribute__ ((unused)))
+{
+  return grub_cpuid_has_longmode ? GRUB_ERR_NONE
+    : grub_error (GRUB_ERR_TEST_FAILURE, "false");
+}
+
+static grub_extcmd_t cmd;
+
+GRUB_MOD_INIT(cpuid)
+{
+#ifdef __x86_64__
+  /* grub-emu */
+  grub_cpuid_has_longmode = 1;
+#else
+  unsigned int eax, ebx, ecx, edx;
+  unsigned int max_level;
+  unsigned int ext_level;
+
+  /* See if we can use cpuid.  */
+  asm volatile ("pushfl; pushfl; popl %0; movl %0,%1; xorl %2,%0;"
+		"pushl %0; popfl; pushfl; popl %0; popfl"
+		: "=&r" (eax), "=&r" (ebx)
+		: "i" (0x00200000));
+  if (((eax ^ ebx) & 0x00200000) == 0)
+    goto done;
+
+  /* Check the highest input value for eax.  */
+  cpuid (0, eax, ebx, ecx, edx);
+  /* We only look at the first four characters.  */
+  max_level = eax;
+  if (max_level == 0)
+    goto done;
+
+  cpuid (0x80000000, eax, ebx, ecx, edx);
+  ext_level = eax;
+  if (ext_level < 0x80000000)
+    goto done;
+
+  cpuid (0x80000001, eax, ebx, ecx, edx);
+  grub_cpuid_has_longmode = !!(edx & bit_LM);
+done:
+#endif
+
+  cmd = grub_register_extcmd ("cpuid", grub_cmd_cpuid, GRUB_COMMAND_FLAG_BOTH,
+			      "[-l]", N_("Check for CPU features."), options);
+}
+
+GRUB_MOD_FINI(cpuid)
+{
+  grub_unregister_extcmd (cmd);
+}

grub-core/commands/i386/pc/acpi.c

@@ -0,0 +1,81 @@
+/* acpi.c - get acpi tables. */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/acpi.h>
+#include <grub/misc.h>
+
+struct grub_acpi_rsdp_v10 *
+grub_machine_acpi_get_rsdpv1 (void)
+{
+  int ebda_len;
+  grub_uint8_t *ebda, *ptr;
+
+  grub_dprintf ("acpi", "Looking for RSDP. Scanning EBDA\n");
+  ebda = (grub_uint8_t *) ((* ((grub_uint16_t *) 0x40e)) << 4);
+  ebda_len = * (grub_uint16_t *) ebda;
+  if (! ebda_len)
+    return 0;
+  for (ptr = ebda; ptr < ebda + 0x400; ptr += 16)
+    if (grub_memcmp (ptr, "RSD PTR ", 8) == 0
+	&& grub_byte_checksum (ptr, sizeof (struct grub_acpi_rsdp_v10)) == 0
+	&& ((struct grub_acpi_rsdp_v10 *) ptr)->revision == 0)
+      return (struct grub_acpi_rsdp_v10 *) ptr;
+
+  grub_dprintf ("acpi", "Looking for RSDP. Scanning BIOS\n");
+  for (ptr = (grub_uint8_t *) 0xe0000; ptr < (grub_uint8_t *) 0x100000;
+       ptr += 16)
+    if (grub_memcmp (ptr, "RSD PTR ", 8) == 0
+	&& grub_byte_checksum (ptr, sizeof (struct grub_acpi_rsdp_v10)) == 0
+	&& ((struct grub_acpi_rsdp_v10 *) ptr)->revision == 0)
+      return (struct grub_acpi_rsdp_v10 *) ptr;
+  return 0;
+}
+
+struct grub_acpi_rsdp_v20 *
+grub_machine_acpi_get_rsdpv2 (void)
+{
+  int ebda_len;
+  grub_uint8_t *ebda, *ptr;
+
+  grub_dprintf ("acpi", "Looking for RSDP. Scanning EBDA\n");
+  ebda = (grub_uint8_t *) ((* ((grub_uint16_t *) 0x40e)) << 4);
+  ebda_len = * (grub_uint16_t *) ebda;
+  if (! ebda_len)
+    return 0;
+  for (ptr = ebda; ptr < ebda + 0x400; ptr += 16)
+    if (grub_memcmp (ptr, "RSD PTR ", 8) == 0
+	&& grub_byte_checksum (ptr, sizeof (struct grub_acpi_rsdp_v10)) == 0
+	&& ((struct grub_acpi_rsdp_v10 *) ptr)->revision != 0
+	&& ((struct grub_acpi_rsdp_v20 *) ptr)->length < 1024
+	&& grub_byte_checksum (ptr, ((struct grub_acpi_rsdp_v20 *) ptr)->length)
+	== 0)
+      return (struct grub_acpi_rsdp_v20 *) ptr;
+
+  grub_dprintf ("acpi", "Looking for RSDP. Scanning BIOS\n");
+  for (ptr = (grub_uint8_t *) 0xe0000; ptr < (grub_uint8_t *) 0x100000;
+       ptr += 16)
+    if (grub_memcmp (ptr, "RSD PTR ", 8) == 0
+	&& grub_byte_checksum (ptr, sizeof (struct grub_acpi_rsdp_v10)) == 0
+	&& ((struct grub_acpi_rsdp_v10 *) ptr)->revision != 0
+	&& ((struct grub_acpi_rsdp_v20 *) ptr)->length < 1024
+	&& grub_byte_checksum (ptr, ((struct grub_acpi_rsdp_v20 *) ptr)->length)
+	== 0)
+      return (struct grub_acpi_rsdp_v20 *) ptr;
+  return 0;
+}

grub-core/commands/i386/pc/drivemap.c

@@ -0,0 +1,421 @@
+/* drivemap.c - command to manage the BIOS drive mappings.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008, 2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/extcmd.h>
+#include <grub/dl.h>
+#include <grub/mm.h>
+#include <grub/misc.h>
+#include <grub/disk.h>
+#include <grub/loader.h>
+#include <grub/env.h>
+#include <grub/machine/memory.h>
+#include <grub/machine/biosnum.h>
+#include <grub/i18n.h>
+
+
+/* Real mode IVT slot (seg:off far pointer) for interrupt 0x13.  */
+static grub_uint32_t *const int13slot = UINT_TO_PTR (4 * 0x13);
+
+/* Remember to update enum opt_idxs accordingly.  */
+static const struct grub_arg_option options[] = {
+  {"list", 'l', 0, N_("Show the current mappings."), 0, 0},
+  {"reset", 'r', 0, N_("Reset all mappings to the default values."), 0, 0},
+  {"swap", 's', 0, N_("Perform both direct and reverse mappings."), 0, 0},
+  {0, 0, 0, 0, 0, 0}
+};
+
+/* Remember to update options[] accordingly.  */
+enum opt_idxs
+{
+  OPTIDX_LIST = 0,
+  OPTIDX_RESET,
+  OPTIDX_SWAP,
+};
+
+/* Realmode far ptr (2 * 16b) to the previous INT13h handler.  */
+extern grub_uint32_t grub_drivemap_oldhandler;
+
+/* The type "void" is used for imported assembly labels, takes no storage and
+   serves just to take the address with &label.  */
+
+/* The assembly function to replace the old INT13h handler. It does not follow
+   any C callspecs and returns with IRET.  */
+extern const void grub_drivemap_handler;
+
+/* Start of the drive mappings area (space reserved at runtime).  */
+extern const void grub_drivemap_mapstart;
+
+typedef struct drivemap_node
+{
+  struct drivemap_node *next;
+  grub_uint8_t newdrive;
+  grub_uint8_t redirto;
+} drivemap_node_t;
+
+typedef struct __attribute__ ((packed)) int13map_node
+{
+  grub_uint8_t disknum;
+  grub_uint8_t mapto;
+} int13map_node_t;
+
+#define INT13H_OFFSET(x) \
+	(((grub_uint8_t *)(x)) - ((grub_uint8_t *)&grub_drivemap_handler))
+
+static drivemap_node_t *map_head;
+static void *drivemap_hook;
+static int drivemap_mmap;
+
+/* Puts the specified mapping into the table, replacing an existing mapping
+   for newdrive or adding a new one if required.  */
+static grub_err_t
+drivemap_set (grub_uint8_t newdrive, grub_uint8_t redirto)
+{
+  drivemap_node_t *mapping = 0;
+  drivemap_node_t *search = map_head;
+  while (search)
+    {
+      if (search->newdrive == newdrive)
+	{
+	  mapping = search;
+	  break;
+	}
+      search = search->next;
+    }
+
+  /* Check for pre-existing mappings to modify before creating a new one.  */
+  if (mapping)
+    mapping->redirto = redirto;
+  else
+    {
+      mapping = grub_malloc (sizeof (drivemap_node_t));
+      if (! mapping)
+	return grub_error (GRUB_ERR_OUT_OF_MEMORY,
+			   "cannot allocate map entry, not enough memory");
+      mapping->newdrive = newdrive;
+      mapping->redirto = redirto;
+      mapping->next = map_head;
+      map_head = mapping;
+    }
+  return GRUB_ERR_NONE;
+}
+
+/* Removes the mapping for newdrive from the table.  If there is no mapping,
+   then this function behaves like a no-op on the map.  */
+static void
+drivemap_remove (grub_uint8_t newdrive)
+{
+  drivemap_node_t *mapping = 0;
+  drivemap_node_t *search = map_head;
+  drivemap_node_t *previous = 0;
+
+  while (search)
+    {
+      if (search->newdrive == newdrive)
+	{
+	  mapping = search;
+	  break;
+	}
+      previous = search;
+      search = search->next;
+    }
+
+  if (mapping)
+    {
+      if (previous)
+	previous->next = mapping->next;
+      else
+	map_head = mapping->next;
+      grub_free (mapping);
+    }
+}
+
+/* Given a GRUB-like device name and a convenient location, stores the
+   related BIOS disk number.  Accepts devices like \((f|h)dN\), with
+   0 <= N < 128.  */
+static grub_err_t
+tryparse_diskstring (const char *str, grub_uint8_t *output)
+{
+  /* Skip opening paren in order to allow both (hd0) and hd0.  */
+  if (*str == '(')
+    str++;
+  if ((str[0] == 'f' || str[0] == 'h') && str[1] == 'd')
+    {
+      grub_uint8_t bios_num = (str[0] == 'h') ? 0x80 : 0x00;
+      unsigned long drivenum = grub_strtoul (str + 2, 0, 0);
+      if (grub_errno == GRUB_ERR_NONE && drivenum < 128)
+	{
+	  bios_num |= drivenum;
+	  if (output)
+	    *output = bios_num;
+	  return GRUB_ERR_NONE;
+	}
+    }
+  return grub_error (GRUB_ERR_BAD_ARGUMENT, "device format \"%s\" "
+		     "invalid: must be (f|h)dN, with 0 <= N < 128", str);
+}
+
+static grub_err_t
+list_mappings (void)
+{
+  /* Show: list mappings.  */
+  if (! map_head)
+    {
+      grub_printf ("No drives have been remapped\n");
+      return GRUB_ERR_NONE;
+    }
+
+  grub_printf ("OS disk #num ------> GRUB/BIOS device\n");
+  drivemap_node_t *curnode = map_head;
+  while (curnode)
+    {
+      grub_printf ("%cD #%-3u (0x%02x)       %cd%d\n",
+		   (curnode->newdrive & 0x80) ? 'H' : 'F',
+		   curnode->newdrive & 0x7F, curnode->newdrive,
+		   (curnode->redirto & 0x80) ? 'h' : 'f',
+		   curnode->redirto & 0x7F
+		   );
+      curnode = curnode->next;
+    }
+  return GRUB_ERR_NONE;
+}
+
+static grub_err_t
+grub_cmd_drivemap (struct grub_extcmd *cmd, int argc, char **args)
+{
+  if (cmd->state[OPTIDX_LIST].set)
+    {
+      return list_mappings ();
+    }
+  else if (cmd->state[OPTIDX_RESET].set)
+    {
+      /* Reset: just delete all mappings, freeing their memory.  */
+      drivemap_node_t *curnode = map_head;
+      drivemap_node_t *prevnode = 0;
+      while (curnode)
+	{
+	  prevnode = curnode;
+	  curnode = curnode->next;
+	  grub_free (prevnode);
+	}
+      map_head = 0;
+      return GRUB_ERR_NONE;
+    }
+  else if (!cmd->state[OPTIDX_SWAP].set && argc == 0)
+    {
+      /* No arguments */
+      return list_mappings ();
+    }
+
+  /* Neither flag: put mapping.  */
+  grub_uint8_t mapfrom = 0;
+  grub_uint8_t mapto = 0xFF;
+  grub_err_t err;
+
+  if (argc != 2)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "two arguments required");
+
+  err = tryparse_diskstring (args[0], &mapfrom);
+  if (err != GRUB_ERR_NONE)
+    return err;
+
+  err = tryparse_diskstring (args[1], &mapto);
+  if (err != GRUB_ERR_NONE)
+    return err;
+
+  if (mapto == mapfrom)
+    {
+      /* Reset to default.  */
+      grub_dprintf ("drivemap", "Removing mapping for %s (%02x)\n",
+		    args[0], mapfrom);
+      drivemap_remove (mapfrom);
+      return GRUB_ERR_NONE;
+    }
+  /* Set the mapping for the disk (overwrites any existing mapping).  */
+  grub_dprintf ("drivemap", "%s %s (%02x) = %s (%02x)\n",
+		cmd->state[OPTIDX_SWAP].set ? "Swapping" : "Mapping",
+		args[1], mapto, args[0], mapfrom);
+  err = drivemap_set (mapto, mapfrom);
+  /* If -s, perform the reverse mapping too (only if the first was OK).  */
+  if (cmd->state[OPTIDX_SWAP].set && err == GRUB_ERR_NONE)
+    err = drivemap_set (mapfrom, mapto);
+  return err;
+}
+
+/* Int13h handler installer - reserves conventional memory for the handler,
+   copies it over and sets the IVT entry for int13h.
+   This code rests on the assumption that GRUB does not activate any kind
+   of memory mapping apart from identity paging, since it accesses
+   realmode structures by their absolute addresses, like the IVT at 0;
+   and transforms a pmode pointer into a rmode seg:off far ptr.  */
+static grub_err_t
+install_int13_handler (int noret __attribute__ ((unused)))
+{
+  /* Size of the full int13 handler "bundle", including code and map.  */
+  grub_uint32_t total_size;
+  /* Base address of the space reserved for the handler bundle.  */
+  grub_uint8_t *handler_base = 0;
+  /* Address of the map within the deployed bundle.  */
+  int13map_node_t *handler_map;
+
+  int i;
+  int entries = 0;
+  drivemap_node_t *curentry = map_head;
+
+  /* Count entries to prepare a contiguous map block.  */
+  while (curentry)
+    {
+      entries++;
+      curentry = curentry->next;
+    }
+  if (entries == 0)
+    {
+      /* No need to install the int13h handler.  */
+      grub_dprintf ("drivemap", "No drives marked as remapped, not installing "
+		    "our int13h handler.\n");
+      return GRUB_ERR_NONE;
+    }
+
+  grub_dprintf ("drivemap", "Installing our int13h handler\n");
+
+  /* Save the pointer to the old handler.  */
+  grub_drivemap_oldhandler = *int13slot;
+  grub_dprintf ("drivemap", "Original int13 handler: %04x:%04x\n",
+		(grub_drivemap_oldhandler >> 16) & 0x0ffff,
+		grub_drivemap_oldhandler & 0x0ffff);
+
+  /* Find a rmode-segment-aligned zone in conventional memory big
+     enough to hold the handler and its data.  */
+  total_size = INT13H_OFFSET (&grub_drivemap_mapstart)
+    + (entries + 1) * sizeof (int13map_node_t);
+  grub_dprintf ("drivemap", "Payload is %u bytes long\n", total_size);
+  handler_base = grub_mmap_malign_and_register (16, total_size,
+						&drivemap_mmap,
+						GRUB_MACHINE_MEMORY_RESERVED,
+						GRUB_MMAP_MALLOC_LOW);
+  if (! handler_base)
+    return grub_error (GRUB_ERR_OUT_OF_MEMORY, "couldn't reserve "
+		       "memory for the int13h handler");
+
+  /* Copy int13h handler bundle to reserved area.  */
+  grub_dprintf ("drivemap", "Reserved memory at %p, copying handler\n",
+		handler_base);
+  grub_memcpy (handler_base, &grub_drivemap_handler,
+	       INT13H_OFFSET (&grub_drivemap_mapstart));
+
+  /* Copy the mappings to the reserved area.  */
+  curentry = map_head;
+  handler_map = (int13map_node_t *) (handler_base +
+				     INT13H_OFFSET (&grub_drivemap_mapstart));
+  grub_dprintf ("drivemap", "Target map at %p, copying mappings\n", handler_map);
+  for (i = 0; i < entries; ++i, curentry = curentry->next)
+    {
+      handler_map[i].disknum = curentry->newdrive;
+      handler_map[i].mapto = curentry->redirto;
+      grub_dprintf ("drivemap", "\t#%d: 0x%02x <- 0x%02x\n", i,
+		    handler_map[i].disknum, handler_map[i].mapto);
+    }
+  /* Signal end-of-map.  */
+  handler_map[i].disknum = 0;
+  handler_map[i].mapto = 0;
+  grub_dprintf ("drivemap", "\t#%d: 0x00 <- 0x00 (end)\n", i);
+
+  /* Install our function as the int13h handler in the IVT.  */
+  *int13slot = ((grub_uint32_t) handler_base) << 12;	/* Segment address.  */
+  grub_dprintf ("drivemap", "New int13 handler: %04x:%04x\n",
+		(*int13slot >> 16) & 0x0ffff, *int13slot & 0x0ffff);
+
+  return GRUB_ERR_NONE;
+}
+
+static grub_err_t
+uninstall_int13_handler (void)
+{
+  if (! grub_drivemap_oldhandler)
+    return GRUB_ERR_NONE;
+
+  *int13slot = grub_drivemap_oldhandler;
+  grub_mmap_free_and_unregister (drivemap_mmap);
+  grub_drivemap_oldhandler = 0;
+  grub_dprintf ("drivemap", "Restored int13 handler: %04x:%04x\n",
+		(*int13slot >> 16) & 0x0ffff, *int13slot & 0x0ffff);
+
+  return GRUB_ERR_NONE;
+}
+
+static int
+grub_get_root_biosnumber_drivemap (void)
+{
+  char *biosnum;
+  int ret = -1;
+  grub_device_t dev;
+
+  biosnum = grub_env_get ("biosnum");
+
+  if (biosnum)
+    return grub_strtoul (biosnum, 0, 0);
+
+  dev = grub_device_open (0);
+  if (dev && dev->disk && dev->disk->dev
+      && dev->disk->dev->id == GRUB_DISK_DEVICE_BIOSDISK_ID)
+    {
+      drivemap_node_t *curnode = map_head;
+      ret = (int) dev->disk->id;
+      while (curnode)
+	{
+	  if (curnode->redirto == ret)
+	    {
+	      ret = curnode->newdrive;
+	      break;
+	    }
+	  curnode = curnode->next;
+	}
+
+    }
+
+  if (dev)
+    grub_device_close (dev);
+
+  return ret;
+}
+
+static grub_extcmd_t cmd;
+static int (*grub_get_root_biosnumber_saved) (void);
+
+GRUB_MOD_INIT (drivemap)
+{
+  grub_get_root_biosnumber_saved = grub_get_root_biosnumber;
+  grub_get_root_biosnumber = grub_get_root_biosnumber_drivemap;
+  cmd = grub_register_extcmd ("drivemap", grub_cmd_drivemap,
+			      GRUB_COMMAND_FLAG_BOTH,
+			      N_("-l | -r | [-s] grubdev osdisk."),
+			      N_("Manage the BIOS drive mappings."),
+			      options);
+  drivemap_hook =
+    grub_loader_register_preboot_hook (&install_int13_handler,
+				       &uninstall_int13_handler,
+				       GRUB_LOADER_PREBOOT_HOOK_PRIO_NORMAL);
+}
+
+GRUB_MOD_FINI (drivemap)
+{
+  grub_get_root_biosnumber = grub_get_root_biosnumber_saved;
+  grub_loader_unregister_preboot_hook (drivemap_hook);
+  drivemap_hook = 0;
+  grub_unregister_extcmd (cmd);
+}

grub-core/commands/i386/pc/drivemap_int13h.S

@@ -0,0 +1,110 @@
+/* drivemap_int13h.S - interrupt handler for the BIOS drive remapper */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008, 2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/symbol.h>
+
+#define INT13H_OFFSET(x) ((x) - LOCAL (base))
+
+.code16
+
+/* Copy starts here.  When deployed, this code must be segment-aligned.  */
+
+/* The replacement int13 handler.   Preserve all registers.  */
+FUNCTION(grub_drivemap_handler)
+LOCAL (base):
+	/* Save %dx for future restore. */
+	push	%dx
+	/* Push flags. Used to simulate interrupt with original flags. */
+	pushf
+
+	/* Map the drive number (always in DL).  */
+	push	%ax
+	push	%bx
+	movw	$INT13H_OFFSET(LOCAL (mapstart)), %bx
+
+more_remaining:
+	movw	%cs:(%bx), %ax
+	cmpb	%ah, %al
+	jz	not_found /* DRV=DST => map end - drive not remapped, keep DL.  */
+	inc	%bx
+	inc	%bx
+	cmpb	%dl, %al
+	jnz	more_remaining /* Not found, but more remaining, loop.  */
+	movb	%ah, %dl /* Found - drive remapped, modify DL.  */
+
+not_found:
+	pop	%bx
+	pop	%ax
+
+	/* If the call isn't ah=0x8 or ah=0x15 we must restore %dx.  */
+	cmpb	$0x8, %ah
+	jz	norestore
+	cmpb	$0x15, %ah
+	jz	norestore
+
+	/* Restore flags.  */
+	popf
+	pushf
+
+	lcall *%cs:INT13H_OFFSET (LOCAL (oldhandler))
+
+	push	%bp
+	mov	%sp, %bp
+
+tail:
+	/* Save new flags below %esp so the caller will recieve new flags.  */
+	pushf
+	pop	%dx
+	mov	%dx, 8(%bp)
+
+	pop	%bp
+
+	/* Restore %dx.  */
+	pop	%dx
+	iret
+
+norestore:
+
+	/* Restore flags.  */
+	popf
+	pushf
+
+	lcall *%cs:INT13H_OFFSET (LOCAL (oldhandler))
+
+	push	%bp
+	mov	%sp, %bp
+
+	/* Save %dx. So it won't be restored to original value.  */
+	mov	%dx, 2(%bp)
+
+	jmp tail
+
+/* Far pointer to the old handler.  Stored as a CS:IP in the style of real-mode
+   IVT entries (thus PI:SC in mem).  */
+VARIABLE(grub_drivemap_oldhandler)
+LOCAL (oldhandler):
+	.word 0x0, 0x0
+
+/* This label MUST be at the end of the copied block, since the installer code
+   reserves additional space for mappings at runtime and copies them over it.  */
+	.align 2
+	
+VARIABLE(grub_drivemap_mapstart)
+LOCAL (mapstart):
+	.byte 0

grub-core/commands/i386/pc/halt.c

@@ -0,0 +1,58 @@
+/* halt.c - command to halt the computer.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2005,2007,2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/dl.h>
+#include <grub/misc.h>
+#include <grub/extcmd.h>
+#include <grub/i18n.h>
+
+static const struct grub_arg_option options[] =
+  {
+    {"no-apm", 'n', 0, N_("Do not use APM to halt the computer."), 0, 0},
+    {0, 0, 0, 0, 0, 0}
+  };
+
+static grub_err_t
+grub_cmd_halt (grub_extcmd_t cmd,
+	       int argc __attribute__ ((unused)),
+	       char **args __attribute__ ((unused)))
+
+{
+  struct grub_arg_list *state = cmd->state;
+  int no_apm = 0;
+  if (state[0].set)
+    no_apm = 1;
+  grub_halt (no_apm);
+  return 0;
+}
+
+static grub_extcmd_t cmd;
+
+GRUB_MOD_INIT(halt)
+{
+  cmd = grub_register_extcmd ("halt", grub_cmd_halt, GRUB_COMMAND_FLAG_BOTH,
+			      "[-n]",
+			      N_("Halt the system, if possible using APM."),
+			      options);
+}
+
+GRUB_MOD_FINI(halt)
+{
+  grub_unregister_extcmd (cmd);
+}

grub-core/commands/i386/pc/play.c

@@ -0,0 +1,273 @@
+/* play.c - command to play a tune  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2005,2007,2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+/* Lots of this file is borrowed from GNU/Hurd generic-speaker driver.  */
+
+#include <grub/dl.h>
+#include <grub/file.h>
+#include <grub/disk.h>
+#include <grub/term.h>
+#include <grub/misc.h>
+#include <grub/machine/time.h>
+#include <grub/cpu/io.h>
+#include <grub/command.h>
+#include <grub/i18n.h>
+
+#define BASE_TEMPO (60 * GRUB_TICKS_PER_SECOND)
+
+/* The speaker port.  */
+#define SPEAKER			0x61
+
+/* If 0, follow state of SPEAKER_DATA bit, otherwise enable output
+   from timer 2.  */
+#define SPEAKER_TMR2		0x01
+
+/* If SPEAKER_TMR2 is not set, this provides direct input into the
+   speaker.  Otherwise, this enables or disables the output from the
+   timer.  */
+#define SPEAKER_DATA		0x02
+
+/* The PIT channel value ports.  You can write to and read from them.
+   Do not mess with timer 0 or 1.  */
+#define PIT_COUNTER_0		0x40
+#define PIT_COUNTER_1		0x41
+#define PIT_COUNTER_2		0x42
+
+/* The frequency of the PIT clock.  */
+#define PIT_FREQUENCY		0x1234dd
+
+/* The PIT control port.  You can only write to it.  Do not mess with
+   timer 0 or 1.  */
+#define PIT_CTRL		0x43
+#define PIT_CTRL_SELECT_MASK	0xc0
+#define PIT_CTRL_SELECT_0	0x00
+#define PIT_CTRL_SELECT_1	0x40
+#define PIT_CTRL_SELECT_2	0x80
+
+/* Read and load control.  */
+#define PIT_CTRL_READLOAD_MASK	0x30
+#define PIT_CTRL_COUNTER_LATCH	0x00	/* Hold timer value until read.  */
+#define PIT_CTRL_READLOAD_LSB	0x10	/* Read/load the LSB.  */
+#define PIT_CTRL_READLOAD_MSB	0x20	/* Read/load the MSB.  */
+#define PIT_CTRL_READLOAD_WORD	0x30	/* Read/load the LSB then the MSB.  */
+
+/* Mode control.  */
+#define PIT_CTRL_MODE_MASK	0x0e
+
+/* Interrupt on terminal count.  Setting the mode sets output to low.
+   When counter is set and terminated, output is set to high.  */
+#define PIT_CTRL_INTR_ON_TERM	0x00
+
+/* Programmable one-shot.  When loading counter, output is set to
+   high.  When counter terminated, output is set to low.  Can be
+   triggered again from that point on by setting the gate pin to
+   high.  */
+#define PIT_CTRL_PROGR_ONE_SHOT	0x02
+
+/* Rate generator.  Output is low for one period of the counter, and
+   high for the other.  */
+#define PIT_CTRL_RATE_GEN	0x04
+
+/* Square wave generator.  Output is low for one half of the period,
+   and high for the other half.  */
+#define PIT_CTRL_SQUAREWAVE_GEN	0x06
+
+/* Software triggered strobe.  Setting the mode sets output to high.
+   When counter is set and terminated, output is set to low.  */
+#define PIT_CTRL_SOFTSTROBE	0x08
+
+/* Hardware triggered strobe.  Like software triggered strobe, but
+   only starts the counter when the gate pin is set to high.  */
+#define PIT_CTRL_HARDSTROBE	0x0a
+
+/* Count mode.  */
+#define PIT_CTRL_COUNT_MASK	0x01
+#define PIT_CTRL_COUNT_BINARY	0x00	/* 16-bit binary counter.  */
+#define PIT_CTRL_COUNT_BCD	0x01	/* 4-decade BCD counter.  */
+
+#define T_REST			((grub_uint16_t) 0)
+#define T_FINE			((grub_uint16_t) -1)
+
+struct note
+{
+  grub_uint16_t pitch;
+  grub_uint16_t duration;
+};
+
+static void
+beep_off (void)
+{
+  unsigned char status;
+
+  status = grub_inb (SPEAKER);
+  grub_outb (status & ~(SPEAKER_TMR2 | SPEAKER_DATA), SPEAKER);
+}
+
+static void
+beep_on (grub_uint16_t pitch)
+{
+  unsigned char status;
+  unsigned int counter;
+
+  if (pitch < 20)
+    pitch = 20;
+  else if (pitch > 20000)
+    pitch = 20000;
+
+  counter = PIT_FREQUENCY / pitch;
+
+  /* Program timer 2.  */
+  grub_outb (PIT_CTRL_SELECT_2 | PIT_CTRL_READLOAD_WORD
+	| PIT_CTRL_SQUAREWAVE_GEN | PIT_CTRL_COUNT_BINARY, PIT_CTRL);
+  grub_outb (counter & 0xff, PIT_COUNTER_2);		/* LSB */
+  grub_outb ((counter >> 8) & 0xff, PIT_COUNTER_2);	/* MSB */
+
+  /* Start speaker.  */
+  status = grub_inb (SPEAKER);
+  grub_outb (status | SPEAKER_TMR2 | SPEAKER_DATA, SPEAKER);
+}
+
+/* Returns whether playing should continue.  */
+static int
+play (unsigned tempo, struct note *note)
+{
+  unsigned int to;
+
+  if (note->pitch == T_FINE || grub_checkkey () >= 0)
+    return 1;
+
+  grub_dprintf ("play", "pitch = %d, duration = %d\n", note->pitch,
+                note->duration);
+
+  switch (note->pitch)
+    {
+      case T_REST:
+        beep_off ();
+        break;
+
+      default:
+        beep_on (note->pitch);
+        break;
+    }
+
+  to = grub_get_rtc () + BASE_TEMPO * note->duration / tempo;
+  while (((unsigned int) grub_get_rtc () <= to) && (grub_checkkey () < 0))
+    ;
+
+  return 0;
+}
+
+static grub_err_t
+grub_cmd_play (grub_command_t cmd __attribute__ ((unused)),
+	       int argc, char **args)
+{
+
+  if (argc < 1)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name or tempo and notes required");
+
+  if (argc == 1)
+    {
+      struct note buf;
+      grub_uint32_t tempo;
+      grub_file_t file;
+
+      file = grub_file_open (args[0]);
+
+      if (! file)
+        return grub_error (GRUB_ERR_FILE_NOT_FOUND, "file not found");
+
+      if (grub_file_read (file, &tempo, sizeof (tempo)) != sizeof (tempo))
+        {
+          grub_file_close (file);
+          return grub_error (GRUB_ERR_FILE_READ_ERROR,
+                             "file doesn't even contains a full tempo record");
+        }
+
+      tempo = grub_le_to_cpu32 (tempo);
+      grub_dprintf ("play","tempo = %d\n", tempo);
+
+      while (grub_file_read (file, &buf,
+                             sizeof (struct note)) == sizeof (struct note))
+        {
+          buf.pitch = grub_le_to_cpu16 (buf.pitch);
+          buf.duration = grub_le_to_cpu16 (buf.duration);
+
+          if (play (tempo, &buf))
+            break;
+        }
+
+      grub_file_close (file);
+    }
+  else
+    {
+      char *end;
+      unsigned tempo;
+      struct note note;
+      int i;
+
+      tempo = grub_strtoul (args[0], &end, 0);
+
+      if (*end)
+        /* Was not a number either, assume it was supposed to be a file name.  */
+        return grub_error (GRUB_ERR_FILE_NOT_FOUND, "file not found");
+
+      grub_dprintf ("play","tempo = %d\n", tempo);
+
+      for (i = 1; i + 1 < argc; i += 2)
+        {
+          note.pitch = grub_strtoul (args[i], &end, 0);
+          if (*end)
+            {
+              grub_error (GRUB_ERR_BAD_NUMBER, "bogus pitch number");
+              break;
+            }
+
+          note.duration = grub_strtoul (args[i + 1], &end, 0);
+          if (*end)
+            {
+              grub_error (GRUB_ERR_BAD_NUMBER, "bogus duration number");
+              break;
+            }
+
+          if (play (tempo, &note))
+            break;
+        }
+    }
+
+  beep_off ();
+
+  while (grub_checkkey () > 0)
+    grub_getkey ();
+
+  return 0;
+}
+
+static grub_command_t cmd;
+
+GRUB_MOD_INIT(play)
+{
+  cmd = grub_register_command ("play", grub_cmd_play,
+			       N_("FILE | TEMPO [PITCH1 DURATION1] [PITCH2 DURATION2] ... "),
+			       N_("Play a tune."));
+}
+
+GRUB_MOD_FINI(play)
+{
+  grub_unregister_command (cmd);
+}

grub-core/commands/i386/pc/pxecmd.c

@@ -0,0 +1,52 @@
+/* pxe.c - command to control the pxe driver  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008,2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/dl.h>
+#include <grub/err.h>
+#include <grub/misc.h>
+#include <grub/machine/pxe.h>
+#include <grub/command.h>
+#include <grub/i18n.h>
+
+static grub_err_t
+grub_cmd_pxe_unload (grub_command_t cmd __attribute__ ((unused)),
+		     int argc __attribute__ ((unused)),
+		     char **args __attribute__ ((unused)))
+{
+  if (! grub_pxe_pxenv)
+    return grub_error (GRUB_ERR_FILE_NOT_FOUND, "no pxe environment");
+
+  grub_pxe_unload ();
+
+  return 0;
+}
+
+static grub_command_t cmd;
+
+GRUB_MOD_INIT(pxecmd)
+{
+  cmd = grub_register_command ("pxe_unload", grub_cmd_pxe_unload,
+			       0,
+			       N_("Unload PXE environment."));
+}
+
+GRUB_MOD_FINI(pxecmd)
+{
+  grub_unregister_command (cmd);
+}

grub-core/commands/i386/pc/vbeinfo.c

@@ -0,0 +1,185 @@
+/* vbeinfo.c - command to list compatible VBE video modes.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2005,2007,2008,2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/dl.h>
+#include <grub/env.h>
+#include <grub/misc.h>
+#include <grub/machine/init.h>
+#include <grub/machine/vbe.h>
+#include <grub/mm.h>
+#include <grub/command.h>
+#include <grub/i18n.h>
+
+static void *
+real2pm (grub_vbe_farptr_t ptr)
+{
+  return (void *) ((((unsigned long) ptr & 0xFFFF0000) >> 12UL)
+		   + ((unsigned long) ptr & 0x0000FFFF));
+}
+
+static grub_err_t
+grub_cmd_vbeinfo (grub_command_t cmd __attribute__ ((unused)),
+		  int argc __attribute__ ((unused)),
+		  char **args __attribute__ ((unused)))
+{
+  struct grub_vbe_info_block controller_info;
+  struct grub_vbe_mode_info_block mode_info_tmp;
+  grub_uint32_t use_mode = GRUB_VBE_DEFAULT_VIDEO_MODE;
+  grub_uint16_t *video_mode_list;
+  grub_uint16_t *p;
+  grub_uint16_t *saved_video_mode_list;
+  grub_size_t video_mode_list_size;
+  grub_err_t err;
+  char *modevar;
+
+  err = grub_vbe_probe (&controller_info);
+  if (err != GRUB_ERR_NONE)
+    return err;
+
+  grub_printf ("VBE info:   version: %d.%d  OEM software rev: %d.%d\n",
+	       controller_info.version >> 8,
+               controller_info.version & 0xFF,
+               controller_info.oem_software_rev >> 8,
+               controller_info.oem_software_rev & 0xFF);
+
+  /* The total_memory field is in 64 KiB units.  */
+  grub_printf ("            total memory: %d KiB\n",
+               (controller_info.total_memory << 16) / 1024);
+
+  /* Because the information on video modes is stored in a temporary place,
+     it is better to copy it to somewhere safe.  */
+  p = video_mode_list = real2pm (controller_info.video_mode_ptr);
+  while (*p++ != 0xFFFF)
+    ;
+
+  video_mode_list_size = (grub_addr_t) p - (grub_addr_t) video_mode_list;
+  saved_video_mode_list = grub_malloc (video_mode_list_size);
+  if (! saved_video_mode_list)
+    return grub_errno;
+
+  grub_memcpy (saved_video_mode_list, video_mode_list, video_mode_list_size);
+
+  grub_printf ("List of compatible video modes:\n");
+  grub_printf ("Legend: P=Packed pixel, D=Direct color, "
+	       "mask/pos=R/G/B/reserved\n");
+
+  /* Walk through all video modes listed.  */
+  for (p = saved_video_mode_list; *p != 0xFFFF; p++)
+    {
+      const char *memory_model = 0;
+      grub_uint32_t mode = (grub_uint32_t) *p;
+
+      err = grub_vbe_get_video_mode_info (mode, &mode_info_tmp);
+      if (err != GRUB_ERR_NONE)
+	{
+	  grub_errno = GRUB_ERR_NONE;
+	  continue;
+	}
+
+      if ((mode_info_tmp.mode_attributes & GRUB_VBE_MODEATTR_SUPPORTED) == 0)
+	/* If not available, skip it.  */
+	continue;
+
+      if ((mode_info_tmp.mode_attributes & GRUB_VBE_MODEATTR_RESERVED_1) == 0)
+	/* Not enough information.  */
+	continue;
+
+      if ((mode_info_tmp.mode_attributes & GRUB_VBE_MODEATTR_COLOR) == 0)
+	/* Monochrome is unusable.  */
+	continue;
+
+      if ((mode_info_tmp.mode_attributes & GRUB_VBE_MODEATTR_LFB_AVAIL) == 0)
+	/* We support only linear frame buffer modes.  */
+	continue;
+
+      if ((mode_info_tmp.mode_attributes & GRUB_VBE_MODEATTR_GRAPHICS) == 0)
+	/* We allow only graphical modes.  */
+	continue;
+
+      switch (mode_info_tmp.memory_model)
+	{
+	case GRUB_VBE_MEMORY_MODEL_PACKED_PIXEL:
+	  memory_model = "Packed";
+	  break;
+	case GRUB_VBE_MEMORY_MODEL_DIRECT_COLOR:
+	  memory_model = "Direct";
+	  break;
+
+	default:
+	  break;
+	}
+
+      if (! memory_model)
+	continue;
+
+      grub_printf ("0x%03x:  %4d x %4d x %2d  %s",
+                   mode,
+                   mode_info_tmp.x_resolution,
+                   mode_info_tmp.y_resolution,
+                   mode_info_tmp.bits_per_pixel,
+                   memory_model);
+
+      /* Show mask and position details for direct color modes.  */
+      if (mode_info_tmp.memory_model == GRUB_VBE_MEMORY_MODEL_DIRECT_COLOR)
+        grub_printf (", mask: %d/%d/%d/%d  pos: %d/%d/%d/%d",
+                     mode_info_tmp.red_mask_size,
+                     mode_info_tmp.green_mask_size,
+                     mode_info_tmp.blue_mask_size,
+                     mode_info_tmp.rsvd_mask_size,
+                     mode_info_tmp.red_field_position,
+                     mode_info_tmp.green_field_position,
+                     mode_info_tmp.blue_field_position,
+                     mode_info_tmp.rsvd_field_position);
+      grub_printf ("\n");
+    }
+
+  grub_free (saved_video_mode_list);
+
+  /* Check existence of vbe_mode environment variable.  */
+  modevar = grub_env_get ("vbe_mode");
+
+  if (modevar != 0)
+    {
+      unsigned long value;
+
+      value = grub_strtoul (modevar, 0, 0);
+      if (grub_errno == GRUB_ERR_NONE)
+	use_mode = value;
+      else
+	grub_errno = GRUB_ERR_NONE;
+    }
+
+  grub_printf ("Configured VBE mode (vbe_mode) = 0x%03x\n", use_mode);
+
+  return 0;
+}
+
+static grub_command_t cmd;
+
+GRUB_MOD_INIT(vbeinfo)
+{
+  cmd =
+    grub_register_command ("vbeinfo", grub_cmd_vbeinfo, 0,
+			   N_("List compatible VESA BIOS extension video modes."));
+}
+
+GRUB_MOD_FINI(vbeinfo)
+{
+  grub_unregister_command (cmd);
+}

grub-core/commands/i386/pc/vbetest.c

@@ -0,0 +1,179 @@
+/* vbetest.c - command to test VESA BIOS Extension 2.0+ support.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2005,2007  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/normal.h>
+#include <grub/dl.h>
+#include <grub/env.h>
+#include <grub/misc.h>
+#include <grub/term.h>
+#include <grub/machine/init.h>
+#include <grub/machine/vbe.h>
+#include <grub/video.h>
+#include <grub/err.h>
+#include <grub/i18n.h>
+
+static grub_err_t
+grub_cmd_vbetest (grub_command_t cmd __attribute__ ((unused)),
+		  int argc __attribute__ ((unused)),
+		  char **args __attribute__ ((unused)))
+{
+  grub_err_t err;
+  char *modevar;
+  struct grub_vbe_mode_info_block mode_info;
+  struct grub_vbe_info_block controller_info;
+  grub_uint32_t use_mode = GRUB_VBE_DEFAULT_VIDEO_MODE;
+  grub_uint32_t old_mode;
+  grub_uint8_t *framebuffer = 0;
+  grub_uint32_t bytes_per_scan_line = 0;
+  unsigned char *ptr;
+  int i;
+
+  grub_printf ("Probing for VESA BIOS Extension ... ");
+
+  /* Check if VESA BIOS exists.  */
+  err = grub_vbe_probe (&controller_info);
+  if (err != GRUB_ERR_NONE)
+    return err;
+
+  grub_printf ("found!\n");
+
+  /* Dump out controller information.  */
+  grub_printf ("VBE signature = %c%c%c%c\n",
+	       controller_info.signature[0],
+	       controller_info.signature[1],
+	       controller_info.signature[2],
+	       controller_info.signature[3]);
+
+  grub_printf ("VBE version = %d.%d\n",
+	       controller_info.version >> 8,
+	       controller_info.version & 0xFF);
+  grub_printf ("OEM string ptr = %08x\n",
+	       controller_info.oem_string_ptr);
+  grub_printf ("Total memory = %d\n",
+	       controller_info.total_memory);
+
+  err = grub_vbe_get_video_mode (&old_mode);
+  grub_printf ("Get video mode err = %04x\n", err);
+
+  if (err == GRUB_ERR_NONE)
+    grub_printf ("Old video mode = %04x\n", old_mode);
+  else
+    grub_errno = GRUB_ERR_NONE;
+
+  /* Check existence of vbe_mode environment variable.  */
+  modevar = grub_env_get ("vbe_mode");
+  if (modevar != 0)
+    {
+      unsigned long value;
+
+      value = grub_strtoul (modevar, 0, 0);
+      if (grub_errno == GRUB_ERR_NONE)
+	use_mode = value;
+      else
+	grub_errno = GRUB_ERR_NONE;
+    }
+
+  err = grub_vbe_get_video_mode_info (use_mode, &mode_info);
+  if (err != GRUB_ERR_NONE)
+    return err;
+
+  /* Dump out details about the mode being tested.  */
+  grub_printf ("mode: 0x%03x\n",
+               use_mode);
+  grub_printf ("width : %d\n",
+               mode_info.x_resolution);
+  grub_printf ("height: %d\n",
+               mode_info.y_resolution);
+  grub_printf ("memory model: %02x\n",
+               mode_info.memory_model);
+  grub_printf ("bytes/scanline: %d\n",
+               mode_info.bytes_per_scan_line);
+  grub_printf ("bytes/scanline (lin): %d\n",
+               mode_info.lin_bytes_per_scan_line);
+  grub_printf ("base address: %08x\n",
+               mode_info.phys_base_addr);
+  grub_printf ("red mask/pos: %d/%d\n",
+               mode_info.red_mask_size,
+               mode_info.red_field_position);
+  grub_printf ("green mask/pos: %d/%d\n",
+               mode_info.green_mask_size,
+               mode_info.green_field_position);
+  grub_printf ("blue mask/pos: %d/%d\n",
+               mode_info.blue_mask_size,
+               mode_info.blue_field_position);
+
+  grub_printf ("Press any key to continue.\n");
+
+  grub_getkey ();
+
+  /* Setup GFX mode.  */
+  err = grub_vbe_set_video_mode (use_mode, &mode_info);
+  if (err != GRUB_ERR_NONE)
+    return err;
+
+  /* Determine framebuffer address and how many bytes are in scan line.  */
+  framebuffer = (grub_uint8_t *) mode_info.phys_base_addr;
+  ptr = framebuffer;
+
+  if (controller_info.version >= 0x300)
+    {
+      bytes_per_scan_line = mode_info.lin_bytes_per_scan_line;
+    }
+  else
+    {
+      bytes_per_scan_line = mode_info.bytes_per_scan_line;
+    }
+
+  /* Draw some random data to screen.  */
+  for (i = 0; i < 256 * 256; i++)
+    {
+      ptr[i] = i & 0x0F;
+    }
+
+  /* Draw white line to screen.  */
+  for (i = 0; i < 100; i++)
+    {
+      ptr[mode_info.bytes_per_scan_line * 50 + i] = 0x0F;
+    }
+
+  /* Draw another white line to screen.  */
+  grub_memset (ptr + bytes_per_scan_line * 51, 0x0f, bytes_per_scan_line);
+
+  grub_getkey ();
+
+  grub_video_restore ();
+
+  /* Restore old video mode.  */
+  grub_vbe_set_video_mode (old_mode, 0);
+
+  return grub_errno;
+}
+
+static grub_command_t cmd;
+
+GRUB_MOD_INIT(vbetest)
+{
+  cmd = grub_register_command ("vbetest", grub_cmd_vbetest,
+			       0, N_("Test VESA BIOS Extension 2.0+ support."));
+}
+
+GRUB_MOD_FINI(vbetest)
+{
+  grub_unregister_command (cmd);
+}

grub-core/commands/ieee1275/suspend.c

@@ -0,0 +1,49 @@
+/* suspend.c - command to suspend GRUB and return to Open Firmware  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2005,2007  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/dl.h>
+#include <grub/misc.h>
+#include <grub/term.h>
+#include <grub/ieee1275/ieee1275.h>
+#include <grub/command.h>
+#include <grub/i18n.h>
+
+static grub_err_t
+grub_cmd_suspend (grub_command_t cmd __attribute__ ((unused)),
+		  int argc __attribute__ ((unused)),
+		  char **args __attribute__ ((unused)))
+{
+  grub_printf ("Run 'go' to resume GRUB.\n");
+  grub_ieee1275_enter ();
+  grub_cls ();
+  return 0;
+}
+
+static grub_command_t cmd;
+
+GRUB_MOD_INIT(ieee1275_suspend)
+{
+  cmd = grub_register_command ("suspend", grub_cmd_suspend,
+			       0, N_("Return to Open Firmware prompt."));
+}
+
+GRUB_MOD_FINI(ieee1275_suspend)
+{
+  grub_unregister_command (cmd);
+}

grub-core/commands/iorw.c

@@ -0,0 +1,150 @@
+/* memrw.c - command to read / write physical memory  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/dl.h>
+#include <grub/misc.h>
+#include <grub/extcmd.h>
+#include <grub/env.h>
+#include <grub/cpu/io.h>
+#include <grub/i18n.h>
+
+static grub_extcmd_t cmd_read_byte, cmd_read_word, cmd_read_dword;
+static grub_command_t cmd_write_byte, cmd_write_word, cmd_write_dword;
+
+static const struct grub_arg_option options[] =
+  {
+    {0, 'v', 0, N_("Save read value into variable VARNAME."),
+     N_("VARNAME"), ARG_TYPE_STRING},
+    {0, 0, 0, 0, 0, 0}
+  };
+
+
+static grub_err_t
+grub_cmd_read (grub_extcmd_t cmd, int argc, char **argv)
+{
+  grub_target_addr_t addr;
+  grub_uint32_t value = 0;
+  char buf[sizeof ("XXXXXXXX")];
+
+  if (argc != 1)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "Invalid number of arguments");
+
+  addr = grub_strtoul (argv[0], 0, 0);
+  switch (cmd->cmd->name[sizeof ("in") - 1])
+    {
+    case 'l':
+      value = grub_inl (addr);
+      break;
+
+    case 'w':
+      value = grub_inw (addr);
+      break;
+
+    case 'b':
+      value = grub_inb (addr);
+      break;
+    }
+
+  if (cmd->state[0].set)
+    {
+      grub_snprintf (buf, sizeof (buf), "%x", value);
+      grub_env_set (cmd->state[0].arg, buf);
+    }
+  else
+    grub_printf ("0x%x\n", value);
+
+  return 0;
+}
+
+static grub_err_t
+grub_cmd_write (grub_command_t cmd, int argc, char **argv)
+{
+  grub_target_addr_t addr;
+  grub_uint32_t value;
+  grub_uint32_t mask = 0xffffffff;
+
+  if (argc != 2 && argc != 3)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "Invalid number of arguments");
+
+  addr = grub_strtoul (argv[0], 0, 0);
+  value = grub_strtoul (argv[1], 0, 0);
+  if (argc == 3)
+    mask = grub_strtoul (argv[2], 0, 0);
+  value &= mask;
+  switch (cmd->name[sizeof ("out") - 1])
+    {
+    case 'l':
+      if (mask != 0xffffffff)
+	grub_outl ((grub_inl (addr) & ~mask) | value, addr);
+      else
+	grub_outl (value, addr);
+      break;
+
+    case 'w':
+      if ((mask & 0xffff) != 0xffff)
+	grub_outw ((grub_inw (addr) & ~mask) | value, addr);
+      else
+	grub_outw (value, addr);
+      break;
+
+    case 'b':
+      if ((mask & 0xff) != 0xff)
+	grub_outb ((grub_inb (addr) & ~mask) | value, addr);
+      else
+	grub_outb (value, addr);
+      break;
+    }
+
+  return 0;
+}
+
+GRUB_MOD_INIT(memrw)
+{
+  cmd_read_byte =
+    grub_register_extcmd ("inb", grub_cmd_read, GRUB_COMMAND_FLAG_BOTH,
+			  N_("PORT"), N_("Read byte from PORT."), options);
+  cmd_read_word =
+    grub_register_extcmd ("inw", grub_cmd_read, GRUB_COMMAND_FLAG_BOTH,
+			  N_("PORT"), N_("Read word from PORT."), options);
+  cmd_read_dword =
+    grub_register_extcmd ("inl", grub_cmd_read, GRUB_COMMAND_FLAG_BOTH,
+			  N_("PORT"), N_("Read dword from PORT."), options);
+  cmd_write_byte =
+    grub_register_command ("outb", grub_cmd_write,
+			   N_("PORT VALUE [MASK]"),
+			   N_("Write byte VALUE to PORT."));
+  cmd_write_word =
+    grub_register_command ("outw", grub_cmd_write,
+			   N_("PORT VALUE [MASK]"),
+			   N_("Write word VALUE to PORT."));
+  cmd_write_dword =
+    grub_register_command ("outl", grub_cmd_write,
+			   N_("ADDR VALUE [MASK]"),
+			   N_("Write dword VALUE to PORT."));
+}
+
+GRUB_MOD_FINI(memrw)
+{
+  grub_unregister_extcmd (cmd_read_byte);
+  grub_unregister_extcmd (cmd_read_word);
+  grub_unregister_extcmd (cmd_read_dword);
+  grub_unregister_command (cmd_write_byte);
+  grub_unregister_command (cmd_write_word);
+  grub_unregister_command (cmd_write_dword);
+}

grub-core/commands/keystatus.c

@@ -0,0 +1,93 @@
+/* keystatus.c - Command to check key modifier status.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/dl.h>
+#include <grub/misc.h>
+#include <grub/extcmd.h>
+#include <grub/term.h>
+#include <grub/i18n.h>
+
+static const struct grub_arg_option options[] =
+  {
+    {"shift", 's', 0, N_("Check Shift key."), 0, 0},
+    {"ctrl", 'c', 0, N_("Check Control key."), 0, 0},
+    {"alt", 'a', 0, N_("Check Alt key."), 0, 0},
+    {0, 0, 0, 0, 0, 0}
+  };
+
+#define grub_cur_term_input	grub_term_get_current_input ()
+
+static grub_err_t
+grub_cmd_keystatus (grub_extcmd_t cmd,
+		    int argc __attribute__ ((unused)),
+		    char **args __attribute__ ((unused)))
+{
+  struct grub_arg_list *state = cmd->state;
+  int expect_mods = 0;
+  int mods;
+
+  if (state[0].set)
+    expect_mods |= GRUB_TERM_STATUS_SHIFT;
+  if (state[1].set)
+    expect_mods |= GRUB_TERM_STATUS_CTRL;
+  if (state[2].set)
+    expect_mods |= GRUB_TERM_STATUS_ALT;
+
+  grub_dprintf ("keystatus", "expect_mods: %d\n", expect_mods);
+
+  /* Without arguments, just check whether getkeystatus is supported at
+     all.  */
+  if (expect_mods == 0)
+    {
+      grub_term_input_t term;
+      int nterms = 0;
+
+      FOR_ACTIVE_TERM_INPUTS (term)
+	if (!term->getkeystatus)
+	  return grub_error (GRUB_ERR_TEST_FAILURE, "false");
+	else
+	  nterms++;
+      if (!nterms)
+	return grub_error (GRUB_ERR_TEST_FAILURE, "false");
+      return 0;
+    }
+
+  mods = grub_getkeystatus ();
+  grub_dprintf ("keystatus", "mods: %d\n", mods);
+  if (mods >= 0 && (mods & expect_mods) != 0)
+    return 0;
+  else
+    return grub_error (GRUB_ERR_TEST_FAILURE, "false");
+}
+
+static grub_extcmd_t cmd;
+
+GRUB_MOD_INIT(keystatus)
+{
+  cmd = grub_register_extcmd ("keystatus", grub_cmd_keystatus,
+			      GRUB_COMMAND_FLAG_BOTH,
+			      N_("[--shift] [--ctrl] [--alt]"),
+			      N_("Check key modifier status."),
+			      options);
+}
+
+GRUB_MOD_FINI(keystatus)
+{
+  grub_unregister_extcmd (cmd);
+}

grub-core/commands/loadenv.c

@@ -0,0 +1,400 @@
+/* loadenv.c - command to load/save environment variable.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008,2009,2010  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/dl.h>
+#include <grub/mm.h>
+#include <grub/file.h>
+#include <grub/disk.h>
+#include <grub/misc.h>
+#include <grub/env.h>
+#include <grub/partition.h>
+#include <grub/lib/envblk.h>
+#include <grub/extcmd.h>
+#include <grub/i18n.h>
+
+static const struct grub_arg_option options[] =
+  {
+    {"file", 'f', 0, N_("Specify filename."), 0, ARG_TYPE_PATHNAME},
+    {0, 0, 0, 0, 0, 0}
+  };
+
+static grub_file_t
+open_envblk_file (char *filename)
+{
+  grub_file_t file;
+
+  if (! filename)
+    {
+      char *prefix;
+
+      prefix = grub_env_get ("prefix");
+      if (prefix)
+        {
+          int len;
+
+          len = grub_strlen (prefix);
+          filename = grub_malloc (len + 1 + sizeof (GRUB_ENVBLK_DEFCFG));
+          if (! filename)
+            return 0;
+
+          grub_strcpy (filename, prefix);
+          filename[len] = '/';
+          grub_strcpy (filename + len + 1, GRUB_ENVBLK_DEFCFG);
+          file = grub_file_open (filename);
+          grub_free (filename);
+          return file;
+        }
+      else
+        {
+          grub_error (GRUB_ERR_FILE_NOT_FOUND, "prefix is not found");
+          return 0;
+        }
+    }
+
+  return grub_file_open (filename);
+}
+
+static grub_envblk_t
+read_envblk_file (grub_file_t file)
+{
+  grub_off_t offset = 0;
+  char *buf;
+  grub_size_t size = grub_file_size (file);
+  grub_envblk_t envblk;
+
+  buf = grub_malloc (size);
+  if (! buf)
+    return 0;
+
+  while (size > 0)
+    {
+      grub_ssize_t ret;
+
+      ret = grub_file_read (file, buf + offset, size);
+      if (ret <= 0)
+        {
+          if (grub_errno == GRUB_ERR_NONE)
+            grub_error (GRUB_ERR_FILE_READ_ERROR, "cannot read");
+          grub_free (buf);
+          return 0;
+        }
+
+      size -= ret;
+      offset += ret;
+    }
+
+  envblk = grub_envblk_open (buf, offset);
+  if (! envblk)
+    {
+      grub_free (buf);
+      grub_error (GRUB_ERR_BAD_FILE_TYPE, "invalid environment block");
+      return 0;
+    }
+
+  return envblk;
+}
+
+static grub_err_t
+grub_cmd_load_env (grub_extcmd_t cmd,
+		   int argc __attribute__ ((unused)),
+		   char **args __attribute__ ((unused)))
+{
+  struct grub_arg_list *state = cmd->state;
+  grub_file_t file;
+  grub_envblk_t envblk;
+
+  auto int set_var (const char *name, const char *value);
+  int set_var (const char *name, const char *value)
+  {
+    grub_env_set (name, value);
+    return 0;
+  }
+
+  file = open_envblk_file ((state[0].set) ? state[0].arg : 0);
+  if (! file)
+    return grub_errno;
+
+  envblk = read_envblk_file (file);
+  if (! envblk)
+    goto fail;
+
+  grub_envblk_iterate (envblk, set_var);
+  grub_envblk_close (envblk);
+
+ fail:
+  grub_file_close (file);
+  return grub_errno;
+}
+
+static grub_err_t
+grub_cmd_list_env (grub_extcmd_t cmd,
+		   int argc __attribute__ ((unused)),
+		   char **args __attribute__ ((unused)))
+{
+  struct grub_arg_list *state = cmd->state;
+  grub_file_t file;
+  grub_envblk_t envblk;
+
+  /* Print all variables in current context.  */
+  auto int print_var (const char *name, const char *value);
+  int print_var (const char *name, const char *value)
+    {
+      grub_printf ("%s=%s\n", name, value);
+      return 0;
+    }
+
+  file = open_envblk_file ((state[0].set) ? state[0].arg : 0);
+  if (! file)
+    return grub_errno;
+
+  envblk = read_envblk_file (file);
+  if (! envblk)
+    goto fail;
+
+  grub_envblk_iterate (envblk, print_var);
+  grub_envblk_close (envblk);
+
+ fail:
+  grub_file_close (file);
+  return grub_errno;
+}
+
+/* Used to maintain a variable length of blocklists internally.  */
+struct blocklist
+{
+  grub_disk_addr_t sector;
+  unsigned offset;
+  unsigned length;
+  struct blocklist *next;
+};
+
+static void
+free_blocklists (struct blocklist *p)
+{
+  struct blocklist *q;
+
+  for (; p; p = q)
+    {
+      q = p->next;
+      grub_free (p);
+    }
+}
+
+static grub_err_t
+check_blocklists (grub_envblk_t envblk, struct blocklist *blocklists,
+                  grub_file_t file)
+{
+  grub_size_t total_length;
+  grub_size_t index;
+  grub_disk_t disk;
+  grub_disk_addr_t part_start;
+  struct blocklist *p;
+  char *buf;
+
+  /* Sanity checks.  */
+  total_length = 0;
+  for (p = blocklists; p; p = p->next)
+    {
+      struct blocklist *q;
+      for (q = p->next; q; q = q->next)
+        {
+          /* Check if any pair of blocks overlap.  */
+          if (p->sector == q->sector)
+            {
+              /* This might be actually valid, but it is unbelievable that
+                 any filesystem makes such a silly allocation.  */
+              return grub_error (GRUB_ERR_BAD_FS, "malformed file");
+            }
+        }
+
+      total_length += p->length;
+    }
+
+  if (total_length != grub_file_size (file))
+    {
+      /* Maybe sparse, unallocated sectors. No way in GRUB.  */
+      return grub_error (GRUB_ERR_BAD_FILE_TYPE, "sparse file not allowed");
+    }
+
+  /* One more sanity check. Re-read all sectors by blocklists, and compare
+     those with the data read via a file.  */
+  disk = file->device->disk;
+
+  part_start = grub_partition_get_start (disk->partition);
+
+  buf = grub_envblk_buffer (envblk);
+  for (p = blocklists, index = 0; p; index += p->length, p = p->next)
+    {
+      char blockbuf[GRUB_DISK_SECTOR_SIZE];
+
+      if (grub_disk_read (disk, p->sector - part_start,
+                          p->offset, p->length, blockbuf))
+        return grub_errno;
+
+      if (grub_memcmp (buf + index, blockbuf, p->length) != 0)
+	return grub_error (GRUB_ERR_FILE_READ_ERROR, "invalid blocklist");
+    }
+
+  return GRUB_ERR_NONE;
+}
+
+static int
+write_blocklists (grub_envblk_t envblk, struct blocklist *blocklists,
+                  grub_file_t file)
+{
+  char *buf;
+  grub_disk_t disk;
+  grub_disk_addr_t part_start;
+  struct blocklist *p;
+  grub_size_t index;
+
+  buf = grub_envblk_buffer (envblk);
+  disk = file->device->disk;
+  part_start = grub_partition_get_start (disk->partition);
+
+  index = 0;
+  for (p = blocklists; p; index += p->length, p = p->next)
+    {
+      if (grub_disk_write (disk, p->sector - part_start,
+                           p->offset, p->length, buf + index))
+        return 0;
+    }
+
+  return 1;
+}
+
+static grub_err_t
+grub_cmd_save_env (grub_extcmd_t cmd, int argc, char **args)
+{
+  struct grub_arg_list *state = cmd->state;
+  grub_file_t file;
+  grub_envblk_t envblk;
+  struct blocklist *head = 0;
+  struct blocklist *tail = 0;
+
+  /* Store blocklists in a linked list.  */
+  auto void NESTED_FUNC_ATTR read_hook (grub_disk_addr_t sector,
+                                        unsigned offset,
+                                        unsigned length);
+  void NESTED_FUNC_ATTR read_hook (grub_disk_addr_t sector,
+                                   unsigned offset, unsigned length)
+    {
+      struct blocklist *block;
+
+      if (offset + length > GRUB_DISK_SECTOR_SIZE)
+        /* Seemingly a bug.  */
+        return;
+
+      block = grub_malloc (sizeof (*block));
+      if (! block)
+        return;
+
+      block->sector = sector;
+      block->offset = offset;
+      block->length = length;
+
+      /* Slightly complicated, because the list should be FIFO.  */
+      block->next = 0;
+      if (tail)
+        tail->next = block;
+      tail = block;
+      if (! head)
+        head = block;
+    }
+
+  if (! argc)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "no variable is specified");
+
+  file = open_envblk_file ((state[0].set) ? state[0].arg : 0);
+  if (! file)
+    return grub_errno;
+
+  if (! file->device->disk)
+    {
+      grub_file_close (file);
+      return grub_error (GRUB_ERR_BAD_DEVICE, "disk device required");
+    }
+
+  file->read_hook = read_hook;
+  envblk = read_envblk_file (file);
+  file->read_hook = 0;
+  if (! envblk)
+    goto fail;
+
+  if (check_blocklists (envblk, head, file))
+    goto fail;
+
+  while (argc)
+    {
+      char *value;
+
+      value = grub_env_get (args[0]);
+      if (value)
+        {
+          if (! grub_envblk_set (envblk, args[0], value))
+            {
+              grub_error (GRUB_ERR_BAD_ARGUMENT, "environment block too small");
+              goto fail;
+            }
+        }
+
+      argc--;
+      args++;
+    }
+
+  write_blocklists (envblk, head, file);
+
+ fail:
+  if (envblk)
+    grub_envblk_close (envblk);
+  free_blocklists (head);
+  grub_file_close (file);
+  return grub_errno;
+}
+
+static grub_extcmd_t cmd_load, cmd_list, cmd_save;
+
+GRUB_MOD_INIT(loadenv)
+{
+  cmd_load =
+    grub_register_extcmd ("load_env", grub_cmd_load_env,
+			  GRUB_COMMAND_FLAG_BOTH,
+			  N_("[-f FILE]"),
+			  N_("Load variables from environment block file."),
+			  options);
+  cmd_list =
+    grub_register_extcmd ("list_env", grub_cmd_list_env,
+			  GRUB_COMMAND_FLAG_BOTH,
+			  N_("[-f FILE]"),
+			  N_("List variables from environment block file."),
+			  options);
+  cmd_save =
+    grub_register_extcmd ("save_env", grub_cmd_save_env,
+			  GRUB_COMMAND_FLAG_BOTH,
+			  N_("[-f FILE] variable_name [...]"),
+			  N_("Save variables to environment block file."),
+			  options);
+}
+
+GRUB_MOD_FINI(loadenv)
+{
+  grub_unregister_extcmd (cmd_load);
+  grub_unregister_extcmd (cmd_list);
+  grub_unregister_extcmd (cmd_save);
+}

grub-core/commands/ls.c

@@ -0,0 +1,276 @@
+/* ls.c - command to list files and devices */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2003,2005,2007,2008,2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/types.h>
+#include <grub/misc.h>
+#include <grub/mm.h>
+#include <grub/err.h>
+#include <grub/dl.h>
+#include <grub/disk.h>
+#include <grub/device.h>
+#include <grub/term.h>
+#include <grub/partition.h>
+#include <grub/file.h>
+#include <grub/normal.h>
+#include <grub/extcmd.h>
+#include <grub/datetime.h>
+#include <grub/i18n.h>
+
+static const struct grub_arg_option options[] =
+  {
+    {"long", 'l', 0, N_("Show a long list with more detailed information."), 0, 0},
+    {"human-readable", 'h', 0, N_("Print sizes in a human readable format."), 0, 0},
+    {"all", 'a', 0, N_("List all files."), 0, 0},
+    {0, 0, 0, 0, 0, 0}
+  };
+
+static const char grub_human_sizes[] = {' ', 'K', 'M', 'G', 'T'};
+
+static grub_err_t
+grub_ls_list_devices (int longlist)
+{
+  auto int grub_ls_print_devices (const char *name);
+  int grub_ls_print_devices (const char *name)
+    {
+      if (longlist)
+	grub_normal_print_device_info (name);
+      else
+	grub_printf ("(%s) ", name);
+
+      return 0;
+    }
+
+  grub_device_iterate (grub_ls_print_devices);
+  grub_putchar ('\n');
+  grub_refresh ();
+
+  return 0;
+}
+
+static grub_err_t
+grub_ls_list_files (char *dirname, int longlist, int all, int human)
+{
+  char *device_name;
+  grub_fs_t fs;
+  const char *path;
+  grub_device_t dev;
+
+  auto int print_files (const char *filename,
+			const struct grub_dirhook_info *info);
+  auto int print_files_long (const char *filename,
+			     const struct grub_dirhook_info *info);
+
+  int print_files (const char *filename, const struct grub_dirhook_info *info)
+    {
+      if (all || filename[0] != '.')
+	grub_printf ("%s%s ", filename, info->dir ? "/" : "");
+
+      return 0;
+    }
+
+  int print_files_long (const char *filename,
+			const struct grub_dirhook_info *info)
+    {
+      if ((! all) && (filename[0] == '.'))
+	return 0;
+
+      if (! info->dir)
+	{
+	  grub_file_t file;
+	  char *pathname;
+
+	  if (dirname[grub_strlen (dirname) - 1] == '/')
+	    pathname = grub_xasprintf ("%s%s", dirname, filename);
+	  else
+	    pathname = grub_xasprintf ("%s/%s", dirname, filename);
+
+	  if (!pathname)
+	    return 1;
+
+	  /* XXX: For ext2fs symlinks are detected as files while they
+	     should be reported as directories.  */
+	  file = grub_file_open (pathname);
+	  if (! file)
+	    {
+	      grub_errno = 0;
+	      grub_free (pathname);
+	      return 0;
+	    }
+
+	  if (! human)
+	    grub_printf ("%-12llu", (unsigned long long) file->size);
+	  else
+	    {
+	      grub_uint64_t fsize = file->size * 100ULL;
+	      int fsz = file->size;
+	      int units = 0;
+	      char buf[20];
+
+	      while (fsz / 1024)
+		{
+		  fsize = (fsize + 512) / 1024;
+		  fsz /= 1024;
+		  units++;
+		}
+
+	      if (units)
+		{
+		  grub_uint32_t whole, fraction;
+
+		  whole = grub_divmod64 (fsize, 100, &fraction);
+		  grub_snprintf (buf, sizeof (buf),
+				 "%u.%02u%c", whole, fraction,
+				 grub_human_sizes[units]);
+		  grub_printf ("%-12s", buf);
+		}
+	      else
+		grub_printf ("%-12llu", (unsigned long long) file->size);
+
+	    }
+	  grub_file_close (file);
+	  grub_free (pathname);
+	}
+      else
+	grub_printf ("%-12s", "DIR");
+
+      if (info->mtimeset)
+	{
+	  struct grub_datetime datetime;
+	  grub_unixtime2datetime (info->mtime, &datetime);
+	  if (human)
+	    grub_printf (" %d-%02d-%02d %02d:%02d:%02d %-11s ",
+			 datetime.year, datetime.month, datetime.day,
+			 datetime.hour, datetime.minute,
+			 datetime.second,
+			 grub_get_weekday_name (&datetime));
+	  else
+	    grub_printf (" %04d%02d%02d%02d%02d%02d ",
+			 datetime.year, datetime.month,
+			 datetime.day, datetime.hour,
+			 datetime.minute, datetime.second);
+	}
+      grub_printf ("%s%s\n", filename, info->dir ? "/" : "");
+
+      return 0;
+    }
+
+  device_name = grub_file_get_device_name (dirname);
+  dev = grub_device_open (device_name);
+  if (! dev)
+    goto fail;
+
+  fs = grub_fs_probe (dev);
+  path = grub_strchr (dirname, ')');
+  if (! path)
+    path = dirname;
+  else
+    path++;
+
+  if (! path && ! device_name)
+    {
+      grub_error (GRUB_ERR_BAD_ARGUMENT, "invalid argument");
+      goto fail;
+    }
+
+  if (! *path)
+    {
+      if (grub_errno == GRUB_ERR_UNKNOWN_FS)
+	grub_errno = GRUB_ERR_NONE;
+
+      grub_normal_print_device_info (device_name);
+    }
+  else if (fs)
+    {
+      if (longlist)
+	(fs->dir) (dev, path, print_files_long);
+      else
+	(fs->dir) (dev, path, print_files);
+
+      if (grub_errno == GRUB_ERR_BAD_FILE_TYPE
+	  && path[grub_strlen (path) - 1] != '/')
+	{
+	  /* PATH might be a regular file.  */
+	  char *p;
+	  grub_file_t file;
+	  struct grub_dirhook_info info;
+	  grub_errno = 0;
+
+	  file = grub_file_open (dirname);
+	  if (! file)
+	    goto fail;
+
+	  grub_file_close (file);
+
+	  p = grub_strrchr (dirname, '/') + 1;
+	  dirname = grub_strndup (dirname, p - dirname);
+	  if (! dirname)
+	    goto fail;
+
+	  all = 1;
+	  grub_memset (&info, 0, sizeof (info));
+	  if (longlist)
+	    print_files_long (p, &info);
+	  else
+	    print_files (p, &info);
+
+	  grub_free (dirname);
+	}
+
+      if (grub_errno == GRUB_ERR_NONE)
+	grub_putchar ('\n');
+
+      grub_refresh ();
+    }
+
+ fail:
+  if (dev)
+    grub_device_close (dev);
+
+  grub_free (device_name);
+
+  return 0;
+}
+
+static grub_err_t
+grub_cmd_ls (grub_extcmd_t cmd, int argc, char **args)
+{
+  struct grub_arg_list *state = cmd->state;
+
+  if (argc == 0)
+    grub_ls_list_devices (state[0].set);
+  else
+    grub_ls_list_files (args[0], state[0].set, state[2].set,
+			state[1].set);
+
+  return 0;
+}
+
+static grub_extcmd_t cmd;
+
+GRUB_MOD_INIT(ls)
+{
+  cmd = grub_register_extcmd ("ls", grub_cmd_ls, GRUB_COMMAND_FLAG_BOTH,
+			      N_("[-l|-h|-a] [FILE]"),
+			      N_("List devices and files."), options);
+}
+
+GRUB_MOD_FINI(ls)
+{
+  grub_unregister_extcmd (cmd);
+}

grub-core/commands/lsmmap.c

@@ -0,0 +1,57 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef GRUB_MACHINE_EMU
+#include <grub/machine/memory.h>
+#endif
+#include <grub/dl.h>
+#include <grub/misc.h>
+#include <grub/command.h>
+#include <grub/i18n.h>
+
+static grub_err_t
+grub_cmd_lsmmap (grub_command_t cmd __attribute__ ((unused)),
+		 int argc __attribute__ ((unused)), char **args __attribute__ ((unused)))
+
+{
+  auto int NESTED_FUNC_ATTR hook (grub_uint64_t, grub_uint64_t, grub_uint32_t);
+  int NESTED_FUNC_ATTR hook (grub_uint64_t addr, grub_uint64_t size, grub_uint32_t type)
+    {
+      grub_printf ("base_addr = 0x%llx, length = 0x%llx, type = 0x%x\n",
+		   (long long) addr, (long long) size, type);
+      return 0;
+    }
+#ifndef GRUB_MACHINE_EMU
+  grub_machine_mmap_iterate (hook);
+#endif
+
+  return 0;
+}
+
+static grub_command_t cmd;
+
+GRUB_MOD_INIT(lsmmap)
+{
+  cmd = grub_register_command ("lsmmap", grub_cmd_lsmmap,
+			       0, N_("List memory map provided by firmware."));
+}
+
+GRUB_MOD_FINI(lsmmap)
+{
+  grub_unregister_command (cmd);
+}

grub-core/commands/lspci.c

@@ -0,0 +1,234 @@
+/* lspci.c - List PCI devices.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008, 2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/pci.h>
+#include <grub/dl.h>
+#include <grub/misc.h>
+#include <grub/extcmd.h>
+#include <grub/i18n.h>
+
+struct grub_pci_classname
+{
+  int class;
+  int subclass;
+  char *desc;
+};
+
+static const struct grub_pci_classname grub_pci_classes[] =
+  {
+    { 0, 0, "" },
+    { 1, 0, "SCSI Controller" },
+    { 1, 1, "IDE Controller" },
+    { 1, 2, "Floppy Controller" },
+    { 1, 3, "IPI Controller" },
+    { 1, 4, "RAID Controller" },
+    { 1, 6, "SATA Controller" },
+    { 1, 0x80, "Mass storage Controller" },
+    { 2, 0, "Ethernet Controller" },
+    { 2, 1, "Token Ring Controller" },
+    { 2, 2, "FDDI Controller" },
+    { 2, 3, "ATM Controller" },
+    { 2, 4, "ISDN Controller" },
+    { 2, 0x80, "Network controller" },
+    { 3, 0, "VGA Controller" },
+    { 3, 1, "XGA Controller" },
+    { 3, 2, "3D Controller" },
+    { 3, 0x80, "Display Controller" },
+    { 4, 0, "Multimedia Video Device" },
+    { 4, 1, "Multimedia Audio Device" },
+    { 4, 2, "Multimedia Telephony Device" },
+    { 4, 0x80, "Multimedia device" },
+    { 5, 0, "RAM Controller" },
+    { 5, 1, "Flash Memory Controller" },
+    { 5, 0x80, "Memory Controller" },
+    { 6, 0, "Host Bridge" },
+    { 6, 1, "ISA Bridge" },
+    { 6, 2, "EISA Bride" },
+    { 6, 3, "MCA Bridge" },
+    { 6, 4, "PCI-PCI Bridge" },
+    { 6, 5, "PCMCIA Bridge" },
+    { 6, 6, "NuBus Bridge" },
+    { 6, 7, "CardBus Bridge" },
+    { 6, 8, "Raceway Bridge" },
+    { 6, 0x80, "Unknown Bridge" },
+    { 7, 0x80, "Communication controller" },
+    { 8, 0x80, "System hardware" },
+    { 9, 0, "Keyboard Controller" },
+    { 9, 1, "Digitizer" },
+    { 9, 2, "Mouse Controller" },
+    { 9, 3, "Scanner Controller" },
+    { 9, 4, "Gameport Controller" },
+    { 9, 0x80, "Unknown Input Device" },
+    { 10, 0, "Generic Docking Station" },
+    { 10, 0x80, "Unknown Docking Station" },
+    { 11, 0, "80386 Processor" },
+    { 11, 1, "80486 Processor" },
+    { 11, 2, "Pentium Processor" },
+    { 11, 0x10, "Alpha Processor" },
+    { 11, 0x20, "PowerPC Processor" },
+    { 11, 0x30, "MIPS Processor" },
+    { 11, 0x40, "Co-Processor" },
+    { 11, 0x80, "Unknown Processor" },
+    { 12, 3, "USB Controller" },
+    { 12, 0x80, "Serial Bus Controller" },
+    { 13, 0x80, "Wireless Controller" },
+    { 14, 0, "I2O" },
+    { 15, 0, "IrDA Controller" },
+    { 15, 1, "Consumer IR" },
+    { 15, 0x10, "RF-Controller" },
+    { 15, 0x80, "Satellite Communication Controller" },
+    { 16, 0, "Network Decryption" },
+    { 16, 1, "Entertainment Decryption" },
+    { 16, 0x80, "Unknown Decryption Controller" },
+    { 17, 0, "Digital IO Module" },
+    { 17, 0x80, "Unknown Data Input System" },
+    { 0, 0, 0 },
+  };
+
+static const char *
+grub_pci_get_class (int class, int subclass)
+{
+  const struct grub_pci_classname *curr = grub_pci_classes;
+
+  while (curr->desc)
+    {
+      if (curr->class == class && curr->subclass == subclass)
+	return curr->desc;
+      curr++;
+    }
+
+  return 0;
+}
+
+static const struct grub_arg_option options[] =
+  {
+    {"iospace", 'i', 0, "show I/O spaces", 0, 0},
+    {0, 0, 0, 0, 0, 0}
+  };
+
+static int iospace;
+
+static int NESTED_FUNC_ATTR
+grub_lspci_iter (grub_pci_device_t dev, grub_pci_id_t pciid)
+{
+  grub_uint32_t class;
+  const char *sclass;
+  grub_pci_address_t addr;
+  int reg;
+
+  grub_printf ("%02x:%02x.%x %04x:%04x", grub_pci_get_bus (dev),
+	       grub_pci_get_device (dev), grub_pci_get_function (dev),
+	       pciid & 0xFFFF, pciid >> 16);
+  addr = grub_pci_make_address (dev, GRUB_PCI_REG_CLASS);
+  class = grub_pci_read (addr);
+
+  /* Lookup the class name, if there isn't a specific one,
+     retry with 0x80 to get the generic class name.  */
+  sclass = grub_pci_get_class (class >> 24, (class >> 16) & 0xFF);
+  if (! sclass)
+    sclass = grub_pci_get_class (class >> 24, 0x80);
+  if (! sclass)
+    sclass = "";
+
+  grub_printf (" [%04x] %s", (class >> 16) & 0xffff, sclass);
+
+  grub_uint8_t pi = (class >> 8) & 0xff;
+  if (pi)
+    grub_printf (" [PI %02x]", pi);
+
+  grub_printf ("\n");
+
+  if (iospace)
+    {
+      reg = GRUB_PCI_REG_ADDRESSES;
+      while (reg < GRUB_PCI_REG_CIS_POINTER)
+	{
+	  grub_uint64_t space;
+	  addr = grub_pci_make_address (dev, reg);
+	  space = grub_pci_read (addr);
+
+	  reg += sizeof (grub_uint32_t);
+
+	  if (space == 0)
+	    continue;
+	 
+	  switch (space & GRUB_PCI_ADDR_SPACE_MASK)
+	    {
+	    case GRUB_PCI_ADDR_SPACE_IO:
+	      grub_printf ("\tIO space %d at 0x%llx\n",
+			   (unsigned) ((reg - GRUB_PCI_REG_ADDRESSES)
+			    / sizeof (grub_uint32_t)) - 1,
+			   (unsigned long long)
+			   (space & GRUB_PCI_ADDR_IO_MASK));
+	      break;
+	    case GRUB_PCI_ADDR_SPACE_MEMORY:
+	      if ((space & GRUB_PCI_ADDR_MEM_TYPE_MASK)
+		  == GRUB_PCI_ADDR_MEM_TYPE_64)
+		{
+		  addr = grub_pci_make_address (dev, reg);
+		  space |= ((grub_uint64_t) grub_pci_read (addr)) << 32;
+		  reg += sizeof (grub_uint32_t);
+		  grub_printf ("\t64-bit memory space %d at 0x%016llx [%s]\n",
+			       (unsigned) ((reg - GRUB_PCI_REG_ADDRESSES)
+				/ sizeof (grub_uint32_t)) - 2,
+			       (unsigned long long)
+			       (space & GRUB_PCI_ADDR_MEM_MASK),
+			       space & GRUB_PCI_ADDR_MEM_PREFETCH
+			       ? "prefetchable" : "non-prefetchable");
+		 
+		}
+	      else
+		grub_printf ("\t32-bit memory space %d at 0x%016llx [%s]\n",
+			     (unsigned) ((reg - GRUB_PCI_REG_ADDRESSES)
+			      / sizeof (grub_uint32_t)) - 1,
+			     (unsigned long long) 
+			     (space & GRUB_PCI_ADDR_MEM_MASK),
+			     space & GRUB_PCI_ADDR_MEM_PREFETCH
+			     ? "prefetchable" : "non-prefetchable");
+	      break;
+	    }
+	}
+    }
+
+
+  return 0;
+}
+
+static grub_err_t
+grub_cmd_lspci (grub_extcmd_t cmd,
+		int argc __attribute__ ((unused)),
+		char **args __attribute__ ((unused)))
+{
+  iospace = cmd->state[0].set;
+  grub_pci_iterate (grub_lspci_iter);
+  return GRUB_ERR_NONE;
+}
+
+static grub_extcmd_t cmd;
+
+GRUB_MOD_INIT(lspci)
+{
+  cmd = grub_register_extcmd ("lspci", grub_cmd_lspci, GRUB_COMMAND_FLAG_BOTH,
+			      "[-i]", N_("List PCI devices."), options);
+}
+
+GRUB_MOD_FINI(lspci)
+{
+  grub_unregister_extcmd (cmd);
+}

grub-core/commands/memrw.c

@@ -0,0 +1,149 @@
+/* memrw.c - command to read / write physical memory  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/dl.h>
+#include <grub/misc.h>
+#include <grub/extcmd.h>
+#include <grub/env.h>
+#include <grub/i18n.h>
+
+static grub_extcmd_t cmd_read_byte, cmd_read_word, cmd_read_dword;
+static grub_command_t cmd_write_byte, cmd_write_word, cmd_write_dword;
+
+static const struct grub_arg_option options[] =
+  {
+    {0, 'v', 0, N_("Save read value into variable VARNAME."),
+     "VARNAME", ARG_TYPE_STRING},
+    {0, 0, 0, 0, 0, 0}
+  };
+
+
+static grub_err_t
+grub_cmd_read (grub_extcmd_t cmd, int argc, char **argv)
+{
+  grub_target_addr_t addr;
+  grub_uint32_t value = 0;
+  char buf[sizeof ("XXXXXXXX")];
+
+  if (argc != 1)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "invalid number of arguments");
+
+  addr = grub_strtoul (argv[0], 0, 0);
+  switch (cmd->cmd->name[sizeof ("read_") - 1])
+    {
+    case 'd':
+      value = *((volatile grub_uint32_t *) addr);
+      break;
+
+    case 'w':
+      value = *((volatile grub_uint16_t *) addr);
+      break;
+
+    case 'b':
+      value = *((volatile grub_uint8_t *) addr);
+      break;
+    }
+
+  if (cmd->state[0].set)
+    {
+      grub_snprintf (buf, sizeof (buf), "%x", value);
+      grub_env_set (cmd->state[0].arg, buf);
+    }
+  else
+    grub_printf ("0x%x\n", value);
+
+  return 0;
+}
+
+static grub_err_t
+grub_cmd_write (grub_command_t cmd, int argc, char **argv)
+{
+  grub_target_addr_t addr;
+  grub_uint32_t value;
+  grub_uint32_t mask = 0xffffffff;
+
+  if (argc != 2 && argc != 3)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "invalid number of arguments");
+
+  addr = grub_strtoul (argv[0], 0, 0);
+  value = grub_strtoul (argv[1], 0, 0);
+  if (argc == 3)
+    mask = grub_strtoul (argv[2], 0, 0);
+  value &= mask;
+  switch (cmd->name[sizeof ("write_") - 1])
+    {
+    case 'd':
+      if (mask != 0xffffffff)
+	*((volatile grub_uint32_t *) addr)
+	  = (*((volatile grub_uint32_t *) addr) & ~mask) | value;
+      else
+	*((volatile grub_uint32_t *) addr) = value;
+      break;
+
+    case 'w':
+      if ((mask & 0xffff) != 0xffff)
+	*((volatile grub_uint16_t *) addr)
+	  = (*((volatile grub_uint16_t *) addr) & ~mask) | value;
+      else
+	*((volatile grub_uint16_t *) addr) = value;
+      break;
+
+    case 'b':
+      if ((mask & 0xff) != 0xff)
+	*((volatile grub_uint8_t *) addr)
+	  = (*((volatile grub_uint8_t *) addr) & ~mask) | value;
+      else
+	*((volatile grub_uint8_t *) addr) = value;
+      break;
+    }
+
+  return 0;
+}
+
+GRUB_MOD_INIT(memrw)
+{
+  cmd_read_byte =
+    grub_register_extcmd ("read_byte", grub_cmd_read, GRUB_COMMAND_FLAG_BOTH,
+			  N_("ADDR"), N_("Read byte from ADDR."), options);
+  cmd_read_word =
+    grub_register_extcmd ("read_word", grub_cmd_read, GRUB_COMMAND_FLAG_BOTH,
+			  N_("ADDR"), N_("Read word from ADDR."), options);
+  cmd_read_dword =
+    grub_register_extcmd ("read_dword", grub_cmd_read, GRUB_COMMAND_FLAG_BOTH,
+			  N_("ADDR"), N_("Read dword from ADDR."), options);
+  cmd_write_byte =
+    grub_register_command ("write_byte", grub_cmd_write,
+			   N_("ADDR VALUE [MASK]"), N_("Write byte VALUE to ADDR."));
+  cmd_write_word =
+    grub_register_command ("write_word", grub_cmd_write,
+			   N_("ADDR VALUE [MASK]"), N_("Write word VALUE to ADDR."));
+  cmd_write_dword =
+    grub_register_command ("write_dword", grub_cmd_write,
+			   N_("ADDR VALUE [MASK]"), N_("Write dword VALUE to ADDR."));
+}
+
+GRUB_MOD_FINI(memrw)
+{
+  grub_unregister_extcmd (cmd_read_byte);
+  grub_unregister_extcmd (cmd_read_word);
+  grub_unregister_extcmd (cmd_read_dword);
+  grub_unregister_command (cmd_write_byte);
+  grub_unregister_command (cmd_write_word);
+  grub_unregister_command (cmd_write_dword);
+}

grub-core/commands/minicmd.c

@@ -0,0 +1,391 @@
+/* minicmd.c - commands for the rescue mode */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2003,2005,2006,2007,2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/dl.h>
+#include <grub/mm.h>
+#include <grub/err.h>
+#include <grub/env.h>
+#include <grub/misc.h>
+#include <grub/file.h>
+#include <grub/disk.h>
+#include <grub/term.h>
+#include <grub/loader.h>
+#include <grub/command.h>
+#include <grub/i18n.h>
+
+/* cat FILE */
+static grub_err_t
+grub_mini_cmd_cat (struct grub_command *cmd __attribute__ ((unused)),
+		   int argc, char *argv[])
+{
+  grub_file_t file;
+  char buf[GRUB_DISK_SECTOR_SIZE];
+  grub_ssize_t size;
+
+  if (argc < 1)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "no file specified");
+
+  file = grub_file_open (argv[0]);
+  if (! file)
+    return grub_errno;
+
+  while ((size = grub_file_read (file, buf, sizeof (buf))) > 0)
+    {
+      int i;
+
+      for (i = 0; i < size; i++)
+	{
+	  unsigned char c = buf[i];
+
+	  if ((grub_isprint (c) || grub_isspace (c)) && c != '\r')
+	    grub_putchar (c);
+	  else
+	    {
+	      grub_setcolorstate (GRUB_TERM_COLOR_HIGHLIGHT);
+	      grub_printf ("<%x>", (int) c);
+	      grub_setcolorstate (GRUB_TERM_COLOR_STANDARD);
+	    }
+	}
+    }
+
+  grub_putchar ('\n');
+  grub_refresh ();
+  grub_file_close (file);
+
+  return 0;
+}
+
+/* help */
+static grub_err_t
+grub_mini_cmd_help (struct grub_command *cmd __attribute__ ((unused)),
+		    int argc __attribute__ ((unused)),
+		    char *argv[] __attribute__ ((unused)))
+{
+  grub_command_t p;
+
+  for (p = grub_command_list; p; p = p->next)
+    grub_printf ("%s (%d%c)\t%s\n", p->name,
+		 p->prio & GRUB_PRIO_LIST_PRIO_MASK,
+		 (p->prio & GRUB_PRIO_LIST_FLAG_ACTIVE) ? '+' : '-',
+		 p->description);
+
+  return 0;
+}
+
+#if 0
+static void
+grub_rescue_cmd_info (void)
+{
+  extern void grub_disk_cache_get_performance (unsigned long *,
+					       unsigned long *);
+  unsigned long hits, misses;
+
+  grub_disk_cache_get_performance (&hits, &misses);
+  grub_printf ("Disk cache: hits = %u, misses = %u ", hits, misses);
+  if (hits + misses)
+    {
+      unsigned long ratio = hits * 10000 / (hits + misses);
+      grub_printf ("(%u.%u%%)\n", ratio / 100, ratio % 100);
+    }
+  else
+    grub_printf ("(N/A)\n");
+}
+#endif
+
+/* root [DEVICE] */
+static grub_err_t
+grub_mini_cmd_root (struct grub_command *cmd __attribute__ ((unused)),
+		    int argc, char *argv[])
+{
+  grub_device_t dev;
+  grub_fs_t fs;
+
+  if (argc > 0)
+    {
+      char *device_name = grub_file_get_device_name (argv[0]);
+      if (! device_name)
+	return grub_errno;
+
+      grub_env_set ("root", device_name);
+      grub_free (device_name);
+    }
+
+  dev = grub_device_open (0);
+  if (! dev)
+    return grub_errno;
+
+  fs = grub_fs_probe (dev);
+  if (grub_errno == GRUB_ERR_UNKNOWN_FS)
+    grub_errno = GRUB_ERR_NONE;
+
+  grub_printf ("(%s): Filesystem is %s.\n",
+	       grub_env_get ("root"), fs ? fs->name : "unknown");
+
+  grub_device_close (dev);
+
+  return 0;
+}
+
+#if 0
+static void
+grub_rescue_cmd_testload (int argc, char *argv[])
+{
+  grub_file_t file;
+  char *buf;
+  grub_ssize_t size;
+  grub_ssize_t pos;
+  auto void read_func (unsigned long sector, unsigned offset, unsigned len);
+
+  void read_func (unsigned long sector __attribute__ ((unused)),
+		  unsigned offset __attribute__ ((unused)),
+		  unsigned len __attribute__ ((unused)))
+    {
+      grub_putchar ('.');
+      grub_refresh ();
+    }
+
+  if (argc < 1)
+    {
+      grub_error (GRUB_ERR_BAD_ARGUMENT, "no file specified");
+      return;
+    }
+
+  file = grub_file_open (argv[0]);
+  if (! file)
+    return;
+
+  size = grub_file_size (file) & ~(GRUB_DISK_SECTOR_SIZE - 1);
+  if (size == 0)
+    {
+      grub_file_close (file);
+      return;
+    }
+
+  buf = grub_malloc (size);
+  if (! buf)
+    goto fail;
+
+  grub_printf ("Reading %s sequentially", argv[0]);
+  file->read_hook = read_func;
+  if (grub_file_read (file, buf, size) != size)
+    goto fail;
+  grub_printf (" Done.\n");
+
+  /* Read sequentially again.  */
+  grub_printf ("Reading %s sequentially again", argv[0]);
+  if (grub_file_seek (file, 0) < 0)
+    goto fail;
+
+  for (pos = 0; pos < size; pos += GRUB_DISK_SECTOR_SIZE)
+    {
+      char sector[GRUB_DISK_SECTOR_SIZE];
+
+      if (grub_file_read (file, sector, GRUB_DISK_SECTOR_SIZE)
+	  != GRUB_DISK_SECTOR_SIZE)
+	goto fail;
+
+      if (grub_memcmp (sector, buf + pos, GRUB_DISK_SECTOR_SIZE) != 0)
+	{
+	  grub_printf ("\nDiffers in %d\n", pos);
+	  goto fail;
+	}
+    }
+  grub_printf (" Done.\n");
+
+  /* Read backwards and compare.  */
+  grub_printf ("Reading %s backwards", argv[0]);
+  pos = size;
+  while (pos > 0)
+    {
+      char sector[GRUB_DISK_SECTOR_SIZE];
+
+      pos -= GRUB_DISK_SECTOR_SIZE;
+
+      if (grub_file_seek (file, pos) < 0)
+	goto fail;
+
+      if (grub_file_read (file, sector, GRUB_DISK_SECTOR_SIZE)
+	  != GRUB_DISK_SECTOR_SIZE)
+	goto fail;
+
+      if (grub_memcmp (sector, buf + pos, GRUB_DISK_SECTOR_SIZE) != 0)
+	{
+	  int i;
+
+	  grub_printf ("\nDiffers in %d\n", pos);
+
+	  for (i = 0; i < GRUB_DISK_SECTOR_SIZE; i++)
+	    grub_putchar (buf[pos + i]);
+
+	  if (i)
+	    grub_refresh ();
+
+	  goto fail;
+	}
+    }
+  grub_printf (" Done.\n");
+
+ fail:
+
+  grub_file_close (file);
+  grub_free (buf);
+}
+#endif
+
+/* dump ADDRESS [SIZE] */
+static grub_err_t
+grub_mini_cmd_dump (struct grub_command *cmd __attribute__ ((unused)),
+		    int argc, char *argv[])
+{
+  grub_uint8_t *addr;
+  grub_size_t size = 4;
+
+  if (argc == 0)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "no address specified");
+
+  addr = (grub_uint8_t *) grub_strtoul (argv[0], 0, 0);
+  if (grub_errno)
+    return grub_errno;
+
+  if (argc > 1)
+    size = (grub_size_t) grub_strtoul (argv[1], 0, 0);
+
+  while (size--)
+    {
+      grub_printf ("%x%x ", *addr >> 4, *addr & 0xf);
+      addr++;
+    }
+
+  return 0;
+}
+
+/* rmmod MODULE */
+static grub_err_t
+grub_mini_cmd_rmmod (struct grub_command *cmd __attribute__ ((unused)),
+		     int argc, char *argv[])
+{
+  grub_dl_t mod;
+
+  if (argc == 0)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "no module specified");
+
+  mod = grub_dl_get (argv[0]);
+  if (! mod)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "no such module");
+
+  if (grub_dl_unref (mod) <= 0)
+    grub_dl_unload (mod);
+
+  return 0;
+}
+
+/* lsmod */
+static grub_err_t
+grub_mini_cmd_lsmod (struct grub_command *cmd __attribute__ ((unused)),
+		     int argc __attribute__ ((unused)),
+		     char *argv[] __attribute__ ((unused)))
+{
+  auto int print_module (grub_dl_t mod);
+
+  int print_module (grub_dl_t mod)
+    {
+      grub_dl_dep_t dep;
+
+      grub_printf ("%s\t%d\t\t", mod->name, mod->ref_count);
+      for (dep = mod->dep; dep; dep = dep->next)
+	{
+	  if (dep != mod->dep)
+	    grub_putchar (',');
+
+	  grub_printf ("%s", dep->mod->name);
+	}
+      grub_putchar ('\n');
+
+      return 0;
+    }
+
+  grub_printf ("Name\tRef Count\tDependencies\n");
+  grub_dl_iterate (print_module);
+
+  return 0;
+}
+
+/* exit */
+static grub_err_t
+grub_mini_cmd_exit (struct grub_command *cmd __attribute__ ((unused)),
+		    int argc __attribute__ ((unused)),
+		    char *argv[] __attribute__ ((unused)))
+{
+  grub_exit ();
+  return 0;
+}
+
+/* clear */
+static grub_err_t
+grub_mini_cmd_clear (struct grub_command *cmd __attribute__ ((unused)),
+		   int argc __attribute__ ((unused)),
+		   char *argv[] __attribute__ ((unused)))
+{
+  grub_cls ();
+  return 0;
+}
+
+static grub_command_t cmd_cat, cmd_help, cmd_root;
+static grub_command_t cmd_dump, cmd_rmmod, cmd_lsmod, cmd_exit;
+static grub_command_t cmd_clear;
+
+GRUB_MOD_INIT(minicmd)
+{
+  cmd_cat =
+    grub_register_command ("cat", grub_mini_cmd_cat,
+			   N_("FILE"), N_("Show the contents of a file."));
+  cmd_help =
+    grub_register_command ("help", grub_mini_cmd_help,
+			   0, N_("Show this message."));
+  cmd_root =
+    grub_register_command ("root", grub_mini_cmd_root,
+			   N_("[DEVICE]"), N_("Set the root device."));
+  cmd_dump =
+    grub_register_command ("dump", grub_mini_cmd_dump,
+			   N_("ADDR"), N_("Dump memory."));
+  cmd_rmmod =
+    grub_register_command ("rmmod", grub_mini_cmd_rmmod,
+			   N_("MODULE"), N_("Remove a module."));
+  cmd_lsmod =
+    grub_register_command ("lsmod", grub_mini_cmd_lsmod,
+			   0, N_("Show loaded modules."));
+  cmd_exit =
+    grub_register_command ("exit", grub_mini_cmd_exit,
+			   0, N_("Exit from GRUB."));
+  cmd_clear =
+    grub_register_command ("clear", grub_mini_cmd_clear,
+			   0, N_("Clear the screen."));
+}
+
+GRUB_MOD_FINI(minicmd)
+{
+  grub_unregister_command (cmd_cat);
+  grub_unregister_command (cmd_help);
+  grub_unregister_command (cmd_root);
+  grub_unregister_command (cmd_dump);
+  grub_unregister_command (cmd_rmmod);
+  grub_unregister_command (cmd_lsmod);
+  grub_unregister_command (cmd_exit);
+  grub_unregister_command (cmd_clear);
+}

grub-core/commands/parttool.c

@@ -0,0 +1,332 @@
+/* parttool.c - common dispatcher and parser for partition operations */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2009  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/types.h>
+#include <grub/misc.h>
+#include <grub/mm.h>
+#include <grub/err.h>
+#include <grub/dl.h>
+#include <grub/normal.h>
+#include <grub/device.h>
+#include <grub/disk.h>
+#include <grub/partition.h>
+#include <grub/parttool.h>
+#include <grub/command.h>
+#include <grub/i18n.h>
+
+static struct grub_parttool *parts = 0;
+static int curhandle = 0;
+static grub_dl_t mymod;
+static char helpmsg[] =
+  "Perform COMMANDS on partition.\n"
+  "Use \"parttool PARTITION help\" for the list "
+  "of available commands.";
+
+int
+grub_parttool_register(const char *part_name,
+		       const grub_parttool_function_t func,
+		       const struct grub_parttool_argdesc *args)
+{
+  struct grub_parttool *cur;
+  int nargs = 0;
+
+  if (! parts)
+    grub_dl_ref (mymod);
+
+  cur = (struct grub_parttool *) grub_malloc (sizeof (struct grub_parttool));
+  cur->next = parts;
+  cur->name = grub_strdup (part_name);
+  cur->handle = curhandle++;
+  for (nargs = 0; args[nargs].name != 0; nargs++);
+  cur->nargs = nargs;
+  cur->args = (struct grub_parttool_argdesc *)
+    grub_malloc ((nargs + 1) * sizeof (struct grub_parttool_argdesc));
+  grub_memcpy (cur->args, args,
+	       (nargs + 1) * sizeof (struct grub_parttool_argdesc));
+
+  cur->func = func;
+  parts = cur;
+  return cur->handle;
+}
+
+void
+grub_parttool_unregister (int handle)
+{
+  struct grub_parttool *prev = 0, *cur, *t;
+  for (cur = parts; cur; )
+    if (cur->handle == handle)
+      {
+	grub_free (cur->args);
+	grub_free (cur->name);
+	if (prev)
+	  prev->next = cur->next;
+	else
+	  parts = cur->next;
+	t = cur;
+	cur = cur->next;
+	grub_free (t);
+      }
+    else
+      {
+	prev = cur;
+	cur = cur->next;
+      }
+  if (! parts)
+    grub_dl_unref (mymod);
+}
+
+static grub_err_t
+grub_cmd_parttool (grub_command_t cmd __attribute__ ((unused)),
+		   int argc, char **args)
+{
+  grub_device_t dev;
+  struct grub_parttool *cur, *ptool;
+  int *parsed;
+  int i, j;
+  grub_err_t err = GRUB_ERR_NONE;
+
+  auto grub_err_t show_help (void);
+  grub_err_t show_help (void)
+  {
+    int found = 0;
+    for (cur = parts; cur; cur = cur->next)
+      if (grub_strcmp (dev->disk->partition->partmap->name, cur->name) == 0)
+	{
+	  struct grub_parttool_argdesc *curarg;
+	  found = 1;
+	  for (curarg = cur->args; curarg->name; curarg++)
+	    {
+	      int spacing = 20;
+
+	      spacing -= grub_strlen (curarg->name);
+	      grub_printf ("%s", curarg->name);
+
+	      switch (curarg->type)
+		{
+		case GRUB_PARTTOOL_ARG_BOOL:
+		  grub_printf ("+/-");
+		  spacing -= 3;
+		  break;
+
+		case GRUB_PARTTOOL_ARG_VAL:
+		  grub_printf ("=VAL");
+		  spacing -= 4;
+		  break;
+
+		    case GRUB_PARTTOOL_ARG_END:
+		      break;
+		}
+	      while (spacing-- > 0)
+		grub_printf (" ");
+	      grub_printf ("%s\n", curarg->desc);
+	    }
+	}
+    if (! found)
+      grub_printf ("Sorry no parttool is available for %s\n",
+		   dev->disk->partition->partmap->name);
+    return GRUB_ERR_NONE;
+  }
+
+  if (argc < 1)
+    {
+      grub_printf ("%s\n", helpmsg);
+      return grub_error (GRUB_ERR_BAD_ARGUMENT, "too few arguments");
+    }
+
+  if (args[0][0] == '(' && args[0][grub_strlen (args[0]) - 1] == ')')
+    {
+      args[0][grub_strlen (args[0]) - 1] = 0;
+      dev = grub_device_open (args[0] + 1);
+      args[0][grub_strlen (args[0]) - 1] = ')';
+    }
+  else
+    dev = grub_device_open (args[0]);
+
+  if (! dev)
+    return grub_errno;
+
+  if (! dev->disk)
+    {
+      grub_device_close (dev);
+      return grub_error (GRUB_ERR_BAD_ARGUMENT, "not a disk");
+    }
+
+  if (! dev->disk->partition)
+    {
+      grub_device_close (dev);
+      return grub_error (GRUB_ERR_BAD_ARGUMENT, "not a partition");
+    }
+
+  /* Load modules. */
+#if defined(GRUB_MACHINE_EMU)
+  {
+    const char *prefix;
+    prefix = grub_env_get ("prefix");
+    if (prefix)
+      {
+	char *filename;
+
+	filename = grub_xasprintf ("%s/parttool.lst", prefix);
+	if (filename)
+	  {
+	    grub_file_t file;
+
+	    file = grub_file_open (filename);
+	    if (file)
+	      {
+		char *buf = 0;
+		for (;; grub_free(buf))
+		  {
+		    char *p, *name;
+
+		    buf = grub_file_getline (file);
+
+		    if (! buf)
+		      break;
+
+		    name = buf;
+
+		    if (! grub_isgraph (name[0]))
+		      continue;
+
+		    p = grub_strchr (name, ':');
+		    if (! p)
+		      continue;
+
+		    *p = '\0';
+		    while (*++p == ' ')
+		      ;
+
+		    if (! grub_isgraph (*p))
+		      continue;
+
+		    if (grub_strcmp (name, dev->disk->partition->partmap->name)
+			!= 0)
+		      continue;
+
+		    grub_dl_load (p);
+		  }
+
+		grub_file_close (file);
+	      }
+
+	    grub_free (filename);
+	  }
+      }
+    /* Ignore errors.  */
+    grub_errno = GRUB_ERR_NONE;
+  }
+#endif
+
+  if (argc == 1)
+    return show_help ();
+
+  for (i = 1; i < argc; i++)
+    if (grub_strcmp (args[i], "help") == 0)
+      return show_help ();
+
+  parsed = (int *) grub_zalloc (argc * sizeof (int));
+
+  for (i = 1; i < argc; i++)
+    if (! parsed[i])
+      {
+	struct grub_parttool_argdesc *curarg;
+	struct grub_parttool_args *pargs;
+	for (cur = parts; cur; cur = cur->next)
+	  if (grub_strcmp (dev->disk->partition->partmap->name, cur->name) == 0)
+	    {
+	      for (curarg = cur->args; curarg->name; curarg++)
+		if (grub_strncmp (curarg->name, args[i],
+				  grub_strlen (curarg->name)) == 0
+		    && ((curarg->type == GRUB_PARTTOOL_ARG_BOOL
+			 && (args[i][grub_strlen (curarg->name)] == '+'
+			     || args[i][grub_strlen (curarg->name)] == '-'
+			     || args[i][grub_strlen (curarg->name)] == 0))
+			|| (curarg->type == GRUB_PARTTOOL_ARG_VAL
+			    && args[i][grub_strlen (curarg->name)] == '=')))
+
+		  break;
+	      if (curarg->name)
+		break;
+	    }
+	if (! cur)
+	  return grub_error (GRUB_ERR_BAD_ARGUMENT, "unrecognised argument %s",
+			     args[i]);
+	ptool = cur;
+	pargs = (struct grub_parttool_args *)
+	  grub_zalloc (ptool->nargs * sizeof (struct grub_parttool_args));
+	for (j = i; j < argc; j++)
+	  if (! parsed[j])
+	    {
+	      for (curarg = ptool->args; curarg->name; curarg++)
+		if (grub_strncmp (curarg->name, args[i],
+				   grub_strlen (curarg->name)) == 0
+		    && ((curarg->type == GRUB_PARTTOOL_ARG_BOOL
+			 && (args[j][grub_strlen (curarg->name)] == '+'
+			     || args[j][grub_strlen (curarg->name)] == '-'
+			     || args[j][grub_strlen (curarg->name)] == 0))
+			|| (curarg->type == GRUB_PARTTOOL_ARG_VAL
+			    && args[j][grub_strlen (curarg->name)] == '=')))
+		  {
+		    parsed[j] = 1;
+		    pargs[curarg - ptool->args].set = 1;
+		    switch (curarg->type)
+		      {
+		      case GRUB_PARTTOOL_ARG_BOOL:
+			pargs[curarg - ptool->args].bool
+			  = (args[j][grub_strlen (curarg->name)] != '-');
+			break;
+
+		      case GRUB_PARTTOOL_ARG_VAL:
+			pargs[curarg - ptool->args].str
+			  = (args[j] + grub_strlen (curarg->name) + 1);
+			break;
+
+		      case GRUB_PARTTOOL_ARG_END:
+			break;
+		      }
+		  }
+	    }
+
+	err = ptool->func (dev, pargs);
+	grub_free (pargs);
+	if (err)
+	  break;
+      }
+
+  grub_free (parsed);
+  grub_device_close (dev);
+  return err;
+}
+
+static grub_command_t cmd;
+
+GRUB_MOD_INIT(parttool)
+{
+  mymod = mod;
+  cmd = grub_register_command ("parttool", grub_cmd_parttool,
+			       N_("PARTITION COMMANDS"),
+			       helpmsg);
+}
+
+GRUB_MOD_FINI(parttool)
+{
+  grub_unregister_command (cmd);
+}

grub-core/commands/password.c

@@ -0,0 +1,86 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/auth.h>
+#include <grub/crypto.h>
+#include <grub/list.h>
+#include <grub/mm.h>
+#include <grub/misc.h>
+#include <grub/env.h>
+#include <grub/normal.h>
+#include <grub/dl.h>
+#include <grub/i18n.h>
+
+static grub_dl_t my_mod;
+
+static grub_err_t
+check_password (const char *user, const char *entered,
+		void *password)
+{
+  if (grub_crypto_memcmp (entered, password, GRUB_AUTH_MAX_PASSLEN) != 0)
+    return GRUB_ACCESS_DENIED;
+
+  grub_auth_authenticate (user);
+
+  return GRUB_ERR_NONE;
+}
+
+static grub_err_t
+grub_cmd_password (grub_command_t cmd __attribute__ ((unused)),
+		   int argc, char **args)
+{
+  grub_err_t err;
+  char *pass;
+  int copylen;
+
+  if (argc != 2)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "two arguments expected");
+
+  pass = grub_zalloc (GRUB_AUTH_MAX_PASSLEN);
+  if (!pass)
+    return grub_errno;
+  copylen = grub_strlen (args[1]);
+  if (copylen >= GRUB_AUTH_MAX_PASSLEN)
+    copylen = GRUB_AUTH_MAX_PASSLEN - 1;
+  grub_memcpy (pass, args[1], copylen);
+
+  err = grub_auth_register_authentication (args[0], check_password, pass);
+  if (err)
+    {
+      grub_free (pass);
+      return err;
+    }
+  grub_dl_ref (my_mod);
+  return GRUB_ERR_NONE;
+}
+
+static grub_command_t cmd;
+
+GRUB_MOD_INIT(password)
+{
+  my_mod = mod;
+  cmd = grub_register_command ("password", grub_cmd_password,
+			       N_("USER PASSWORD"),
+			       N_("Set user password (plaintext). "
+			       "Unrecommended and insecure."));
+}
+
+GRUB_MOD_FINI(password)
+{
+  grub_unregister_command (cmd);
+}

grub-core/commands/password_pbkdf2.c

@@ -0,0 +1,197 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/auth.h>
+#include <grub/crypto.h>
+#include <grub/list.h>
+#include <grub/mm.h>
+#include <grub/misc.h>
+#include <grub/env.h>
+#include <grub/normal.h>
+#include <grub/dl.h>
+#include <grub/i18n.h>
+
+static grub_dl_t my_mod;
+
+struct pbkdf2_password
+{
+  grub_uint8_t *salt;
+  grub_size_t saltlen;
+  unsigned int c;
+  grub_uint8_t *expected;
+  grub_size_t buflen;
+};
+
+static grub_err_t
+check_password (const char *user, const char *entered, void *pin)
+{
+  grub_uint8_t *buf;
+  struct pbkdf2_password *pass = pin;
+  gcry_err_code_t err;
+
+  buf = grub_malloc (pass->buflen);
+  if (!buf)
+    return grub_crypto_gcry_error (GPG_ERR_OUT_OF_MEMORY);
+
+  err = grub_crypto_pbkdf2 (GRUB_MD_SHA512, (grub_uint8_t *) entered,
+			    grub_strlen (entered),
+			    pass->salt, pass->saltlen, pass->c,
+			    buf, pass->buflen);
+  if (err)
+    {
+      grub_free (buf);
+      return grub_crypto_gcry_error (err);
+    }
+
+  if (grub_crypto_memcmp (buf, pass->expected, pass->buflen) != 0)
+    return GRUB_ACCESS_DENIED;
+
+  grub_auth_authenticate (user);
+
+  return GRUB_ERR_NONE;
+}
+
+static inline int
+hex2val (char hex)
+{
+  if ('0' <= hex && hex <= '9')
+    return hex - '0';
+  if ('a' <= hex && hex <= 'f')
+    return hex - 'a' + 10;
+  if ('A' <= hex && hex <= 'F')
+    return hex - 'A' + 10;
+  return -1;
+}
+
+static grub_err_t
+grub_cmd_password (grub_command_t cmd __attribute__ ((unused)),
+		   int argc, char **args)
+{
+  grub_err_t err;
+  char *ptr, *ptr2;
+  grub_uint8_t *ptro;
+  struct pbkdf2_password *pass;
+
+  if (argc != 2)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "Two arguments expected.");
+
+  if (grub_memcmp (args[1], "grub.pbkdf2.sha512.",
+		   sizeof ("grub.pbkdf2.sha512.") - 1) != 0)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "Incorrect PBKDF2 password.");
+
+  ptr = args[1] + sizeof ("grub.pbkdf2.sha512.") - 1;
+
+  pass = grub_malloc (sizeof (*pass));
+  if (!pass)
+    return grub_errno;
+
+  pass->c = grub_strtoul (ptr, &ptr, 0);
+  if (*ptr != '.')
+    {
+      grub_free (pass);
+      return grub_error (GRUB_ERR_BAD_ARGUMENT, "Incorrect PBKDF2 password.");
+    }
+  ptr++;
+
+  ptr2 = grub_strchr (ptr, '.');
+  if (!ptr2 || ((ptr2 - ptr) & 1) || grub_strlen (ptr2 + 1) & 1)
+    {
+      grub_free (pass);
+      return grub_error (GRUB_ERR_BAD_ARGUMENT, "Incorrect PBKDF2 password.");
+    }
+
+  pass->saltlen = (ptr2 - ptr) >> 1;
+  pass->buflen = grub_strlen (ptr2 + 1) >> 1;
+  ptro = pass->salt = grub_malloc (pass->saltlen);
+  if (!ptro)
+    {
+      grub_free (pass);
+      return grub_errno;
+    }
+  while (ptr < ptr2)
+    {
+      int hex1, hex2;
+      hex1 = hex2val (*ptr);
+      ptr++;
+      hex2 = hex2val (*ptr);
+      ptr++;
+      if (hex1 < 0 || hex2 < 0)
+	{
+	  grub_free (pass->salt);
+	  grub_free (pass);
+	  return grub_error (GRUB_ERR_BAD_ARGUMENT,
+			     "Incorrect PBKDF2 password.");
+	}
+
+      *ptro = (hex1 << 4) | hex2;
+      ptro++;
+    }
+
+  ptro = pass->expected = grub_malloc (pass->buflen);
+  if (!ptro)
+    {
+      grub_free (pass->salt);
+      grub_free (pass);
+      return grub_errno;
+    }
+  ptr = ptr2 + 1;
+  ptr2 += grub_strlen (ptr2); 
+  while (ptr < ptr2)
+    {
+      int hex1, hex2;
+      hex1 = hex2val (*ptr);
+      ptr++;
+      hex2 = hex2val (*ptr);
+      ptr++;
+      if (hex1 < 0 || hex2 < 0)
+	{
+	  grub_free (pass->expected);
+	  grub_free (pass->salt);
+	  grub_free (pass);
+	  return grub_error (GRUB_ERR_BAD_ARGUMENT,
+			     "Incorrect PBKDF2 password.");
+	}
+
+      *ptro = (hex1 << 4) | hex2;
+      ptro++;
+    }
+
+  err = grub_auth_register_authentication (args[0], check_password, pass);
+  if (err)
+    {
+      grub_free (pass);
+      return err;
+    }
+  grub_dl_ref (my_mod);
+  return GRUB_ERR_NONE;
+}
+
+static grub_command_t cmd;
+
+GRUB_MOD_INIT(password_pbkdf2)
+{
+  my_mod = mod;
+  cmd = grub_register_command ("password_pbkdf2", grub_cmd_password,
+			       N_("USER PBKDF2_PASSWORD"),
+			       N_("Set user password (PBKDF2). "));
+}
+
+GRUB_MOD_FINI(password_pbkdf2)
+{
+  grub_unregister_command (cmd);
+}

grub-core/commands/probe.c

@@ -0,0 +1,161 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/types.h>
+#include <grub/misc.h>
+#include <grub/mm.h>
+#include <grub/err.h>
+#include <grub/dl.h>
+#include <grub/device.h>
+#include <grub/disk.h>
+#include <grub/partition.h>
+#include <grub/net.h>
+#include <grub/fs.h>
+#include <grub/file.h>
+#include <grub/misc.h>
+#include <grub/env.h>
+#include <grub/extcmd.h>
+#include <grub/i18n.h>
+
+static const struct grub_arg_option options[] =
+  {
+    {"set",             's', GRUB_ARG_OPTION_OPTIONAL,
+     N_("Set a variable to return value."), "VAR", ARG_TYPE_STRING},
+    {"driver",		'd', 0, N_("Determine driver."), 0, 0},
+    {"partmap",		'p', 0, N_("Determine partition map type."), 0, 0},
+    {"fs",		'f', 0, N_("Determine filesystem type."), 0, 0},
+    {"fs-uuid",		'u', 0, N_("Determine filesystem UUID."), 0, 0},
+    {"label",		'l', 0, N_("Determine filesystem label."), 0, 0},
+    {0, 0, 0, 0, 0, 0}
+  };
+
+static grub_err_t
+grub_cmd_probe (grub_extcmd_t cmd, int argc, char **args)
+{
+  struct grub_arg_list *state = cmd->state;
+  grub_device_t dev;
+  grub_fs_t fs;
+  char *ptr;
+  grub_err_t err;
+
+  if (argc < 1)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "device name required");
+
+  ptr = args[0] + grub_strlen (args[0]) - 1;
+  if (args[0][0] == '(' && *ptr == ')')
+    {
+      *ptr = 0;
+      dev = grub_device_open (args[0] + 1);
+      *ptr = ')';
+    }
+  else
+    dev = grub_device_open (args[0]);
+  if (! dev)
+    return grub_error (GRUB_ERR_BAD_DEVICE, "couldn't open device");
+
+  if (state[1].set)
+    {
+      const char *val = "none";
+      if (dev->net)
+	val = dev->net->dev->name;
+      if (dev->disk)
+	val = dev->disk->dev->name;
+      if (state[0].set)
+	grub_env_set (state[0].arg, val);
+      else
+	grub_printf ("%s", val);
+      return GRUB_ERR_NONE;
+    }
+  if (state[2].set)
+    {
+      const char *val = "none";
+      if (dev->disk && dev->disk->partition)
+	val = dev->disk->partition->partmap->name;
+      if (state[0].set)
+	grub_env_set (state[0].arg, val);
+      else
+	grub_printf ("%s", val);
+      return GRUB_ERR_NONE;
+    }
+  fs = grub_fs_probe (dev);
+  if (! fs)
+    return grub_error (GRUB_ERR_UNKNOWN_FS, "unrecognised fs");
+  if (state[3].set)
+    {
+      if (state[0].set)
+	grub_env_set (state[0].arg, fs->name);
+      else
+	grub_printf ("%s", fs->name);
+      return GRUB_ERR_NONE;
+    }
+  if (state[4].set)
+    {
+      char *uuid;
+      if (! fs->uuid)
+	return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
+			   "uuid for this FS isn't supported yet");
+      err = fs->uuid (dev, &uuid);
+      if (err)
+	return err;
+      if (! uuid)
+	return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
+			   "uuid for this FS isn't supported yet");
+
+      if (state[0].set)
+	grub_env_set (state[0].arg, uuid);
+      else
+	grub_printf ("%s", uuid);
+      grub_free (uuid);
+      return GRUB_ERR_NONE;
+    }
+  if (state[5].set)
+    {
+      char *label;
+      if (! fs->label)
+	return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
+			   "label for this FS isn't supported yet");
+      err = fs->label (dev, &label);
+      if (err)
+	return err;
+      if (! label)
+	return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
+			   "uuid for this FS isn't supported yet");
+
+      if (state[0].set)
+	grub_env_set (state[0].arg, label);
+      else
+	grub_printf ("%s", label);
+      grub_free (label);
+      return GRUB_ERR_NONE;
+    }
+  return grub_error (GRUB_ERR_BAD_ARGUMENT, "unrecognised target");
+}
+
+static grub_extcmd_t cmd;
+
+GRUB_MOD_INIT (probe)
+{
+  cmd = grub_register_extcmd ("probe", grub_cmd_probe, GRUB_COMMAND_FLAG_BOTH,
+			      N_("[DEVICE]"),
+			      N_("Retrieve device info."), options);
+}
+
+GRUB_MOD_FINI (probe)
+{
+  grub_unregister_extcmd (cmd);
+}

grub-core/commands/read.c

@@ -0,0 +1,90 @@
+/* read.c - Command to read variables from user.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2006,2007,2008  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/dl.h>
+#include <grub/misc.h>
+#include <grub/mm.h>
+#include <grub/env.h>
+#include <grub/term.h>
+#include <grub/types.h>
+#include <grub/command.h>
+#include <grub/i18n.h>
+
+static char *
+grub_getline (void)
+{
+  int i;
+  char *line;
+  char *tmp;
+  char c;
+
+  i = 0;
+  line = grub_malloc (1 + i + sizeof('\0'));
+  if (! line)
+    return NULL;
+
+  while (1)
+    {
+      c = grub_getkey ();
+      if ((c == '\n') || (c == '\r'))
+	break;
+
+      line[i] = c;
+      if (grub_isprint (c))
+	grub_putchar (c);
+      i++;
+      tmp = grub_realloc (line, 1 + i + sizeof('\0'));
+      if (! tmp)
+	{
+	  grub_free (line);
+	  return NULL;
+	}
+      line = tmp;
+    }
+  line[i] = '\0';
+
+  return line;
+}
+
+static grub_err_t
+grub_cmd_read (grub_command_t cmd __attribute__ ((unused)), int argc, char **args)
+{
+  char *line = grub_getline ();
+  if (! line)
+    return grub_errno;
+  if (argc > 0)
+    grub_env_set (args[0], line);
+
+  grub_free (line);
+  return 0;
+}
+
+static grub_command_t cmd;
+
+GRUB_MOD_INIT(read)
+{
+  cmd = grub_register_command ("read", grub_cmd_read,
+			       N_("[ENVVAR]"),
+			       N_("Set variable with user input."));
+}
+
+GRUB_MOD_FINI(read)
+{
+  grub_unregister_command (cmd);
+}

grub-core/commands/reboot.c

@@ -0,0 +1,45 @@
+/* reboot.c - command to reboot the computer.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2005,2007,2008  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/dl.h>
+#include <grub/command.h>
+#include <grub/misc.h>
+#include <grub/i18n.h>
+
+static grub_err_t
+grub_cmd_reboot (grub_command_t cmd __attribute__ ((unused)),
+		 int argc __attribute__ ((unused)),
+		 char **args __attribute__ ((unused)))
+{
+  grub_reboot ();
+  return 0;
+}
+
+static grub_command_t cmd;
+
+GRUB_MOD_INIT(reboot)
+{
+  cmd = grub_register_command ("reboot", grub_cmd_reboot,
+			       0, N_("Reboot the computer."));
+}
+
+GRUB_MOD_FINI(reboot)
+{
+  grub_unregister_command (cmd);
+}

grub-core/commands/regexp.c

@@ -0,0 +1,80 @@
+/* regexp.c -- The regexp command.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2005,2007  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/dl.h>
+#include <grub/misc.h>
+#include <grub/mm.h>
+#include <grub/command.h>
+#include <grub/i18n.h>
+#include <regex.h>
+
+static grub_err_t
+grub_cmd_regexp (grub_command_t cmd __attribute__ ((unused)),
+		 int argc, char **args)
+{
+  int argn = 0;
+  int matches = 0;
+  regex_t regex;
+  int ret;
+  grub_size_t s;
+  char *comperr;
+  grub_err_t err;
+
+  if (argc != 2)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "2 arguments expected");
+
+  ret = regcomp (&regex, args[0], RE_SYNTAX_GNU_AWK);
+  if (ret)
+    goto fail;
+
+  ret = regexec (&regex, args[1], 0, 0, 0);
+  if (!ret)
+    {
+      regfree (&regex);
+      return GRUB_ERR_NONE;
+    }
+
+ fail:
+  s = regerror (ret, &regex, 0, 0);
+  comperr = grub_malloc (s);
+  if (!comperr)
+    {
+      regfree (&regex);
+      return grub_errno;
+    }
+  regerror (ret, &regex, comperr, s);
+  err = grub_error (GRUB_ERR_TEST_FAILURE, "%s", comperr);
+  regfree (&regex);
+  grub_free (comperr);
+  return err;
+}
+
+static grub_command_t cmd;
+
+GRUB_MOD_INIT(regexp)
+{
+  cmd = grub_register_command ("regexp", grub_cmd_regexp,
+			       N_("REGEXP STRING"),
+			       N_("Test if REGEXP matches STRING."));
+}
+
+GRUB_MOD_FINI(regexp)
+{
+  grub_unregister_command (cmd);
+}

grub-core/commands/search.c

@@ -0,0 +1,174 @@
+/* search.c - search devices based on a file or a filesystem label */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2005,2007,2008,2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/types.h>
+#include <grub/misc.h>
+#include <grub/mm.h>
+#include <grub/err.h>
+#include <grub/dl.h>
+#include <grub/device.h>
+#include <grub/file.h>
+#include <grub/env.h>
+#include <grub/command.h>
+#include <grub/search.h>
+#include <grub/i18n.h>
+
+void
+FUNC_NAME (const char *key, const char *var, int no_floppy)
+{
+  int count = 0;
+  grub_fs_autoload_hook_t saved_autoload;
+
+  auto int iterate_device (const char *name);
+  int iterate_device (const char *name)
+  {
+    int found = 0;
+
+    /* Skip floppy drives when requested.  */
+    if (no_floppy &&
+	name[0] == 'f' && name[1] == 'd' && name[2] >= '0' && name[2] <= '9')
+      return 0;
+
+#ifdef DO_SEARCH_FILE
+      {
+	char *buf;
+	grub_file_t file;
+
+	buf = grub_xasprintf ("(%s)%s", name, key);
+	if (! buf)
+	  return 1;
+
+	file = grub_file_open (buf);
+	if (file)
+	  {
+	    found = 1;
+	    grub_file_close (file);
+	  }
+	grub_free (buf);
+      }
+#else
+      {
+	/* SEARCH_FS_UUID or SEARCH_LABEL */
+	grub_device_t dev;
+	grub_fs_t fs;
+	char *quid;
+
+	dev = grub_device_open (name);
+	if (dev)
+	  {
+	    fs = grub_fs_probe (dev);
+
+#ifdef DO_SEARCH_FS_UUID
+#define compare_fn grub_strcasecmp
+#define read_fn uuid
+#else
+#define compare_fn grub_strcmp
+#define read_fn label
+#endif
+
+	    if (fs && fs->read_fn)
+	      {
+		fs->read_fn (dev, &quid);
+
+		if (grub_errno == GRUB_ERR_NONE && quid)
+		  {
+		    if (compare_fn (quid, key) == 0)
+		      found = 1;
+
+		    grub_free (quid);
+		  }
+	      }
+
+	    grub_device_close (dev);
+	  }
+      }
+#endif
+
+    if (found)
+      {
+	count++;
+	if (var)
+	  grub_env_set (var, name);
+	else
+	  grub_printf (" %s", name);
+      }
+
+    grub_errno = GRUB_ERR_NONE;
+    return (found && var);
+  }
+
+  /* First try without autoloading if we're setting variable. */
+  if (var)
+    {
+      saved_autoload = grub_fs_autoload_hook;
+      grub_fs_autoload_hook = 0;
+      grub_device_iterate (iterate_device);
+
+      /* Restore autoload hook.  */
+      grub_fs_autoload_hook = saved_autoload;
+
+      /* Retry with autoload if nothing found.  */
+      if (grub_errno == GRUB_ERR_NONE && count == 0)
+	grub_device_iterate (iterate_device);
+    }
+  else
+    grub_device_iterate (iterate_device);
+
+  if (grub_errno == GRUB_ERR_NONE && count == 0)
+    grub_error (GRUB_ERR_FILE_NOT_FOUND, "no such device: %s", key);
+}
+
+static grub_err_t
+grub_cmd_do_search (grub_command_t cmd __attribute__ ((unused)), int argc,
+		    char **args)
+{
+  if (argc == 0)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "no argument specified");
+
+  FUNC_NAME (args[0], argc == 1 ? 0 : args[1], 0);
+
+  return grub_errno;
+}
+
+static grub_command_t cmd;
+
+#ifdef DO_SEARCH_FILE
+GRUB_MOD_INIT(search_fs_file)
+#elif defined (DO_SEARCH_FS_UUID)
+GRUB_MOD_INIT(search_fs_uuid)
+#else
+GRUB_MOD_INIT(search_label)
+#endif
+{
+  cmd =
+    grub_register_command (COMMAND_NAME, grub_cmd_do_search,
+			   N_("NAME [VARIABLE]"),
+			   HELP_MESSAGE);
+}
+
+#ifdef DO_SEARCH_FILE
+GRUB_MOD_FINI(search_fs_file)
+#elif defined (DO_SEARCH_FS_UUID)
+GRUB_MOD_FINI(search_fs_uuid)
+#else
+GRUB_MOD_FINI(search_label)
+#endif
+{
+  grub_unregister_command (cmd);
+}

grub-core/commands/search_file.c

@@ -0,0 +1,6 @@
+#define DO_SEARCH_FILE 1
+#define FUNC_NAME grub_search_fs_file
+#define COMMAND_NAME "search.file"
+#define SEARCH_TARGET "file"
+#define HELP_MESSAGE N_("Search devices by file. If VARIABLE is specified, the first device found is set to a variable.")
+#include "search.c"

grub-core/commands/search_label.c

@@ -0,0 +1,6 @@
+#define DO_SEARCH_FS_LABEL 1
+#define FUNC_NAME grub_search_label
+#define COMMAND_NAME "search.fs_label"
+#define SEARCH_TARGET "filesystem label"
+#define HELP_MESSAGE N_("Search devices by label. If VARIABLE is specified, the first device found is set to a variable.")
+#include "search.c"

grub-core/commands/search_uuid.c

@@ -0,0 +1,6 @@
+#define DO_SEARCH_FS_UUID 1
+#define FUNC_NAME grub_search_fs_uuid
+#define COMMAND_NAME "search.fs_uuid"
+#define SEARCH_TARGET "filesystem UUID"
+#define HELP_MESSAGE N_("Search devices by UUID. If VARIABLE is specified, the first device found is set to a variable.")
+#include "search.c"

grub-core/commands/search_wrap.c

@@ -0,0 +1,95 @@
+/* search.c - search devices based on a file or a filesystem label */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2005,2007,2008,2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/types.h>
+#include <grub/misc.h>
+#include <grub/mm.h>
+#include <grub/err.h>
+#include <grub/dl.h>
+#include <grub/env.h>
+#include <grub/extcmd.h>
+#include <grub/search.h>
+#include <grub/i18n.h>
+
+static const struct grub_arg_option options[] =
+  {
+    {"file",		'f', 0, N_("Search devices by a file."), 0, 0},
+    {"label",		'l', 0, N_("Search devices by a filesystem label."),
+     0, 0},
+    {"fs-uuid",		'u', 0, N_("Search devices by a filesystem UUID."),
+     0, 0},
+    {"set",		's', GRUB_ARG_OPTION_OPTIONAL,
+     N_("Set a variable to the first device found."), "VAR", ARG_TYPE_STRING},
+    {"no-floppy",	'n', 0, N_("Do not probe any floppy drive."), 0, 0},
+    {0, 0, 0, 0, 0, 0}
+  };
+
+enum options
+  {
+    SEARCH_FILE,
+    SEARCH_LABEL,
+    SEARCH_FS_UUID,
+    SEARCH_SET,
+    SEARCH_NO_FLOPPY,
+ };
+
+static grub_err_t
+grub_cmd_search (grub_extcmd_t cmd, int argc, char **args)
+{
+  struct grub_arg_list *state = cmd->state;
+  const char *var = 0;
+
+  if (argc == 0)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "no argument specified");
+
+  if (state[SEARCH_SET].set)
+    var = state[SEARCH_SET].arg ? state[SEARCH_SET].arg : "root";
+
+  if (state[SEARCH_LABEL].set)
+    grub_search_label (args[0], var, state[SEARCH_NO_FLOPPY].set);
+  else if (state[SEARCH_FS_UUID].set)
+    grub_search_fs_uuid (args[0], var, state[SEARCH_NO_FLOPPY].set);
+  else if (state[SEARCH_FILE].set)
+    grub_search_fs_file (args[0], var, state[SEARCH_NO_FLOPPY].set);
+  else
+    return grub_error (GRUB_ERR_INVALID_COMMAND, "unspecified search type");
+
+  return grub_errno;
+}
+
+static grub_extcmd_t cmd;
+
+GRUB_MOD_INIT(search)
+{
+  cmd =
+    grub_register_extcmd ("search", grub_cmd_search,
+			  GRUB_COMMAND_FLAG_BOTH,
+			  N_("search [-f|-l|-u|-s|-n] NAME"),
+			  N_("Search devices by file, filesystem label"
+			     " or filesystem UUID."
+			     " If --set is specified, the first device found is"
+			     " set to a variable. If no variable name is"
+			     " specified, \"root\" is used."),
+			  options);
+}
+
+GRUB_MOD_FINI(search)
+{
+  grub_unregister_extcmd (cmd);
+}

grub-core/commands/setpci.c

@@ -0,0 +1,341 @@
+/* lspci.c - List PCI devices.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008, 2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/pci.h>
+#include <grub/dl.h>
+#include <grub/misc.h>
+#include <grub/extcmd.h>
+#include <grub/env.h>
+#include <grub/mm.h>
+#include <grub/i18n.h>
+
+struct pci_register
+{
+  const char *name;
+  grub_uint16_t addr;
+  unsigned size;
+};
+
+struct pci_register pci_registers[] =
+  {
+    {"VENDOR_ID",       GRUB_PCI_REG_VENDOR      , 2},
+    {"DEVICE_ID",       GRUB_PCI_REG_DEVICE      , 2},
+    {"COMMAND",         GRUB_PCI_REG_COMMAND     , 2},
+    {"STATUS",          GRUB_PCI_REG_STATUS      , 2},
+    {"REVISION",        GRUB_PCI_REG_REVISION    , 1},
+    {"CLASS_PROG",      GRUB_PCI_REG_CLASS + 1   , 1},
+    {"CLASS_DEVICE",    GRUB_PCI_REG_CLASS + 2   , 2},
+    {"CACHE_LINE_SIZE", GRUB_PCI_REG_CACHELINE   , 1},
+    {"LATENCY_TIMER",   GRUB_PCI_REG_LAT_TIMER   , 1},
+    {"HEADER_TYPE",     GRUB_PCI_REG_HEADER_TYPE , 1},
+    {"BIST",            GRUB_PCI_REG_BIST        , 1},
+    {"BASE_ADDRESS_0",  GRUB_PCI_REG_ADDRESS_REG0, 4},
+    {"BASE_ADDRESS_1",  GRUB_PCI_REG_ADDRESS_REG1, 4},
+    {"BASE_ADDRESS_2",  GRUB_PCI_REG_ADDRESS_REG2, 4},
+    {"BASE_ADDRESS_3",  GRUB_PCI_REG_ADDRESS_REG3, 4},
+    {"BASE_ADDRESS_4",  GRUB_PCI_REG_ADDRESS_REG4, 4},
+    {"BASE_ADDRESS_5",  GRUB_PCI_REG_ADDRESS_REG5, 4},
+    {"CARDBUS_CIS",     GRUB_PCI_REG_CIS_POINTER , 4},
+    {"SUBVENDOR_ID",    GRUB_PCI_REG_SUBVENDOR   , 2},
+    {"SUBSYSTEM_ID",    GRUB_PCI_REG_SUBSYSTEM   , 2},
+    {"ROM_ADDRESS",     GRUB_PCI_REG_ROM_ADDRESS , 4},
+    {"CAP_POINTER",     GRUB_PCI_REG_CAP_POINTER , 1},
+    {"INTERRUPT_LINE",  GRUB_PCI_REG_IRQ_LINE    , 1},
+    {"INTERRUPT_PIN",   GRUB_PCI_REG_IRQ_PIN     , 1},
+    {"MIN_GNT",         GRUB_PCI_REG_MIN_GNT     , 1},
+    {"MAX_LAT",         GRUB_PCI_REG_MIN_GNT     , 1},
+  };
+
+static const struct grub_arg_option options[] =
+  {
+    {0, 'd', 0, "Select device by vendor and device IDs.",
+     "[vendor]:[device]", ARG_TYPE_STRING},
+    {0, 's', 0, "Select device by its position on the bus.",
+     "[bus]:[slot][.func]", ARG_TYPE_STRING},
+    {0, 'v', 0, "Save read value into variable VARNAME.",
+     "VARNAME", ARG_TYPE_STRING},
+    {0, 0, 0, 0, 0, 0}
+  };
+
+static grub_uint32_t pciid_check_mask, pciid_check_value;
+static int bus, device, function;
+static int check_bus, check_device, check_function;
+static grub_uint32_t write_mask, regwrite;
+static int regsize;
+static grub_uint16_t regaddr;
+static const char *varname;
+
+static int NESTED_FUNC_ATTR
+grub_setpci_iter (grub_pci_device_t dev, grub_pci_id_t pciid)
+{
+  grub_uint32_t regval = 0;
+  grub_pci_address_t addr;
+
+  if ((pciid & pciid_check_mask) != pciid_check_value)
+    return 0;
+
+  if (check_bus && grub_pci_get_bus (dev) != bus)
+    return 0;
+
+  if (check_device && grub_pci_get_device (dev) != device)
+    return 0;
+
+  if (check_function && grub_pci_get_function (dev) != device)
+    return 0;
+
+  addr = grub_pci_make_address (dev, regaddr);
+
+  switch (regsize)
+    {
+    case 1:
+      regval = grub_pci_read_byte (addr);
+      break;
+
+    case 2:
+      regval = grub_pci_read_word (addr);
+      break;
+
+    case 4:
+      regval = grub_pci_read (addr);
+      break;
+    }
+
+  if (varname)
+    {
+      char buf[sizeof ("XXXXXXXX")];
+      grub_snprintf (buf, sizeof (buf), "%x", regval);
+      grub_env_set (varname, buf);
+      return 1;
+    }
+
+  if (!write_mask)
+    {
+      grub_printf ("Register %x of %d:%d.%d is %x\n", regaddr,
+		   grub_pci_get_bus (dev),
+		   grub_pci_get_device (dev),
+		   grub_pci_get_function (dev),
+		   regval);
+      return 0;
+    }
+
+  regval = (regval & ~write_mask) | regwrite;
+
+  switch (regsize)
+    {
+    case 1:
+      grub_pci_write_byte (addr, regval);
+      break;
+
+    case 2:
+      grub_pci_write_word (addr, regval);
+      break;
+
+    case 4:
+      grub_pci_write (addr, regval);
+      break;
+    }
+
+  return 0;
+}
+
+static grub_err_t
+grub_cmd_setpci (grub_extcmd_t cmd, int argc, char **argv)
+{
+  const char *ptr;
+  unsigned i;
+
+  pciid_check_value = 0;
+  pciid_check_mask = 0;
+
+  if (cmd->state[0].set)
+    {
+      ptr = cmd->state[0].arg;
+      pciid_check_value |= (grub_strtoul (ptr, (char **) &ptr, 16) & 0xffff);
+      if (grub_errno == GRUB_ERR_BAD_NUMBER)
+	{
+	  grub_errno = GRUB_ERR_NONE;
+	  ptr = cmd->state[0].arg;
+	}
+      else
+	pciid_check_mask |= 0xffff;
+      if (grub_errno)
+	return grub_errno;
+      if (*ptr != ':')
+	return grub_error (GRUB_ERR_BAD_ARGUMENT, "Colon expected.");
+      ptr++;
+      pciid_check_value |= (grub_strtoul (ptr, (char **) &ptr, 16) & 0xffff)
+	<< 16;
+      if (grub_errno == GRUB_ERR_BAD_NUMBER)
+	grub_errno = GRUB_ERR_NONE;
+      else
+	pciid_check_mask |= 0xffff0000;
+    }
+
+  pciid_check_value &= pciid_check_mask;
+
+  check_bus = check_device = check_function = 0;
+
+  if (cmd->state[1].set)
+    {
+      const char *optr;
+      
+      ptr = cmd->state[1].arg;
+      optr = ptr;
+      bus = grub_strtoul (ptr, (char **) &ptr, 16);
+      if (grub_errno == GRUB_ERR_BAD_NUMBER)
+	{
+	  grub_errno = GRUB_ERR_NONE;
+	  ptr = optr;
+	}
+      else
+	check_bus = 1;
+      if (grub_errno)
+	return grub_errno;
+      if (*ptr != ':')
+	return grub_error (GRUB_ERR_BAD_ARGUMENT, "Colon expected.");
+      ptr++;
+      optr = ptr;
+      device = grub_strtoul (ptr, (char **) &ptr, 16);
+      if (grub_errno == GRUB_ERR_BAD_NUMBER)
+	{
+	  grub_errno = GRUB_ERR_NONE;
+	  ptr = optr;
+	}
+      else
+	check_device = 1;
+      if (*ptr == '.')
+	{
+	  ptr++;
+	  function = grub_strtoul (ptr, (char **) &ptr, 16);
+	  if (grub_errno)
+	    return grub_errno;
+	  check_function = 1;
+	}
+    }
+
+  if (cmd->state[2].set)
+    varname = cmd->state[2].arg;
+  else
+    varname = NULL;
+
+  write_mask = 0;
+
+  if (argc == 0)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "Command expected.");
+
+  if (argc > 1)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "Only one command is supported.");
+
+  ptr = argv[0];
+
+  for (i = 0; i < ARRAY_SIZE (pci_registers); i++)
+    {
+      if (grub_strncmp (ptr, pci_registers[i].name,
+			grub_strlen (pci_registers[i].name)) == 0)
+	break;
+    }
+  if (i == ARRAY_SIZE (pci_registers))
+    {
+      regsize = 0;
+      regaddr = grub_strtoul (ptr, (char **) &ptr, 16);
+      if (grub_errno)
+	return grub_error (GRUB_ERR_BAD_ARGUMENT, "Unknown register");
+    }
+  else
+    {
+      regaddr = pci_registers[i].addr;
+      regsize = pci_registers[i].size;
+      ptr += grub_strlen (pci_registers[i].name);
+    }
+
+  if (grub_errno)
+    return grub_errno;
+
+  if (*ptr == '+')
+    {
+      ptr++;
+      regaddr += grub_strtoul (ptr, (char **) &ptr, 16);
+      if (grub_errno)
+	return grub_errno;
+    }
+
+  if (grub_memcmp (ptr, ".L", sizeof (".L") - 1) == 0
+      || grub_memcmp (ptr, ".l", sizeof (".l") - 1) == 0)
+    {
+      regsize = 4;
+      ptr += sizeof (".l") - 1;
+    }
+  else if (grub_memcmp (ptr, ".W", sizeof (".W") - 1) == 0
+      || grub_memcmp (ptr, ".w", sizeof (".w") - 1) == 0)
+    {
+      regsize = 2;
+      ptr += sizeof (".w") - 1;
+    }
+  else if (grub_memcmp (ptr, ".B", sizeof (".B") - 1) == 0
+      || grub_memcmp (ptr, ".b", sizeof (".b") - 1) == 0)
+    {
+      regsize = 1;
+      ptr += sizeof (".b") - 1;
+    }
+
+  if (!regsize)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT,
+		       "Unknown register size.");
+
+  write_mask = 0;
+  if (*ptr == '=')
+    {
+      ptr++;
+      regwrite = grub_strtoul (ptr, (char **) &ptr, 16);
+      if (grub_errno)
+	return grub_errno;
+      write_mask = 0xffffffff;
+      if (*ptr == ':')
+	{
+	  ptr++;
+	  write_mask = grub_strtoul (ptr, (char **) &ptr, 16);
+	  if (grub_errno)
+	    return grub_errno;
+	  write_mask = 0xffffffff;
+	}
+      regwrite &= write_mask;
+    }
+
+  if (write_mask && varname)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT,
+		       "Option -v isn't valid for writes.");
+
+  grub_pci_iterate (grub_setpci_iter);
+  return GRUB_ERR_NONE;
+}
+
+static grub_extcmd_t cmd;
+
+GRUB_MOD_INIT(setpci)
+{
+  cmd = grub_register_extcmd ("setpci", grub_cmd_setpci, GRUB_COMMAND_FLAG_BOTH,
+			      N_("[-s POSITION] [-d DEVICE] [-v VAR] "
+				 "[REGISTER][=VALUE[:MASK]]"),
+			      N_("Manipulate PCI devices."), options);
+}
+
+GRUB_MOD_FINI(setpci)
+{
+  grub_unregister_extcmd (cmd);
+}

grub-core/commands/sleep.c

@@ -0,0 +1,113 @@
+/* sleep.c - Command to wait a specified number of seconds.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2006,2007,2008  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/dl.h>
+#include <grub/term.h>
+#include <grub/time.h>
+#include <grub/types.h>
+#include <grub/misc.h>
+#include <grub/extcmd.h>
+#include <grub/i18n.h>
+
+static const struct grub_arg_option options[] =
+  {
+    {"verbose", 'v', 0, N_("Verbose countdown."), 0, 0},
+    {"interruptible", 'i', 0, N_("Interruptible with ESC."), 0, 0},
+    {0, 0, 0, 0, 0, 0}
+  };
+
+static grub_uint16_t *pos;
+
+static void
+do_print (int n)
+{
+  grub_term_restore_pos (pos);
+  /* NOTE: Do not remove the trailing space characters.
+     They are required to clear the line.  */
+  grub_printf ("%d    ", n);
+}
+
+/* Based on grub_millisleep() from kern/generic/millisleep.c.  */
+static int
+grub_interruptible_millisleep (grub_uint32_t ms)
+{
+  grub_uint64_t start;
+
+  start = grub_get_time_ms ();
+
+  while (grub_get_time_ms () - start < ms)
+    if (grub_checkkey () >= 0 &&
+	GRUB_TERM_ASCII_CHAR (grub_getkey ()) == GRUB_TERM_ESC)
+      return 1;
+
+  return 0;
+}
+
+static grub_err_t
+grub_cmd_sleep (grub_extcmd_t cmd, int argc, char **args)
+{
+  struct grub_arg_list *state = cmd->state;
+  int n;
+
+  if (argc != 1)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "missing operand");
+
+  n = grub_strtoul (args[0], 0, 10);
+
+  if (n == 0)
+    {
+      /* Either `0' or broken input.  */
+      return 0;
+    }
+
+  pos = grub_term_save_pos ();
+
+  for (; n; n--)
+    {
+      if (state[0].set)
+	do_print (n);
+
+      if (state[1].set)
+	{
+	  if (grub_interruptible_millisleep (1000))
+	    return 1;
+	}
+      else
+	grub_millisleep (1000);
+    }
+  if (state[0].set)
+    do_print (0);
+
+  return 0;
+}
+
+static grub_extcmd_t cmd;
+
+GRUB_MOD_INIT(sleep)
+{
+  cmd = grub_register_extcmd ("sleep", grub_cmd_sleep, GRUB_COMMAND_FLAG_BOTH,
+			      N_("NUMBER_OF_SECONDS"),
+			      N_("Wait for a specified number of seconds."),
+			      options);
+}
+
+GRUB_MOD_FINI(sleep)
+{
+  grub_unregister_extcmd (cmd);
+}

grub-core/commands/terminal.c

@@ -0,0 +1,246 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2009,2010  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/mm.h>
+#include <grub/dl.h>
+#include <grub/command.h>
+#include <grub/term.h>
+#include <grub/i18n.h>
+#include <grub/misc.h>
+
+struct grub_term_autoload *grub_term_input_autoload = NULL;
+struct grub_term_autoload *grub_term_output_autoload = NULL;
+
+struct abstract_terminal
+{
+  struct abstract_terminal *next;
+  const char *name;
+  grub_err_t (*init) (void);
+  grub_err_t (*fini) (void);
+};
+
+static grub_err_t
+handle_command (int argc, char **args, struct abstract_terminal **enabled,
+               struct abstract_terminal **disabled,
+               struct grub_term_autoload *autoloads,
+               const char *active_str,
+               const char *available_str)
+{
+  int i;
+  struct abstract_terminal *term;
+  struct grub_term_autoload *aut;
+
+  if (argc == 0)
+    {
+      grub_puts_ (active_str);
+      for (term = *enabled; term; term = term->next)
+       grub_printf ("%s ", term->name);
+      grub_printf ("\n");
+      grub_puts_ (available_str);
+      for (term = *disabled; term; term = term->next)
+       grub_printf ("%s ", term->name);
+      /* This is quadratic but we don't expect mode than 30 terminal
+        modules ever.  */
+      for (aut = autoloads; aut; aut = aut->next)
+       {
+         for (term = *disabled; term; term = term->next)
+           if (grub_strcmp (term->name, aut->name) == 0)
+             break;
+         if (!term)
+           for (term = *enabled; term; term = term->next)
+             if (grub_strcmp (term->name, aut->name) == 0)
+               break;
+         if (!term)
+           grub_printf ("%s ", aut->name);
+       }
+      grub_printf ("\n");
+      return GRUB_ERR_NONE;
+    }
+  i = 0;
+
+  if (grub_strcmp (args[0], "--append") == 0
+      || grub_strcmp (args[0], "--remove") == 0)
+    i++;
+
+  if (i == argc)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, N_ ("no terminal specified"));
+
+  for (; i < argc; i++)
+    {
+      int again = 0;
+      while (1)
+       {
+         for (term = *disabled; term; term = term->next)
+           if (grub_strcmp (args[i], term->name) == 0)
+             break;
+         if (term == 0)
+           for (term = *enabled; term; term = term->next)
+             if (grub_strcmp (args[i], term->name) == 0)
+               break;
+         if (term)
+           break;
+         if (again)
+           return grub_error (GRUB_ERR_BAD_ARGUMENT, "unknown terminal '%s'\n",
+                              args[i]);
+         for (aut = autoloads; aut; aut = aut->next)
+           if (grub_strcmp (args[i], aut->name) == 0)
+             {
+               grub_dl_t mod;
+               mod = grub_dl_load (aut->modname);
+               if (mod)
+                 grub_dl_ref (mod);
+               grub_errno = GRUB_ERR_NONE;
+               break;
+             }
+         if (!aut)
+           return grub_error (GRUB_ERR_BAD_ARGUMENT, "unknown terminal '%s'\n",
+                              args[i]);
+         again = 1;
+       }
+    }
+
+  if (grub_strcmp (args[0], "--append") == 0)
+    {
+      for (i = 1; i < argc; i++)
+       {
+         for (term = *disabled; term; term = term->next)
+           if (grub_strcmp (args[i], term->name) == 0)
+             break;
+         if (term)
+           {
+              if (term->init && term->init () != GRUB_ERR_NONE)
+                return grub_errno;
+
+             grub_list_remove (GRUB_AS_LIST_P (disabled), GRUB_AS_LIST (term));
+             grub_list_push (GRUB_AS_LIST_P (enabled), GRUB_AS_LIST (term));
+           }
+       }
+      return GRUB_ERR_NONE;
+    }
+
+  if (grub_strcmp (args[0], "--remove") == 0)
+    {
+      for (i = 1; i < argc; i++)
+       {
+         for (term = *enabled; term; term = term->next)
+           if (grub_strcmp (args[i], term->name) == 0)
+             break;
+         if (term)
+           {
+             if (!term->next && term == *enabled)
+               return grub_error (GRUB_ERR_BAD_ARGUMENT,
+                                  "can't remove the last terminal");
+             grub_list_remove (GRUB_AS_LIST_P (enabled), GRUB_AS_LIST (term));
+             if (term->fini)
+               term->fini ();
+             grub_list_push (GRUB_AS_LIST_P (disabled), GRUB_AS_LIST (term));
+           }
+       }
+      return GRUB_ERR_NONE;
+    }
+  for (i = 0; i < argc; i++)
+    {
+      for (term = *disabled; term; term = term->next)
+       if (grub_strcmp (args[i], term->name) == 0)
+         break;
+      if (term)
+       {
+         if (term->init && term->init () != GRUB_ERR_NONE)
+           return grub_errno;
+
+         grub_list_remove (GRUB_AS_LIST_P (disabled), GRUB_AS_LIST (term));
+         grub_list_push (GRUB_AS_LIST_P (enabled), GRUB_AS_LIST (term));
+       }       
+    }
+  
+  {
+    struct abstract_terminal *next;
+    for (term = *enabled; term; term = next)
+      {
+       next = term->next;
+       for (i = 0; i < argc; i++)
+         if (grub_strcmp (args[i], term->name) == 0)
+           break;
+       if (i == argc)
+         {
+           if (!term->next && term == *enabled)
+             return grub_error (GRUB_ERR_BAD_ARGUMENT,
+                                "can't remove the last terminal");
+           grub_list_remove (GRUB_AS_LIST_P (enabled), GRUB_AS_LIST (term));
+           if (term->fini)
+             term->fini ();
+           grub_list_push (GRUB_AS_LIST_P (disabled), GRUB_AS_LIST (term));
+         }
+      }
+  }
+
+  return GRUB_ERR_NONE;
+}
+
+static grub_err_t
+grub_cmd_terminal_input (grub_command_t cmd __attribute__ ((unused)),
+			 int argc, char **args)
+{
+  (void) GRUB_FIELD_MATCH (grub_term_inputs, struct abstract_terminal *, next);
+  (void) GRUB_FIELD_MATCH (grub_term_inputs, struct abstract_terminal *, name);
+  (void) GRUB_FIELD_MATCH (grub_term_inputs, struct abstract_terminal *, init);
+  (void) GRUB_FIELD_MATCH (grub_term_inputs, struct abstract_terminal *, fini);
+  return handle_command (argc, args,
+                        (struct abstract_terminal **) &grub_term_inputs,
+                        (struct abstract_terminal **) &grub_term_inputs_disabled,
+                        grub_term_input_autoload,
+                        N_ ("Active input terminals:"),
+                        N_ ("Available input terminals:"));
+}
+
+static grub_err_t
+grub_cmd_terminal_output (grub_command_t cmd __attribute__ ((unused)),
+                         int argc, char **args)
+{
+  (void) GRUB_FIELD_MATCH (grub_term_outputs, struct abstract_terminal *, next);
+  (void) GRUB_FIELD_MATCH (grub_term_outputs, struct abstract_terminal *, name);
+  (void) GRUB_FIELD_MATCH (grub_term_outputs, struct abstract_terminal *, init);
+  (void) GRUB_FIELD_MATCH (grub_term_outputs, struct abstract_terminal *, fini);
+  return handle_command (argc, args, (struct abstract_terminal **) &grub_term_outputs,
+                        (struct abstract_terminal **) &grub_term_outputs_disabled,
+                        grub_term_output_autoload,
+                        N_ ("Active output terminals:"),
+                        N_ ("Available output terminals:"));
+}
+
+static grub_command_t cmd_terminal_input, cmd_terminal_output;
+
+GRUB_MOD_INIT(terminal)
+{
+  cmd_terminal_input =
+    grub_register_command ("terminal_input", grub_cmd_terminal_input,
+			   N_("[--append|--remove] "
+			      "[TERMINAL1] [TERMINAL2] ..."),
+			   N_("List or select an input terminal."));
+  cmd_terminal_output =
+    grub_register_command ("terminal_output", grub_cmd_terminal_output,
+			   N_("[--append|--remove] "
+			      "[TERMINAL1] [TERMINAL2] ..."),
+			   N_("List or select an output terminal."));
+}
+
+GRUB_MOD_FINI(terminal)
+{
+  grub_unregister_command (cmd_terminal_input);
+  grub_unregister_command (cmd_terminal_output);
+}

grub-core/commands/test.c

@@ -0,0 +1,433 @@
+/* test.c -- The test command..  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2005,2007,2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/dl.h>
+#include <grub/misc.h>
+#include <grub/mm.h>
+#include <grub/env.h>
+#include <grub/fs.h>
+#include <grub/device.h>
+#include <grub/file.h>
+#include <grub/command.h>
+#include <grub/i18n.h>
+
+/* A simple implementation for signed numbers. */
+static int
+grub_strtosl (char *arg, char **end, int base)
+{
+  if (arg[0] == '-')
+    return -grub_strtoul (arg + 1, end, base);
+  return grub_strtoul (arg, end, base);
+}
+
+/* Parse a test expression starting from *argn. */
+static int
+test_parse (char **args, int *argn, int argc)
+{
+  int ret = 0, discard = 0, invert = 0;
+  int file_exists;
+  struct grub_dirhook_info file_info;
+
+  auto void update_val (int val);
+  auto void get_fileinfo (char *pathname);
+
+  /* Take care of discarding and inverting. */
+  void update_val (int val)
+  {
+    if (! discard)
+      ret = invert ? ! val : val;
+    invert = discard = 0;
+  }
+
+  /* Check if file exists and fetch its information. */
+  void get_fileinfo (char *path)
+  {
+    char *filename, *pathname;
+    char *device_name;
+    grub_fs_t fs;
+    grub_device_t dev;
+
+    /* A hook for iterating directories. */
+    auto int find_file (const char *cur_filename,
+			const struct grub_dirhook_info *info);
+    int find_file (const char *cur_filename,
+		   const struct grub_dirhook_info *info)
+    {
+      if ((info->case_insensitive ? grub_strcasecmp (cur_filename, filename)
+	   : grub_strcmp (cur_filename, filename)) == 0)
+	{
+	  file_info = *info;
+	  file_exists = 1;
+	  return 1;
+	}
+      return 0;
+    }
+
+    file_exists = 0;
+    device_name = grub_file_get_device_name (path);
+    dev = grub_device_open (device_name);
+    if (! dev)
+      {
+	grub_free (device_name);
+	return;
+      }
+
+    fs = grub_fs_probe (dev);
+    if (! fs)
+      {
+	grub_free (device_name);
+	grub_device_close (dev);
+	return;
+      }
+
+    pathname = grub_strchr (path, ')');
+    if (! pathname)
+      pathname = path;
+    else
+      pathname++;
+
+    /* Remove trailing '/'. */
+    while (*pathname && pathname[grub_strlen (pathname) - 1] == '/')
+      pathname[grub_strlen (pathname) - 1] = 0;
+
+    /* Split into path and filename. */
+    filename = grub_strrchr (pathname, '/');
+    if (! filename)
+      {
+	path = grub_strdup ("/");
+	filename = pathname;
+      }
+    else
+      {
+	filename++;
+	path = grub_strdup (pathname);
+	path[filename - pathname] = 0;
+      }
+
+    /* It's the whole device. */
+    if (! *pathname)
+      {
+	file_exists = 1;
+	grub_memset (&file_info, 0, sizeof (file_info));
+	/* Root is always a directory. */
+	file_info.dir = 1;
+
+	/* Fetch writing time. */
+	file_info.mtimeset = 0;
+	if (fs->mtime)
+	  {
+	    if (! fs->mtime (dev, &file_info.mtime))
+	      file_info.mtimeset = 1;
+	    grub_errno = GRUB_ERR_NONE;
+	  }
+      }
+    else
+      (fs->dir) (dev, path, find_file);
+
+    grub_device_close (dev);
+    grub_free (path);
+    grub_free (device_name);
+  }
+
+  /* Here we have the real parsing. */
+  while (*argn < argc)
+    {
+      /* First try 3 argument tests. */
+      if (*argn + 2 < argc)
+	{
+	  /* String tests. */
+	  if (grub_strcmp (args[*argn + 1], "=") == 0
+	      || grub_strcmp (args[*argn + 1], "==") == 0)
+	    {
+	      update_val (grub_strcmp (args[*argn], args[*argn + 2]) == 0);
+	      (*argn) += 3;
+	      continue;
+	    }
+
+	  if (grub_strcmp (args[*argn + 1], "!=") == 0)
+	    {
+	      update_val (grub_strcmp (args[*argn], args[*argn + 2]) != 0);
+	      (*argn) += 3;
+	      continue;
+	    }
+
+	  /* GRUB extension: lexicographical sorting. */
+	  if (grub_strcmp (args[*argn + 1], "<") == 0)
+	    {
+	      update_val (grub_strcmp (args[*argn], args[*argn + 2]) < 0);
+	      (*argn) += 3;
+	      continue;
+	    }
+
+	  if (grub_strcmp (args[*argn + 1], "<=") == 0)
+	    {
+	      update_val (grub_strcmp (args[*argn], args[*argn + 2]) <= 0);
+	      (*argn) += 3;
+	      continue;
+	    }
+
+	  if (grub_strcmp (args[*argn + 1], ">") == 0)
+	    {
+	      update_val (grub_strcmp (args[*argn], args[*argn + 2]) > 0);
+	      (*argn) += 3;
+	      continue;
+	    }
+
+	  if (grub_strcmp (args[*argn + 1], ">=") == 0)
+	    {
+	      update_val (grub_strcmp (args[*argn], args[*argn + 2]) >= 0);
+	      (*argn) += 3;
+	      continue;
+	    }
+
+	  /* Number tests. */
+	  if (grub_strcmp (args[*argn + 1], "-eq") == 0)
+	    {
+	      update_val (grub_strtosl (args[*argn], 0, 0)
+			  == grub_strtosl (args[*argn + 2], 0, 0));
+	      (*argn) += 3;
+	      continue;
+	    }
+
+	  if (grub_strcmp (args[*argn + 1], "-ge") == 0)
+	    {
+	      update_val (grub_strtosl (args[*argn], 0, 0)
+			  >= grub_strtosl (args[*argn + 2], 0, 0));
+	      (*argn) += 3;
+	      continue;
+	    }
+
+	  if (grub_strcmp (args[*argn + 1], "-gt") == 0)
+	    {
+	      update_val (grub_strtosl (args[*argn], 0, 0)
+			  > grub_strtosl (args[*argn + 2], 0, 0));
+	      (*argn) += 3;
+	      continue;
+	    }
+
+	  if (grub_strcmp (args[*argn + 1], "-le") == 0)
+	    {
+	      update_val (grub_strtosl (args[*argn], 0, 0)
+		      <= grub_strtosl (args[*argn + 2], 0, 0));
+	      (*argn) += 3;
+	      continue;
+	    }
+
+	  if (grub_strcmp (args[*argn + 1], "-lt") == 0)
+	    {
+	      update_val (grub_strtosl (args[*argn], 0, 0)
+			  < grub_strtosl (args[*argn + 2], 0, 0));
+	      (*argn) += 3;
+	      continue;
+	    }
+
+	  if (grub_strcmp (args[*argn + 1], "-ne") == 0)
+	    {
+	      update_val (grub_strtosl (args[*argn], 0, 0)
+			  != grub_strtosl (args[*argn + 2], 0, 0));
+	      (*argn) += 3;
+	      continue;
+	    }
+
+	  /* GRUB extension: compare numbers skipping prefixes.
+	     Useful for comparing versions. E.g. vmlinuz-2 -plt vmlinuz-11. */
+	  if (grub_strcmp (args[*argn + 1], "-pgt") == 0
+	      || grub_strcmp (args[*argn + 1], "-plt") == 0)
+	    {
+	      int i;
+	      /* Skip common prefix. */
+	      for (i = 0; args[*argn][i] == args[*argn + 2][i]
+		     && args[*argn][i]; i++);
+
+	      /* Go the digits back. */
+	      i--;
+	      while (grub_isdigit (args[*argn][i]) && i > 0)
+		i--;
+	      i++;
+
+	      if (grub_strcmp (args[*argn + 1], "-pgt") == 0)
+		update_val (grub_strtoul (args[*argn] + i, 0, 0)
+			    > grub_strtoul (args[*argn + 2] + i, 0, 0));
+	      else
+		update_val (grub_strtoul (args[*argn] + i, 0, 0)
+			    < grub_strtoul (args[*argn + 2] + i, 0, 0));
+	      (*argn) += 3;
+	      continue;
+	    }
+
+	  /* -nt and -ot tests. GRUB extension: when doing -?t<bias> bias
+	     will be added to the first mtime. */
+	  if (grub_memcmp (args[*argn + 1], "-nt", 3) == 0
+	      || grub_memcmp (args[*argn + 1], "-ot", 3) == 0)
+	    {
+	      struct grub_dirhook_info file1;
+	      int file1exists;
+	      int bias = 0;
+
+	      /* Fetch fileinfo. */
+	      get_fileinfo (args[*argn]);
+	      file1 = file_info;
+	      file1exists = file_exists;
+	      get_fileinfo (args[*argn + 2]);
+
+	      if (args[*argn + 1][3])
+		bias = grub_strtosl (args[*argn + 1] + 3, 0, 0);
+
+	      if (grub_memcmp (args[*argn + 1], "-nt", 3) == 0)
+		update_val ((file1exists && ! file_exists)
+			    || (file1.mtimeset && file_info.mtimeset
+				&& file1.mtime + bias > file_info.mtime));
+	      else
+		update_val ((! file1exists && file_exists)
+			    || (file1.mtimeset && file_info.mtimeset
+				&& file1.mtime + bias < file_info.mtime));
+	      (*argn) += 3;
+	      continue;
+	    }
+	}
+
+      /* Two-argument tests. */
+      if (*argn + 1 < argc)
+	{
+	  /* File tests. */
+	  if (grub_strcmp (args[*argn], "-d") == 0)
+	    {
+	      get_fileinfo (args[*argn + 1]);
+	      update_val (file_exists && file_info.dir);
+	      (*argn) += 2;
+	      return ret;
+	    }
+
+	  if (grub_strcmp (args[*argn], "-e") == 0)
+	    {
+	      get_fileinfo (args[*argn + 1]);
+	      update_val (file_exists);
+	      (*argn) += 2;
+	      return ret;
+	    }
+
+	  if (grub_strcmp (args[*argn], "-f") == 0)
+	    {
+	      get_fileinfo (args[*argn + 1]);
+	      /* FIXME: check for other types. */
+	      update_val (file_exists && ! file_info.dir);
+	      (*argn) += 2;
+	      return ret;
+	    }
+
+	  if (grub_strcmp (args[*argn], "-s") == 0)
+	    {
+	      grub_file_t file;
+	      file = grub_file_open (args[*argn + 1]);
+	      update_val (file && (grub_file_size (file) != 0));
+	      if (file)
+		grub_file_close (file);
+	      grub_errno = GRUB_ERR_NONE;
+	      (*argn) += 2;
+	      return ret;
+	    }
+
+	  /* String tests. */
+	  if (grub_strcmp (args[*argn], "-n") == 0)
+	    {
+	      update_val (args[*argn + 1][0]);
+
+	      (*argn) += 2;
+	      continue;
+	    }
+	  if (grub_strcmp (args[*argn], "-z") == 0)
+	    {
+	      update_val (! args[*argn + 1][0]);
+	      (*argn) += 2;
+	      continue;
+	    }
+	}
+
+      /* Special modifiers. */
+
+      /* End of expression. return to parent. */
+      if (grub_strcmp (args[*argn], ")") == 0)
+	{
+	  (*argn)++;
+	  return ret;
+	}
+      /* Recursively invoke if parenthesis. */
+      if (grub_strcmp (args[*argn], "(") == 0)
+	{
+	  (*argn)++;
+	  update_val (test_parse (args, argn, argc));
+	  continue;
+	}
+
+      if (grub_strcmp (args[*argn], "!") == 0)
+	{
+	  invert = ! invert;
+	  (*argn)++;
+	  continue;
+	}
+      if (grub_strcmp (args[*argn], "-a") == 0)
+	{
+	  /* If current value is 0 second value is to be discarded. */
+	  discard = ! ret;
+	  (*argn)++;
+	  continue;
+	}
+      if (grub_strcmp (args[*argn], "-o") == 0)
+	{
+	  /* If current value is 1 second value is to be discarded. */
+	  discard = ret;
+	  (*argn)++;
+	  continue;
+	}
+
+      /* No test found. Interpret if as just a string. */
+      update_val (args[*argn][0]);
+      (*argn)++;
+    }
+  return ret;
+}
+
+static grub_err_t
+grub_cmd_test (grub_command_t cmd __attribute__ ((unused)),
+	       int argc, char **args)
+{
+  int argn = 0;
+
+  if (argc >= 1 && grub_strcmp (args[argc - 1], "]") == 0)
+    argc--;
+
+  return test_parse (args, &argn, argc) ? GRUB_ERR_NONE
+    : grub_error (GRUB_ERR_TEST_FAILURE, "false");
+}
+
+static grub_command_t cmd_1, cmd_2;
+
+GRUB_MOD_INIT(test)
+{
+  cmd_1 = grub_register_command ("[", grub_cmd_test,
+				 N_("EXPRESSION ]"), N_("Evaluate an expression."));
+  cmd_2 = grub_register_command ("test", grub_cmd_test,
+				 N_("EXPRESSION"), N_("Evaluate an expression."));
+}
+
+GRUB_MOD_FINI(test)
+{
+  grub_unregister_command (cmd_1);
+  grub_unregister_command (cmd_2);
+}

grub-core/commands/true.c

@@ -0,0 +1,57 @@
+/* true.c - true and false commands.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/dl.h>
+#include <grub/command.h>
+#include <grub/i18n.h>
+
+static grub_err_t
+grub_cmd_true (struct grub_command *cmd __attribute__ ((unused)),
+	       int argc __attribute__ ((unused)),
+	       char *argv[] __attribute__ ((unused)))
+{
+  return 0;
+}
+
+static grub_err_t
+grub_cmd_false (struct grub_command *cmd __attribute__ ((unused)),
+		int argc __attribute__ ((unused)),
+		char *argv[] __attribute__ ((unused)))
+{
+  return grub_error (GRUB_ERR_TEST_FAILURE, "false");
+}
+
+static grub_command_t cmd_true, cmd_false;
+
+
+GRUB_MOD_INIT(true)
+{
+  cmd_true =
+    grub_register_command ("true", grub_cmd_true,
+			   0, N_("Do nothing, successfully."));
+  cmd_false =
+    grub_register_command ("false", grub_cmd_false,
+			   0, N_("Do nothing, unsuccessfully."));
+}
+
+GRUB_MOD_FINI(true)
+{
+  grub_unregister_command (cmd_true);
+  grub_unregister_command (cmd_false);
+}

grub-core/commands/usbtest.c

@@ -0,0 +1,205 @@
+/* usbtest.c - test module for USB */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2008  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/types.h>
+#include <grub/misc.h>
+#include <grub/charset.h>
+#include <grub/mm.h>
+#include <grub/err.h>
+#include <grub/dl.h>
+#include <grub/usb.h>
+#include <grub/command.h>
+#include <grub/i18n.h>
+
+static const char *usb_classes[] =
+  {
+    "",
+    "Audio",
+    "Communication Interface",
+    "HID",
+    "",
+    "Physical",
+    "Image",
+    "Printer",
+    "Mass Storage",
+    "Hub",
+    "Data Interface",
+    "Smart Card",
+    "Content Security",
+    "Video"
+  };
+
+static const char *usb_endp_type[] =
+  {
+    "Control",
+    "Isochronous",
+    "Bulk",
+    "Interrupt"
+  };
+
+static const char *usb_devspeed[] =
+  {
+    "",
+    "Low",
+    "Full",
+    "High"
+  };
+
+static grub_usb_err_t
+grub_usb_get_string (grub_usb_device_t dev, grub_uint8_t index, int langid,
+		     char **string)
+{
+  struct grub_usb_desc_str descstr;
+  struct grub_usb_desc_str *descstrp;
+  grub_usb_err_t err;
+
+  /* Only get the length.  */
+  err = grub_usb_control_msg (dev, 1 << 7,
+			      0x06, (3 << 8) | index,
+			      langid, 1, (char *) &descstr);
+  if (err)
+    return err;
+
+  descstrp = grub_malloc (descstr.length);
+  if (! descstrp)
+    return GRUB_USB_ERR_INTERNAL;
+  err = grub_usb_control_msg (dev, 1 << 7,
+			      0x06, (3 << 8) | index,
+			      langid, descstr.length, (char *) descstrp);
+
+  *string = grub_malloc (descstr.length / 2);
+  if (! *string)
+    {
+      grub_free (descstrp);
+      return GRUB_USB_ERR_INTERNAL;
+    }
+
+  grub_utf16_to_utf8 ((grub_uint8_t *) *string, descstrp->str, descstrp->length / 2 - 1);
+  (*string)[descstr.length / 2 - 1] = '\0';
+  grub_free (descstrp);
+
+  return GRUB_USB_ERR_NONE;
+}
+
+static void
+usb_print_str (const char *description, grub_usb_device_t dev, int idx)
+{
+  char *name;
+  grub_usb_err_t err;
+  /* XXX: LANGID  */
+
+  if (! idx)
+    return;
+
+  err = grub_usb_get_string (dev, idx, 0x0409, &name);
+  if (err)
+    grub_printf ("Error %d retrieving %s\n", err, description);
+  else
+    {
+      grub_printf ("%s: `%s'\n", description, name);
+      grub_free (name);
+    }
+}
+
+static int
+usb_iterate (grub_usb_device_t dev)
+{
+  struct grub_usb_desc_device *descdev;
+  int i;
+
+  descdev = &dev->descdev;
+
+  usb_print_str ("Product", dev, descdev->strprod);
+  usb_print_str ("Vendor", dev, descdev->strvendor);
+  usb_print_str ("Serial", dev, descdev->strserial);
+
+  if (descdev->class > 0 && descdev->class <= 0x0E)
+    grub_printf ("Class: (0x%02x) %s, Subclass: 0x%02x, Protocol: 0x%02x\n",
+		 descdev->class, usb_classes[descdev->class],
+		 descdev->subclass, descdev->protocol);
+  grub_printf ("USB version %d.%d, VendorID: 0x%02x, ProductID: 0x%02x, #conf: %d\n",
+	       descdev->usbrel >> 8, (descdev->usbrel >> 4) & 0x0F,
+	       descdev->vendorid, descdev->prodid, descdev->configcnt);
+
+  grub_printf ("%s speed device\n", usb_devspeed[dev->speed]);
+
+  for (i = 0; i < descdev->configcnt; i++)
+    {
+      struct grub_usb_desc_config *config;
+
+      config = dev->config[i].descconf;
+      usb_print_str ("Configuration:", dev, config->strconfig);
+    }
+
+  for (i = 0; i < dev->config[0].descconf->numif; i++)
+    {
+      int j;
+      struct grub_usb_desc_if *interf;
+      interf = dev->config[0].interf[i].descif;
+
+      grub_printf ("Interface #%d: #Endpoints: %d   ",
+		   i, interf->endpointcnt);
+      if (interf->class > 0 && interf->class <= 0x0E)
+	grub_printf ("Class: (0x%02x) %s, Subclass: 0x%02x, Protocol: 0x%02x\n",
+		     interf->class, usb_classes[interf->class],
+		     interf->subclass, interf->protocol);
+
+      usb_print_str ("Interface", dev, interf->strif);
+
+      for (j = 0; j < interf->endpointcnt; j++)
+	{
+	  struct grub_usb_desc_endp *endp;
+	  endp = &dev->config[0].interf[i].descendp[j];
+
+	  grub_printf ("Endpoint #%d: %s, max packed size: %d, transfer type: %s, latency: %d\n",
+		       endp->endp_addr & 15,
+		       (endp->endp_addr & 128) ? "IN" : "OUT",
+		       endp->maxpacket, usb_endp_type[endp->attrib & 3],
+		       endp->interval);
+	}
+    }
+
+  grub_printf("\n");
+
+  return 0;
+}
+
+static grub_err_t
+grub_cmd_usbtest (grub_command_t cmd __attribute__ ((unused)),
+		  int argc __attribute__ ((unused)),
+		  char **args __attribute__ ((unused)))
+{
+  grub_printf ("USB devices:\n\n");
+  grub_usb_iterate (usb_iterate);
+
+  return 0;
+}
+
+static grub_command_t cmd;
+
+GRUB_MOD_INIT(usbtest)
+{
+  cmd = grub_register_command ("usb", grub_cmd_usbtest,
+			       0, N_("Test USB support."));
+}
+
+GRUB_MOD_FINI(usbtest)
+{
+  grub_unregister_command (cmd);
+}

grub-core/commands/videotest.c

@@ -0,0 +1,186 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2006,2007,2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/video.h>
+#include <grub/types.h>
+#include <grub/dl.h>
+#include <grub/misc.h>
+#include <grub/mm.h>
+#include <grub/font.h>
+#include <grub/term.h>
+#include <grub/command.h>
+#include <grub/i18n.h>
+
+static grub_err_t
+grub_cmd_videotest (grub_command_t cmd __attribute__ ((unused)),
+                    int argc __attribute__ ((unused)),
+                    char **args __attribute__ ((unused)))
+{
+  grub_err_t err;
+  grub_video_color_t color;
+  unsigned int x;
+  unsigned int y;
+  unsigned int width;
+  unsigned int height;
+  int i;
+  grub_font_t sansbig;
+  grub_font_t sans;
+  grub_font_t sanssmall;
+  grub_font_t fixed;
+  struct grub_font_glyph *glyph;
+  struct grub_video_render_target *text_layer;
+  grub_video_color_t palette[16];
+  const char *str;
+  int texty;
+
+  err = grub_video_set_mode ("auto", GRUB_VIDEO_MODE_TYPE_PURE_TEXT, 0);
+  if (err)
+    return err;
+
+  grub_video_get_viewport (&x, &y, &width, &height);
+
+  grub_video_create_render_target (&text_layer, width, height,
+                                   GRUB_VIDEO_MODE_TYPE_RGB
+                                   | GRUB_VIDEO_MODE_TYPE_ALPHA);
+
+  grub_video_set_active_render_target (GRUB_VIDEO_RENDER_TARGET_DISPLAY);
+
+  color = grub_video_map_rgb (0, 0, 0);
+  grub_video_fill_rect (color, 0, 0, width, height);
+
+  color = grub_video_map_rgb (255, 0, 0);
+  grub_video_fill_rect (color, 0, 0, 100, 100);
+
+  color = grub_video_map_rgb (0, 255, 255);
+  grub_video_fill_rect (color, 100, 100, 100, 100);
+
+  sansbig = grub_font_get ("Unknown Regular 16");
+  sans = grub_font_get ("Unknown Regular 16");
+  sanssmall = grub_font_get ("Unknown Regular 16");
+  fixed = grub_font_get ("Fixed 20");
+  if (! sansbig || ! sans || ! sanssmall || ! fixed)
+    return grub_error (GRUB_ERR_BAD_FONT, "no font loaded");
+
+  glyph = grub_font_get_glyph (fixed, '*');
+  grub_font_draw_glyph (glyph, color, 200 ,0);
+
+  grub_video_set_viewport (x + 150, y + 150,
+                           width - 150 * 2, height - 150 * 2);
+  color = grub_video_map_rgb (77, 33, 77);
+  grub_video_fill_rect (color, 0, 0, width, height);
+
+  grub_video_set_active_render_target (text_layer);
+
+  color = grub_video_map_rgb (255, 255, 255);
+
+  texty = 32;
+  grub_font_draw_string ("The quick brown fox jumped over the lazy dog.",
+                         sans, color, 16, texty);
+  texty += grub_font_get_descent (sans) + grub_font_get_leading (sans);
+
+  texty += grub_font_get_ascent (fixed);
+  grub_font_draw_string ("The quick brown fox jumped over the lazy dog.",
+                         fixed, color, 16, texty);
+  texty += grub_font_get_descent (fixed) + grub_font_get_leading (fixed);
+
+  /* To convert Unicode characters into UTF-8 for this test, the following
+     command is useful:
+       echo -ne '\x00\x00\x26\x3A' | iconv -f UTF-32BE -t UTF-8 | od -t x1
+     This converts the Unicode character U+263A to UTF-8.  */
+
+  /* Characters used:
+     Code point  Description                    UTF-8 encoding
+     ----------- ------------------------------ --------------
+     U+263A      unfilled smiley face           E2 98 BA
+     U+00A1      inverted exclamation point     C2 A1
+     U+00A3      British pound currency symbol  C2 A3
+     U+03C4      Greek tau                      CF 84
+     U+00E4      lowercase letter a with umlaut C3 A4
+     U+2124      set 'Z' symbol (integers)      E2 84 A4
+     U+2287      subset symbol                  E2 8A 87
+     U+211D      set 'R' symbol (real numbers)  E2 84 9D  */
+
+  str =
+    "Unicode test: happy\xE2\x98\xBA \xC2\xA3 5.00"
+    " \xC2\xA1\xCF\x84\xC3\xA4u! "
+    " \xE2\x84\xA4\xE2\x8A\x87\xE2\x84\x9D";
+  color = grub_video_map_rgb (128, 128, 255);
+
+  /* All characters in the string exist in the 'Fixed 20' (10x20) font.  */
+  texty += grub_font_get_ascent(fixed);
+  grub_font_draw_string (str, fixed, color, 16, texty);
+  texty += grub_font_get_descent (fixed) + grub_font_get_leading (fixed);
+
+  texty += grub_font_get_ascent(sansbig);
+  grub_font_draw_string (str, sansbig, color, 16, texty);
+  texty += grub_font_get_descent (sansbig) + grub_font_get_leading (sansbig);
+
+  texty += grub_font_get_ascent(sans);
+  grub_font_draw_string (str, sans, color, 16, texty);
+  texty += grub_font_get_descent (sans) + grub_font_get_leading (sans);
+
+  texty += grub_font_get_ascent(sanssmall);
+  grub_font_draw_string (str, sanssmall, color, 16, texty);
+  texty += (grub_font_get_descent (sanssmall)
+            + grub_font_get_leading (sanssmall));
+
+  glyph = grub_font_get_glyph (fixed, '*');
+
+  for (i = 0; i < 16; i++)
+    {
+      color = grub_video_map_color (i);
+      palette[i] = color;
+      grub_font_draw_glyph (glyph, color, 16 + i * 16, 220);
+    }
+
+  grub_video_set_active_render_target (GRUB_VIDEO_RENDER_TARGET_DISPLAY);
+
+  for (i = 0; i < 5; i++)
+    {
+      color = grub_video_map_rgb (i, 33, 77);
+      grub_video_fill_rect (color, 0, 0, width, height);
+      grub_video_blit_render_target (text_layer, GRUB_VIDEO_BLIT_BLEND, 0, 0,
+                                     0, 0, width, height);
+      grub_video_swap_buffers ();
+    }
+
+  grub_getkey ();
+
+  grub_video_delete_render_target (text_layer);
+
+  grub_video_restore ();
+
+  for (i = 0; i < 16; i++)
+    grub_printf("color %d: %08x\n", i, palette[i]);
+
+  grub_errno = GRUB_ERR_NONE;
+  return grub_errno;
+}
+
+static grub_command_t cmd;
+
+GRUB_MOD_INIT(videotest)
+{
+  cmd = grub_register_command ("videotest", grub_cmd_videotest,
+			       0, N_("Test video subsystem."));
+}
+
+GRUB_MOD_FINI(videotest)
+{
+  grub_unregister_command (cmd);
+}

grub-core/commands/xnu_uuid.c

@@ -0,0 +1,100 @@
+/* xnu_uuid.c - transform 64-bit serial number
+   to 128-bit uuid suitable for xnu. */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 1995,1996,1998,1999,2001,2002,
+ *                2003, 2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/types.h>
+#include <grub/misc.h>
+#include <grub/mm.h>
+#include <grub/err.h>
+#include <grub/dl.h>
+#include <grub/device.h>
+#include <grub/disk.h>
+#include <grub/fs.h>
+#include <grub/file.h>
+#include <grub/misc.h>
+#include <grub/env.h>
+#include <grub/command.h>
+#include <grub/i18n.h>
+#include <grub/crypto.h>
+
+/* This prefix is used by xnu and boot-132 to hash
+   together with volume serial. */
+static grub_uint8_t hash_prefix[16]
+  = {0xB3, 0xE2, 0x0F, 0x39, 0xF2, 0x92, 0x11, 0xD6,
+     0x97, 0xA4, 0x00, 0x30, 0x65, 0x43, 0xEC, 0xAC};
+
+static grub_err_t
+grub_cmd_xnu_uuid (grub_command_t cmd __attribute__ ((unused)),
+		   int argc, char **args)
+{
+  grub_uint64_t serial;
+  grub_uint8_t *xnu_uuid;
+  char uuid_string[sizeof ("xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx")];
+  char *ptr;
+  grub_uint8_t ctx[GRUB_MD_MD5->contextsize];
+
+  if (argc < 1)
+    return grub_error (GRUB_ERR_BAD_ARGUMENT, "UUID required");
+
+  serial = grub_cpu_to_be64 (grub_strtoull (args[0], 0, 16));
+
+  GRUB_MD_MD5->init (&ctx);
+  GRUB_MD_MD5->write (&ctx, hash_prefix, sizeof (hash_prefix));
+  GRUB_MD_MD5->write (&ctx, &serial, sizeof (serial));
+  GRUB_MD_MD5->final (&ctx);
+  xnu_uuid = GRUB_MD_MD5->read (&ctx);
+
+  grub_snprintf (uuid_string, sizeof (uuid_string),
+		"%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
+		(unsigned int) xnu_uuid[0], (unsigned int) xnu_uuid[1],
+		(unsigned int) xnu_uuid[2], (unsigned int) xnu_uuid[3],
+		(unsigned int) xnu_uuid[4], (unsigned int) xnu_uuid[5],
+		(unsigned int) ((xnu_uuid[6] & 0xf) | 0x30),
+		(unsigned int) xnu_uuid[7],
+		(unsigned int) ((xnu_uuid[8] & 0x3f) | 0x80),
+		(unsigned int) xnu_uuid[9],
+		(unsigned int) xnu_uuid[10], (unsigned int) xnu_uuid[11],
+		(unsigned int) xnu_uuid[12], (unsigned int) xnu_uuid[13],
+		(unsigned int) xnu_uuid[14], (unsigned int) xnu_uuid[15]);
+  for (ptr = uuid_string; *ptr; ptr++)
+    *ptr = grub_toupper (*ptr);
+  if (argc == 1)
+    grub_printf ("%s", uuid_string);
+  if (argc > 1)
+    grub_env_set (args[1], uuid_string);
+
+  return GRUB_ERR_NONE;
+}
+
+static grub_command_t cmd;
+
+
+GRUB_MOD_INIT (xnu_uuid)
+{
+  cmd = grub_register_command ("xnu_uuid", grub_cmd_xnu_uuid,
+			       N_("GRUBUUID [VARNAME]"),
+			       N_("Transform 64-bit UUID to format "
+			       "suitable for XNU."));
+}
+
+GRUB_MOD_FINI (xnu_uuid)
+{
+  grub_unregister_command (cmd);
+}

grub-core/conf/any-emu.rmk

@@ -0,0 +1,113 @@
+# -*- makefile -*-
+
+COMMON_CFLAGS += -nostdinc -isystem $(shell $(TARGET_CC) -print-file-name=include)
+
+kernel_img_RELOCATABLE = yes
+pkglib_PROGRAMS = kernel.img
+kernel_img_SOURCES = kern/device.c kern/disk.c kern/dl.c kern/env.c	\
+	kern/err.c kern/list.c kern/handler.c kern/command.c		\
+	kern/corecmd.c kern/file.c kern/fs.c kern/main.c kern/misc.c	\
+	kern/parser.c kern/partition.c kern/term.c			\
+	kern/rescue_reader.c kern/rescue_parser.c			\
+	\
+	util/console.c  util/grub-emu.c util/misc.c			\
+	util/hostdisk.c util/getroot.c util/mm.c util/time.c		\
+	\
+	gnulib/progname.c util/hostfs.c disk/host.c
+kernel_img_HEADERS += datetime.h util/misc.h
+kernel_img_CFLAGS = $(TARGET_CPPFLAGS) $(TARGET_CFLAGS) -Wno-undef -I$(srcdir)/gnulib
+kernel_img_LDFLAGS = $(COMMON_LDFLAGS)
+TARGET_NO_STRIP = yes
+
+ifneq ($(TARGET_NO_MODULES), yes)
+kernel_img_SOURCES += symlist.c kern/$(target_cpu)/dl.c
+ifneq ($(target_cpu), i386)
+ifneq ($(target_cpu), x86_64)
+kernel_img_SOURCES += kern/$(target_cpu)/cache.S
+endif
+endif
+else
+kernel_img_SOURCES += grub_emu_init.c
+endif
+
+# For halt.mod.
+pkglib_MODULES += halt.mod
+halt_mod_SOURCES = commands/halt.c
+halt_mod_CFLAGS = $(COMMON_CFLAGS)
+halt_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+ifeq ($(target_cpu), i386)
+pkglib_MODULES += cpuid.mod
+cpuid_mod_SOURCES = commands/i386/cpuid.c
+cpuid_mod_CFLAGS = $(COMMON_CFLAGS)
+cpuid_mod_LDFLAGS = $(COMMON_LDFLAGS)
+endif
+
+grub_emu_LDFLAGS = $(LIBCURSES)
+
+ifeq ($(enable_grub_emu_usb), yes)
+kernel_img_HEADERS += libusb.h
+
+pkglib_MODULES += libusb.mod
+libusb_mod_SOURCES = util/usb.c
+libusb_mod_CFLAGS = 
+libusb_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For usb.mod
+pkglib_MODULES += usb.mod
+usb_mod_SOURCES = bus/usb/usb.c
+usb_mod_CFLAGS = $(COMMON_CFLAGS)
+usb_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For usbtest.mod
+pkglib_MODULES += usbtest.mod
+usbtest_mod_SOURCES = commands/usbtest.c
+usbtest_mod_CFLAGS = $(COMMON_CFLAGS)
+usbtest_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For usbms.mod
+pkglib_MODULES += usbms.mod
+usbms_mod_SOURCES = disk/usbms.c
+usbms_mod_CFLAGS = $(COMMON_CFLAGS)
+usbms_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+grub_emu_LDFLAGS += $(LIBUSB)
+endif
+
+ifeq ($(enable_grub_emu_sdl), yes)
+pkglib_MODULES += sdl.mod
+sdl_mod_SOURCES = util/sdl.c
+sdl_mod_CFLAGS = 
+sdl_mod_LDFLAGS = $(COMMON_LDFLAGS)
+grub_emu_LDFLAGS += $(LIBSDL)
+kernel_img_HEADERS += sdl.h
+endif
+
+ifeq ($(enable_grub_emu_pci), yes)
+pkglib_MODULES += pci.mod
+pci_mod_SOURCES = util/pci.c commands/lspci.c
+pci_mod_LDFLAGS = $(COMMON_LDFLAGS)
+grub_emu_LDFLAGS += $(LIBPCIACCESS)
+kernel_img_HEADERS += libpciaccess.h
+endif
+
+include $(srcdir)/conf/common.mk
+
+grub_emu_init.h: genemuinitheader.sh $(pkglib_MODULES)
+	rm -f $@; echo $(pkglib_MODULES) | sh $(srcdir)/genemuinitheader.sh $(NM)  > $@
+DISTCLEANFILES += grub_emu_init.h
+
+grub_emu_init.c: genemuinit.sh $(pkglib_MODULES) grub_emu_init.h
+	rm -f $@; echo $(pkglib_MODULES) | sh $(srcdir)/genemuinit.sh $(NM) > $@
+DISTCLEANFILES += grub_emu_init.c
+
+CLEANFILES += grub-emu
+ifneq ($(TARGET_NO_MODULES), yes)
+grub-emu: $(pkglib_PROGRAMS)
+	$(CC) -o $@ $(pkglib_PROGRAMS) $(grub_emu_LDFLAGS) $(LDFLAGS)
+else
+grub-emu: $(pkglib_MODULES) $(pkglib_PROGRAMS)
+	$(CC) -o $@ $(pkglib_MODULES) $(pkglib_PROGRAMS) $(grub_emu_LDFLAGS) $(LDFLAGS)
+endif
+GRUB_EMU=grub-emu
+

grub-core/conf/common.rmk

@@ -0,0 +1,867 @@
+# -*- makefile -*-
+
+# Used by various components.  These rules need to precede them.
+script/lexer.c_DEPENDENCIES = grub_script.tab.h
+
+sbin_UTILITIES += grub-mkdevicemap
+grub_mkdevicemap_SOURCES = gnulib/progname.c util/grub-mkdevicemap.c \
+	util/deviceiter.c \
+	util/misc.c
+
+ifeq ($(target_cpu)-$(platform), sparc64-ieee1275)
+grub_mkdevicemap_SOURCES += util/ieee1275/ofpath.c util/ieee1275/devicemap.c
+else
+grub_mkdevicemap_SOURCES += util/devicemap.c
+endif
+
+# For grub-mkelfimage.
+bin_UTILITIES += grub-mkelfimage
+grub_mkelfimage_SOURCES = gnulib/progname.c \
+	util/elf/grub-mkimage.c util/misc.c \
+	util/resolve.c
+util/elf/grub-mkimage.c_DEPENDENCIES = Makefile
+
+# For grub-probe.
+sbin_UTILITIES += grub-probe
+util/grub-probe.c_DEPENDENCIES = grub_probe_init.h
+grub_probe_SOURCES = gnulib/progname.c util/grub-probe.c	\
+	util/hostdisk.c	util/misc.c util/getroot.c util/mm.c	\
+	kern/device.c kern/disk.c kern/err.c kern/misc.c	\
+	kern/parser.c kern/partition.c kern/file.c kern/list.c	\
+	\
+	fs/affs.c fs/cpio.c fs/fat.c fs/ext2.c fs/hfs.c		\
+	fs/hfsplus.c fs/iso9660.c fs/udf.c fs/jfs.c fs/minix.c	\
+	fs/nilfs2.c fs/ntfs.c fs/ntfscomp.c fs/reiserfs.c	\
+	fs/sfs.c fs/ufs.c fs/ufs2.c fs/xfs.c fs/afs.c		\
+	fs/afs_be.c fs/befs.c fs/befs_be.c fs/tar.c		\
+	\
+	partmap/msdos.c partmap/bsdlabel.c partmap/apple.c \
+	partmap/sun.c partmap/sunpc.c partmap/gpt.c \
+	kern/fs.c kern/env.c fs/fshelp.c			\
+	disk/raid.c disk/mdraid_linux.c disk/lvm.c grub_probe_init.c
+
+ifeq ($(enable_grub_fstest), yes)
+bin_UTILITIES += grub-fstest
+endif
+
+bin_UTILITIES += grub-mkisofs
+grub_mkisofs_SOURCES = util/mkisofs/eltorito.c 				\
+	util/mkisofs/hash.c util/mkisofs/joliet.c			\
+	util/mkisofs/match.c util/mkisofs/mkisofs.c			\
+	util/mkisofs/multi.c util/mkisofs/name.c			\
+	util/mkisofs/rock.c util/mkisofs/tree.c				\
+	util/mkisofs/write.c						\
+	\
+	gnulib/fnmatch.c gnulib/getopt1.c gnulib/getopt.c		\
+	gnulib/error.c gnulib/progname.c
+grub_mkisofs_CFLAGS = -D_FILE_OFFSET_BITS=64 				\
+	-I$(srcdir)/util/mkisofs/include				\
+	-Wno-all -Werror $(GNULIB_UTIL_CFLAGS)
+
+# For grub-fstest.
+util/grub-fstest.c_DEPENDENCIES = grub_fstest_init.h
+grub_fstest_SOURCES = gnulib/progname.c util/grub-fstest.c util/hostfs.c \
+	util/misc.c util/mm.c 	\
+	kern/file.c kern/device.c kern/disk.c kern/err.c kern/misc.c	\
+	disk/host.c disk/loopback.c kern/list.c kern/command.c		\
+	lib/arg.c commands/extcmd.c normal/datetime.c normal/misc.c	\
+	lib/hexdump.c lib/crc.c commands/blocklist.c commands/ls.c 	\
+	\
+	fs/affs.c fs/cpio.c fs/fat.c fs/ext2.c fs/hfs.c			\
+	fs/hfsplus.c fs/iso9660.c fs/udf.c fs/jfs.c fs/minix.c		\
+	fs/nilfs2.c fs/ntfs.c fs/ntfscomp.c fs/reiserfs.c fs/sfs.c	\
+	fs/ufs.c fs/ufs2.c fs/xfs.c fs/afs.c fs/afs_be.c fs/befs.c 	\
+	fs/befs_be.c fs/tar.c			\
+	\
+	kern/partition.c partmap/msdos.c partmap/bsdlabel.c 		\
+	partmap/apple.c partmap/sun.c partmap/sunpc.c partmap/gpt.c	\
+	kern/fs.c kern/env.c fs/fshelp.c disk/raid.c			\
+	disk/raid5_recover.c disk/raid6_recover.c 			\
+	disk/mdraid_linux.c disk/dmraid_nvidia.c disk/lvm.c 		\
+	grub_fstest_init.c
+
+# For grub-mkfont.
+ifeq ($(enable_grub_mkfont), yes)
+bin_UTILITIES += grub-mkfont
+grub_mkfont_SOURCES = gnulib/progname.c util/grub-mkfont.c util/misc.c
+grub_mkfont_CFLAGS = $(freetype_cflags)
+grub_mkfont_LDFLAGS = $(freetype_libs)
+endif
+
+# For grub-mkrelpath.
+bin_UTILITIES += grub-mkrelpath
+grub_mkrelpath_SOURCES = gnulib/progname.c util/grub-mkrelpath.c util/misc.c
+
+bin_UTILITIES += grub-bin2h
+grub_bin2h_SOURCES = gnulib/progname.c util/bin2h.c
+
+# For the lexer.
+grub_script.yy.c grub_script.yy.h: script/yylex.l
+	$(LEX) -o grub_script.yy.c --header-file=grub_script.yy.h $(srcdir)/script/yylex.l
+DISTCLEANFILES += grub_script.yy.c grub_script.yy.h
+
+# For grub-script-check.
+bin_UTILITIES += grub-script-check
+util/grub-script-check.c_DEPENDENCIES = grub_script_check_init.h
+grub_script_check_SOURCES = gnulib/progname.c gnulib/getdelim.c gnulib/getline.c \
+	util/grub-script-check.c util/misc.c util/mm.c \
+	script/main.c script/script.c script/function.c script/lexer.c \
+	kern/handler.c kern/err.c kern/parser.c kern/list.c \
+	kern/misc.c kern/env.c grub_script_check_init.c grub_script.tab.c \
+	grub_script.yy.c
+grub_script_check_CFLAGS = $(GNULIB_UTIL_CFLAGS)
+MOSTLYCLEANFILES += symlist.c kernel_syms.lst
+DEFSYMFILES += kernel_syms.lst
+
+kernel_img_HEADERS += boot.h cache.h device.h disk.h dl.h elf.h elfload.h \
+	env.h err.h file.h fs.h kernel.h loader.h misc.h mm.h net.h parser.h \
+	partition.h msdos_partition.h reader.h symbol.h term.h time.h types.h \
+	list.h handler.h command.h i18n.h env_private.h libgcc.h
+
+ifneq ($(platform), emu)
+kernel_img_HEADERS += machine/memory.h machine/loader.h machine/kernel.h
+endif
+
+symlist.c: $(addprefix include/grub/,$(kernel_img_HEADERS)) config.h gensymlist.sh
+	/bin/sh gensymlist.sh $(filter %.h,$^) > $@ || (rm -f $@; exit 1)
+
+kernel_syms.lst: $(addprefix include/grub/,$(kernel_img_HEADERS)) config.h genkernsyms.sh
+	/bin/sh genkernsyms.sh $(filter %.h,$^) > $@ || (rm -f $@; exit 1)
+
+# For the parser.
+grub_script.tab.c grub_script.tab.h: script/parser.y
+	$(YACC) -d -p grub_script_yy -b grub_script $(srcdir)/script/parser.y
+DISTCLEANFILES += grub_script.tab.c grub_script.tab.h
+
+# For grub-script-check.
+grub_script_check_init.lst: geninit.sh $(filter-out grub_script_check_init.c,$(grub_script_check_SOURCES))
+	rm -f $@; grep GRUB_MOD_INIT $(filter %.c,$^) /dev/null > $@
+DISTCLEANFILES += grub_script_check_init.lst
+
+grub_script_check_init.h: grub_script_check_init.lst $(filter-out grub_script_check_init.c,$(grub_script_check_SOURCES)) geninitheader.sh
+	rm -f $@; sh $(srcdir)/geninitheader.sh $< > $@
+DISTCLEANFILES += grub_script_check_init.h
+
+grub_script_check_init.c: grub_script_check_init.lst $(filter-out grub_script_check_init.c,$(grub_script_check_SOURCES)) geninit.sh
+	rm -f $@; sh $(srcdir)/geninit.sh $< $(filter %.c,$^) > $@
+DISTCLEANFILES += grub_script_check_init.c
+
+# For grub-probe.
+grub_probe_init.lst: geninit.sh $(filter-out grub_probe_init.c,$(grub_probe_SOURCES))
+	rm -f $@; grep GRUB_MOD_INIT $(filter %.c,$^) /dev/null > $@
+DISTCLEANFILES += grub_probe_init.lst
+
+grub_probe_init.h: grub_probe_init.lst $(filter-out grub_probe_init.c,$(grub_probe_SOURCES)) geninitheader.sh
+	rm -f $@; sh $(srcdir)/geninitheader.sh $< > $@
+DISTCLEANFILES += grub_probe_init.h
+
+grub_probe_init.c: grub_probe_init.lst $(filter-out grub_probe_init.c,$(grub_probe_SOURCES)) geninit.sh grub_probe_init.h
+	rm -f $@; sh $(srcdir)/geninit.sh $< $(filter %.c,$^) > $@
+DISTCLEANFILES += grub_probe_init.c
+
+# For grub-setup.
+grub_setup_init.lst: geninit.sh $(filter-out grub_setup_init.c,$(grub_setup_SOURCES))
+	rm -f $@; grep GRUB_MOD_INIT $(filter %.c,$^) /dev/null > $@
+DISTCLEANFILES += grub_setup_init.lst
+
+grub_setup_init.h: grub_setup_init.lst $(filter-out grub_setup_init.c,$(grub_setup_SOURCES)) geninitheader.sh
+	rm -f $@; sh $(srcdir)/geninitheader.sh $< > $@
+DISTCLEANFILES += grub_setup_init.h
+
+grub_setup_init.c: grub_setup_init.lst $(filter-out grub_setup_init.c,$(grub_setup_SOURCES)) geninit.sh grub_setup_init.h
+	rm -f $@; sh $(srcdir)/geninit.sh $< $(filter %.c,$^) > $@
+DISTCLEANFILES += grub_setup_init.c
+
+# For grub-fstest.
+grub_fstest_init.lst: geninit.sh $(filter-out grub_fstest_init.c,$(grub_fstest_SOURCES))
+	rm -f $@; grep GRUB_MOD_INIT $(filter %.c,$^) /dev/null > $@
+DISTCLEANFILES += grub_fstest_init.lst
+
+grub_fstest_init.h: grub_fstest_init.lst $(filter-out grub_fstest_init.c,$(grub_fstest_SOURCES)) geninitheader.sh
+	rm -f $@; sh $(srcdir)/geninitheader.sh $< > $@
+DISTCLEANFILES += grub_fstest_init.h
+
+grub_fstest_init.c: grub_fstest_init.lst $(filter-out grub_fstest_init.c,$(grub_fstest_SOURCES)) geninit.sh grub_fstest_init.h
+	rm -f $@; sh $(srcdir)/geninit.sh $< $(filter %.c,$^) > $@
+DISTCLEANFILES += grub_fstest_init.c
+
+# for grub-editenv
+bin_UTILITIES += grub-editenv
+grub_editenv_SOURCES = gnulib/progname.c util/grub-editenv.c lib/envblk.c util/misc.c util/mm.c kern/misc.c kern/err.c
+CLEANFILES += grub-editenv
+
+# Needed for genmk.rb to work
+ifeq (0,1)
+bin_UTILITIES += grub-macho2img grub-pe2elf
+endif
+
+grub_pe2elf_SOURCES = gnulib/progname.c util/grub-pe2elf.c util/misc.c
+CLEANFILES += grub-pe2elf
+
+grub_macho2img_SOURCES = util/grub-macho2img.c
+CLEANFILES += grub-macho2img
+
+# For grub-mkconfig
+grub-mkconfig: util/grub-mkconfig.in config.status
+	./config.status --file=$@:$<
+	chmod +x $@
+sbin_SCRIPTS += grub-mkconfig
+CLEANFILES += grub-mkconfig
+
+grub-mkconfig_lib: util/grub-mkconfig_lib.in config.status
+	./config.status --file=$@:$<
+	chmod +x $@
+lib_SCRIPTS += grub-mkconfig_lib
+CLEANFILES += grub-mkconfig_lib
+
+update-grub_lib: util/update-grub_lib.in config.status
+	./config.status --file=$@:$<
+	chmod +x $@
+lib_SCRIPTS += update-grub_lib
+CLEANFILES += update-grub_lib
+
+grub-gettext_lib: util/grub-gettext_lib.in config.status
+	./config.status --file=$@:$<
+	chmod +x $@
+lib_DATA += grub-gettext_lib
+CLEANFILES += grub-gettext_lib
+
+%: util/grub.d/%.in config.status
+	./config.status --file=$@:$<
+	chmod +x $@
+grub-mkconfig_SCRIPTS = 00_header 30_os-prober 40_custom
+ifneq (, $(host_kernel))
+grub-mkconfig_SCRIPTS += 10_$(host_kernel)
+endif
+
+CLEANFILES += $(grub-mkconfig_SCRIPTS)
+
+grub-mkconfig_DATA += util/grub.d/README
+
+# For grub-set-default.
+grub-set-default: util/grub-set-default.in config.status
+	./config.status --file=$@:$<
+	chmod +x $@
+sbin_SCRIPTS += grub-set-default
+CLEANFILES += grub-set-default
+
+# For grub-reboot.
+grub-reboot: util/grub-reboot.in config.status
+	./config.status --file=$@:$<
+	chmod +x $@
+sbin_SCRIPTS += grub-reboot
+CLEANFILES += grub-reboot
+
+# Filing systems.
+pkglib_MODULES += fshelp.mod fat.mod ufs1.mod ufs2.mod ext2.mod ntfs.mod \
+	ntfscomp.mod minix.mod hfs.mod jfs.mod iso9660.mod xfs.mod	\
+	affs.mod sfs.mod hfsplus.mod reiserfs.mod cpio.mod tar.mod	\
+	udf.mod	afs.mod afs_be.mod befs.mod befs_be.mod
+
+# For fshelp.mod.
+fshelp_mod_SOURCES = fs/fshelp.c
+fshelp_mod_CFLAGS = $(COMMON_CFLAGS)
+fshelp_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For fat.mod.
+fat_mod_SOURCES = fs/fat.c
+fat_mod_CFLAGS = $(COMMON_CFLAGS)
+fat_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For ufs1.mod.
+ufs1_mod_SOURCES = fs/ufs.c
+ufs1_mod_CFLAGS = $(COMMON_CFLAGS)
+ufs1_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For ufs2.mod.
+ufs2_mod_SOURCES = fs/ufs2.c
+ufs2_mod_CFLAGS = $(COMMON_CFLAGS)
+ufs2_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For ext2.mod.
+ext2_mod_SOURCES = fs/ext2.c
+ext2_mod_CFLAGS = $(COMMON_CFLAGS)
+ext2_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For ntfs.mod.
+ntfs_mod_SOURCES = fs/ntfs.c
+ntfs_mod_CFLAGS = $(COMMON_CFLAGS)
+ntfs_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For ntfscomp.mod.
+ntfscomp_mod_SOURCES = fs/ntfscomp.c
+ntfscomp_mod_CFLAGS = $(COMMON_CFLAGS)
+ntfscomp_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For minix.mod.
+minix_mod_SOURCES = fs/minix.c
+minix_mod_CFLAGS = $(COMMON_CFLAGS)
+minix_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For nilfs2.mod.
+pkglib_MODULES += nilfs2.mod
+nilfs2_mod_SOURCES = fs/nilfs2.c
+nilfs2_mod_CFLAGS = $(COMMON_CFLAGS)
+nilfs2_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For hfs.mod.
+hfs_mod_SOURCES = fs/hfs.c
+hfs_mod_CFLAGS = $(COMMON_CFLAGS)
+hfs_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For jfs.mod.
+jfs_mod_SOURCES = fs/jfs.c
+jfs_mod_CFLAGS = $(COMMON_CFLAGS)
+jfs_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For iso9660.mod.
+iso9660_mod_SOURCES = fs/iso9660.c
+iso9660_mod_CFLAGS = $(COMMON_CFLAGS)
+iso9660_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For xfs.mod.
+xfs_mod_SOURCES = fs/xfs.c
+xfs_mod_CFLAGS = $(COMMON_CFLAGS)
+xfs_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For affs.mod.
+affs_mod_SOURCES = fs/affs.c
+affs_mod_CFLAGS = $(COMMON_CFLAGS)
+affs_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For sfs.mod.
+sfs_mod_SOURCES = fs/sfs.c
+sfs_mod_CFLAGS = $(COMMON_CFLAGS)
+sfs_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For hfsplus.mod.
+hfsplus_mod_SOURCES = fs/hfsplus.c
+hfsplus_mod_CFLAGS = $(COMMON_CFLAGS)
+hfsplus_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For reiserfs.mod.
+reiserfs_mod_SOURCES = fs/reiserfs.c
+reiserfs_mod_CFLAGS = $(COMMON_CFLAGS)
+reiserfs_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For cpio.mod.
+cpio_mod_SOURCES = fs/cpio.c
+cpio_mod_CFLAGS = $(COMMON_CFLAGS)
+cpio_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For tar.mod.
+tar_mod_SOURCES = fs/tar.c
+tar_mod_CFLAGS = $(COMMON_CFLAGS)
+tar_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For udf.mod.
+udf_mod_SOURCES = fs/udf.c
+udf_mod_CFLAGS = $(COMMON_CFLAGS)
+udf_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For afs.mod.
+afs_mod_SOURCES = fs/afs.c
+afs_mod_CFLAGS = $(COMMON_CFLAGS)
+afs_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For afs_be.mod.
+afs_be_mod_SOURCES = fs/afs_be.c
+afs_be_mod_CFLAGS = $(COMMON_CFLAGS)
+afs_be_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For befs.mod.
+befs_mod_SOURCES = fs/befs.c
+befs_mod_CFLAGS = $(COMMON_CFLAGS)
+befs_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For befs_be.mod.
+befs_be_mod_SOURCES = fs/befs_be.c
+befs_be_mod_CFLAGS = $(COMMON_CFLAGS)
+befs_be_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# Partition maps.
+
+pkglib_MODULES += part_amiga.mod
+part_amiga_mod_SOURCES = partmap/amiga.c
+part_amiga_mod_CFLAGS = $(COMMON_CFLAGS)
+part_amiga_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+pkglib_MODULES += part_apple.mod
+part_apple_mod_SOURCES = partmap/apple.c
+part_apple_mod_CFLAGS = $(COMMON_CFLAGS)
+part_apple_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+pkglib_MODULES += part_msdos.mod
+part_msdos_mod_SOURCES = partmap/msdos.c
+part_msdos_mod_CFLAGS = $(COMMON_CFLAGS)
+part_msdos_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+pkglib_MODULES += part_sun.mod
+part_sun_mod_SOURCES = partmap/sun.c
+part_sun_mod_CFLAGS = $(COMMON_CFLAGS)
+part_sun_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+pkglib_MODULES += part_acorn.mod
+part_acorn_mod_SOURCES = partmap/acorn.c
+part_acorn_mod_CFLAGS = $(COMMON_CFLAGS)
+part_acorn_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+pkglib_MODULES += part_gpt.mod
+part_gpt_mod_SOURCES = partmap/gpt.c
+part_gpt_mod_CFLAGS = $(COMMON_CFLAGS)
+part_gpt_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+pkglib_MODULES += part_bsd.mod
+part_bsd_mod_SOURCES = partmap/bsdlabel.c
+part_bsd_mod_CFLAGS = $(COMMON_CFLAGS)
+part_bsd_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+pkglib_MODULES += part_sunpc.mod
+part_sunpc_mod_SOURCES = partmap/sunpc.c
+part_sunpc_mod_CFLAGS = $(COMMON_CFLAGS)
+part_sunpc_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# Special disk structures and generic drivers
+
+pkglib_MODULES += raid.mod raid5rec.mod raid6rec.mod mdraid.mod dm_nv.mod \
+	lvm.mod scsi.mod
+
+# For raid.mod
+raid_mod_SOURCES = disk/raid.c
+raid_mod_CFLAGS = $(COMMON_CFLAGS)
+raid_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For raid5rec.mod
+raid5rec_mod_SOURCES = disk/raid5_recover.c
+raid5rec_mod_CFLAGS = $(COMMON_CFLAGS)
+raid5rec_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For raid6rec.mod
+raid6rec_mod_SOURCES = disk/raid6_recover.c
+raid6rec_mod_CFLAGS = $(COMMON_CFLAGS)
+raid6rec_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For mdraid.mod
+mdraid_mod_SOURCES = disk/mdraid_linux.c
+mdraid_mod_CFLAGS = $(COMMON_CFLAGS)
+mdraid_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For dm_nv.mod
+dm_nv_mod_SOURCES = disk/dmraid_nvidia.c
+dm_nv_mod_CFLAGS = $(COMMON_CFLAGS)
+dm_nv_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For lvm.mod
+lvm_mod_SOURCES = disk/lvm.c
+lvm_mod_CFLAGS = $(COMMON_CFLAGS)
+lvm_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For scsi.mod
+scsi_mod_SOURCES = disk/scsi.c
+scsi_mod_CFLAGS = $(COMMON_CFLAGS)
+scsi_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# Commands.
+pkglib_MODULES += minicmd.mod extcmd.mod hello.mod handler.mod	\
+	ls.mod cmp.mod cat.mod help.mod search.mod loopback.mod	\
+	configfile.mod echo.mod		\
+	terminfo.mod test.mod blocklist.mod hexdump.mod		\
+	read.mod sleep.mod loadenv.mod crc.mod parttool.mod	\
+	msdospart.mod memrw.mod normal.mod sh.mod 		\
+	gptsync.mod true.mod probe.mod password.mod		\
+	keystatus.mod
+
+# For password.mod.
+password_mod_SOURCES = commands/password.c
+password_mod_CFLAGS = $(COMMON_CFLAGS)
+password_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For gptsync.mod.
+gptsync_mod_SOURCES = commands/gptsync.c
+gptsync_mod_CFLAGS = $(COMMON_CFLAGS)
+gptsync_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For minicmd.mod.
+minicmd_mod_SOURCES = commands/minicmd.c
+minicmd_mod_CFLAGS = $(COMMON_CFLAGS)
+minicmd_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For extcmd.mod.
+extcmd_mod_SOURCES = commands/extcmd.c lib/arg.c
+extcmd_mod_CFLAGS = $(COMMON_CFLAGS)
+extcmd_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For hello.mod.
+hello_mod_SOURCES = hello/hello.c
+hello_mod_CFLAGS = $(COMMON_CFLAGS)
+hello_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For gfxmenu.mod.
+pkglib_MODULES += gfxmenu.mod
+gfxmenu_mod_SOURCES = \
+	gfxmenu/gfxmenu.c \
+	gfxmenu/model.c \
+	gfxmenu/view.c \
+	gfxmenu/icon_manager.c \
+	gfxmenu/theme_loader.c \
+	gfxmenu/widget-box.c \
+	gfxmenu/gui_canvas.c \
+	gfxmenu/gui_circular_progress.c \
+	gfxmenu/gui_box.c \
+	gfxmenu/gui_label.c \
+	gfxmenu/gui_list.c \
+	gfxmenu/gui_image.c \
+	gfxmenu/gui_progress_bar.c \
+	gfxmenu/gui_util.c \
+	gfxmenu/gui_string_util.c \
+	gfxmenu/named_colors.c
+gfxmenu_mod_CFLAGS = $(COMMON_CFLAGS)
+gfxmenu_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For parttool.mod.
+parttool_mod_SOURCES = commands/parttool.c
+parttool_mod_CFLAGS = $(COMMON_CFLAGS)
+parttool_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For msdospart.mod.
+msdospart_mod_SOURCES = parttool/msdospart.c
+msdospart_mod_CFLAGS = $(COMMON_CFLAGS)
+msdospart_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For handler.mod.
+handler_mod_SOURCES = commands/handler.c
+handler_mod_CFLAGS = $(COMMON_CFLAGS)
+handler_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For ls.mod.
+ls_mod_SOURCES = commands/ls.c
+ls_mod_CFLAGS = $(COMMON_CFLAGS)
+ls_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For cmp.mod.
+cmp_mod_SOURCES = commands/cmp.c
+cmp_mod_CFLAGS = $(COMMON_CFLAGS)
+cmp_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For cat.mod.
+cat_mod_SOURCES = commands/cat.c
+cat_mod_CFLAGS = $(COMMON_CFLAGS)
+cat_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For echo.mod
+echo_mod_SOURCES = commands/echo.c
+echo_mod_CFLAGS = $(COMMON_CFLAGS)
+echo_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For help.mod.
+help_mod_SOURCES = commands/help.c
+help_mod_CFLAGS = $(COMMON_CFLAGS)
+help_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For search.mod.
+search_mod_SOURCES = commands/search_wrap.c
+search_mod_CFLAGS = $(COMMON_CFLAGS)
+search_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+pkglib_MODULES += search_fs_file.mod search_fs_uuid.mod search_label.mod
+
+# For search.mod.
+search_fs_file_mod_SOURCES = commands/search_file.c
+search_fs_file_mod_CFLAGS = $(COMMON_CFLAGS)
+search_fs_file_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For search.mod.
+search_label_mod_SOURCES = commands/search_label.c
+search_label_mod_CFLAGS = $(COMMON_CFLAGS)
+search_label_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For search.mod.
+search_fs_uuid_mod_SOURCES = commands/search_uuid.c
+search_fs_uuid_mod_CFLAGS = $(COMMON_CFLAGS)
+search_fs_uuid_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For test.mod.
+test_mod_SOURCES = commands/test.c
+test_mod_CFLAGS = $(COMMON_CFLAGS)
+test_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For loopback.mod
+loopback_mod_SOURCES = disk/loopback.c
+loopback_mod_CFLAGS = $(COMMON_CFLAGS)
+loopback_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For configfile.mod
+configfile_mod_SOURCES = commands/configfile.c
+configfile_mod_CFLAGS = $(COMMON_CFLAGS)
+configfile_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For terminfo.mod.
+terminfo_mod_SOURCES = term/terminfo.c term/tparm.c
+terminfo_mod_CFLAGS = $(COMMON_CFLAGS)
+terminfo_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For blocklist.mod.
+blocklist_mod_SOURCES = commands/blocklist.c
+blocklist_mod_CFLAGS = $(COMMON_CFLAGS)
+blocklist_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For hexdump.mod.
+hexdump_mod_SOURCES = commands/hexdump.c lib/hexdump.c
+hexdump_mod_CFLAGS = $(COMMON_CFLAGS)
+hexdump_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For read.mod.
+read_mod_SOURCES = commands/read.c
+read_mod_CFLAGS = $(COMMON_CFLAGS)
+read_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For sleep.mod.
+sleep_mod_SOURCES = commands/sleep.c
+sleep_mod_CFLAGS = $(COMMON_CFLAGS)
+sleep_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For loadenv.mod.
+loadenv_mod_SOURCES = commands/loadenv.c lib/envblk.c
+loadenv_mod_CFLAGS = $(COMMON_CFLAGS)
+loadenv_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For crc.mod.
+crc_mod_SOURCES = commands/crc.c lib/crc.c
+crc_mod_CFLAGS = $(COMMON_CFLAGS)
+crc_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For memrw.mod.
+memrw_mod_SOURCES = commands/memrw.c
+memrw_mod_CFLAGS = $(COMMON_CFLAGS)
+memrw_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For true.mod
+true_mod_SOURCES = commands/true.c
+true_mod_CFLAGS = $(COMMON_CFLAGS)
+true_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For probe.mod.
+probe_mod_SOURCES = commands/probe.c
+probe_mod_CFLAGS = $(COMMON_CFLAGS)
+probe_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For keystatus.mod.
+keystatus_mod_SOURCES = commands/keystatus.c
+keystatus_mod_CFLAGS = $(COMMON_CFLAGS)
+keystatus_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For normal.mod.
+normal_mod_SOURCES = normal/main.c normal/cmdline.c normal/dyncmd.c \
+	normal/auth.c normal/autofs.c normal/handler.c \
+	normal/color.c normal/completion.c normal/datetime.c normal/menu.c \
+	normal/menu_entry.c normal/menu_text.c \
+	normal/misc.c normal/crypto.c normal/term.c normal/context.c
+normal_mod_CFLAGS = $(COMMON_CFLAGS)
+normal_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For sh.mod.
+sh_mod_SOURCES = script/main.c script/script.c script/execute.c \
+	script/function.c script/lexer.c grub_script.tab.c grub_script.yy.c
+sh_mod_CFLAGS = $(COMMON_CFLAGS) $(POSIX_CFLAGS) -Wno-error
+sh_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+ifneq (, $(FONT_SOURCE))
+font/font.c_DEPENDENCIES = ascii.h
+endif
+
+# Common Video Subsystem specific modules.
+# On Yeeloong it's part of kernel
+ifneq ($(platform), yeeloong)
+
+# For video.mod.
+pkglib_MODULES += video.mod
+video_mod_SOURCES = video/video.c
+video_mod_CFLAGS = $(COMMON_CFLAGS)
+video_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+pkglib_MODULES += video_fb.mod
+video_fb_mod_SOURCES = video/fb/video_fb.c video/fb/fbblit.c \
+		  video/fb/fbfill.c video/fb/fbutil.c
+video_fb_mod_CFLAGS = $(COMMON_CFLAGS)
+video_fb_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For bitmap.mod
+pkglib_MODULES += bitmap.mod
+bitmap_mod_SOURCES = video/bitmap.c
+bitmap_mod_CFLAGS = $(COMMON_CFLAGS)
+bitmap_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For bitmap_scale.mod
+pkglib_MODULES += bitmap_scale.mod
+bitmap_scale_mod_SOURCES = video/bitmap_scale.c
+bitmap_scale_mod_CFLAGS = $(COMMON_CFLAGS)
+bitmap_scale_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+pkglib_MODULES += font.mod
+font_mod_SOURCES = font/font_cmd.c font/font.c
+font_mod_CFLAGS = $(COMMON_CFLAGS)
+font_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For gfxterm.mod.
+pkglib_MODULES += gfxterm.mod
+gfxterm_mod_SOURCES = term/gfxterm.c
+gfxterm_mod_CFLAGS = $(COMMON_CFLAGS)
+gfxterm_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+endif
+
+# For videotest.mod.
+pkglib_MODULES += videotest.mod
+videotest_mod_SOURCES = commands/videotest.c
+videotest_mod_CFLAGS = $(COMMON_CFLAGS)
+videotest_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For tga.mod
+pkglib_MODULES += tga.mod
+tga_mod_SOURCES = video/readers/tga.c
+tga_mod_CFLAGS = $(COMMON_CFLAGS)
+tga_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For jpeg.mod.
+pkglib_MODULES += jpeg.mod
+jpeg_mod_SOURCES = video/readers/jpeg.c
+jpeg_mod_CFLAGS = $(COMMON_CFLAGS)
+jpeg_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For png.mod.
+pkglib_MODULES += png.mod
+png_mod_SOURCES = video/readers/png.c
+png_mod_CFLAGS = $(COMMON_CFLAGS)
+png_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+
+# Misc.
+pkglib_MODULES += gzio.mod elf.mod
+
+# For elf.mod.
+elf_mod_SOURCES = kern/elf.c
+elf_mod_CFLAGS = $(COMMON_CFLAGS)
+elf_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For gzio.mod.
+gzio_mod_SOURCES = io/gzio.c
+gzio_mod_CFLAGS = $(COMMON_CFLAGS)
+gzio_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# On Yeeloong it's part of kernel
+ifneq ($(platform), yeeloong)
+# For bufio.mod.
+pkglib_MODULES += bufio.mod
+bufio_mod_SOURCES = io/bufio.c
+bufio_mod_CFLAGS = $(COMMON_CFLAGS)
+bufio_mod_LDFLAGS = $(COMMON_LDFLAGS)
+endif
+
+# For gettext.mod.
+pkglib_MODULES += gettext.mod
+gettext_mod_SOURCES = gettext/gettext.c
+gettext_mod_CFLAGS = $(COMMON_CFLAGS)
+gettext_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# Misc.
+pkglib_MODULES += xnu_uuid.mod
+
+# For elf.mod.
+xnu_uuid_mod_SOURCES = commands/xnu_uuid.c
+xnu_uuid_mod_CFLAGS = $(COMMON_CFLAGS)
+xnu_uuid_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+pkglib_MODULES += trig.mod
+trig_mod_SOURCES = trigtables.c
+trig_mod_CFLAGS = $(COMMON_CFLAGS)
+trig_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+trigtables.c: gentrigtables
+	./gentrigtables > $@
+DISTCLEANFILES += trigtables.c
+gentrigtables: gentrigtables.c
+	$(CC) -o $@ $^ $(CPPFLAGS) -lm
+DISTCLEANFILES += gentrigtables
+
+pkglib_MODULES += setjmp.mod
+setjmp_mod_SOURCES = lib/$(target_cpu)/setjmp.S
+setjmp_mod_ASFLAGS = $(COMMON_ASFLAGS)
+setjmp_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+pkglib_MODULES += charset.mod
+charset_mod_SOURCES = lib/charset.c
+charset_mod_CFLAGS = $(COMMON_CFLAGS)
+charset_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+pkglib_MODULES += regexp.mod
+regexp_mod_SOURCES = gnulib/regex.c commands/regexp.c
+regexp_mod_CFLAGS = $(COMMON_CFLAGS) $(GNULIB_CFLAGS)
+regexp_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+pkglib_MODULES += terminal.mod
+terminal_mod_SOURCES = commands/terminal.c
+terminal_mod_CFLAGS = $(COMMON_CFLAGS)
+terminal_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+pkglib_MODULES += crypto.mod
+crypto_mod_SOURCES = lib/crypto.c
+crypto_mod_CFLAGS = $(COMMON_CFLAGS)
+crypto_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+pkglib_MODULES += hashsum.mod
+hashsum_mod_SOURCES = commands/hashsum.c
+hashsum_mod_CFLAGS = $(COMMON_CFLAGS)
+hashsum_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+pkglib_MODULES += pbkdf2.mod
+pbkdf2_mod_SOURCES = lib/pbkdf2.c
+pbkdf2_mod_CFLAGS = $(COMMON_CFLAGS)
+pbkdf2_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For password_pbkdf2.mod.
+pkglib_MODULES += password_pbkdf2.mod
+password_pbkdf2_mod_SOURCES = commands/password_pbkdf2.c
+password_pbkdf2_mod_CFLAGS = $(COMMON_CFLAGS)
+password_pbkdf2_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For memdisk.mod.
+pkglib_MODULES += memdisk.mod
+memdisk_mod_SOURCES = disk/memdisk.c
+memdisk_mod_CFLAGS = $(COMMON_CFLAGS)
+memdisk_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For reboot.mod.
+pkglib_MODULES += reboot.mod
+reboot_mod_SOURCES = commands/reboot.c
+reboot_mod_CFLAGS = $(COMMON_CFLAGS)
+reboot_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For date.mod
+pkglib_MODULES += date.mod
+date_mod_SOURCES = commands/date.c
+date_mod_CFLAGS = $(COMMON_CFLAGS)
+date_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For datehook.mod
+pkglib_MODULES += datehook.mod
+datehook_mod_SOURCES = hook/datehook.c
+datehook_mod_CFLAGS = $(COMMON_CFLAGS)
+datehook_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For lsmmap.mod
+pkglib_MODULES += lsmmap.mod
+lsmmap_mod_SOURCES = commands/lsmmap.c
+lsmmap_mod_CFLAGS = $(COMMON_CFLAGS)
+lsmmap_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For boot.mod.
+pkglib_MODULES += boot.mod
+boot_mod_SOURCES = commands/boot.c lib/i386/pc/biosnum.c
+boot_mod_CFLAGS = $(COMMON_CFLAGS)
+boot_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+bin_UTILITIES += grub-mkpasswd-pbkdf2
+grub_mkpasswd_pbkdf2_SOURCES = gnulib/progname.c gnulib/getdelim.c gnulib/getline.c util/grub-mkpasswd-pbkdf2.c lib/crypto.c lib/libgcrypt-grub/cipher/sha512.c lib/pbkdf2.c util/misc.c util/mm.c kern/err.c
+grub_mkpasswd_pbkdf2_CFLAGS += -Wno-missing-field-initializers -Wno-error -I$(srcdir)/lib/libgcrypt_wrap -DGRUB_MKPASSWD=1
+
+include $(srcdir)/conf/gcry.mk

grub-core/conf/i386-coreboot.rmk

@@ -0,0 +1,74 @@
+# -*- makefile -*-
+
+COMMON_CFLAGS = -mrtd -mregparm=3 
+
+# Images.
+
+GRUB_KERNEL_MACHINE_LINK_ADDR	= 0x8200
+
+pkglib_PROGRAMS += kernel.img
+kernel_img_SOURCES = kern/i386/coreboot/startup.S \
+	kern/i386/misc.S \
+	kern/i386/coreboot/init.c \
+       kern/i386/coreboot/mmap.c \
+	kern/i386/halt.c \
+	kern/main.c kern/device.c \
+	kern/disk.c kern/dl.c kern/file.c kern/fs.c kern/err.c \
+	kern/misc.c kern/mm.c kern/term.c \
+	kern/rescue_parser.c kern/rescue_reader.c \
+	kern/time.c kern/list.c kern/handler.c kern/command.c kern/corecmd.c \
+	kern/$(target_cpu)/dl.c kern/parser.c kern/partition.c \
+	kern/i386/tsc.c kern/i386/pit.c \
+	kern/generic/rtc_get_time_ms.c \
+	kern/generic/millisleep.c \
+	kern/env.c \
+	term/i386/pc/vga_text.c term/i386/vga_common.c \
+	symlist.c
+kernel_img_CFLAGS = $(COMMON_CFLAGS)
+kernel_img_ASFLAGS = $(COMMON_ASFLAGS)
+kernel_img_LDFLAGS += $(COMMON_LDFLAGS) -Wl,-N,-S,-Ttext,$(GRUB_KERNEL_MACHINE_LINK_ADDR),-Bstatic
+
+sbin_SCRIPTS += grub-install
+grub_install_SOURCES = util/grub-install.in
+
+bin_SCRIPTS += grub-mkrescue
+grub_mkrescue_SOURCES = util/grub-mkrescue.in
+
+# Modules.
+pkglib_MODULES = linux.mod aout.mod halt.mod datetime.mod mmap.mod
+
+# For mmap.mod.
+mmap_mod_SOURCES = mmap/mmap.c mmap/i386/uppermem.c mmap/i386/mmap.c
+mmap_mod_CFLAGS = $(COMMON_CFLAGS)
+mmap_mod_LDFLAGS = $(COMMON_LDFLAGS)
+mmap_mod_ASFLAGS = $(COMMON_ASFLAGS)
+
+# For linux.mod.
+linux_mod_SOURCES = loader/i386/linux.c
+linux_mod_CFLAGS = $(COMMON_CFLAGS)
+linux_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For halt.mod.
+halt_mod_SOURCES = commands/halt.c
+halt_mod_CFLAGS = $(COMMON_CFLAGS)
+halt_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For aout.mod.
+aout_mod_SOURCES = loader/aout.c
+aout_mod_CFLAGS = $(COMMON_CFLAGS)
+aout_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For bsd.mod
+pkglib_MODULES += bsd.mod
+bsd_mod_SOURCES = loader/i386/bsd.c loader/i386/bsd32.c loader/i386/bsd64.c loader/i386/bsd_helper.S loader/i386/bsd_trampoline.S
+bsd_mod_CFLAGS = $(COMMON_CFLAGS)
+bsd_mod_LDFLAGS = $(COMMON_LDFLAGS)
+bsd_mod_ASFLAGS = $(COMMON_ASFLAGS)
+
+# For datetime.mod
+datetime_mod_SOURCES = lib/cmos_datetime.c
+datetime_mod_CFLAGS = $(COMMON_CFLAGS)
+datetime_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+include $(srcdir)/conf/i386.mk
+include $(srcdir)/conf/common.mk

grub-core/conf/i386-efi.rmk

@@ -0,0 +1,5 @@
+# -*- makefile -*-
+
+COMMON_LDFLAGS = -melf_i386
+
+include $(srcdir)/conf/x86-efi.mk

grub-core/conf/i386-ieee1275.rmk

@@ -0,0 +1,81 @@
+# -*- makefile -*-
+
+COMMON_CFLAGS	= -mrtd -mregparm=3
+
+# Images.
+pkglib_PROGRAMS = kernel.img
+
+# For kernel.img.
+kernel_img_SOURCES = kern/i386/ieee1275/startup.S \
+	kern/i386/misc.S \
+	kern/i386/ieee1275/init.c \
+	kern/ieee1275/init.c \
+	kern/ieee1275/mmap.c \
+	kern/ieee1275/cmain.c kern/ieee1275/openfw.c \
+	kern/main.c kern/device.c \
+	kern/disk.c kern/dl.c kern/file.c kern/fs.c kern/err.c \
+	kern/misc.c kern/mm.c kern/term.c \
+	kern/rescue_parser.c kern/rescue_reader.c \
+	kern/$(target_cpu)/dl.c kern/parser.c kern/partition.c \
+	kern/env.c \
+	kern/time.c kern/list.c kern/handler.c kern/command.c kern/corecmd.c \
+	kern/generic/millisleep.c \
+	kern/ieee1275/ieee1275.c \
+	term/ieee1275/ofconsole.c \
+	disk/ieee1275/ofdisk.c \
+	symlist.c
+kernel_img_HEADERS += ieee1275/ieee1275.h
+kernel_img_CFLAGS = $(COMMON_CFLAGS)
+kernel_img_ASFLAGS = $(COMMON_ASFLAGS)
+kernel_img_LDFLAGS += $(COMMON_LDFLAGS) -Wl,-N,-S,-Ttext,0x10000,-Bstatic
+
+# Scripts.
+sbin_SCRIPTS = grub-install
+
+# For grub-install.
+grub_install_SOURCES = util/ieee1275/grub-install.in
+
+# Modules.
+pkglib_MODULES = halt.mod suspend.mod		\
+	aout.mod linux.mod	\
+	nand.mod datetime.mod	\
+	mmap.mod
+
+# For mmap.mod.
+mmap_mod_SOURCES = mmap/mmap.c mmap/i386/uppermem.c mmap/i386/mmap.c
+mmap_mod_CFLAGS = $(COMMON_CFLAGS)
+mmap_mod_LDFLAGS = $(COMMON_LDFLAGS)
+mmap_mod_ASFLAGS = $(COMMON_ASFLAGS)
+
+# For aout.mod.
+aout_mod_SOURCES = loader/aout.c
+aout_mod_CFLAGS = $(COMMON_CFLAGS)
+aout_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For suspend.mod
+suspend_mod_SOURCES = commands/ieee1275/suspend.c
+suspend_mod_CFLAGS = $(COMMON_CFLAGS)
+suspend_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For halt.mod
+halt_mod_SOURCES = commands/halt.c
+halt_mod_CFLAGS = $(COMMON_CFLAGS)
+halt_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For linux.mod.
+linux_mod_SOURCES = loader/i386/ieee1275/linux.c
+linux_mod_CFLAGS = $(COMMON_CFLAGS)
+linux_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For nand.mod.
+nand_mod_SOURCES = disk/ieee1275/nand.c
+nand_mod_CFLAGS = $(COMMON_CFLAGS)
+nand_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For datetime.mod
+datetime_mod_SOURCES = lib/cmos_datetime.c
+datetime_mod_CFLAGS = $(COMMON_CFLAGS)
+datetime_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+include $(srcdir)/conf/i386.mk
+include $(srcdir)/conf/common.mk

grub-core/conf/i386-multiboot.rmk

@@ -0,0 +1,74 @@
+# -*- makefile -*-
+
+COMMON_CFLAGS = -mrtd -mregparm=3 
+
+# Images.
+
+GRUB_KERNEL_MACHINE_LINK_ADDR	= 0x8200
+
+pkglib_PROGRAMS += kernel.img
+kernel_img_SOURCES = kern/i386/coreboot/startup.S \
+	kern/i386/misc.S \
+	kern/i386/coreboot/init.c \
+	kern/i386/multiboot_mmap.c \
+	kern/i386/halt.c \
+	kern/main.c kern/device.c \
+	kern/disk.c kern/dl.c kern/file.c kern/fs.c kern/err.c \
+	kern/misc.c kern/mm.c kern/term.c \
+	kern/rescue_parser.c kern/rescue_reader.c \
+	kern/time.c kern/list.c kern/handler.c kern/command.c kern/corecmd.c \
+	kern/$(target_cpu)/dl.c kern/parser.c kern/partition.c \
+	kern/i386/tsc.c kern/i386/pit.c \
+	kern/generic/rtc_get_time_ms.c \
+	kern/generic/millisleep.c \
+	kern/env.c \
+	term/i386/pc/vga_text.c term/i386/vga_common.c \
+	symlist.c
+kernel_img_CFLAGS = $(COMMON_CFLAGS)
+kernel_img_ASFLAGS = $(COMMON_ASFLAGS)
+kernel_img_LDFLAGS += $(COMMON_LDFLAGS) -Wl,-N,-S,-Ttext,$(GRUB_KERNEL_MACHINE_LINK_ADDR),-Bstatic
+
+sbin_SCRIPTS += grub-install
+grub_install_SOURCES = util/grub-install.in
+
+bin_SCRIPTS += grub-mkrescue
+grub_mkrescue_SOURCES = util/grub-mkrescue.in
+
+# Modules.
+pkglib_MODULES = linux.mod aout.mod halt.mod datetime.mod mmap.mod
+
+# For mmap.mod.
+mmap_mod_SOURCES = mmap/mmap.c mmap/i386/uppermem.c mmap/i386/mmap.c
+mmap_mod_CFLAGS = $(COMMON_CFLAGS)
+mmap_mod_LDFLAGS = $(COMMON_LDFLAGS)
+mmap_mod_ASFLAGS = $(COMMON_ASFLAGS)
+
+# For linux.mod.
+linux_mod_SOURCES = loader/i386/linux.c
+linux_mod_CFLAGS = $(COMMON_CFLAGS)
+linux_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For halt.mod.
+halt_mod_SOURCES = commands/halt.c
+halt_mod_CFLAGS = $(COMMON_CFLAGS)
+halt_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For aout.mod.
+aout_mod_SOURCES = loader/aout.c
+aout_mod_CFLAGS = $(COMMON_CFLAGS)
+aout_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For bsd.mod
+pkglib_MODULES += bsd.mod
+bsd_mod_SOURCES = loader/i386/bsd.c loader/i386/bsd32.c loader/i386/bsd64.c loader/i386/bsd_helper.S loader/i386/bsd_trampoline.S
+bsd_mod_CFLAGS = $(COMMON_CFLAGS)
+bsd_mod_LDFLAGS = $(COMMON_LDFLAGS)
+bsd_mod_ASFLAGS = $(COMMON_ASFLAGS)
+
+# For datetime.mod
+datetime_mod_SOURCES = lib/cmos_datetime.c
+datetime_mod_CFLAGS = $(COMMON_CFLAGS)
+datetime_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+include $(srcdir)/conf/i386.mk
+include $(srcdir)/conf/common.mk

grub-core/conf/i386-pc-cygwin-img-ld.sc

@@ -0,0 +1,53 @@
+/* Linker script to create grub .img files on Cygwin.  */
+
+SECTIONS
+{
+  .text :
+  {
+    start = . ;
+    *(.text)
+    etext = . ;
+  }
+  .data :
+  {
+    __data_start__ = . ;
+    *(.data)
+    __data_end__ = . ;
+  }
+  .rdata :
+  {
+    __rdata_start__ = . ;
+    *(.rdata)
+    __rdata_end__ = . ;
+  }
+  .pdata :
+  {
+    *(.pdata)
+    edata = . ;
+  }
+  .bss :
+  {
+    __bss_start__ = . ;
+    *(.bss)
+    __common_start__ = . ;
+    *(COMMON)
+    __bss_end__ = . ;
+  }
+  .edata :
+  {
+    *(.edata)
+    end = . ;
+  }
+  .stab :
+  {
+    *(.stab)
+  }
+  .stabstr :
+  {
+    *(.stabstr)
+  }
+}
+
+ASSERT("__rdata_end__"=="edata", ".pdata not empty")
+ASSERT("__bss_end__"  =="end"  , ".edata not empty")
+

grub-core/conf/i386-pc.rmk

@@ -0,0 +1,305 @@
+# -*- makefile -*-
+
+GRUB_KERNEL_MACHINE_LINK_ADDR = 0x8200
+
+COMMON_CFLAGS = -mrtd -mregparm=3
+
+# Images.
+pkglib_IMAGES = boot.img cdboot.img diskboot.img kernel.img lnxboot.img \
+	pxeboot.img
+
+# For boot.img.
+boot_img_SOURCES = boot/i386/pc/boot.S
+boot_img_ASFLAGS = $(COMMON_ASFLAGS)
+boot_img_LDFLAGS = $(COMMON_LDFLAGS) $(TARGET_IMG_LDFLAGS)0x7C00
+boot_img_FORMAT = binary
+
+# For pxeboot.img
+pxeboot_img_SOURCES = boot/i386/pc/pxeboot.S
+pxeboot_img_ASFLAGS = $(COMMON_ASFLAGS)
+pxeboot_img_LDFLAGS = $(COMMON_LDFLAGS) $(TARGET_IMG_LDFLAGS)0x7C00
+pxeboot_img_FORMAT = binary
+
+# For diskboot.img.
+diskboot_img_SOURCES = boot/i386/pc/diskboot.S
+diskboot_img_ASFLAGS = $(COMMON_ASFLAGS)
+diskboot_img_LDFLAGS = $(COMMON_LDFLAGS) $(TARGET_IMG_LDFLAGS)0x8000
+diskboot_img_FORMAT = binary
+
+# For lnxboot.img.
+lnxboot_img_SOURCES = boot/i386/pc/lnxboot.S
+lnxboot_img_ASFLAGS = $(COMMON_ASFLAGS)
+lnxboot_img_LDFLAGS = $(COMMON_LDFLAGS) $(TARGET_IMG_LDFLAGS)0x6000
+lnxboot_img_FORMAT = binary
+
+# For cdboot.img.
+cdboot_img_SOURCES = boot/i386/pc/cdboot.S
+cdboot_img_ASFLAGS = $(COMMON_ASFLAGS)
+cdboot_img_LDFLAGS = $(COMMON_LDFLAGS) $(TARGET_IMG_LDFLAGS)0x7C00
+cdboot_img_FORMAT = binary
+
+# For kernel.img.
+kernel_img_SOURCES = kern/i386/pc/startup.S \
+	kern/i386/misc.S \
+	kern/main.c kern/device.c \
+	kern/disk.c kern/dl.c kern/file.c kern/fs.c kern/err.c \
+	kern/misc.c kern/mm.c kern/term.c \
+	kern/rescue_parser.c kern/rescue_reader.c \
+	kern/time.c kern/list.c kern/handler.c kern/command.c kern/corecmd.c \
+	kern/$(target_cpu)/dl.c kern/i386/pc/init.c kern/i386/pc/mmap.c \
+	kern/parser.c kern/partition.c \
+	kern/i386/tsc.c kern/i386/pit.c \
+	kern/generic/rtc_get_time_ms.c \
+	kern/generic/millisleep.c \
+	kern/env.c \
+	term/i386/pc/console.c term/i386/vga_common.c \
+	symlist.c
+kernel_img_HEADERS += machine/biosdisk.h machine/vga.h machine/vbe.h \
+	machine/pxe.h i386/pit.h
+kernel_img_CFLAGS = $(COMMON_CFLAGS)  $(TARGET_IMG_CFLAGS)
+kernel_img_ASFLAGS = $(COMMON_ASFLAGS)
+kernel_img_LDFLAGS += $(COMMON_LDFLAGS) $(TARGET_IMG_LDFLAGS)$(GRUB_KERNEL_MACHINE_LINK_ADDR) $(COMMON_CFLAGS)
+kernel_img_FORMAT = binary
+
+# Utilities.
+bin_UTILITIES = grub-mkimage
+sbin_UTILITIES = grub-setup
+
+# For grub-mkimage.
+grub_mkimage_SOURCES = gnulib/progname.c util/grub-mkrawimage.c util/misc.c \
+	util/resolve.c lib/LzmaEnc.c lib/LzFind.c
+grub_mkimage_CFLAGS = -DGRUB_KERNEL_MACHINE_LINK_ADDR=$(GRUB_KERNEL_MACHINE_LINK_ADDR)
+util/grub-mkrawimage.c_DEPENDENCIES = Makefile
+
+# For grub-setup.
+util/i386/pc/grub-setup.c_DEPENDENCIES = grub_setup_init.h
+grub_setup_SOURCES = gnulib/progname.c \
+	util/i386/pc/grub-setup.c util/hostdisk.c	\
+	util/misc.c util/getroot.c kern/device.c kern/disk.c	\
+	kern/err.c kern/misc.c kern/parser.c kern/partition.c	\
+	kern/file.c kern/fs.c kern/env.c kern/list.c		\
+	fs/fshelp.c						\
+	\
+	fs/affs.c fs/cpio.c fs/ext2.c fs/fat.c fs/hfs.c		 \
+	fs/hfsplus.c fs/iso9660.c fs/udf.c fs/jfs.c fs/minix.c	 \
+	fs/nilfs2.c fs/ntfs.c fs/ntfscomp.c fs/reiserfs.c	\
+	fs/sfs.c fs/ufs.c fs/ufs2.c fs/xfs.c fs/afs.c		\
+	fs/afs_be.c fs/befs.c fs/befs_be.c fs/tar.c		\
+	\
+	partmap/msdos.c partmap/bsdlabel.c partmap/sunpc.c	\
+	partmap/gpt.c		\
+	\
+	disk/raid.c disk/mdraid_linux.c disk/lvm.c		\
+	util/raid.c util/lvm.c util/mm.c			\
+	grub_setup_init.c
+
+sbin_SCRIPTS += grub-install
+grub_install_SOURCES = util/grub-install.in
+
+bin_SCRIPTS += grub-mkrescue
+grub_mkrescue_SOURCES = util/grub-mkrescue.in
+
+pkglib_MODULES = biosdisk.mod chain.mod 				\
+	halt.mod				\
+	vbe.mod vbetest.mod vbeinfo.mod 		\
+	vga.mod				\
+	aout.mod bsd.mod pxe.mod pxecmd.mod datetime.mod  	\
+	ata_pthru.mod hdparm.mod 		\
+	usb.mod uhci.mod ohci.mod usbtest.mod usbms.mod usb_keyboard.mod \
+	efiemu.mod mmap.mod acpi.mod drivemap.mod
+
+# For drivemap.mod.
+drivemap_mod_SOURCES = commands/i386/pc/drivemap.c \
+                       commands/i386/pc/drivemap_int13h.S
+drivemap_mod_ASFLAGS = $(COMMON_ASFLAGS)
+drivemap_mod_CFLAGS = $(COMMON_CFLAGS)
+drivemap_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For efiemu.mod.
+efiemu_mod_SOURCES = efiemu/main.c efiemu/i386/loadcore32.c \
+		     efiemu/i386/loadcore64.c efiemu/i386/pc/cfgtables.c \
+		     efiemu/mm.c efiemu/loadcore_common.c efiemu/symbols.c \
+		     efiemu/loadcore32.c efiemu/loadcore64.c \
+		     efiemu/prepare32.c efiemu/prepare64.c efiemu/pnvram.c \
+		     efiemu/i386/coredetect.c
+efiemu_mod_CFLAGS = $(COMMON_CFLAGS)
+efiemu_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For acpi.mod.
+acpi_mod_SOURCES = commands/acpi.c commands/i386/pc/acpi.c
+acpi_mod_CFLAGS = $(COMMON_CFLAGS)
+acpi_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For mmap.mod.
+mmap_mod_SOURCES = mmap/mmap.c mmap/i386/uppermem.c mmap/i386/mmap.c \
+		   mmap/i386/pc/mmap.c mmap/i386/pc/mmap_helper.S
+mmap_mod_CFLAGS = $(COMMON_CFLAGS)
+mmap_mod_LDFLAGS = $(COMMON_LDFLAGS)
+mmap_mod_ASFLAGS = $(COMMON_ASFLAGS)
+
+# For biosdisk.mod.
+biosdisk_mod_SOURCES = disk/i386/pc/biosdisk.c
+biosdisk_mod_CFLAGS = $(COMMON_CFLAGS)
+biosdisk_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For chain.mod.
+chain_mod_SOURCES = loader/i386/pc/chainloader.c
+chain_mod_CFLAGS = $(COMMON_CFLAGS)
+chain_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+pkglib_MODULES += linux16.mod
+linux16_mod_SOURCES = loader/i386/pc/linux.c
+linux16_mod_CFLAGS = $(COMMON_CFLAGS)
+linux16_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+pkglib_MODULES += linux.mod
+linux_mod_SOURCES = loader/i386/linux.c
+linux_mod_CFLAGS = $(COMMON_CFLAGS)
+linux_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+pkglib_MODULES += xnu.mod
+xnu_mod_SOURCES = loader/xnu_resume.c loader/i386/xnu.c loader/i386/pc/xnu.c \
+	 loader/macho32.c loader/macho64.c loader/macho.c loader/xnu.c
+xnu_mod_CFLAGS = $(COMMON_CFLAGS)
+xnu_mod_LDFLAGS = $(COMMON_LDFLAGS)
+xnu_mod_ASFLAGS = $(COMMON_ASFLAGS)
+
+# For halt.mod.
+halt_mod_SOURCES = commands/i386/pc/halt.c
+halt_mod_CFLAGS = $(COMMON_CFLAGS)
+halt_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For vbe.mod.
+vbe_mod_SOURCES = video/i386/pc/vbe.c
+vbe_mod_CFLAGS = $(COMMON_CFLAGS)
+vbe_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For vbeinfo.mod.
+vbeinfo_mod_SOURCES = commands/i386/pc/vbeinfo.c
+vbeinfo_mod_CFLAGS = $(COMMON_CFLAGS)
+vbeinfo_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For vbetest.mod.
+vbetest_mod_SOURCES = commands/i386/pc/vbetest.c
+vbetest_mod_CFLAGS = $(COMMON_CFLAGS)
+vbetest_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For vga.mod.
+vga_mod_SOURCES = term/i386/pc/vga.c
+vga_mod_CFLAGS = $(COMMON_CFLAGS)
+vga_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For aout.mod
+aout_mod_SOURCES = loader/aout.c
+aout_mod_CFLAGS = $(COMMON_CFLAGS)
+aout_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For bsd.mod
+bsd_mod_SOURCES = loader/i386/bsd.c loader/i386/bsd32.c loader/i386/bsd64.c loader/i386/bsd_helper.S loader/i386/bsd_trampoline.S
+bsd_mod_CFLAGS = $(COMMON_CFLAGS)
+bsd_mod_LDFLAGS = $(COMMON_LDFLAGS)
+bsd_mod_ASFLAGS = $(COMMON_ASFLAGS)
+
+# For usb.mod
+usb_mod_SOURCES = bus/usb/usb.c bus/usb/usbtrans.c bus/usb/usbhub.c
+usb_mod_CFLAGS = $(COMMON_CFLAGS)
+usb_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For usbtest.mod
+usbtest_mod_SOURCES = commands/usbtest.c
+usbtest_mod_CFLAGS = $(COMMON_CFLAGS)
+usbtest_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For uhci.mod
+uhci_mod_SOURCES = bus/usb/uhci.c
+uhci_mod_CFLAGS = $(COMMON_CFLAGS)
+uhci_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For ohci.mod
+ohci_mod_SOURCES = bus/usb/ohci.c
+ohci_mod_CFLAGS = $(COMMON_CFLAGS)
+ohci_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For usbms.mod
+usbms_mod_SOURCES = disk/usbms.c
+usbms_mod_CFLAGS = $(COMMON_CFLAGS)
+usbms_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For usb_keyboard.mod
+usb_keyboard_mod_SOURCES = term/usb_keyboard.c
+usb_keyboard_mod_CFLAGS = $(COMMON_CFLAGS)
+usb_keyboard_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For pxe.mod
+pxe_mod_SOURCES = fs/i386/pc/pxe.c
+pxe_mod_CFLAGS = $(COMMON_CFLAGS)
+pxe_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For pxecmd.mod
+pxecmd_mod_SOURCES = commands/i386/pc/pxecmd.c
+pxecmd_mod_CFLAGS = $(COMMON_CFLAGS)
+pxecmd_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For datetime.mod
+datetime_mod_SOURCES = lib/cmos_datetime.c
+datetime_mod_CFLAGS = $(COMMON_CFLAGS)
+datetime_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For ata_pthru.mod.
+ata_pthru_mod_SOURCES = disk/ata_pthru.c
+ata_pthru_mod_CFLAGS = $(COMMON_CFLAGS)
+ata_pthru_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For hdparm.mod.
+hdparm_mod_SOURCES = commands/hdparm.c lib/hexdump.c
+hdparm_mod_CFLAGS = $(COMMON_CFLAGS)
+hdparm_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+ifeq ($(enable_efiemu), yes)
+
+efiemu32.o: efiemu/runtime/efiemu.c $(TARGET_OBJ2ELF)
+	-rm -f $@
+ifeq ($(TARGET_APPLE_CC), 1)
+	-rm -f $@.bin
+	$(TARGET_CC) -c -m32 -DELF32 -DAPPLE_CC -o $@.bin -Wall -Werror $< -nostdlib -O2 -I$(srcdir)/efiemu/runtime -I$(srcdir)/include -Iinclude
+	$(OBJCONV) -felf32 -nu -nd $@.bin $@
+	-rm -f $@.bin
+else
+	$(TARGET_CC) -c -m32 -DELF32 -o $@ -Wall -Werror $< -nostdlib -O2 -I$(srcdir)/efiemu/runtime -I$(srcdir)/include -Iinclude
+	if test ! -z $(TARGET_OBJ2ELF); then ./$(TARGET_OBJ2ELF) $@ || (rm -f $@; exit 1); fi
+endif
+
+efiemu64_c.o: efiemu/runtime/efiemu.c
+ifeq ($(TARGET_APPLE_CC), 1)
+	$(TARGET_CC) -c -m64 -DAPPLE_CC=1 -DELF64 -o $@ -Wall -Werror $< -nostdlib -mno-red-zone -O2 -I$(srcdir)/efiemu/runtime -I$(srcdir)/include -Iinclude
+else
+	$(TARGET_CC) -c -m64 -DELF64 -o $@ -Wall -Werror $< -nostdlib  -mcmodel=large -mno-red-zone -O2 -I$(srcdir)/efiemu/runtime -I$(srcdir)/include -Iinclude
+endif
+
+efiemu64_s.o: efiemu/runtime/efiemu.S
+	-rm -f $@
+ifeq ($(TARGET_APPLE_CC), 1)
+	$(TARGET_CC) -c -m64 -DAPPLE_CC=1 -DELF64 -o $@ -Wall -Werror $< -nostdlib -mno-red-zone -O2 -I$(srcdir)/efiemu/runtime -I$(srcdir)/include -Iinclude
+else
+	$(TARGET_CC) -c -m64 -DELF64 -o $@ -Wall -Werror $< -nostdlib  -mcmodel=large -mno-red-zone -O2 -I$(srcdir)/efiemu/runtime -I$(srcdir)/include -Iinclude
+endif
+
+efiemu64.o: efiemu64_c.o efiemu64_s.o  $(TARGET_OBJ2ELF)
+	-rm -f $@
+ifeq ($(TARGET_APPLE_CC), 1)
+	-rm -f $@.bin
+	$(TARGET_CC) -m64 -o $@.bin -Wl,-r $^ -nostdlib
+	$(OBJCONV) -felf64 -nu -nd $@.bin $@
+	-rm -f $@.bin
+else
+	$(TARGET_CC) -m64 -o $@ -Wl,-r $^ -nostdlib
+	if test ! -z $(TARGET_OBJ2ELF); then ./$(TARGET_OBJ2ELF) $@ || (rm -f $@; exit 1); fi
+endif
+
+CLEANFILES += efiemu32.o efiemu64.o efiemu64_c.o efiemu64_s.o
+pkglib_DATA += efiemu32.o efiemu64.o
+
+endif
+
+include $(srcdir)/conf/i386.mk
+include $(srcdir)/conf/common.mk

grub-core/conf/i386-qemu.rmk

@@ -0,0 +1,88 @@
+# -*- makefile -*-
+
+COMMON_CFLAGS = -mrtd -mregparm=3
+
+# Images.
+
+GRUB_KERNEL_MACHINE_LINK_ADDR	= 0x8200
+GRUB_BOOT_MACHINE_LINK_ADDR	= 0xffe00
+
+pkglib_IMAGES += boot.img
+boot_img_SOURCES = boot/i386/qemu/boot.S
+boot_img_ASFLAGS = $(COMMON_ASFLAGS) -DGRUB_BOOT_MACHINE_LINK_ADDR=$(GRUB_BOOT_MACHINE_LINK_ADDR)
+boot_img_LDFLAGS = $(COMMON_LDFLAGS) $(TARGET_IMG_LDFLAGS)$(GRUB_BOOT_MACHINE_LINK_ADDR)
+boot_img_FORMAT = binary
+
+bin_UTILITIES += grub-mkimage
+grub_mkimage_SOURCES = util/grub-mkrawimage.c util/misc.c \
+	util/resolve.c gnulib/progname.c
+grub_mkimage_CFLAGS = -DGRUB_KERNEL_MACHINE_LINK_ADDR=$(GRUB_KERNEL_MACHINE_LINK_ADDR)
+util/grub-mkrawimage.c_DEPENDENCIES = Makefile
+
+pkglib_IMAGES += kernel.img
+kernel_img_SOURCES = kern/i386/qemu/startup.S \
+	kern/i386/misc.S \
+	kern/i386/coreboot/init.c \
+	kern/i386/qemu/mmap.c \
+	kern/i386/halt.c \
+	kern/main.c kern/device.c \
+	kern/disk.c kern/dl.c kern/file.c kern/fs.c kern/err.c \
+	kern/misc.c kern/mm.c kern/term.c \
+	kern/rescue_parser.c kern/rescue_reader.c \
+	kern/time.c kern/list.c kern/handler.c kern/command.c kern/corecmd.c \
+	kern/$(target_cpu)/dl.c kern/parser.c kern/partition.c \
+	kern/i386/tsc.c kern/i386/pit.c \
+	kern/generic/rtc_get_time_ms.c \
+	kern/generic/millisleep.c \
+	kern/env.c \
+	term/i386/pc/vga_text.c term/i386/vga_common.c \
+	symlist.c
+kernel_img_CFLAGS = $(COMMON_CFLAGS) -DGRUB_BOOT_MACHINE_LINK_ADDR=$(GRUB_BOOT_MACHINE_LINK_ADDR)
+kernel_img_ASFLAGS = $(COMMON_ASFLAGS) -DGRUB_KERNEL_MACHINE_LINK_ADDR=$(GRUB_KERNEL_MACHINE_LINK_ADDR)
+kernel_img_LDFLAGS += $(COMMON_LDFLAGS) $(TARGET_IMG_LDFLAGS)$(GRUB_KERNEL_MACHINE_LINK_ADDR)
+kernel_img_FORMAT = binary
+
+sbin_SCRIPTS += grub-install
+grub_install_SOURCES = util/grub-install.in
+
+bin_SCRIPTS += grub-mkrescue
+grub_mkrescue_SOURCES = util/grub-mkrescue.in
+
+# Modules.
+pkglib_MODULES = linux.mod aout.mod halt.mod datetime.mod mmap.mod
+
+# For mmap.mod.
+mmap_mod_SOURCES = mmap/mmap.c mmap/i386/uppermem.c mmap/i386/mmap.c
+mmap_mod_CFLAGS = $(COMMON_CFLAGS)
+mmap_mod_LDFLAGS = $(COMMON_LDFLAGS)
+mmap_mod_ASFLAGS = $(COMMON_ASFLAGS)
+
+# For linux.mod.
+linux_mod_SOURCES = loader/i386/linux.c
+linux_mod_CFLAGS = $(COMMON_CFLAGS)
+linux_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For halt.mod.
+halt_mod_SOURCES = commands/halt.c
+halt_mod_CFLAGS = $(COMMON_CFLAGS)
+halt_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For aout.mod.
+aout_mod_SOURCES = loader/aout.c
+aout_mod_CFLAGS = $(COMMON_CFLAGS)
+aout_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For bsd.mod
+pkglib_MODULES += bsd.mod
+bsd_mod_SOURCES = loader/i386/bsd.c loader/i386/bsd32.c loader/i386/bsd64.c loader/i386/bsd_helper.S loader/i386/bsd_trampoline.S
+bsd_mod_CFLAGS = $(COMMON_CFLAGS)
+bsd_mod_LDFLAGS = $(COMMON_LDFLAGS)
+bsd_mod_ASFLAGS = $(COMMON_ASFLAGS)
+
+# For datetime.mod
+datetime_mod_SOURCES = lib/cmos_datetime.c
+datetime_mod_CFLAGS = $(COMMON_CFLAGS)
+datetime_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+include $(srcdir)/conf/i386.mk
+include $(srcdir)/conf/common.mk

grub-core/conf/i386.rmk

@@ -0,0 +1,75 @@
+# -*- makefile -*-
+
+pkglib_MODULES += cpuid.mod
+cpuid_mod_SOURCES = commands/i386/cpuid.c
+cpuid_mod_CFLAGS = $(COMMON_CFLAGS)
+cpuid_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+pkglib_MODULES += at_keyboard.mod
+at_keyboard_mod_SOURCES = term/at_keyboard.c
+at_keyboard_mod_CFLAGS = $(COMMON_CFLAGS)
+at_keyboard_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+pkglib_MODULES += vga_text.mod
+vga_text_mod_SOURCES = term/i386/pc/vga_text.c term/i386/vga_common.c
+vga_text_mod_CFLAGS = $(COMMON_CFLAGS)
+vga_text_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+pkglib_MODULES += relocator.mod
+relocator_mod_SOURCES = lib/i386/relocator.c lib/i386/relocator_asm.S lib/i386/relocator_backward.S
+relocator_mod_CFLAGS = $(COMMON_CFLAGS)
+relocator_mod_ASFLAGS = $(COMMON_ASFLAGS)
+relocator_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+pkglib_MODULES += ata.mod
+ata_mod_SOURCES = disk/ata.c
+ata_mod_CFLAGS = $(COMMON_CFLAGS)
+ata_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For setpci.mod
+pkglib_MODULES += setpci.mod
+setpci_mod_SOURCES = commands/setpci.c
+setpci_mod_CFLAGS = $(COMMON_CFLAGS)
+setpci_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+pkglib_MODULES += multiboot.mod
+multiboot_mod_SOURCES = loader/multiboot.c loader/i386/multiboot_mbi.c
+multiboot_mod_CFLAGS = $(COMMON_CFLAGS)
+multiboot_mod_LDFLAGS = $(COMMON_LDFLAGS)
+multiboot_mod_ASFLAGS = $(COMMON_ASFLAGS)
+
+pkglib_MODULES += multiboot2.mod
+multiboot2_mod_SOURCES = loader/multiboot.c loader/multiboot_mbi2.c
+multiboot2_mod_CFLAGS = $(COMMON_CFLAGS) -DGRUB_USE_MULTIBOOT2
+multiboot2_mod_LDFLAGS = $(COMMON_LDFLAGS)
+multiboot2_mod_ASFLAGS = $(COMMON_ASFLAGS)
+
+# For serial.mod.
+pkglib_MODULES += serial.mod
+serial_mod_SOURCES = term/serial.c
+serial_mod_CFLAGS = $(COMMON_CFLAGS)
+serial_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For pci.mod
+pkglib_MODULES += pci.mod
+pci_mod_SOURCES = bus/pci.c
+pci_mod_CFLAGS = $(COMMON_CFLAGS)
+pci_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For lspci.mod
+pkglib_MODULES += lspci.mod
+lspci_mod_SOURCES = commands/lspci.c
+lspci_mod_CFLAGS = $(COMMON_CFLAGS)
+lspci_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For play.mod.
+pkglib_MODULES += play.mod
+play_mod_SOURCES = commands/i386/pc/play.c
+play_mod_CFLAGS = $(COMMON_CFLAGS)
+play_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For iorw.mod.
+pkglib_MODULES += iorw.mod
+iorw_mod_SOURCES = commands/iorw.c
+iorw_mod_CFLAGS = $(COMMON_CFLAGS)
+iorw_mod_LDFLAGS = $(COMMON_LDFLAGS)

grub-core/conf/mips-qemu-mips.rmk

@@ -0,0 +1,22 @@
+# -*- makefile -*-
+LINK_BASE = 0x80010000
+target_machine=qemu-mips
+COMMON_CFLAGS += -march=mips3
+COMMON_ASFLAGS += -march=mips3
+include $(srcdir)/conf/mips.mk
+
+pkglib_IMAGES = kernel.img
+kernel_img_SOURCES = kern/$(target_cpu)/startup.S \
+	kern/main.c kern/device.c kern/$(target_cpu)/init.c \
+	kern/$(target_cpu)/$(target_machine)/init.c 		\
+	kern/disk.c kern/dl.c kern/err.c kern/file.c kern/fs.c 		\
+	kern/misc.c kern/mm.c kern/term.c 	\
+	kern/rescue_parser.c kern/rescue_reader.c \
+	kern/list.c kern/handler.c kern/command.c kern/corecmd.c	\
+	kern/parser.c kern/partition.c kern/env.c kern/$(target_cpu)/dl.c 	\
+	kern/generic/millisleep.c kern/generic/rtc_get_time_ms.c kern/time.c    \
+	symlist.c kern/$(target_cpu)/cache.S
+kernel_img_CFLAGS = $(COMMON_CFLAGS)
+kernel_img_ASFLAGS = $(COMMON_ASFLAGS)
+kernel_img_LDFLAGS = $(COMMON_LDFLAGS) -Wl,-N,-S,-Ttext,$(LINK_BASE),-Bstatic
+kernel_img_FORMAT = binary

grub-core/conf/mips-yeeloong.rmk

@@ -0,0 +1,73 @@
+# -*- makefile -*-
+LINK_BASE = 0x80200000
+target_machine=yeeloong
+COMMON_CFLAGS += -march=mips3
+COMMON_ASFLAGS += -march=mips3
+
+kernel_img_HEADERS += pci.h bitmap.h video.h gfxterm.h font.h bitmap_scale.h bufio.h
+
+include $(srcdir)/conf/mips.mk
+
+pkglib_IMAGES = kernel.img
+kernel_img_SOURCES = kern/$(target_cpu)/startup.S \
+	kern/main.c kern/device.c kern/$(target_cpu)/init.c \
+	kern/$(target_cpu)/$(target_machine)/init.c 		\
+	kern/disk.c kern/dl.c kern/err.c kern/file.c kern/fs.c 		\
+	kern/misc.c kern/mm.c kern/term.c 	\
+	kern/rescue_parser.c kern/rescue_reader.c \
+	kern/list.c kern/handler.c kern/command.c kern/corecmd.c	\
+	kern/parser.c kern/partition.c kern/env.c kern/$(target_cpu)/dl.c 	\
+	kern/generic/millisleep.c kern/generic/rtc_get_time_ms.c kern/time.c    \
+	kern/$(target_cpu)/cache.S \
+	\
+	term/at_keyboard.c \
+	font/font_cmd.c font/font.c io/bufio.c \
+	video/video.c video/fb/video_fb.c video/fb/fbblit.c \
+	video/fb/fbfill.c video/fb/fbutil.c video/bitmap.c \
+	video/bitmap_scale.c video/sm712.c bus/pci.c bus/bonito.c \
+	term/gfxterm.c commands/extcmd.c lib/arg.c \
+	symlist.c
+kernel_img_CFLAGS = $(COMMON_CFLAGS) -DUSE_ASCII_FAILBACK
+kernel_img_ASFLAGS = $(COMMON_ASFLAGS)
+kernel_img_LDFLAGS += $(COMMON_LDFLAGS) -Wl,-N,-S,-Ttext,$(LINK_BASE),-Bstatic
+kernel_img_FORMAT = binary
+
+# For ata.mod.
+pkglib_MODULES += ata.mod
+ata_mod_SOURCES = disk/ata.c
+ata_mod_CFLAGS = $(COMMON_CFLAGS)
+ata_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For lspci.mod
+pkglib_MODULES += lspci.mod
+lspci_mod_SOURCES = commands/lspci.c
+lspci_mod_CFLAGS = $(COMMON_CFLAGS)
+lspci_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For ata_pthru.mod.
+pkglib_MODULES += ata_pthru.mod
+ata_pthru_mod_SOURCES = disk/ata_pthru.c
+ata_pthru_mod_CFLAGS = $(COMMON_CFLAGS)
+ata_pthru_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For mmap.mod.
+pkglib_MODULES += mmap.mod
+mmap_mod_SOURCES = mmap/mmap.c mmap/mips/yeeloong/uppermem.c
+mmap_mod_CFLAGS = $(COMMON_CFLAGS)
+mmap_mod_LDFLAGS = $(COMMON_LDFLAGS)
+mmap_mod_ASFLAGS = $(COMMON_ASFLAGS)
+
+# For datetime.mod
+pkglib_MODULES += datetime.mod
+datetime_mod_SOURCES = lib/cmos_datetime.c
+datetime_mod_CFLAGS = $(COMMON_CFLAGS)
+datetime_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+pkglib_MODULES += linux.mod
+linux_mod_SOURCES = loader/$(target_cpu)/linux.c
+linux_mod_CFLAGS = $(COMMON_CFLAGS)
+linux_mod_ASFLAGS = $(COMMON_ASFLAGS)
+linux_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+sbin_SCRIPTS += grub-install
+grub_install_SOURCES = util/grub-install.in

grub-core/conf/mips.rmk

@@ -0,0 +1,40 @@
+
+# -*- makefile -*-
+
+COMMON_CFLAGS += -mexplicit-relocs -mflush-func=grub_cpu_flush_cache
+
+# Images.
+kernel_img_HEADERS += cpu/cache.h
+
+# Scripts.
+sbin_SCRIPTS = 
+bin_SCRIPTS = 
+
+# For grub-mkimage.
+bin_UTILITIES += grub-mkimage
+grub_mkimage_SOURCES = gnulib/progname.c util/grub-mkrawimage.c util/misc.c \
+	util/resolve.c lib/LzmaEnc.c lib/LzFind.c
+grub_mkimage_CFLAGS = -DGRUB_KERNEL_MACHINE_LINK_ADDR=$(LINK_BASE)
+util/grub-mkrawimage.c_DEPENDENCIES = Makefile
+
+# For serial.mod.
+pkglib_MODULES += serial.mod
+serial_mod_SOURCES = term/serial.c
+serial_mod_CFLAGS = $(COMMON_CFLAGS)
+serial_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For relocator.mod.
+pkglib_MODULES += relocator.mod
+relocator_mod_SOURCES = lib/$(target_cpu)/relocator.c lib/$(target_cpu)/relocator_asm.S
+relocator_mod_CFLAGS = $(COMMON_CFLAGS)
+relocator_mod_ASFLAGS = $(COMMON_ASFLAGS)
+relocator_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+pkglib_MODULES += multiboot2.mod
+multiboot2_mod_SOURCES = loader/multiboot.c \
+			 loader/multiboot_mbi2.c
+multiboot2_mod_CFLAGS = $(COMMON_CFLAGS) -DGRUB_USE_MULTIBOOT2
+multiboot2_mod_LDFLAGS = $(COMMON_LDFLAGS)
+multiboot2_mod_ASFLAGS = $(COMMON_ASFLAGS)
+
+include $(srcdir)/conf/common.mk

grub-core/conf/powerpc-ieee1275.rmk

@@ -0,0 +1,68 @@
+
+# -*- makefile -*-
+
+# Images.
+
+kernel_img_HEADERS += ieee1275/ieee1275.h
+
+# Programs
+pkglib_PROGRAMS = kernel.img
+
+kernel_img_SOURCES = kern/powerpc/ieee1275/startup.S kern/ieee1275/cmain.c \
+	kern/ieee1275/ieee1275.c kern/main.c kern/device.c 		\
+	kern/disk.c kern/dl.c kern/err.c kern/file.c kern/fs.c 		\
+	kern/misc.c kern/mm.c kern/term.c 	\
+	kern/rescue_parser.c kern/rescue_reader.c \
+	kern/list.c kern/handler.c kern/command.c kern/corecmd.c	\
+	kern/ieee1275/init.c 						\
+	kern/ieee1275/mmap.c						\
+	term/ieee1275/ofconsole.c 		\
+	kern/ieee1275/openfw.c disk/ieee1275/ofdisk.c 		\
+	kern/parser.c kern/partition.c kern/env.c kern/$(target_cpu)/dl.c 	\
+	kern/generic/millisleep.c kern/time.c                            \
+	symlist.c kern/$(target_cpu)/cache.S
+kernel_img_CFLAGS = $(COMMON_CFLAGS)
+kernel_img_ASFLAGS = $(COMMON_ASFLAGS)
+kernel_img_LDFLAGS += $(COMMON_LDFLAGS) -Wl,-N,-S,-Ttext,0x200000,-Bstatic
+
+# Scripts.
+sbin_SCRIPTS = grub-install
+bin_SCRIPTS = grub-mkrescue
+
+# For grub-install.
+grub_install_SOURCES = util/ieee1275/grub-install.in
+
+# For grub-mkrescue.
+grub_mkrescue_SOURCES = util/powerpc/ieee1275/grub-mkrescue.in
+
+# Modules.
+pkglib_MODULES += ieee1275_fb.mod 
+ieee1275_fb_mod_SOURCES = video/ieee1275.c
+ieee1275_fb_mod_CFLAGS = $(COMMON_CFLAGS)
+ieee1275_fb_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For linux.mod.
+pkglib_MODULES += linux.mod
+linux_mod_SOURCES = loader/powerpc/ieee1275/linux.c
+linux_mod_CFLAGS = $(COMMON_CFLAGS)
+linux_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For suspend.mod
+pkglib_MODULES += suspend.mod
+suspend_mod_SOURCES = commands/ieee1275/suspend.c
+suspend_mod_CFLAGS = $(COMMON_CFLAGS)
+suspend_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For halt.mod
+pkglib_MODULES += halt.mod
+halt_mod_SOURCES = commands/halt.c
+halt_mod_CFLAGS = $(COMMON_CFLAGS)
+halt_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For datetime.mod
+pkglib_MODULES += datetime.mod
+datetime_mod_SOURCES = lib/ieee1275/datetime.c
+datetime_mod_CFLAGS = $(COMMON_CFLAGS)
+datetime_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+include $(srcdir)/conf/common.mk

grub-core/conf/sparc64-ieee1275.rmk

@@ -0,0 +1,106 @@
+
+# -*- makefile -*-
+
+COMMON_CFLAGS = -mno-app-regs
+COMMON_LDFLAGS = -melf64_sparc -mno-relax
+
+# Images.
+pkglib_IMAGES = boot.img diskboot.img kernel.img
+
+# For boot.img.
+boot_img_SOURCES = boot/sparc64/ieee1275/boot.S
+boot_img_ASFLAGS = $(COMMON_ASFLAGS)
+boot_img_LDFLAGS = $(COMMON_LDFLAGS) -Wl,-N,-Ttext,0x4000
+boot_img_FORMAT = a.out-sunos-big
+
+# For diskboot.img.
+diskboot_img_SOURCES = boot/sparc64/ieee1275/diskboot.S
+diskboot_img_ASFLAGS = $(COMMON_ASFLAGS)
+diskboot_img_LDFLAGS = $(COMMON_LDFLAGS) -Wl,-N,-Ttext,0x4200
+diskboot_img_FORMAT = binary
+
+kernel_img_HEADERS += ieee1275/ieee1275.h cpu/ieee1275/ieee1275.h
+kernel_img_SOURCES = kern/sparc64/ieee1275/crt0.S kern/ieee1275/cmain.c	\
+	kern/ieee1275/ieee1275.c kern/main.c kern/device.c		\
+	kern/disk.c kern/dl.c kern/err.c kern/file.c kern/fs.c		\
+	kern/misc.c kern/mm.c kern/term.c			\
+	kern/rescue_parser.c kern/rescue_reader.c \
+	kern/list.c kern/handler.c kern/command.c kern/corecmd.c	\
+	kern/sparc64/ieee1275/ieee1275.c 				\
+	kern/sparc64/ieee1275/init.c 					\
+	kern/ieee1275/mmap.c						\
+	term/ieee1275/ofconsole.c 					\
+	kern/ieee1275/openfw.c disk/ieee1275/ofdisk.c 			\
+	kern/parser.c kern/partition.c kern/env.c kern/$(target_cpu)/dl.c	\
+	kern/generic/millisleep.c kern/time.c				\
+	symlist.c kern/$(target_cpu)/cache.S
+kernel_img_CFLAGS = $(COMMON_CFLAGS)
+kernel_img_ASFLAGS = $(COMMON_ASFLAGS)
+kernel_img_LDFLAGS += -nostdlib -Wl,-N,-Ttext,0x4400,-Bstatic,-melf64_sparc
+kernel_img_FORMAT = binary
+
+# Utilities.
+bin_UTILITIES = grub-mkimage
+sbin_UTILITIES = grub-setup grub-ofpathname
+
+# For grub-mkimage.
+grub_mkimage_SOURCES = util/grub-mkrawimage.c util/misc.c \
+        util/resolve.c gnulib/progname.c
+
+# For grub-setup.
+util/sparc64/ieee1275/grub-setup.c_DEPENDENCIES = grub_setup_init.h
+grub_setup_SOURCES = util/sparc64/ieee1275/grub-setup.c util/hostdisk.c	\
+	util/ieee1275/ofpath.c \
+	util/misc.c util/getroot.c kern/device.c kern/disk.c	\
+	kern/err.c kern/misc.c kern/parser.c kern/partition.c	\
+	kern/file.c kern/fs.c kern/env.c kern/list.c		\
+	fs/fshelp.c						\
+	\
+	fs/affs.c fs/cpio.c fs/ext2.c fs/fat.c fs/hfs.c		\
+	fs/hfsplus.c fs/iso9660.c fs/udf.c fs/jfs.c fs/minix.c	\
+	fs/nilfs2.c fs/ntfs.c fs/ntfscomp.c fs/reiserfs.c	\
+	fs/sfs.c fs/ufs.c fs/ufs2.c fs/xfs.c fs/afs.c		\
+	fs/afs_be.c fs/befs.c fs/befs_be.c fs/tar.c		\
+	\
+	partmap/amiga.c	partmap/apple.c partmap/msdos.c 	\
+	partmap/bsdlabel.c partmap/sun.c partmap/acorn.c	\
+	\
+	disk/raid.c disk/mdraid_linux.c disk/lvm.c		\
+	util/raid.c util/lvm.c util/mm.c gnulib/progname.c	\
+	grub_setup_init.c
+
+# For grub-ofpathname.
+grub_ofpathname_SOURCES = util/ieee1275/grub-ofpathname.c \
+	util/ieee1275/ofpath.c util/misc.c gnulib/progname.c
+
+# Scripts.
+sbin_SCRIPTS = grub-install
+
+# For grub-install.
+grub_install_SOURCES = util/grub-install.in
+
+# Modules.
+pkglib_MODULES += ieee1275_fb.mod 
+ieee1275_fb_mod_SOURCES = video/ieee1275.c
+ieee1275_fb_mod_CFLAGS = $(COMMON_CFLAGS)
+ieee1275_fb_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For linux.mod.
+pkglib_MODULES += linux.mod 
+linux_mod_SOURCES = loader/sparc64/ieee1275/linux.c
+linux_mod_CFLAGS = $(COMMON_CFLAGS)
+linux_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For halt.mod.
+pkglib_MODULES += halt.mod
+halt_mod_SOURCES = commands/halt.c
+halt_mod_CFLAGS = $(COMMON_CFLAGS)
+halt_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For datetime.mod
+pkglib_MODULES += datetime.mod
+datetime_mod_SOURCES = lib/ieee1275/datetime.c
+datetime_mod_CFLAGS = $(COMMON_CFLAGS)
+datetime_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+include $(srcdir)/conf/common.mk

grub-core/conf/tests.rmk

@@ -0,0 +1,94 @@
+# -*- makefile -*-
+
+# For grub-shell
+grub-shell: tests/util/grub-shell.in config.status
+	./config.status --file=$@:$<
+	chmod +x $@
+check_SCRIPTS += grub-shell
+CLEANFILES += grub-shell
+
+# For grub-shell-tester
+grub-shell-tester: tests/util/grub-shell-tester.in config.status
+	./config.status --file=$@:$<
+	chmod +x $@
+check_SCRIPTS += grub-shell-tester
+CLEANFILES += grub-shell-tester
+
+pkglib_MODULES += functional_test.mod
+functional_test_mod_SOURCES = tests/lib/functional_test.c tests/lib/test.c
+functional_test_mod_CFLAGS  = $(COMMON_CFLAGS)
+functional_test_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# Rules for unit tests
+check_UTILITIES += example_unit_test
+example_unit_test_SOURCES = tests/example_unit_test.c kern/list.c kern/misc.c tests/lib/test.c tests/lib/unit_test.c
+example_unit_test_CFLAGS  = -Wno-format
+
+# Rules for functional tests
+pkglib_MODULES += example_functional_test.mod
+example_functional_test_mod_SOURCES = tests/example_functional_test.c
+example_functional_test_mod_CFLAGS  = -Wno-format $(COMMON_CFLAGS)
+example_functional_test_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# Rules for scripted tests
+check_SCRIPTS += example_scripted_test
+example_scripted_test_SOURCES = tests/example_scripted_test.in
+
+check_SCRIPTS += example_grub_script_test
+example_grub_script_test_SOURCES = tests/example_grub_script_test.in
+
+#
+# Rules for real tests
+#
+
+check_SCRIPTS += grub_script_echo1
+grub_script_echo1_SOURCES = tests/grub_script_echo1.in
+
+check_SCRIPTS += grub_script_echo_keywords
+grub_script_echo_keywords_SOURCES = tests/grub_script_echo_keywords.in
+
+check_SCRIPTS += grub_script_vars1
+grub_script_vars1_SOURCES = tests/grub_script_vars1.in
+
+check_SCRIPTS += grub_script_for1
+grub_script_for1_SOURCES = tests/grub_script_for1.in
+
+check_SCRIPTS += grub_script_while1
+grub_script_while1_SOURCES = tests/grub_script_while1.in
+
+check_SCRIPTS += grub_script_if
+grub_script_if_SOURCES = tests/grub_script_if.in
+
+check_SCRIPTS += grub_script_blanklines
+grub_script_blanklines_SOURCES = tests/grub_script_blanklines.in
+
+check_SCRIPTS += grub_script_final_semicolon
+grub_script_final_semicolon_SOURCES = tests/grub_script_final_semicolon.in
+
+check_SCRIPTS += grub_script_dollar
+grub_script_dollar_SOURCES = tests/grub_script_dollar.in
+
+check_SCRIPTS += grub_script_comments
+grub_script_comments_SOURCES = tests/grub_script_comments.in
+
+# List of tests to execute on "make check"
+# SCRIPTED_TESTS    = example_scripted_test
+# SCRIPTED_TESTS   += example_grub_script_test
+# UNIT_TESTS        = example_unit_test
+# FUNCTIONAL_TESTS  = example_functional_test.mod
+
+SCRIPTED_TESTS  = grub_script_echo1
+SCRIPTED_TESTS += grub_script_echo_keywords
+SCRIPTED_TESTS += grub_script_vars1
+SCRIPTED_TESTS += grub_script_for1
+SCRIPTED_TESTS += grub_script_while1
+SCRIPTED_TESTS += grub_script_if
+SCRIPTED_TESTS += grub_script_blanklines
+SCRIPTED_TESTS += grub_script_final_semicolon
+SCRIPTED_TESTS += grub_script_dollar
+SCRIPTED_TESTS += grub_script_comments
+
+# dependencies between tests and testing-tools
+$(SCRIPTED_TESTS): grub-shell grub-shell-tester
+$(FUNCTIONAL_TESTS): functional_test.mod
+

grub-core/conf/x86-efi.rmk

@@ -0,0 +1,117 @@
+# -*- makefile -*-
+
+# Utilities.
+bin_UTILITIES = grub-mkimage
+
+# For grub-mkimage.
+grub_mkimage_SOURCES = gnulib/progname.c util/i386/efi/grub-mkimage.c \
+	util/misc.c util/resolve.c
+util/i386/efi/grub-mkimage.c_DEPENDENCIES = Makefile
+
+# Scripts.
+sbin_SCRIPTS = grub-install
+
+# For grub-install.
+grub_install_SOURCES = util/i386/efi/grub-install.in
+
+# Modules.
+pkglib_PROGRAMS = kernel.img
+pkglib_MODULES = chain.mod appleldr.mod \
+	linux.mod halt.mod  \
+	datetime.mod loadbios.mod \
+	fixvideo.mod mmap.mod acpi.mod
+
+# For kernel.img.
+kernel_img_RELOCATABLE = yes
+kernel_img_SOURCES = kern/$(target_cpu)/efi/startup.S kern/main.c kern/device.c \
+	kern/disk.c kern/dl.c kern/file.c kern/fs.c kern/err.c \
+	kern/misc.c kern/mm.c kern/term.c \
+	kern/rescue_parser.c kern/rescue_reader.c \
+	kern/$(target_cpu)/dl.c kern/i386/efi/init.c kern/parser.c kern/partition.c \
+	kern/env.c symlist.c kern/efi/efi.c kern/efi/init.c kern/efi/mm.c \
+	term/efi/console.c disk/efi/efidisk.c \
+	kern/time.c kern/list.c kern/handler.c kern/command.c kern/corecmd.c \
+	kern/i386/tsc.c kern/i386/pit.c \
+	kern/generic/rtc_get_time_ms.c \
+	kern/generic/millisleep.c
+ifeq ($(target_cpu),x86_64)
+kernel_img_SOURCES += kern/x86_64/efi/callwrap.S
+endif
+kernel_img_HEADERS += efi/efi.h efi/time.h efi/disk.h i386/pit.h
+kernel_img_CFLAGS = $(COMMON_CFLAGS)
+kernel_img_ASFLAGS = $(COMMON_ASFLAGS)
+kernel_img_LDFLAGS += $(COMMON_LDFLAGS)
+
+# For acpi.mod.
+acpi_mod_SOURCES = commands/acpi.c commands/efi/acpi.c
+acpi_mod_CFLAGS = $(COMMON_CFLAGS)
+acpi_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For mmap.mod.
+mmap_mod_SOURCES = mmap/mmap.c mmap/i386/uppermem.c mmap/i386/mmap.c \
+		   mmap/efi/mmap.c
+mmap_mod_CFLAGS = $(COMMON_CFLAGS)
+mmap_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For chain.mod.
+chain_mod_SOURCES = loader/efi/chainloader.c
+chain_mod_CFLAGS = $(COMMON_CFLAGS)
+chain_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For appleldr.mod.
+appleldr_mod_SOURCES = loader/efi/appleloader.c
+appleldr_mod_CFLAGS = $(COMMON_CFLAGS)
+appleldr_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For linux.mod.
+ifeq ($(target_cpu), x86_64)
+linux_mod_SOURCES = loader/i386/efi/linux.c loader/i386/linux_trampoline.S
+linux_mod_CFLAGS = $(COMMON_CFLAGS)
+linux_mod_ASFLAGS = $(COMMON_ASFLAGS)
+linux_mod_LDFLAGS = $(COMMON_LDFLAGS)
+else
+linux_mod_SOURCES = loader/i386/efi/linux.c
+linux_mod_CFLAGS = $(COMMON_CFLAGS)
+linux_mod_ASFLAGS = $(COMMON_ASFLAGS)
+linux_mod_LDFLAGS = $(COMMON_LDFLAGS)
+endif
+
+# For halt.mod.
+halt_mod_SOURCES = commands/halt.c
+halt_mod_CFLAGS = $(COMMON_CFLAGS)
+halt_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For datetime.mod
+datetime_mod_SOURCES = lib/efi/datetime.c
+datetime_mod_CFLAGS = $(COMMON_CFLAGS)
+datetime_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For loadbios.mod
+loadbios_mod_SOURCES = commands/efi/loadbios.c
+loadbios_mod_CFLAGS = $(COMMON_CFLAGS)
+loadbios_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+# For fixvideo.mod
+fixvideo_mod_SOURCES = commands/efi/fixvideo.c
+fixvideo_mod_CFLAGS = $(COMMON_CFLAGS)
+fixvideo_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+pkglib_MODULES += efi_uga.mod
+efi_uga_mod_SOURCES = video/efi_uga.c
+efi_uga_mod_CFLAGS = $(COMMON_CFLAGS)
+efi_uga_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+pkglib_MODULES += efi_gop.mod
+efi_gop_mod_SOURCES = video/efi_gop.c
+efi_gop_mod_CFLAGS = $(COMMON_CFLAGS)
+efi_gop_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+pkglib_MODULES += xnu.mod
+xnu_mod_SOURCES = loader/xnu_resume.c loader/i386/xnu.c loader/i386/efi/xnu.c \
+	loader/macho32.c loader/macho64.c loader/macho.c loader/xnu.c
+xnu_mod_CFLAGS = $(COMMON_CFLAGS)
+xnu_mod_LDFLAGS = $(COMMON_LDFLAGS)
+xnu_mod_ASFLAGS = $(COMMON_ASFLAGS)
+
+include $(srcdir)/conf/i386.mk
+include $(srcdir)/conf/common.mk

grub-core/conf/x86_64-efi.rmk

@@ -0,0 +1,5 @@
+# -*- makefile -*-
+
+COMMON_LDFLAGS = -melf_x86_64
+
+include $(srcdir)/conf/x86-efi.mk

grub-core/configure.ac

@@ -0,0 +1,91 @@
+# Process this file with autoconf to produce a configure script.
+
+# Copyright (C) 2010  Free Software Foundation, Inc.
+#
+# This configure.ac is free software; the author
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+dnl This configure script is complicated, because GRUB needs to deal
+dnl with three potentially different types:
+dnl
+dnl   build  -- the environment for building GRUB
+dnl   host   -- the environment for running utilities
+dnl   target -- the environment for running GRUB
+dnl
+dnl In addition, GRUB needs to deal with a platform specification
+dnl which specifies the system running GRUB, such as firmware.
+dnl This is necessary because the target type in autoconf does not
+dnl describe such a system very well.
+dnl
+dnl The current strategy is to build utilities using host
+dnl cross-compiler and grub core and modules using target
+dnl cross-compiler.  For this we use nested packages approach, where
+dnl top-level package grub utilities is built with HOSTCC and nested
+dnl package (in grub-core directory) builds with TARGETCC.
+
+# NOTE: ../configure.ac must also be updated.
+AC_INIT([GRUB],[1.98],[bug-grub@gnu.org])
+AC_CONFIG_AUX_DIR([.])
+
+# Checks for host and target systems.
+AC_CANONICAL_HOST
+AC_CANONICAL_TARGET
+
+AM_INIT_AUTOMAKE()
+AC_PREREQ(2.60)
+AC_CONFIG_SRCDIR([include/grub/dl.h])
+AC_CONFIG_HEADER([config.h])
+
+m4_include([configure.common])
+
+TARGET_CPP="$TARGET_CC -E"
+TARGET_CCAS=$TARGET_CC
+
+CC=$TARGET_CC
+CPP=$TARGET_CC
+CCAS=$TARGET_CC
+
+AC_SUBST(TARGET_CC)
+AC_SUBST(TARGET_CPP)
+AC_SUBST(TARGET_CCAS)
+AC_SUBST(TARGET_IMG_LDSCRIPT)
+AC_SUBST(TARGET_IMG_LDFLAGS)
+AC_SUBST(TARGET_IMG_CFLAGS)
+AC_SUBST(TARGET_OBJ2ELF)
+AC_SUBST(TARGET_MODULE_FORMAT)
+AC_SUBST(OBJCONV)
+AC_SUBST(TARGET_APPLE_CC)
+AC_SUBST(ASFLAGS)
+AC_SUBST(TARGET_CFLAGS)
+AC_SUBST(TARGET_ASFLAGS)
+AC_SUBST(TARGET_LDFLAGS)
+AC_SUBST(TARGET_CPPFLAGS)
+
+# Output files.
+grub_CHECK_LINK_DIR
+if test x"$link_dir" = xyes ; then
+  AC_CONFIG_LINKS([include/grub/cpu:include/grub/$target_cpu])
+  if test "$platform" != emu ; then
+    AC_CONFIG_LINKS([include/grub/machine:include/grub/$target_cpu/$platform])
+  fi
+else
+  mkdir -p include/grub 2>/dev/null
+  rm -rf include/grub/cpu
+  cp -rp $srcdir/include/grub/$target_cpu include/grub/cpu 2>/dev/null
+  if test "$platform" != emu ; then
+    rm -rf include/grub/machine
+    cp -rp $srcdir/include/grub/$target_cpu/$platform include/grub/machine 2>/dev/null
+  fi
+fi
+
+AC_CONFIG_FILES([Makefile])
+AC_CONFIG_FILES([po/Makefile])
+AC_CONFIG_FILES([stamp-h], [echo timestamp > stamp-h])
+
+AC_OUTPUT

grub-core/disk/ata.c

@@ -0,0 +1,894 @@
+/* ata.c - ATA disk access.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2007, 2008, 2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/ata.h>
+#include <grub/dl.h>
+#include <grub/disk.h>
+#include <grub/mm.h>
+#include <grub/time.h>
+#include <grub/pci.h>
+#include <grub/scsi.h>
+
+/* At the moment, only two IDE ports are supported.  */
+static const grub_port_t grub_ata_ioaddress[] = { 0x1f0, 0x170 };
+static const grub_port_t grub_ata_ioaddress2[] = { 0x3f6, 0x376 };
+
+static struct grub_ata_device *grub_ata_devices;
+
+/* Wait for !BSY.  */
+grub_err_t
+grub_ata_wait_not_busy (struct grub_ata_device *dev, int milliseconds)
+{
+  /* ATA requires 400ns (after a write to CMD register) or
+     1 PIO cycle (after a DRQ block transfer) before
+     first check of BSY.  */
+  grub_millisleep (1);
+
+  int i = 1;
+  grub_uint8_t sts;
+  while ((sts = grub_ata_regget (dev, GRUB_ATA_REG_STATUS))
+	 & GRUB_ATA_STATUS_BUSY)
+    {
+      if (i >= milliseconds)
+        {
+	  grub_dprintf ("ata", "timeout: %dms, status=0x%x\n",
+			milliseconds, sts);
+	  return grub_error (GRUB_ERR_TIMEOUT, "ATA timeout");
+	}
+
+      grub_millisleep (1);
+      i++;
+    }
+
+  return GRUB_ERR_NONE;
+}
+
+static inline void
+grub_ata_wait (void)
+{
+  grub_millisleep (50);
+}
+
+/* Wait for !BSY, DRQ.  */
+grub_err_t
+grub_ata_wait_drq (struct grub_ata_device *dev, int rw,
+		   int milliseconds)
+{
+  if (grub_ata_wait_not_busy (dev, milliseconds))
+    return grub_errno;
+
+  /* !DRQ implies error condition.  */
+  grub_uint8_t sts = grub_ata_regget (dev, GRUB_ATA_REG_STATUS);
+  if ((sts & (GRUB_ATA_STATUS_DRQ | GRUB_ATA_STATUS_ERR))
+      != GRUB_ATA_STATUS_DRQ)
+    {
+      grub_dprintf ("ata", "ata error: status=0x%x, error=0x%x\n",
+		    sts, grub_ata_regget (dev, GRUB_ATA_REG_ERROR));
+      if (! rw)
+        return grub_error (GRUB_ERR_READ_ERROR, "ATA read error");
+      else
+        return grub_error (GRUB_ERR_WRITE_ERROR, "ATA write error");
+    }
+
+  return GRUB_ERR_NONE;
+}
+
+/* Byteorder has to be changed before strings can be read.  */
+static void
+grub_ata_strncpy (char *dst, char *src, grub_size_t len)
+{
+  grub_uint16_t *src16 = (grub_uint16_t *) src;
+  grub_uint16_t *dst16 = (grub_uint16_t *) dst;
+  unsigned int i;
+
+  for (i = 0; i < len / 2; i++)
+    *(dst16++) = grub_be_to_cpu16 (*(src16++));
+  dst[len] = '\0';
+}
+
+void
+grub_ata_pio_read (struct grub_ata_device *dev, char *buf, grub_size_t size)
+{
+  grub_uint16_t *buf16 = (grub_uint16_t *) buf;
+  unsigned int i;
+
+  /* Read in the data, word by word.  */
+  for (i = 0; i < size / 2; i++)
+    buf16[i] = grub_le_to_cpu16 (grub_inw(dev->ioaddress + GRUB_ATA_REG_DATA));
+}
+
+static void
+grub_ata_pio_write (struct grub_ata_device *dev, char *buf, grub_size_t size)
+{
+  grub_uint16_t *buf16 = (grub_uint16_t *) buf;
+  unsigned int i;
+
+  /* Write the data, word by word.  */
+  for (i = 0; i < size / 2; i++)
+    grub_outw(grub_cpu_to_le16 (buf16[i]), dev->ioaddress + GRUB_ATA_REG_DATA);
+}
+
+static void
+grub_ata_dumpinfo (struct grub_ata_device *dev, char *info)
+{
+  char text[41];
+
+  /* The device information was read, dump it for debugging.  */
+  grub_ata_strncpy (text, info + 20, 20);
+  grub_dprintf ("ata", "Serial: %s\n", text);
+  grub_ata_strncpy (text, info + 46, 8);
+  grub_dprintf ("ata", "Firmware: %s\n", text);
+  grub_ata_strncpy (text, info + 54, 40);
+  grub_dprintf ("ata", "Model: %s\n", text);
+
+  if (! dev->atapi)
+    {
+      grub_dprintf ("ata", "Addressing: %d\n", dev->addr);
+      grub_dprintf ("ata", "Sectors: %lld\n", (unsigned long long) dev->size);
+    }
+}
+
+static grub_err_t
+grub_atapi_identify (struct grub_ata_device *dev)
+{
+  char *info;
+
+  info = grub_malloc (GRUB_DISK_SECTOR_SIZE);
+  if (! info)
+    return grub_errno;
+
+  grub_ata_regset (dev, GRUB_ATA_REG_DISK, 0xE0 | dev->device << 4);
+  grub_ata_wait ();
+  if (grub_ata_check_ready (dev))
+    {
+      grub_free (info);
+      return grub_errno;
+    }
+
+  grub_ata_regset (dev, GRUB_ATA_REG_CMD, GRUB_ATA_CMD_IDENTIFY_PACKET_DEVICE);
+  grub_ata_wait ();
+
+  if (grub_ata_wait_drq (dev, 0, GRUB_ATA_TOUT_STD))
+    {
+      grub_free (info);
+      return grub_errno;
+    }
+  grub_ata_pio_read (dev, info, GRUB_DISK_SECTOR_SIZE);
+
+  dev->atapi = 1;
+
+  grub_ata_dumpinfo (dev, info);
+
+  grub_free (info);
+
+  return GRUB_ERR_NONE;
+}
+
+static grub_err_t
+grub_atapi_wait_drq (struct grub_ata_device *dev,
+		     grub_uint8_t ireason,
+		     int milliseconds)
+{
+  /* Wait for !BSY, DRQ, ireason */
+  if (grub_ata_wait_not_busy (dev, milliseconds))
+    return grub_errno;
+
+  grub_uint8_t sts = grub_ata_regget (dev, GRUB_ATA_REG_STATUS);
+  grub_uint8_t irs = grub_ata_regget (dev, GRUB_ATAPI_REG_IREASON);
+
+  /* OK if DRQ is asserted and interrupt reason is as expected.  */
+  if ((sts & GRUB_ATA_STATUS_DRQ)
+      && (irs & GRUB_ATAPI_IREASON_MASK) == ireason)
+    return GRUB_ERR_NONE;
+
+  /* !DRQ implies error condition.  */
+  grub_dprintf ("ata", "atapi error: status=0x%x, ireason=0x%x, error=0x%x\n",
+	        sts, irs, grub_ata_regget (dev, GRUB_ATA_REG_ERROR));
+
+  if (! (sts & GRUB_ATA_STATUS_DRQ)
+      && (irs & GRUB_ATAPI_IREASON_MASK) == GRUB_ATAPI_IREASON_ERROR)
+    {
+      if (ireason == GRUB_ATAPI_IREASON_CMD_OUT)
+	return grub_error (GRUB_ERR_READ_ERROR, "ATA PACKET command error");
+      else
+	return grub_error (GRUB_ERR_READ_ERROR, "ATAPI read error");
+    }
+
+  return grub_error (GRUB_ERR_READ_ERROR, "ATAPI protocol error");
+}
+
+static grub_err_t
+grub_atapi_packet (struct grub_ata_device *dev, char *packet,
+		   grub_size_t size)
+{
+  grub_ata_regset (dev, GRUB_ATA_REG_DISK, dev->device << 4);
+  if (grub_ata_check_ready (dev))
+    return grub_errno;
+
+  /* Send ATA PACKET command.  */
+  grub_ata_regset (dev, GRUB_ATA_REG_FEATURES, 0);
+  grub_ata_regset (dev, GRUB_ATAPI_REG_IREASON, 0);
+  grub_ata_regset (dev, GRUB_ATAPI_REG_CNTHIGH, size >> 8);
+  grub_ata_regset (dev, GRUB_ATAPI_REG_CNTLOW, size & 0xFF);
+
+  grub_ata_regset (dev, GRUB_ATA_REG_CMD, GRUB_ATA_CMD_PACKET);
+
+  /* Wait for !BSY, DRQ, !I/O, C/D.  */
+  if (grub_atapi_wait_drq (dev, GRUB_ATAPI_IREASON_CMD_OUT, GRUB_ATA_TOUT_STD))
+    return grub_errno;
+
+  /* Write the packet.  */
+  grub_ata_pio_write (dev, packet, 12);
+
+  return GRUB_ERR_NONE;
+}
+
+static grub_err_t
+grub_ata_identify (struct grub_ata_device *dev)
+{
+  char *info;
+  grub_uint16_t *info16;
+
+  info = grub_malloc (GRUB_DISK_SECTOR_SIZE);
+  if (! info)
+    return grub_errno;
+
+  info16 = (grub_uint16_t *) info;
+
+  grub_ata_regset (dev, GRUB_ATA_REG_DISK, 0xE0 | dev->device << 4);
+  grub_ata_wait ();
+  if (grub_ata_check_ready (dev))
+    {
+      grub_free (info);
+      return grub_errno;
+    }
+
+  grub_ata_regset (dev, GRUB_ATA_REG_CMD, GRUB_ATA_CMD_IDENTIFY_DEVICE);
+  grub_ata_wait ();
+
+  if (grub_ata_wait_drq (dev, 0, GRUB_ATA_TOUT_STD))
+    {
+      grub_free (info);
+      grub_errno = GRUB_ERR_NONE;
+      grub_uint8_t sts = grub_ata_regget (dev, GRUB_ATA_REG_STATUS);
+
+      if ((sts & (GRUB_ATA_STATUS_BUSY | GRUB_ATA_STATUS_DRQ
+	  | GRUB_ATA_STATUS_ERR)) == GRUB_ATA_STATUS_ERR
+	  && (grub_ata_regget (dev, GRUB_ATA_REG_ERROR) & 0x04 /* ABRT */))
+	/* Device without ATA IDENTIFY, try ATAPI.  */
+	return grub_atapi_identify (dev);
+
+      else if (sts == 0x00)
+	/* No device, return error but don't print message.  */
+	return GRUB_ERR_UNKNOWN_DEVICE;
+
+      else
+	/* Other Error.  */
+	return grub_error (GRUB_ERR_UNKNOWN_DEVICE,
+			   "device cannot be identified");
+    }
+
+  grub_ata_pio_read (dev, info, GRUB_DISK_SECTOR_SIZE);
+
+  /* Re-check status to avoid bogus identify data due to stuck DRQ.  */
+  grub_uint8_t sts = grub_ata_regget (dev, GRUB_ATA_REG_STATUS);
+  if (sts & (GRUB_ATA_STATUS_BUSY | GRUB_ATA_STATUS_DRQ | GRUB_ATA_STATUS_ERR))
+    {
+      grub_dprintf ("ata", "bad status=0x%x\n", sts);
+      grub_free (info);
+      /* No device, return error but don't print message.  */
+      grub_errno = GRUB_ERR_NONE;
+      return GRUB_ERR_UNKNOWN_DEVICE;
+    }
+
+  /* Now it is certain that this is not an ATAPI device.  */
+  dev->atapi = 0;
+
+  /* CHS is always supported.  */
+  dev->addr = GRUB_ATA_CHS;
+
+  /* Check if LBA is supported.  */
+  if (info16[49] & (1 << 9))
+    {
+      /* Check if LBA48 is supported.  */
+      if (info16[83] & (1 << 10))
+	dev->addr = GRUB_ATA_LBA48;
+      else
+	dev->addr = GRUB_ATA_LBA;
+    }
+
+  /* Determine the amount of sectors.  */
+  if (dev->addr != GRUB_ATA_LBA48)
+    dev->size = grub_le_to_cpu32(*((grub_uint32_t *) &info16[60]));
+  else
+    dev->size = grub_le_to_cpu64(*((grub_uint64_t *) &info16[100]));
+
+  /* Read CHS information.  */
+  dev->cylinders = info16[1];
+  dev->heads = info16[3];
+  dev->sectors_per_track = info16[6];
+
+  grub_ata_dumpinfo (dev, info);
+
+  grub_free(info);
+
+  return 0;
+}
+
+static grub_err_t
+grub_ata_device_initialize (int port, int device, int addr, int addr2)
+{
+  struct grub_ata_device *dev;
+  struct grub_ata_device **devp;
+
+  grub_dprintf ("ata", "detecting device %d,%d (0x%x, 0x%x)\n",
+		port, device, addr, addr2);
+
+  dev = grub_malloc (sizeof(*dev));
+  if (! dev)
+    return grub_errno;
+
+  /* Setup the device information.  */
+  dev->port = port;
+  dev->device = device;
+  dev->ioaddress = addr + GRUB_MACHINE_PCI_IO_BASE;
+  dev->ioaddress2 = addr2 + GRUB_MACHINE_PCI_IO_BASE;
+  dev->next = NULL;
+
+  grub_ata_regset (dev, GRUB_ATA_REG_DISK, dev->device << 4);
+  grub_ata_wait ();
+
+  /* Try to detect if the port is in use by writing to it,
+     waiting for a while and reading it again.  If the value
+     was preserved, there is a device connected.  */
+  grub_ata_regset (dev, GRUB_ATA_REG_SECTORS, 0x5A);
+  grub_ata_wait ();
+  grub_uint8_t sec = grub_ata_regget (dev, GRUB_ATA_REG_SECTORS);
+  grub_dprintf ("ata", "sectors=0x%x\n", sec);
+  if (sec != 0x5A)
+    {
+      grub_free(dev);
+      return 0;
+    }
+
+  /* The above test may detect a second (slave) device
+     connected to a SATA controller which supports only one
+     (master) device.  It is not safe to use the status register
+     READY bit to check for controller channel existence.  Some
+     ATAPI commands (RESET, DIAGNOSTIC) may clear this bit.  */
+
+  /* Use the IDENTIFY DEVICE command to query the device.  */
+  if (grub_ata_identify (dev))
+    {
+      grub_free (dev);
+      return 0;
+    }
+
+  /* Register the device.  */
+  for (devp = &grub_ata_devices; *devp; devp = &(*devp)->next);
+  *devp = dev;
+
+  return 0;
+}
+
+static int NESTED_FUNC_ATTR
+grub_ata_pciinit (grub_pci_device_t dev,
+		  grub_pci_id_t pciid)
+{
+  static int compat_use[2] = { 0 };
+  grub_pci_address_t addr;
+  grub_uint32_t class;
+  grub_uint32_t bar1;
+  grub_uint32_t bar2;
+  int rega;
+  int regb;
+  int i;
+  static int controller = 0;
+  int cs5536 = 0;
+  int nports = 2;
+
+  /* Read class.  */
+  addr = grub_pci_make_address (dev, GRUB_PCI_REG_CLASS);
+  class = grub_pci_read (addr);
+
+  /* AMD CS5536 Southbridge.  */
+  if (pciid == 0x208f1022)
+    {
+      cs5536 = 1;
+      nports = 1;
+    }
+
+  /* Check if this class ID matches that of a PCI IDE Controller.  */
+  if (!cs5536 && (class >> 16 != 0x0101))
+    return 0;
+
+  for (i = 0; i < nports; i++)
+    {
+      /* Set to 0 when the channel operated in compatibility mode.  */
+      int compat;
+
+      /* We don't support non-compatibility mode for CS5536.  */
+      if (cs5536)
+	compat = 0;
+      else
+	compat = (class >> (8 + 2 * i)) & 1;
+
+      rega = 0;
+      regb = 0;
+
+      /* If the channel is in compatibility mode, just assign the
+	 default registers.  */
+      if (compat == 0 && !compat_use[i])
+	{
+	  rega = grub_ata_ioaddress[i];
+	  regb = grub_ata_ioaddress2[i];
+	  compat_use[i] = 1;
+	}
+      else if (compat)
+	{
+	  /* Read the BARs, which either contain a mmapped IO address
+	     or the IO port address.  */
+	  addr = grub_pci_make_address (dev, GRUB_PCI_REG_ADDRESSES
+					+ sizeof (grub_uint64_t) * i);
+	  bar1 = grub_pci_read (addr);
+	  addr = grub_pci_make_address (dev, GRUB_PCI_REG_ADDRESSES
+					+ sizeof (grub_uint64_t) * i
+					+ sizeof (grub_uint32_t));
+	  bar2 = grub_pci_read (addr);
+
+	  /* Check if the BARs describe an IO region.  */
+	  if ((bar1 & 1) && (bar2 & 1))
+	    {
+	      rega = bar1 & ~3;
+	      regb = bar2 & ~3;
+	    }
+	}
+
+      grub_dprintf ("ata",
+		    "PCI dev (%d,%d,%d) compat=%d rega=0x%x regb=0x%x\n",
+		    grub_pci_get_bus (dev), grub_pci_get_device (dev),
+		    grub_pci_get_function (dev), compat, rega, regb);
+
+      if (rega && regb)
+	{
+	  grub_errno = GRUB_ERR_NONE;
+	  grub_ata_device_initialize (controller * 2 + i, 0, rega, regb);
+
+	  /* Most errors raised by grub_ata_device_initialize() are harmless.
+	     They just indicate this particular drive is not responding, most
+	     likely because it doesn't exist.  We might want to ignore specific
+	     error types here, instead of printing them.  */
+	  if (grub_errno)
+	    {
+	      grub_print_error ();
+	      grub_errno = GRUB_ERR_NONE;
+	    }
+
+	  grub_ata_device_initialize (controller * 2 + i, 1, rega, regb);
+
+	  /* Likewise.  */
+	  if (grub_errno)
+	    {
+	      grub_print_error ();
+	      grub_errno = GRUB_ERR_NONE;
+	    }
+	}
+    }
+
+  controller++;
+
+  return 0;
+}
+
+static grub_err_t
+grub_ata_initialize (void)
+{
+  grub_pci_iterate (grub_ata_pciinit);
+  return 0;
+}
+
+static void
+grub_ata_setlba (struct grub_ata_device *dev, grub_disk_addr_t sector,
+		 grub_size_t size)
+{
+  grub_ata_regset (dev, GRUB_ATA_REG_SECTORS, size);
+  grub_ata_regset (dev, GRUB_ATA_REG_LBALOW, sector & 0xFF);
+  grub_ata_regset (dev, GRUB_ATA_REG_LBAMID, (sector >> 8) & 0xFF);
+  grub_ata_regset (dev, GRUB_ATA_REG_LBAHIGH, (sector >> 16) & 0xFF);
+}
+
+static grub_err_t
+grub_ata_setaddress (struct grub_ata_device *dev,
+		     grub_ata_addressing_t addressing,
+		     grub_disk_addr_t sector,
+		     grub_size_t size)
+{
+  switch (addressing)
+    {
+    case GRUB_ATA_CHS:
+      {
+	unsigned int cylinder;
+	unsigned int head;
+	unsigned int sect;
+
+	/* Calculate the sector, cylinder and head to use.  */
+	sect = ((grub_uint32_t) sector % dev->sectors_per_track) + 1;
+	cylinder = (((grub_uint32_t) sector / dev->sectors_per_track)
+		    / dev->heads);
+	head = ((grub_uint32_t) sector / dev->sectors_per_track) % dev->heads;
+
+	if (sect > dev->sectors_per_track
+	    || cylinder > dev->cylinders
+	    || head > dev->heads)
+	  return grub_error (GRUB_ERR_OUT_OF_RANGE,
+			     "sector %d cannot be addressed "
+			     "using CHS addressing", sector);
+
+	grub_ata_regset (dev, GRUB_ATA_REG_DISK, (dev->device << 4) | head);
+	if (grub_ata_check_ready (dev))
+	  return grub_errno;
+
+	grub_ata_regset (dev, GRUB_ATA_REG_SECTNUM, sect);
+	grub_ata_regset (dev, GRUB_ATA_REG_CYLLSB, cylinder & 0xFF);
+	grub_ata_regset (dev, GRUB_ATA_REG_CYLMSB, cylinder >> 8);
+
+	break;
+      }
+
+    case GRUB_ATA_LBA:
+      if (size == 256)
+	size = 0;
+      grub_ata_regset (dev, GRUB_ATA_REG_DISK,
+		       0xE0 | (dev->device << 4) | ((sector >> 24) & 0x0F));
+      if (grub_ata_check_ready (dev))
+	return grub_errno;
+
+      grub_ata_setlba (dev, sector, size);
+      break;
+
+    case GRUB_ATA_LBA48:
+      if (size == 65536)
+	size = 0;
+
+      grub_ata_regset (dev, GRUB_ATA_REG_DISK, 0xE0 | (dev->device << 4));
+      if (grub_ata_check_ready (dev))
+	return grub_errno;
+
+      /* Set "Previous".  */
+      grub_ata_setlba (dev, sector >> 24, size >> 8);
+      /* Set "Current".  */
+      grub_ata_setlba (dev, sector, size);
+
+      break;
+    }
+
+  return GRUB_ERR_NONE;
+}
+
+static grub_err_t
+grub_ata_readwrite (grub_disk_t disk, grub_disk_addr_t sector,
+		    grub_size_t size, char *buf, int rw)
+{
+  struct grub_ata_device *dev = (struct grub_ata_device *) disk->data;
+
+  grub_dprintf("ata", "grub_ata_readwrite (size=%llu, rw=%d)\n", (unsigned long long) size, rw);
+
+  grub_ata_addressing_t addressing = dev->addr;
+  grub_size_t batch;
+  int cmd, cmd_write;
+
+  if (addressing == GRUB_ATA_LBA48 && ((sector + size) >> 28) != 0)
+    {
+      batch = 65536;
+      cmd = GRUB_ATA_CMD_READ_SECTORS_EXT;
+      cmd_write = GRUB_ATA_CMD_WRITE_SECTORS_EXT;
+    }
+  else
+    {
+      if (addressing == GRUB_ATA_LBA48)
+	addressing = GRUB_ATA_LBA;
+      batch = 256;
+      cmd = GRUB_ATA_CMD_READ_SECTORS;
+      cmd_write = GRUB_ATA_CMD_WRITE_SECTORS;
+    }
+
+  grub_size_t nsectors = 0;
+  while (nsectors < size)
+    {
+      if (size - nsectors < batch)
+	batch = size - nsectors;
+
+      grub_dprintf("ata", "rw=%d, sector=%llu, batch=%llu\n", rw, (unsigned long long) sector, (unsigned long long) batch);
+
+      /* Send read/write command.  */
+      if (grub_ata_setaddress (dev, addressing, sector, batch))
+	return grub_errno;
+
+      grub_ata_regset (dev, GRUB_ATA_REG_CMD, (! rw ? cmd : cmd_write));
+
+      unsigned sect;
+      for (sect = 0; sect < batch; sect++)
+	{
+	  /* Wait for !BSY, DRQ.  */
+	  if (grub_ata_wait_drq (dev, rw, GRUB_ATA_TOUT_DATA))
+	    return grub_errno;
+
+	  /* Transfer data.  */
+	  if (! rw)
+	    grub_ata_pio_read (dev, buf, GRUB_DISK_SECTOR_SIZE);
+	  else
+	    grub_ata_pio_write (dev, buf, GRUB_DISK_SECTOR_SIZE);
+
+	  buf += GRUB_DISK_SECTOR_SIZE;
+	}
+
+      if (rw)
+        {
+	  /* Check for write error.  */
+	  if (grub_ata_wait_not_busy (dev, GRUB_ATA_TOUT_DATA))
+	    return grub_errno;
+
+	  if (grub_ata_regget (dev, GRUB_ATA_REG_STATUS)
+	      & (GRUB_ATA_STATUS_DRQ | GRUB_ATA_STATUS_ERR))
+	    return grub_error (GRUB_ERR_WRITE_ERROR, "ATA write error");
+	}
+
+      sector += batch;
+      nsectors += batch;
+    }
+
+  return GRUB_ERR_NONE;
+}
+
+
+
+static int
+grub_ata_iterate (int (*hook) (const char *name))
+{
+  struct grub_ata_device *dev;
+
+  for (dev = grub_ata_devices; dev; dev = dev->next)
+    {
+      char devname[10];
+
+      if (dev->atapi)
+	continue;
+
+      grub_snprintf (devname, sizeof (devname), 
+		     "ata%d", dev->port * 2 + dev->device);
+
+      if (hook (devname))
+	return 1;
+    }
+
+  return 0;
+}
+
+static grub_err_t
+grub_ata_open (const char *name, grub_disk_t disk)
+{
+  struct grub_ata_device *dev;
+
+  for (dev = grub_ata_devices; dev; dev = dev->next)
+    {
+      char devname[10];
+      grub_snprintf (devname, sizeof (devname),
+		     "ata%d", dev->port * 2 + dev->device);
+      if (grub_strcmp (name, devname) == 0)
+	break;
+    }
+
+  if (! dev)
+    return grub_error (GRUB_ERR_UNKNOWN_DEVICE, "can't open device");
+
+  if (dev->atapi)
+    return grub_error (GRUB_ERR_UNKNOWN_DEVICE, "not an ATA harddisk");
+
+  disk->total_sectors = dev->size;
+
+  disk->id = (unsigned long) dev;
+
+  disk->has_partitions = 1;
+  disk->data = dev;
+
+  return 0;
+}
+
+static void
+grub_ata_close (grub_disk_t disk __attribute__((unused)))
+{
+
+}
+
+static grub_err_t
+grub_ata_read (grub_disk_t disk, grub_disk_addr_t sector,
+	       grub_size_t size, char *buf)
+{
+  return grub_ata_readwrite (disk, sector, size, buf, 0);
+}
+
+static grub_err_t
+grub_ata_write (grub_disk_t disk,
+		grub_disk_addr_t sector,
+		grub_size_t size,
+		const char *buf)
+{
+  return grub_ata_readwrite (disk, sector, size, (char *) buf, 1);
+}
+
+static struct grub_disk_dev grub_atadisk_dev =
+  {
+    .name = "ATA",
+    .id = GRUB_DISK_DEVICE_ATA_ID,
+    .iterate = grub_ata_iterate,
+    .open = grub_ata_open,
+    .close = grub_ata_close,
+    .read = grub_ata_read,
+    .write = grub_ata_write,
+    .next = 0
+  };
+
+
+
+/* ATAPI code.  */
+
+static int
+grub_atapi_iterate (int (*hook) (const char *name, int luns))
+{
+  struct grub_ata_device *dev;
+
+  for (dev = grub_ata_devices; dev; dev = dev->next)
+    {
+      char devname[10];
+      grub_snprintf (devname, sizeof (devname),
+		     "ata%d", dev->port * 2 + dev->device);
+
+      if (! dev->atapi)
+	continue;
+
+      if (hook (devname, 1))
+	return 1;
+    }
+
+  return 0;
+
+}
+
+static grub_err_t
+grub_atapi_read (struct grub_scsi *scsi,
+		 grub_size_t cmdsize __attribute__((unused)),
+		 char *cmd, grub_size_t size, char *buf)
+{
+  struct grub_ata_device *dev = (struct grub_ata_device *) scsi->data;
+
+  grub_dprintf("ata", "grub_atapi_read (size=%llu)\n", (unsigned long long) size);
+
+  if (grub_atapi_packet (dev, cmd, size))
+    return grub_errno;
+
+  grub_size_t nread = 0;
+  while (nread < size)
+    {
+      /* Wait for !BSY, DRQ, I/O, !C/D.  */
+      if (grub_atapi_wait_drq (dev, GRUB_ATAPI_IREASON_DATA_IN, GRUB_ATA_TOUT_DATA))
+	return grub_errno;
+
+      /* Get byte count for this DRQ assertion.  */
+      unsigned cnt = grub_ata_regget (dev, GRUB_ATAPI_REG_CNTHIGH) << 8
+		   | grub_ata_regget (dev, GRUB_ATAPI_REG_CNTLOW);
+      grub_dprintf("ata", "DRQ count=%u\n", cnt);
+
+      /* Count of last transfer may be uneven.  */
+      if (! (0 < cnt && cnt <= size - nread && (! (cnt & 1) || cnt == size - nread)))
+	return grub_error (GRUB_ERR_READ_ERROR, "invalid ATAPI transfer count");
+
+      /* Read the data.  */
+      grub_ata_pio_read (dev, buf + nread, cnt);
+
+      if (cnt & 1)
+	buf[nread + cnt - 1] = (char) grub_le_to_cpu16 (grub_inw (dev->ioaddress + GRUB_ATA_REG_DATA));
+
+      nread += cnt;
+    }
+
+  return GRUB_ERR_NONE;
+}
+
+static grub_err_t
+grub_atapi_write (struct grub_scsi *scsi __attribute__((unused)),
+		  grub_size_t cmdsize __attribute__((unused)),
+		  char *cmd __attribute__((unused)),
+		  grub_size_t size __attribute__((unused)),
+		  char *buf __attribute__((unused)))
+{
+  // XXX: scsi.mod does not use write yet.
+  return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET, "ATAPI write not implemented");
+}
+
+static grub_err_t
+grub_atapi_open (const char *name, struct grub_scsi *scsi)
+{
+  struct grub_ata_device *dev;
+  struct grub_ata_device *devfnd = 0;
+
+  for (dev = grub_ata_devices; dev; dev = dev->next)
+    {
+      char devname[10];
+      grub_snprintf (devname, sizeof (devname),
+		     "ata%d", dev->port * 2 + dev->device);
+
+      if (!grub_strcmp (devname, name))
+	{
+	  devfnd = dev;
+	  break;
+	}
+    }
+
+  grub_dprintf ("ata", "opening ATAPI dev `%s'\n", name);
+
+  if (! devfnd)
+    return grub_error (GRUB_ERR_UNKNOWN_DEVICE, "no such ATAPI device");
+
+  scsi->data = devfnd;
+
+  return GRUB_ERR_NONE;
+}
+
+static void
+grub_atapi_close (struct grub_scsi *scsi)
+{
+  grub_free (scsi->name);
+}
+
+static struct grub_scsi_dev grub_atapi_dev =
+  {
+    .name = "ATAPI",
+    .iterate = grub_atapi_iterate,
+    .open = grub_atapi_open,
+    .close = grub_atapi_close,
+    .read = grub_atapi_read,
+    .write = grub_atapi_write
+  };
+
+
+
+GRUB_MOD_INIT(ata)
+{
+  /* To prevent two drivers operating on the same disks.  */
+  grub_disk_firmware_is_tainted = 1;
+  if (grub_disk_firmware_fini)
+    {
+      grub_disk_firmware_fini ();
+      grub_disk_firmware_fini = NULL;
+    }
+
+  /* ATA initialization.  */
+  grub_ata_initialize ();
+
+  grub_disk_dev_register (&grub_atadisk_dev);
+
+  /* ATAPI devices are handled by scsi.mod.  */
+  grub_scsi_dev_register (&grub_atapi_dev);
+}
+
+GRUB_MOD_FINI(ata)
+{
+  grub_scsi_dev_unregister (&grub_atapi_dev);
+  grub_disk_dev_unregister (&grub_atadisk_dev);
+}

grub-core/disk/ata_pthru.c

@@ -0,0 +1,107 @@
+/* ata_pthru.c - ATA pass through for ata.mod.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2009  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 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <grub/ata.h>
+#include <grub/disk.h>
+#include <grub/dl.h>
+#include <grub/mm.h>
+
+
+/* ATA pass through support, used by hdparm.mod.  */
+static grub_err_t
+grub_ata_pass_through (grub_disk_t disk,
+		       struct grub_disk_ata_pass_through_parms *parms)
+{
+  if (disk->dev->id != GRUB_DISK_DEVICE_ATA_ID)
+    return grub_error (GRUB_ERR_BAD_DEVICE,
+		       "device not accessed via ata.mod");
+
+  struct grub_ata_device *dev = (struct grub_ata_device *) disk->data;
+
+  if (! (parms->size == 0 || parms->size == GRUB_DISK_SECTOR_SIZE))
+    return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET,
+		       "ATA multi-sector read and DATA OUT not implemented");
+
+  grub_dprintf ("ata", "ata_pass_through: cmd=0x%x, features=0x%x, sectors=0x%x\n",
+		parms->taskfile[GRUB_ATA_REG_CMD],
+		parms->taskfile[GRUB_ATA_REG_FEATURES],
+		parms->taskfile[GRUB_ATA_REG_SECTORS]);
+  grub_dprintf ("ata", "lba_high=0x%x, lba_mid=0x%x, lba_low=0x%x, size=%d\n",
+	        parms->taskfile[GRUB_ATA_REG_LBAHIGH],
+	        parms->taskfile[GRUB_ATA_REG_LBAMID],
+	        parms->taskfile[GRUB_ATA_REG_LBALOW], parms->size);
+
+  /* Set registers.  */
+  grub_ata_regset (dev, GRUB_ATA_REG_DISK, 0xE0 | dev->device << 4
+		   | (parms->taskfile[GRUB_ATA_REG_DISK] & 0xf));
+  if (grub_ata_check_ready (dev))
+    return grub_errno;
+
+  int i;
+  for (i = GRUB_ATA_REG_FEATURES; i <= GRUB_ATA_REG_LBAHIGH; i++)
+    grub_ata_regset (dev, i, parms->taskfile[i]);
+
+  /* Start command. */
+  grub_ata_regset (dev, GRUB_ATA_REG_CMD, parms->taskfile[GRUB_ATA_REG_CMD]);
+
+  /* Wait for !BSY.  */
+  if (grub_ata_wait_not_busy (dev, GRUB_ATA_TOUT_DATA))
+    return grub_errno;
+
+  /* Check status.  */
+  grub_int8_t sts = grub_ata_regget (dev, GRUB_ATA_REG_STATUS);
+  grub_dprintf ("ata", "status=0x%x\n", sts);
+
+  /* Transfer data.  */
+  if ((sts & (GRUB_ATA_STATUS_DRQ | GRUB_ATA_STATUS_ERR)) == GRUB_ATA_STATUS_DRQ)
+    {
+      if (parms->size != GRUB_DISK_SECTOR_SIZE)
+        return grub_error (GRUB_ERR_READ_ERROR, "DRQ unexpected");
+      grub_ata_pio_read (dev, parms->buffer, GRUB_DISK_SECTOR_SIZE);
+    }
+
+  /* Return registers.  */
+  for (i = GRUB_ATA_REG_ERROR; i <= GRUB_ATA_REG_STATUS; i++)
+    parms->taskfile[i] = grub_ata_regget (dev, i);
+
+  grub_dprintf ("ata", "status=0x%x, error=0x%x, sectors=0x%x\n",
+	        parms->taskfile[GRUB_ATA_REG_STATUS],
+	        parms->taskfile[GRUB_ATA_REG_ERROR],
+		parms->taskfile[GRUB_ATA_REG_SECTORS]);
+
+  if (parms->taskfile[GRUB_ATA_REG_STATUS]
+      & (GRUB_ATA_STATUS_DRQ | GRUB_ATA_STATUS_ERR))
+    return grub_error (GRUB_ERR_READ_ERROR, "ATA passthrough failed");
+
+  return GRUB_ERR_NONE;
+}
+
+
+
+GRUB_MOD_INIT(ata_pthru)
+{
+  /* Register ATA pass through function.  */
+  grub_disk_ata_pass_through = grub_ata_pass_through;
+}
+
+GRUB_MOD_FINI(ata_pthru)
+{
+  if (grub_disk_ata_pass_through == grub_ata_pass_through)
+    grub_disk_ata_pass_through = NULL;
+}