merge with mainline

.bzrignore

@@ -2,6 +2,7 @@
 10_*
 30_os-prober
 40_custom
+41_custom
 aclocal.m4
 ascii.bitmaps
 ascii.h
@@ -75,3 +76,4 @@ stamp-h.in
 symlist.c
 trigtables.c
 update-grub_lib
+unidata.c

Makefile.in

@@ -53,9 +53,13 @@ XGETTEXT = @XGETTEXT@
 MSGMERGE = @MSGMERGE@
 MSGFMT = @MSGFMT@
 
+ifeq (@USE_NLS@,yes)
 LINGUAS = $(shell for i in $(srcdir)/po/*.po ; do \
 			if test -e $$i ; then echo $$i ; fi ; \
 		done | sed -e "s,.*/po/\(.*\)\.po$$,\1,")
+else
+LINGUAS =
+endif
 
 PACKAGE = @PACKAGE@
 PACKAGE_NAME = @PACKAGE_NAME@
@@ -164,7 +168,9 @@ DISTCLEANFILES = config.status config.cache config.log config.h \
 MAINTAINER_CLEANFILES = $(srcdir)/configure $(srcdir)/aclocal.m4 \
 	$(MKFILES) $(srcdir)/config.guess \
 	$(srcdir)/config.sub $(srcdir)/install-sh $(srcdir)/missing \
-	$(srcdir)/DISTLIST $(srcdir)/config.h.in $(srcdir)/stamp-h.in $(INFOS)
+	$(srcdir)/DISTLIST $(srcdir)/config.h.in $(srcdir)/stamp-h.in \
+	$(srcdir)/unidata.c \
+	$(INFOS)
 
 # The default target.
 all: all-local
@@ -247,10 +253,9 @@ docs/stamp-vti: docs/grub.texi configure.ac
 	-@rm -f vti.tmp
 	@cp $(builddir)/docs/version.texi $@
 
-# Use --force until such time as the documentation is cleaned up.
 docs/grub.info: docs/grub.texi docs/version.texi docs/fdl.texi
 	$(MKDIR_P) docs
-	-$(MAKEINFO) -P $(builddir)/docs --no-split --force $< -o $@
+	$(MAKEINFO) -P $(builddir)/docs --no-split $< -o $@
 
 ifeq (, $(FONT_SOURCE))
 else
@@ -276,7 +281,13 @@ ascii.bitmaps: $(FONT_SOURCE) grub-mkfont
 ascii.h: ascii.bitmaps grub-bin2h
 	$(builddir)/grub-bin2h ascii_bitmaps < $< > $@
 
-TARGET_CFLAGS += -DUSE_ASCII_FAILBACK=1
+widthspec.bin: $(FONT_SOURCE) grub-mkfont
+	$(builddir)/grub-mkfont --width-spec -o $@ $(FONT_SOURCE)
+
+widthspec.h: widthspec.bin grub-bin2h
+	$(builddir)/grub-bin2h widthspec < $< > $@
+
+TARGET_CFLAGS += -DUSE_ASCII_FAILBACK=1 -DHAVE_UNIFONT_WIDTHSPEC=1
 endif
 endif
 
@@ -323,26 +334,26 @@ install-local: all
 	  if test -f "$$file"; then dir=; else dir="$(srcdir)/"; fi; \
 	  dest="`echo $$file | sed 's,.*/,,' | sed '$(transform)'`"; \
 	  $(INSTALL_PROGRAM) $$dir$$file $(DESTDIR)$(bindir)/$$dest; \
-	  $(HELP2MAN) --section=1 -o $(DESTDIR)$(mandir)/man1/$$dest.1 $(builddir)/$$file; \
+	  PATH="$(builddir):$$PATH" $(HELP2MAN) --section=1 -i $(srcdir)/docs/man/$$file.h2m -o $(DESTDIR)$(mandir)/man1/$$dest.1 $$file; \
 	done
 	$(SHELL) $(mkinstalldirs) $(DESTDIR)$(sbindir) $(DESTDIR)$(mandir)/man8
 	@list='$(sbin_UTILITIES)'; for file in $$list; do \
 	  if test -f "$$file"; then dir=; else dir="$(srcdir)/"; fi; \
 	  dest="`echo $$file | sed 's,.*/,,' | sed '$(transform)'`"; \
 	  $(INSTALL_PROGRAM) $$dir$$file $(DESTDIR)$(sbindir)/$$dest; \
-	  $(HELP2MAN) --section=8 -o $(DESTDIR)$(mandir)/man8/$$dest.8 $(builddir)/$$file; \
+	  PATH="$(builddir):$$PATH" $(HELP2MAN) --section=8 -i $(srcdir)/docs/man/$$file.h2m -o $(DESTDIR)$(mandir)/man8/$$dest.8 $$file; \
 	done
 	@list='$(bin_SCRIPTS)'; for file in $$list; do \
 	  if test -f "$$file"; then dir=; else dir="$(srcdir)/"; fi; \
 	  dest="`echo $$file | sed 's,.*/,,' | sed '$(transform)'`"; \
 	  $(INSTALL_SCRIPT) $$dir$$file $(DESTDIR)$(bindir)/$$dest; \
-	  $(HELP2MAN) --section=1 -o $(DESTDIR)$(mandir)/man1/$$dest.1 $(builddir)/$$file; \
+	  PATH="$(builddir):$$PATH" $(HELP2MAN) --section=1 -i $(srcdir)/docs/man/$$file.h2m -o $(DESTDIR)$(mandir)/man1/$$dest.1 $$file; \
 	done
 	@list='$(sbin_SCRIPTS)'; for file in $$list; do \
 	  if test -f "$$file"; then dir=; else dir="$(srcdir)/"; fi; \
 	  dest="`echo $$file | sed 's,.*/,,' | sed '$(transform)'`"; \
 	  $(INSTALL_SCRIPT) $$dir$$file $(DESTDIR)$(sbindir)/$$dest; \
-	  $(HELP2MAN) --section=8 -o $(DESTDIR)$(mandir)/man8/$$dest.8 $(builddir)/$$file; \
+	  PATH="$(builddir):$$PATH" $(HELP2MAN) --section=8 -i $(srcdir)/docs/man/$$file.h2m -o $(DESTDIR)$(mandir)/man8/$$dest.8 $$file; \
 	done
 	$(SHELL) $(mkinstalldirs) $(DESTDIR)$(sysconfdir)/grub.d
 	@list='$(grub-mkconfig_SCRIPTS)'; for file in $$list; do \
@@ -513,8 +524,8 @@ check: all $(UNIT_TESTS) $(FUNCTIONAL_TESTS) $(SCRIPTED_TESTS)
 	  $(builddir)/$$file; \
 	done
 
-.SUFFIX:
+.SUFFIXES:
-.SUFFIX: .c .o .S .d
+.SUFFIXES: .c .o .S .d
 
 # Regenerate configure and Makefile automatically.
 $(srcdir)/aclocal.m4: configure.ac acinclude.m4

README

@@ -10,5 +10,13 @@ GRUB 2 data and program files.
 Please visit the official web page of GRUB 2, for more information.
 The URL is <http://www.gnu.org/software/grub/grub.html>.
 
-For now, there is not much documentation yet. Please look at the GRUB
+More extensive documentation is available in the Info manual,
-Wiki <http://grub.enbug.org> for testing procedures.
+accessible using 'info grub' after building and installing GRUB 2.
+Please look at the GRUB Wiki <http://grub.enbug.org> for testing
+procedures.
+
+There are a number of important user-visible differences from the
+first version of GRUB, now known as GRUB Legacy. For a summary, please
+see:
+
+  info grub Introduction 'Changes from GRUB Legacy'

autogen.sh

@@ -13,6 +13,8 @@ echo timestamp > stamp-h.in
 
 python util/import_gcry.py lib/libgcrypt/ .
 
+python util/import_unicode.py unicode/UnicodeData.txt unicode/BidiMirroring.txt unicode/ArabicShaping.txt unidata.c
+
 for rmk in conf/*.rmk ${GRUB_CONTRIB}/*/conf/*.rmk; do
   if test -e $rmk ; then
     ruby genmk.rb < $rmk > `echo $rmk | sed 's/\.rmk$/.mk/'`

boot/i386/qemu/boot.S

@@ -36,9 +36,6 @@ 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

boot/mips/yeeloong/fwstart.S

@@ -0,0 +1,630 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2000,2001,2002,2003,2004,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/mips/yeeloong/serial.h>
+#include <grub/mips/yeeloong/pci.h>
+#include <grub/mips/loongson.h>
+#include <grub/pci.h>
+#include <grub/serial.h>
+#include <grub/cs5536.h>
+#include <grub/smbus.h>
+
+	.set noreorder
+	.set noat
+	.set nomacro
+
+	.global start,_start,__start
+start:
+_start:
+__start:	
+	bal serial_hw_init
+	 nop
+	/* Find CS5536 controller.  */
+	/* $t4 chooses device in priority encoding.  */
+	/* Resulting value is kept in GRUB_MACHINE_PCI_CONF_CTRL_REG.
+	   This way we don't need to sacrifice a register for it.  */
+	/* We have only one bus (0). Function is 0.  */
+	lui $t0, %hi(GRUB_MACHINE_PCI_CONF_CTRL_REG_ADDR)
+	lui $t1, %hi(GRUB_MACHINE_PCI_CONFSPACE)
+	lui $t3, %hi(GRUB_CS5536_PCIID)
+	addiu $t3, $t3, %lo(GRUB_CS5536_PCIID)
+	ori $t4, $zero, 1
+	lui $a0, %hi(no_cs5536)
+1:
+	andi $t4, $t4, ((1 << GRUB_PCI_NUM_DEVICES) - 1)
+	beql  $t4, $zero, fatal
+	 addiu $a0, $a0, %lo(no_cs5536)
+	sw   $t4, %lo(GRUB_MACHINE_PCI_CONF_CTRL_REG_ADDR) ($t0)
+	lw   $t2, (%lo(GRUB_MACHINE_PCI_CONFSPACE) + GRUB_PCI_REG_PCI_ID) ($t1)
+	bnel  $t2, $t3, 1b
+	 sll $t4, $t4, 1
+
+	bal message
+	 addiu $a0, $a0, %lo(cs5536_found)
+	bal printhex
+	 move $a0, $t4
+
+	/* Initialise SMBus controller.  */
+	/* Set GPIO LBAR.  */
+	lui $a0, %hi(GRUB_CS5536_MSR_GPIO_BAR)
+	addiu $a0, $a0, %lo(GRUB_CS5536_MSR_GPIO_BAR)
+	ori $a1, $zero, GRUB_CS5536_LBAR_GPIO
+	/* Set mask to 0xf and enabled bit to 1.  */
+	bal wrmsr
+	 ori $a2, $zero, ((GRUB_CS5536_LBAR_MASK_MASK \
+	                  | GRUB_CS5536_LBAR_ENABLE) >> 32)
+
+	/* Set SMBUS LBAR.  */
+	lui $a0, %hi(GRUB_CS5536_MSR_SMB_BAR)
+	addiu $a0, $a0, %lo(GRUB_CS5536_MSR_SMB_BAR)
+	ori $a1, $zero, GRUB_CS5536_LBAR_SMBUS
+	/* Set mask to 0xf and enabled bit to 1.  */
+	bal wrmsr
+	 ori $a2, $zero, ((GRUB_CS5536_LBAR_MASK_MASK \
+	                   | GRUB_CS5536_LBAR_ENABLE) >> 32)
+
+	lui $a0, %hi(smbus_enabled)
+	bal message
+	  addiu $a0, $a0, %lo(smbus_enabled)
+
+	/* Enable SMBus controller pins.  */
+	lui $t0, %hi(GRUB_MACHINE_PCI_IO_BASE + GRUB_CS5536_LBAR_GPIO)
+	ori $t1, $zero, GRUB_GPIO_SMBUS_PINS
+	sw  $t1, %lo(GRUB_MACHINE_PCI_IO_BASE + GRUB_CS5536_LBAR_GPIO + GRUB_GPIO_REG_OUT_EN) ($t0)
+	sw  $t1, %lo(GRUB_MACHINE_PCI_IO_BASE + GRUB_CS5536_LBAR_GPIO + GRUB_GPIO_REG_OUT_AUX1) ($t0)
+	sw  $t1, %lo(GRUB_MACHINE_PCI_IO_BASE + GRUB_CS5536_LBAR_GPIO + GRUB_GPIO_REG_IN_EN) ($t0)
+	sw  $t1, %lo(GRUB_MACHINE_PCI_IO_BASE + GRUB_CS5536_LBAR_GPIO + GRUB_GPIO_REG_IN_AUX1) ($t0)
+
+	lui $t0, %hi(GRUB_MACHINE_PCI_IO_BASE + GRUB_CS5536_LBAR_SMBUS)
+
+	/* Disable SMB.  */
+	sb $zero, %lo(GRUB_MACHINE_PCI_IO_BASE + GRUB_CS5536_LBAR_SMBUS + GRUB_CS5536_SMB_REG_CTRL2) ($t0)
+
+	/* Disable interrupts.  */
+	sb $zero, %lo(GRUB_MACHINE_PCI_IO_BASE + GRUB_CS5536_LBAR_SMBUS + GRUB_CS5536_SMB_REG_CTRL1) ($t0)
+
+	/* Set as master.  */
+	sb $zero, %lo(GRUB_MACHINE_PCI_IO_BASE + GRUB_CS5536_LBAR_SMBUS + GRUB_CS5536_SMB_REG_ADDR) ($t0)
+
+	/* Launch SMBus controller at slowest speed possible.  */
+	ori $t1, $zero, 0xff
+	sb $t1, %lo(GRUB_MACHINE_PCI_IO_BASE + GRUB_CS5536_LBAR_SMBUS + GRUB_CS5536_SMB_REG_CTRL3) ($t0)
+	sb $t1, %lo(GRUB_MACHINE_PCI_IO_BASE + GRUB_CS5536_LBAR_SMBUS + GRUB_CS5536_SMB_REG_CTRL2) ($t0)
+
+	/* Yeeloong has only one memory slot.  */
+	/* Output first byte on serial for debugging.  */
+	ori $a1, $zero, GRUB_SMB_RAM_START_ADDR
+	bal read_spd
+	 move $a0, $zero
+	bal printhex
+	 move $a0, $v0
+
+	bal read_spd
+	 ori $a0, $zero, GRUB_SMBUS_SPD_MEMORY_TYPE_ADDR
+	ori $t0, $zero, GRUB_SMBUS_SPD_MEMORY_TYPE_DDR2
+	lui $a0, %hi(unimplemented_memory_type)
+	bne $t0, $v0, fatal
+	 addiu $a0, $a0, %hi(unimplemented_memory_type)
+
+	/* And here is our goal: DDR2 controller initialisation.  */
+        lui	$t0, %hi(GRUB_CPU_LOONGSON_CORECFG)
+        ld	$t1, %lo(GRUB_CPU_LOONGSON_CORECFG) ($t0)
+	/* Use addiu for sign-extension.  */
+	addiu	$t2, $zero, ~(GRUB_CPU_LOONGSON_CORECFG_DISABLE_DDR2_SPACE|GRUB_CPU_LOONGSON_CORECFG_BUFFER_CPU)
+	and	$t1, $t1, $t2
+	sd	$t1, %lo (GRUB_CPU_LOONGSON_CORECFG) ($t0)
+
+	b continue
+
+	. = start + GRUB_CPU_LOONGSON_FLASH_TLB_REFILL - GRUB_CPU_LOONGSON_FLASH_START
+tlb_refill:	
+	mfc0 $s1, GRUB_CPU_LOONGSON_COP0_EPC
+	mfc0 $s2, GRUB_CPU_LOONGSON_COP0_BADVADDR
+	move $s3, $ra
+	lui $a0, %hi(epc)
+	bal message
+	 addiu $a0, $a0, %lo(epc)
+
+	bal printhex
+	 move $a0, $s1
+
+	lui $a0, %hi(badvaddr)
+	bal message
+	 addiu $a0, $a0, %lo(badvaddr)
+
+	bal printhex
+	 move $a0, $s2
+
+	lui $a0, %hi(return_msg)
+	bal message
+	 addiu $a0, $a0, %lo(return_msg)
+
+	bal printhex
+	 move $a0, $s3
+	
+	lui $a0, %hi(newline)
+	bal message
+	 addiu $a0, $a0, %lo(newline)
+
+	lui $a0, %hi(unhandled_tlb_refill)
+	b fatal
+	 addiu $a0, $a0, %lo(unhandled_tlb_refill)
+
+	. = start + GRUB_CPU_LOONGSON_FLASH_CACHE_ERROR - GRUB_CPU_LOONGSON_FLASH_START
+cache_error:
+	lui $a0, %hi(unhandled_cache_error)
+	b fatal
+	 addiu $a0, $a0, %lo(unhandled_cache_error)
+
+	. = start + GRUB_CPU_LOONGSON_FLASH_OTHER_EXCEPTION - GRUB_CPU_LOONGSON_FLASH_START
+other_exception:
+	mfc0 $s0, GRUB_CPU_LOONGSON_COP0_CAUSE
+	mfc0 $s1, GRUB_CPU_LOONGSON_COP0_EPC
+	mfc0 $s2, GRUB_CPU_LOONGSON_COP0_BADVADDR
+	lui $a0, %hi(cause)
+	bal message
+	 addiu $a0, $a0, %lo(cause)
+
+	bal printhex
+	 move $a0, $s0
+
+	lui $a0, %hi(epc)
+	bal message
+	 addiu $a0, $a0, %lo(epc)
+
+	bal printhex
+	 move $a0, $s1
+
+	lui $a0, %hi(badvaddr)
+	bal message
+	 addiu $a0, $a0, %lo(badvaddr)
+
+	bal printhex
+	 move $a0, $s2
+	
+	lui $a0, %hi(newline)
+	bal message
+	 addiu $a0, $a0, %lo(newline)
+	
+	lui $a0, %hi(unhandled_exception)
+	b fatal
+	 addiu $a0, $a0, %lo(unhandled_exception)
+
+	/* Same as similarly named C function but in asm since
+	   we need it early.  */
+	/* In: none. Out: none. Clobbered: $t0, $t1, $a0.  */
+serial_hw_init:
+	lui $t0, %hi (GRUB_MACHINE_SERIAL_PORT)
+
+	/* Turn off the interrupt.  */
+	sb $zero, (%lo (GRUB_MACHINE_SERIAL_PORT) + UART_IER)($t0)
+
+	/* Set DLAB.  */
+	ori $t1, $zero, UART_DLAB
+	sb  $t1, (%lo (GRUB_MACHINE_SERIAL_PORT) + UART_LCR)($t0)
+
+	/* Set the baud rate 115200.  */
+	ori $t1, $zero, GRUB_MACHINE_SERIAL_DIVISOR_115200
+	sb $t1, (%lo (GRUB_MACHINE_SERIAL_PORT) + UART_DLL)($t0) 
+	sb $zero, (%lo (GRUB_MACHINE_SERIAL_PORT) + UART_DLH)($t0) 
+
+	/* Set the line status.  */
+	ori $t1, $zero, (UART_NO_PARITY | UART_8BITS_WORD | UART_1_STOP_BIT)
+        sb  $t1, (%lo (GRUB_MACHINE_SERIAL_PORT) + UART_LCR)($t0)
+
+	/* Enable the FIFO.  */
+	ori $t1, $zero, UART_ENABLE_FIFO_TRIGGER1
+	sb $t1, (%lo (GRUB_MACHINE_SERIAL_PORT) + UART_FCR)($t0)
+
+	/* Turn on DTR and RTS.  */
+	ori $t1, $zero, UART_ENABLE_DTRRTS
+	sb  $t1, (%lo (GRUB_MACHINE_SERIAL_PORT) + UART_MCR)($t0)
+
+	/* Let message return to original caller.  */
+	lui  $a0, %hi(notification_string)
+	addiu $a0, $a0, %lo(notification_string)
+
+	/* Print message on serial console.  */
+	/* In: $a0 = asciiz message. Out: none. Clobbered: $t0, $t1, $a0.  */
+message:
+	lui $t0, %hi (GRUB_MACHINE_SERIAL_PORT)
+1:
+	lb $t1, (%lo (GRUB_MACHINE_SERIAL_PORT) + UART_LSR)($t0)
+	andi $t1, $t1, UART_EMPTY_TRANSMITTER
+	beq $t1, $zero, 1b
+	 nop
+	lb  $t1, 0($a0)
+	sb  $t1, (%lo (GRUB_MACHINE_SERIAL_PORT) + UART_TX)($t0)
+	bne $t1, $zero, 1b
+	 addiu $a0, $a0, 1
+	jr  $ra
+	 nop
+	
+	/* Print 32-bit hexadecimal on serial.
+           In:	$a0. Out: None. Clobbered: $a0, $t0, $t1, $t2
+	*/
+printhex:
+	lui $t0, %hi  (GRUB_MACHINE_SERIAL_PORT)
+	ori $t2, $zero, 8
+1:
+	lb $t1, (%lo (GRUB_MACHINE_SERIAL_PORT) + UART_LSR)($t0)
+	andi $t1, $t1, UART_EMPTY_TRANSMITTER
+	beq $t1, $zero, 1b
+	 nop
+	srl  $t1, $a0, 28
+	addiu $t1, $t1, -10
+	blt  $t1, $zero, 2f
+	 sll  $a0, $a0, 4
+	addiu $t1, $t1, 'A'-10-'0' 
+2:	addiu $t1, $t1, '0'+10
+	sb  $t1, (%lo (GRUB_MACHINE_SERIAL_PORT) + UART_TX)($t0)
+	addiu $t2, $t2, -1
+	bne $t2, $zero, 1b
+	 nop
+	jr  $ra
+	 nop
+
+fatal:
+	bal message
+	 nop
+self:
+	b self
+	 nop
+	
+	/* Write CS5536 MSR.
+           In:   $a0 address, $a1 lower word, $a2 upper word.
+           Out:	 None
+           Clobbered:	 $t0
+	*/
+wrmsr:
+	lui $t0, %hi(GRUB_MACHINE_PCI_CONFSPACE)
+	sw  $a0, (%lo(GRUB_MACHINE_PCI_CONFSPACE) + GRUB_CS5536_MSR_MAILBOX_ADDR) ($t0)
+	sw  $a1, (%lo(GRUB_MACHINE_PCI_CONFSPACE) + GRUB_CS5536_MSR_MAILBOX_DATA0) ($t0)
+	jr $ra
+	 sw  $a2, (%lo(GRUB_MACHINE_PCI_CONFSPACE) + GRUB_CS5536_MSR_MAILBOX_DATA1) ($t0)
+
+	/* Wait for SMBus data or empty transmitter.  */
+	/* In: $a0 = exception handler. Out: none. Clobbered: $t0, $t1  */
+smbus_wait:
+1:	
+	lui $t0, %hi(GRUB_CS5536_LBAR_SMBUS + GRUB_CS5536_SMB_REG_STATUS + GRUB_MACHINE_PCI_IO_BASE)
+	lb $t0, %lo(GRUB_CS5536_LBAR_SMBUS + GRUB_CS5536_SMB_REG_STATUS + GRUB_MACHINE_PCI_IO_BASE) ($t0)
+	andi $t1, $t0, GRUB_CS5536_SMB_REG_STATUS_SDAST
+	bne $t1, $zero, return
+	 nop
+	andi $t1, $t0, (GRUB_CS5536_SMB_REG_STATUS_BER | GRUB_CS5536_SMB_REG_STATUS_NACK)
+	beq $t1, $zero, 1b
+	 nop
+	jr $a0
+	 nop
+return:
+	jr $ra
+	 nop
+	
+	/* Read SPD byte. In: $a0 byte, $a1 device. Out: $v0 read byte (0x100 on failure).
+           Clobbered: $t0, $t1, $t2, $t3, $a0. */
+read_spd:
+	move $t2, $a0
+	move $t3, $ra
+	lui $a0, %hi(read_spd_fail)
+	addiu $a0, $a0, %hi(read_spd_fail)
+
+	/* Send START.  */
+	lui $t0, %hi(GRUB_CS5536_LBAR_SMBUS + GRUB_CS5536_SMB_REG_CTRL1 + GRUB_MACHINE_PCI_IO_BASE)
+	lb $t1, %lo(GRUB_CS5536_LBAR_SMBUS + GRUB_CS5536_SMB_REG_CTRL1 + GRUB_MACHINE_PCI_IO_BASE) ($t0)
+	ori $t1, $t1, GRUB_CS5536_SMB_REG_CTRL1_START
+	bal smbus_wait
+	 sb $t1, %lo(GRUB_CS5536_LBAR_SMBUS + GRUB_CS5536_SMB_REG_CTRL1 + GRUB_MACHINE_PCI_IO_BASE) ($t0)
+	
+	/* Send device address.  */
+	lui $t0, %hi(GRUB_CS5536_LBAR_SMBUS + GRUB_CS5536_SMB_REG_DATA + GRUB_MACHINE_PCI_IO_BASE)
+	sll $t1, $a1, 1
+	bal smbus_wait
+	 sb $t1, %lo(GRUB_CS5536_LBAR_SMBUS + GRUB_CS5536_SMB_REG_DATA + GRUB_MACHINE_PCI_IO_BASE) ($t0)
+
+	/* Send ACK.  */
+	lui $t0, %hi(GRUB_CS5536_LBAR_SMBUS + GRUB_CS5536_SMB_REG_CTRL1 + GRUB_MACHINE_PCI_IO_BASE)
+	lb $t1, %lo(GRUB_CS5536_LBAR_SMBUS + GRUB_CS5536_SMB_REG_CTRL1 + GRUB_MACHINE_PCI_IO_BASE) ($t0)
+	ori $t1, $t1, GRUB_CS5536_SMB_REG_CTRL1_ACK
+	sb $t1, %lo(GRUB_CS5536_LBAR_SMBUS + GRUB_CS5536_SMB_REG_CTRL1 + GRUB_MACHINE_PCI_IO_BASE) ($t0)
+
+	/* Send byte address.  */
+	lui $t0, %hi(GRUB_CS5536_LBAR_SMBUS + GRUB_CS5536_SMB_REG_DATA + GRUB_MACHINE_PCI_IO_BASE)
+	bal smbus_wait
+	 sb $t2, %lo(GRUB_CS5536_LBAR_SMBUS + GRUB_CS5536_SMB_REG_DATA + GRUB_MACHINE_PCI_IO_BASE) ($t0)
+
+	/* Send START.  */
+	lui $t0, %hi(GRUB_CS5536_LBAR_SMBUS + GRUB_CS5536_SMB_REG_CTRL1 + GRUB_MACHINE_PCI_IO_BASE)
+	lb $t1, %lo(GRUB_CS5536_LBAR_SMBUS + GRUB_CS5536_SMB_REG_CTRL1 + GRUB_MACHINE_PCI_IO_BASE) ($t0)
+	ori $t1, $t1, GRUB_CS5536_SMB_REG_CTRL1_START
+	bal smbus_wait
+	 sb $t1, %lo(GRUB_CS5536_LBAR_SMBUS + GRUB_CS5536_SMB_REG_CTRL1 + GRUB_MACHINE_PCI_IO_BASE) ($t0)
+
+	/* Send device address.  */
+	lui $t0, %hi(GRUB_CS5536_LBAR_SMBUS + GRUB_CS5536_SMB_REG_DATA + GRUB_MACHINE_PCI_IO_BASE)
+	sll $t1, $a1, 1
+	ori $t1, $t1, 1
+	bal smbus_wait
+	 sb $t1, %lo(GRUB_CS5536_LBAR_SMBUS + GRUB_CS5536_SMB_REG_DATA + GRUB_MACHINE_PCI_IO_BASE) ($t0)
+
+	/* Send STOP.  */
+	lui $t0, %hi(GRUB_CS5536_LBAR_SMBUS + GRUB_CS5536_SMB_REG_CTRL1 + GRUB_MACHINE_PCI_IO_BASE)
+	lb $t1, %lo(GRUB_CS5536_LBAR_SMBUS + GRUB_CS5536_SMB_REG_CTRL1 + GRUB_MACHINE_PCI_IO_BASE) ($t0)
+	ori $t1, $t1, GRUB_CS5536_SMB_REG_CTRL1_STOP
+	bal smbus_wait
+	 sb $t1, %lo(GRUB_CS5536_LBAR_SMBUS + GRUB_CS5536_SMB_REG_CTRL1 + GRUB_MACHINE_PCI_IO_BASE) ($t0)
+
+	lui $t0, %hi(GRUB_CS5536_LBAR_SMBUS + GRUB_CS5536_SMB_REG_DATA + GRUB_MACHINE_PCI_IO_BASE)
+	lb $v0, %lo(GRUB_CS5536_LBAR_SMBUS + GRUB_CS5536_SMB_REG_DATA + GRUB_MACHINE_PCI_IO_BASE) ($t0)
+	jr $t3
+	 andi $v0, $v0, 0xff
+read_spd_fail:
+	jr $t3
+	 ori $v0, $v0, 0x100
+
+notification_string:	.asciz "GRUB "
+no_cs5536:	.asciz "No CS5536 found.\n\r"
+cs5536_found:	.asciz "CS5536 at "
+sm_failed: .asciz "SM transaction failed.\n\r"
+unhandled_tlb_refill:	.asciz "Unhandled TLB refill.\n\r"
+unhandled_cache_error:	.asciz "Unhandled cache error.\n\r"
+unhandled_exception:	.asciz "Unhandled exception.\n\r"
+smbus_enabled:	.asciz "SMBus controller enabled.\n\r"
+unimplemented_memory_type:	.asciz "non-DDR2 memory isn't supported.\n\r"
+no_cas_latency:		.asciz "Couldn't determine CAS latency.\n\r"
+cause:	 .asciz "Cause: "
+epc:	.asciz "\n\rEPC: "
+badvaddr:	.asciz "\n\rBadVaddr: "
+newline:	.asciz "\n\r"
+return_msg:	  .asciz "\n\rReturn address: "
+caches_enabled:	.asciz "Caches enabled\n\r"
+
+	.p2align 3
+
+regdump:
+	.quad 0x0100010000000101 /* 0 */
+	.quad 0x0100010100000000 /* 2 */
+	.quad 0x0101000001000000 /* 3 */
+	.quad 0x0100020200010101 /* 4 */
+	.quad 0x0a04030603050203 /* 6 */
+	.quad 0x0f0e040000010a0b /* 7 */
+	.quad 0x0000010200000102 /* 8 */
+	.quad 0x0000060c00000000 /* 9 */
+	.quad 0x2323233f3f1f0200 /* a */
+	.quad 0x5f7f232323232323 /* b */
+	.quad 0x002a3c0615000000 /* c */
+	.quad 0x002a002a002a002a /* d */
+	.quad 0x002a002a002a002a /* e */
+	.quad 0x00b40020006d0004 /* f */
+	.quad 0x070007ff00000087 /* 10 */
+	.quad 0x000000000016101f /* 11 */
+	.quad 0x001c000000000000 /* 12 */
+	.quad 0x28e1000200c8006b /* 13 */
+	.quad 0x0000204200c8002f /* 14 */
+	.quad 0x0000000000030d40 /* 15 */
+	.quad 0 /* 16 */
+	.quad 0 /* 17 */
+	.quad 0 /* 18 */
+	.quad 0 /* 19 */
+	.quad 0 /* 1a */
+	.quad 0 /* 1b */
+	.quad 0 /* 1c */
+
+	.p2align
+
+write_dumpreg:	
+	ld $t2, 0($t6)
+	sd $t2, 0($t4)
+	addiu $t4, $t4, GRUB_CPU_LOONGSON_DDR2_REG_STEP
+	jr $ra
+	 addiu $t6, $t6, GRUB_CPU_LOONGSON_DDR2_REG_SIZE
+
+continue:
+	lui $t4, %hi(GRUB_CPU_LOONGSON_DDR2_BASE)
+	addiu $t4, $t4, %lo(GRUB_CPU_LOONGSON_DDR2_BASE)
+	lui $t6, %hi(regdump)
+
+	/* 0 */
+	bal write_dumpreg
+	 addiu $t6, $t6, %lo(regdump)
+
+	/* 1 */
+	ori $a1, $a1, GRUB_SMB_RAM_START_ADDR
+	move $t8, $zero
+	lui  $t5, 0x0001
+	bal read_spd
+	 ori $a0, $zero, GRUB_SMBUS_SPD_MEMORY_NUM_BANKS_ADDR
+	ori $t7, $zero, 8
+	bne $v0, $t7, 1f
+	 ori $t5, $t5, 0x0001
+	ori $t8, $t8, GRUB_CPU_LOONGSON_DDR2_REG1_HI_8BANKS
+1:
+	dsll $t8, $t8, 32
+	or $t5, $t5, $t8
+	sd  $t5, 0 ($t4)
+	addiu $t4, $t4, GRUB_CPU_LOONGSON_DDR2_REG_STEP
+
+	/* 2 */
+	bal write_dumpreg
+	 nop
+
+	/* 3 */
+	bal write_dumpreg
+	 nop
+
+	/* 4 */
+	bal write_dumpreg
+	 nop
+
+	/* 5 */
+	/* FIXME: figure termination resistance.  */
+	ori $t5, $zero, 0x2
+	bal read_spd
+	 ori $a0, $zero, GRUB_SMBUS_SPD_MEMORY_NUM_ROWS_ADDR
+	/* $v0 = 15 - $v0.  */
+	xori $v0, $v0, 0xf
+	andi $v0, $v0, 0x7
+	sll $v0, $v0, 8
+	or $t5, $t5, $v0
+
+	/* Find the fastest supported CAS latency.  */
+	bal read_spd
+	 ori $a0, $zero, GRUB_SMBUS_SPD_MEMORY_CAS_LATENCY_ADDR
+	ori $t0, $zero, GRUB_SMBUS_SPD_MEMORY_CAS_LATENCY_MIN_VALUE
+	ori $t1, $zero, (1 << GRUB_SMBUS_SPD_MEMORY_CAS_LATENCY_MIN_VALUE)
+2:	
+	and $t2, $t1, $v0
+	bne $t2, $zero, 1f
+	 ori $t3, $zero, 8
+	lui $a0, %hi(no_cas_latency)
+	beq $t0, $t3, fatal
+	 addiu $a0, $a0, %lo(no_cas_latency)
+	addiu $t0, $t0, 1
+	b 2b
+	 sll $t1, $t1, 1
+1:
+	sll $t0, $t0, 16
+	or $t5, $t5, $t0
+	
+	bal read_spd
+	 ori $a0, $zero, GRUB_SMBUS_SPD_MEMORY_NUM_COLUMNS_ADDR
+	/* $v0 = 15 - ($v0 + 1) = 14 - $v0.  */
+	addiu $v0, $v0, 1
+	xori $v0, $v0, 0xf
+	andi $v0, $v0, 0x7
+	sll $v0, 24
+	or $t5, $t5, $v0
+	sd  $t5, 0 ($t4)
+
+	addiu $t4, $t4, GRUB_CPU_LOONGSON_DDR2_REG_STEP
+	
+	ori $t7, $zero, 0x16
+
+1:	
+	ld $t2, 0($t6)
+	sd $t2, 0($t4)
+	addiu $t4, $t4, GRUB_CPU_LOONGSON_DDR2_REG_STEP
+	addiu $t7, $t7, -1
+	bne $t7, $zero, 1b
+	 addiu $t6, $t6, GRUB_CPU_LOONGSON_DDR2_REG_SIZE
+	
+	lui $t4, %hi(GRUB_CPU_LOONGSON_DDR2_BASE)
+	ld  $t5, (%lo(GRUB_CPU_LOONGSON_DDR2_BASE) + 0x30) ($t4)
+	ori $t0, $zero, 1
+	dsll $t0, $t0, 40
+	or $t5, $t5, $t0
+	sd  $t5, (%lo(GRUB_CPU_LOONGSON_DDR2_BASE) + 0x30) ($t4)
+
+	/* Desactivate DDR2 registers.  */
+        lui	$t0, %hi (GRUB_CPU_LOONGSON_CORECFG)
+        ld	$t1, %lo (GRUB_CPU_LOONGSON_CORECFG) ($t0)
+	ori	$t1, $t1, GRUB_CPU_LOONGSON_CORECFG_DISABLE_DDR2_SPACE
+        sd	$t1, %lo (GRUB_CPU_LOONGSON_CORECFG) ($t0)
+
+	/* Enable cache.  */
+	mfc0	$t0, GRUB_CPU_LOONGSON_COP0_CACHE_CONFIG
+	addiu 	$t1, $zero, ~GRUB_CPU_LOONGSON_CACHE_TYPE_MASK
+	and     $t0, $t1, $t1
+	/* Set line size to 32 bytes and disabled cache.  */
+	ori   	$t0, $t0, (GRUB_CPU_LOONGSON_COP0_CACHE_CONFIG_ILINESIZE \
+	                   | GRUB_CPU_LOONGSON_COP0_CACHE_CONFIG_DLINESIZE \
+	                   | GRUB_CPU_LOONGSON_CACHE_ACCELERATED)
+	mtc0	$t0, GRUB_CPU_LOONGSON_COP0_CACHE_CONFIG
+
+	/* Invalidate all I-cache entries.  */
+	srl $t1, $t0, GRUB_CPU_LOONGSON_COP0_CACHE_ISIZE_SHIFT
+	andi $t1, $t1, GRUB_CPU_LOONGSON_COP0_CACHE_SIZE_MASK
+	ori $t2, $zero, (1 << (GRUB_CPU_LOONGSON_COP0_CACHE_SIZE_OFFSET \
+	                       - GRUB_CPU_LOONGSON_CACHE_LINE_SIZE_LOG_BIG \
+	                       - GRUB_CPU_LOONGSON_I_CACHE_LOG_WAYS))
+	sll $t1, $t2, $t1
+	lui $t2, 0x8000
+
+1:	
+	cache GRUB_CPU_LOONGSON_COP0_I_INDEX_INVALIDATE, 0($t2)
+	addiu $t1, $t1, -1
+	bne $t1, $zero, 1b
+	 addiu $t2, $t2, (1 << GRUB_CPU_LOONGSON_COP0_I_INDEX_BIT_OFFSET)
+
+	/* Invalidate all D-cache entries.  */
+	srl $t1, $t0, GRUB_CPU_LOONGSON_COP0_CACHE_DSIZE_SHIFT
+	andi $t1, $t1, GRUB_CPU_LOONGSON_COP0_CACHE_SIZE_MASK
+	ori $t2, $zero, (1 << (GRUB_CPU_LOONGSON_COP0_CACHE_SIZE_OFFSET \
+	                       - GRUB_CPU_LOONGSON_CACHE_LINE_SIZE_LOG_BIG \
+	                       - GRUB_CPU_LOONGSON_D_CACHE_LOG_WAYS))
+	sll $t1, $t2, $t1
+	lui $t2, 0x8000
+	mtc0 $zero, GRUB_CPU_LOONGSON_COP0_CACHE_TAGLO
+	mtc0 $zero, GRUB_CPU_LOONGSON_COP0_CACHE_TAGHI
+1:
+	/* All four ways.  */
+	cache GRUB_CPU_LOONGSON_COP0_D_INDEX_TAG_STORE, 0($t2)
+	cache GRUB_CPU_LOONGSON_COP0_D_INDEX_TAG_STORE, 1($t2)
+	cache GRUB_CPU_LOONGSON_COP0_D_INDEX_TAG_STORE, 2($t2)
+	cache GRUB_CPU_LOONGSON_COP0_D_INDEX_TAG_STORE, 3($t2)
+	addiu $t1, $t1, -1
+	bne $t1, $zero, 1b
+	 addiu $t2, $t2, (1 << GRUB_CPU_LOONGSON_COP0_D_INDEX_BIT_OFFSET)
+
+	/* Invalidate all S-cache entries.  */
+	ori $t1, $zero, (1 << (GRUB_CPU_LOONGSON_SECONDARY_CACHE_LOG_SIZE \
+	                       - GRUB_CPU_LOONGSON_CACHE_LINE_SIZE_LOG_BIG \
+	                       - GRUB_CPU_LOONGSON_S_CACHE_LOG_WAYS))
+	lui $t2, 0x8000
+	mtc0 $zero, GRUB_CPU_LOONGSON_COP0_CACHE_TAGLO
+	mtc0 $zero, GRUB_CPU_LOONGSON_COP0_CACHE_TAGHI
+1:
+	/* All four ways.  */
+	cache GRUB_CPU_LOONGSON_COP0_S_INDEX_TAG_STORE, 0($t2)
+	cache GRUB_CPU_LOONGSON_COP0_S_INDEX_TAG_STORE, 1($t2)
+	cache GRUB_CPU_LOONGSON_COP0_S_INDEX_TAG_STORE, 2($t2)
+	cache GRUB_CPU_LOONGSON_COP0_S_INDEX_TAG_STORE, 3($t2)
+	addiu $t1, $t1, -1
+	bne $t1, $zero, 1b
+	 addiu $t2, $t2, (1 << GRUB_CPU_LOONGSON_COP0_D_INDEX_BIT_OFFSET)
+	
+	/* Finally enable cache.  */
+	mfc0	$t0, GRUB_CPU_LOONGSON_COP0_CACHE_CONFIG
+	addiu 	$t1, $zero, ~GRUB_CPU_LOONGSON_CACHE_TYPE_MASK
+	and     $t0, $t1, $t1
+	ori   	$t0, $t0, GRUB_CPU_LOONGSON_CACHE_CACHED
+	mtc0	$t0, GRUB_CPU_LOONGSON_COP0_CACHE_CONFIG
+
+	lui $a0, %hi(caches_enabled)
+	bal message
+	  addiu $a0, $a0, %lo(caches_enabled)
+
+	/* Set ROM delay cycles to 1.  */
+	lui $t0, %hi(GRUB_CPU_LOONGSON_LIOCFG)
+	lw  $t1, %lo(GRUB_CPU_LOONGSON_LIOCFG) ($t0)
+	addiu $t2, $zero, ~(GRUB_CPU_LOONGSON_ROM_DELAY_MASK \
+	                    << GRUB_CPU_LOONGSON_ROM_DELAY_OFFSET)
+	and $t1, $t1, $t2
+	ori $t1, $t1, (1 << GRUB_CPU_LOONGSON_ROM_DELAY_OFFSET)
+	sw  $t1, %lo(GRUB_CPU_LOONGSON_LIOCFG) ($t0)
+	
+	addiu $a0, $zero, -1
+	addiu $a1, $zero, -1
+
+	/* Take advantage of cache.  */
+	lui $t0, %hi(cached_continue - 0x20000000)
+	addiu $t0, $t0, %lo(cached_continue - 0x20000000)
+	jr $t0
+	 addiu $a2, $zero, -1
+
+cached_continue:

bus/cs5536.c

@@ -213,3 +213,168 @@ grub_cs5536_read_spd (grub_port_t smbbase, grub_uint8_t dev,
   return GRUB_ERR_NONE;
 }
 
+/* Dump of GPIO connections. FIXME: Remove useless and macroify.  */
+static grub_uint32_t gpiodump[] = {
+  0xffff0000, 0x2ffdd002, 0xffff0000, 0xffff0000,
+  0x2fffd000, 0xffff0000, 0x1000efff, 0xefff1000,
+  0x3ffbc004, 0xffff0000, 0xffff0000, 0xffff0000,
+  0x3ffbc004, 0x3ffbc004, 0xffff0000, 0x00000000,
+  0xffff0000, 0xffff0000, 0x3ffbc004, 0x3f9bc064,
+  0x00000000, 0x00000000, 0x00000000, 0x00000000,
+  0x00000000, 0x00000000, 0x00000000, 0x00000000,
+  0x00000000, 0x00000000, 0x00000000, 0x00000000,
+  0xffff0000, 0xffff0000, 0xffff0000, 0xffff0000,
+  0xffff0000, 0xffff0000, 0x0000ffff, 0xffff0000,
+  0xefff1000, 0xffff0000, 0xffff0000, 0xffff0000,
+  0xefff1000, 0xefff1000, 0xffff0000, 0x00000000,
+  0xffff0000, 0xffff0000, 0xefff1000, 0xffff0000,
+  0x00000000, 0x00000000, 0x00000000, 0x00000000,
+  0x00000000, 0x00000000, 0x00000000, 0x00000000,
+  0x00000000, 0x50000000, 0x00000000, 0x00000000,
+};
+
+static inline void
+set_io_space (grub_pci_device_t dev, int num, grub_uint16_t start,
+	      grub_uint16_t len)
+{
+  grub_cs5536_write_msr (dev, GRUB_CS5536_MSR_GL_REGIONS_START + num,
+			 ((((grub_uint64_t) start + len - 4)
+			   << GRUB_CS5536_MSR_GL_REGION_IO_TOP_SHIFT)
+			  & GRUB_CS5536_MSR_GL_REGION_TOP_MASK)
+			 | (((grub_uint64_t) start
+			     << GRUB_CS5536_MSR_GL_REGION_IO_BASE_SHIFT)
+			  & GRUB_CS5536_MSR_GL_REGION_BASE_MASK)
+			 | GRUB_CS5536_MSR_GL_REGION_IO
+			 | GRUB_CS5536_MSR_GL_REGION_ENABLE);
+}
+
+static inline void
+set_iod (grub_pci_device_t dev, int num, int dest, int start, int mask)
+{
+  grub_cs5536_write_msr (dev, GRUB_CS5536_MSR_GL_IOD_START + num,
+			 ((grub_uint64_t) dest << GRUB_CS5536_IOD_DEST_SHIFT)
+			 | (((grub_uint64_t) start & GRUB_CS5536_IOD_ADDR_MASK)
+			    << GRUB_CS5536_IOD_BASE_SHIFT)
+			 | ((mask & GRUB_CS5536_IOD_ADDR_MASK)
+			    << GRUB_CS5536_IOD_MASK_SHIFT));
+}
+
+static inline void
+set_p2d (grub_pci_device_t dev, int num, int dest, grub_uint32_t start)
+{
+  grub_cs5536_write_msr (dev, GRUB_CS5536_MSR_GL_P2D_START + num,
+			 (((grub_uint64_t) dest) << GRUB_CS5536_P2D_DEST_SHIFT)
+			 | ((grub_uint64_t) (start >> GRUB_CS5536_P2D_LOG_ALIGN)
+			    << GRUB_CS5536_P2D_BASE_SHIFT)
+			 | (((1 << (32 - GRUB_CS5536_P2D_LOG_ALIGN)) - 1)
+			    << GRUB_CS5536_P2D_MASK_SHIFT));
+}
+
+void
+grub_cs5536_init_geode (grub_pci_device_t dev)
+{
+  int i;
+
+  /* Make sure GPIO is where we expect it to be.  */
+  grub_cs5536_write_msr (dev, GRUB_CS5536_MSR_GPIO_BAR,
+			 GRUB_CS5536_LBAR_TURN_ON | GRUB_CS5536_LBAR_GPIO);
+
+  /* Setup GPIO.  */
+  for (i = 0; i < (int) ARRAY_SIZE (gpiodump); i++)
+    ((volatile grub_uint32_t *) (GRUB_MACHINE_PCI_IO_BASE 
+				 + GRUB_CS5536_LBAR_GPIO)) [i] = gpiodump[i];
+
+  /* Enable more BARs.  */
+  grub_cs5536_write_msr (dev, GRUB_CS5536_MSR_IRQ_MAP_BAR,
+			 GRUB_CS5536_LBAR_TURN_ON | GRUB_CS5536_LBAR_IRQ_MAP);
+  grub_cs5536_write_msr (dev, GRUB_CS5536_MSR_MFGPT_BAR,
+			 GRUB_CS5536_LBAR_TURN_ON | GRUB_CS5536_LBAR_MFGPT);
+  grub_cs5536_write_msr (dev, GRUB_CS5536_MSR_ACPI_BAR,
+			 GRUB_CS5536_LBAR_TURN_ON | GRUB_CS5536_LBAR_ACPI);
+  grub_cs5536_write_msr (dev, GRUB_CS5536_MSR_PM_BAR,
+			 GRUB_CS5536_LBAR_TURN_ON | GRUB_CS5536_LBAR_PM);
+
+  /* Setup DIVIL.  */
+  grub_cs5536_write_msr (dev, GRUB_CS5536_MSR_DIVIL_LEG_IO,
+			 GRUB_CS5536_MSR_DIVIL_LEG_IO_MODE_X86
+			 | GRUB_CS5536_MSR_DIVIL_LEG_IO_F_REMAP
+			 | GRUB_CS5536_MSR_DIVIL_LEG_IO_RTC_ENABLE0
+			 | GRUB_CS5536_MSR_DIVIL_LEG_IO_RTC_ENABLE1);
+  grub_cs5536_write_msr (dev, GRUB_CS5536_MSR_DIVIL_IRQ_MAPPER_PRIMARY_MASK,
+			 (~GRUB_CS5536_DIVIL_LPC_INTERRUPTS) & 0xffff);
+  grub_cs5536_write_msr (dev, GRUB_CS5536_MSR_DIVIL_IRQ_MAPPER_LPC_MASK,
+			 GRUB_CS5536_DIVIL_LPC_INTERRUPTS);
+  grub_cs5536_write_msr (dev, GRUB_CS5536_MSR_DIVIL_LPC_SERIAL_IRQ_CONTROL,
+			 GRUB_CS5536_MSR_DIVIL_LPC_SERIAL_IRQ_CONTROL_ENABLE);
+
+  /* Initialise USB controller.  */
+  /* FIXME: assign adresses dynamically.  */
+  grub_cs5536_write_msr (dev, GRUB_CS5536_MSR_USB_OHCI_BASE, 
+			 GRUB_CS5536_MSR_USB_BASE_BUS_MASTER
+			 | GRUB_CS5536_MSR_USB_BASE_MEMORY_ENABLE
+			 | 0x05024000);
+  grub_cs5536_write_msr (dev, GRUB_CS5536_MSR_USB_EHCI_BASE,
+			 GRUB_CS5536_MSR_USB_BASE_BUS_MASTER
+			 | GRUB_CS5536_MSR_USB_BASE_MEMORY_ENABLE
+			 | (0x20ULL << GRUB_CS5536_MSR_USB_EHCI_BASE_FLDJ_SHIFT)
+			 | 0x05023000);
+  grub_cs5536_write_msr (dev, GRUB_CS5536_MSR_USB_CONTROLLER_BASE,
+			 GRUB_CS5536_MSR_USB_BASE_BUS_MASTER
+			 | GRUB_CS5536_MSR_USB_BASE_MEMORY_ENABLE | 0x05020000);
+  grub_cs5536_write_msr (dev, GRUB_CS5536_MSR_USB_OPTION_CONTROLLER_BASE,
+			 GRUB_CS5536_MSR_USB_BASE_MEMORY_ENABLE | 0x05022000);
+  set_p2d (dev, 0, GRUB_CS5536_DESTINATION_USB, 0x05020000);
+  set_p2d (dev, 1, GRUB_CS5536_DESTINATION_USB, 0x05022000);
+  set_p2d (dev, 5, GRUB_CS5536_DESTINATION_USB, 0x05024000);
+  set_p2d (dev, 6, GRUB_CS5536_DESTINATION_USB, 0x05023000);
+
+  {
+    volatile grub_uint32_t *oc;
+    oc = grub_pci_device_map_range (dev, 0x05022000,
+				    GRUB_CS5536_USB_OPTION_REGS_SIZE);
+
+    oc[GRUB_CS5536_USB_OPTION_REG_UOCMUX] =
+      (oc[GRUB_CS5536_USB_OPTION_REG_UOCMUX]
+       & ~GRUB_CS5536_USB_OPTION_REG_UOCMUX_PMUX_MASK)
+      | GRUB_CS5536_USB_OPTION_REG_UOCMUX_PMUX_HC;
+    grub_pci_device_unmap_range (dev, oc, GRUB_CS5536_USB_OPTION_REGS_SIZE);
+  }
+
+  /* Setup IDE controller.  */
+  grub_cs5536_write_msr (dev, GRUB_CS5536_MSR_IDE_IO_BAR,
+			 GRUB_CS5536_LBAR_IDE
+			 | GRUB_CS5536_MSR_IDE_IO_BAR_UNITS);
+  grub_cs5536_write_msr (dev, GRUB_CS5536_MSR_IDE_CFG,
+			 GRUB_CS5536_MSR_IDE_CFG_CHANNEL_ENABLE);
+  grub_cs5536_write_msr (dev, GRUB_CS5536_MSR_IDE_TIMING,
+			 (GRUB_CS5536_MSR_IDE_TIMING_PIO0
+			  << GRUB_CS5536_MSR_IDE_TIMING_DRIVE0_SHIFT)
+			 | (GRUB_CS5536_MSR_IDE_TIMING_PIO0
+			    << GRUB_CS5536_MSR_IDE_TIMING_DRIVE1_SHIFT));
+  grub_cs5536_write_msr (dev, GRUB_CS5536_MSR_IDE_CAS_TIMING,
+			 (GRUB_CS5536_MSR_IDE_CAS_TIMING_CMD_PIO0
+			  << GRUB_CS5536_MSR_IDE_CAS_TIMING_CMD_SHIFT)
+			 | (GRUB_CS5536_MSR_IDE_CAS_TIMING_PIO0
+			    << GRUB_CS5536_MSR_IDE_CAS_TIMING_DRIVE0_SHIFT)
+			 | (GRUB_CS5536_MSR_IDE_CAS_TIMING_PIO0
+			    << GRUB_CS5536_MSR_IDE_CAS_TIMING_DRIVE1_SHIFT));
+
+  /* Setup Geodelink PCI.  */
+  grub_cs5536_write_msr (dev, GRUB_CS5536_MSR_GL_PCI_CTRL,
+			 (4ULL << GRUB_CS5536_MSR_GL_PCI_CTRL_OUT_THR_SHIFT)
+			 | (4ULL << GRUB_CS5536_MSR_GL_PCI_CTRL_IN_THR_SHIFT)
+			 | (8ULL << GRUB_CS5536_MSR_GL_PCI_CTRL_LATENCY_SHIFT)
+			 | GRUB_CS5536_MSR_GL_PCI_CTRL_IO_ENABLE
+			 | GRUB_CS5536_MSR_GL_PCI_CTRL_MEMORY_ENABLE);
+
+  /* Setup windows.  */
+  set_io_space (dev, 0, GRUB_CS5536_LBAR_SMBUS, GRUB_CS5536_SMBUS_REGS_SIZE);
+  set_io_space (dev, 1, GRUB_CS5536_LBAR_GPIO, GRUB_CS5536_GPIO_REGS_SIZE);
+  set_io_space (dev, 2, GRUB_CS5536_LBAR_MFGPT, GRUB_CS5536_MFGPT_REGS_SIZE);
+  set_io_space (dev, 3, GRUB_CS5536_LBAR_IRQ_MAP, GRUB_CS5536_IRQ_MAP_REGS_SIZE);
+  set_io_space (dev, 4, GRUB_CS5536_LBAR_PM, GRUB_CS5536_PM_REGS_SIZE);
+  set_io_space (dev, 5, GRUB_CS5536_LBAR_ACPI, GRUB_CS5536_ACPI_REGS_SIZE);
+  set_iod (dev, 0, GRUB_CS5536_DESTINATION_IDE, GRUB_ATA_CH0_PORT1, 0xffff8);
+  set_iod (dev, 1, GRUB_CS5536_DESTINATION_ACC, GRUB_CS5536_LBAR_ACC, 0xfff80);
+  set_iod (dev, 2, GRUB_CS5536_DESTINATION_IDE, GRUB_CS5536_LBAR_IDE, 0xffff0);
+}

bus/usb/uhci.c

@@ -612,8 +612,23 @@ grub_uhci_portstatus (grub_usb_controller_t dev,
   status = grub_uhci_readreg16 (u, reg);
   grub_dprintf ("uhci", "detect=0x%02x\n", status);
 
+  if (!enable) /* We don't need reset port */
+    {
+      /* Disable the port.  */
+      grub_uhci_writereg16 (u, reg, 0 << 2);
+      grub_dprintf ("uhci", "waiting for the port to be disabled\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;
+    }
+    
   /* Reset the port.  */
-  grub_uhci_writereg16 (u, reg, enable << 9);
+  grub_uhci_writereg16 (u, reg, 1 << 9);
 
   /* Wait for the reset to complete.  XXX: How long exactly?  */
   grub_millisleep (50); /* For root hub should be nominaly 50ms */
@@ -623,16 +638,20 @@ grub_uhci_portstatus (grub_usb_controller_t dev,
   grub_millisleep (10);
 
   /* Enable the port.  */
-  grub_uhci_writereg16 (u, reg, enable << 2);
+  grub_uhci_writereg16 (u, reg, 1 << 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)))
+  while (! ((status = grub_uhci_readreg16 (u, reg)) & (1 << 2)))
     if (grub_get_time_ms () > endtime)
       return grub_error (GRUB_ERR_IO, "UHCI Timed out");
 
+  /* Reset bit Connect Status Change */
+  grub_uhci_writereg16 (u, reg, status | (1 << 1));
+
+  /* Read final port status */
   status = grub_uhci_readreg16 (u, reg);
   grub_dprintf ("uhci", ">3detect=0x%02x\n", status);
 
@@ -641,7 +660,7 @@ grub_uhci_portstatus (grub_usb_controller_t dev,
 }
 
 static grub_usb_speed_t
-grub_uhci_detect_dev (grub_usb_controller_t dev, int port)
+grub_uhci_detect_dev (grub_usb_controller_t dev, int port, int *changed)
 {
   struct grub_uhci *u = (struct grub_uhci *) dev->data;
   int reg;
@@ -661,6 +680,9 @@ grub_uhci_detect_dev (grub_usb_controller_t dev, int port)
 
   grub_dprintf ("uhci", "detect=0x%02x port=%d\n", status, port);
 
+  /* Connect Status Change bit - it detects change of connection */
+  *changed = ((status & (1 << 1)) != 0);
+    
   if (! (status & 1))
     return GRUB_USB_SPEED_NONE;
   else if (status & (1 << 8))

bus/usb/usb.c

@@ -21,8 +21,10 @@
 #include <grub/mm.h>
 #include <grub/usb.h>
 #include <grub/misc.h>
+#include <grub/list.h>
 
 static grub_usb_controller_dev_t grub_usb_list;
+struct grub_usb_attach_desc *attach_hooks;
 
 void
 grub_usb_controller_dev_register (grub_usb_controller_dev_t usb)
@@ -232,3 +234,75 @@ grub_usb_device_initialize (grub_usb_device_t dev)
 
   return err;
 }
+
+void grub_usb_device_attach (grub_usb_device_t dev)
+{
+  int i;
+  
+  /* XXX: Just check configuration 0 for now.  */
+  for (i = 0; i < dev->config[0].descconf->numif; i++)
+    {
+      struct grub_usb_desc_if *interf;
+      struct grub_usb_attach_desc *desc;
+
+      interf = dev->config[0].interf[i].descif;
+
+      grub_dprintf ("usb", "iterate: interf=%d, class=%d, subclass=%d, protocol=%d\n",
+		    i, interf->class, interf->subclass, interf->protocol);
+
+      if (dev->config[0].interf[i].attached)
+	continue;
+
+      for (desc = attach_hooks; desc; desc = desc->next)
+	if (interf->class == desc->class && desc->hook (dev, 0, i))
+	  dev->config[0].interf[i].attached = 1;
+    }
+}
+
+void
+grub_usb_register_attach_hook_class (struct grub_usb_attach_desc *desc)
+{
+  auto int usb_iterate (grub_usb_device_t dev);
+
+  int usb_iterate (grub_usb_device_t usbdev)
+    {
+      struct grub_usb_desc_device *descdev = &usbdev->descdev;
+      int i;
+
+      if (descdev->class != 0 || descdev->subclass || descdev->protocol != 0
+	  || descdev->configcnt == 0)
+	return 0;
+
+      /* XXX: Just check configuration 0 for now.  */
+      for (i = 0; i < usbdev->config[0].descconf->numif; i++)
+	{
+	  struct grub_usb_desc_if *interf;
+
+	  interf = usbdev->config[0].interf[i].descif;
+
+	  grub_dprintf ("usb", "iterate: interf=%d, class=%d, subclass=%d, protocol=%d\n",
+	                i, interf->class, interf->subclass, interf->protocol);
+
+	  if (usbdev->config[0].interf[i].attached)
+	    continue;
+
+	  if (interf->class != desc->class)
+	    continue;
+	  if (desc->hook (usbdev, 0, i))
+	    usbdev->config[0].interf[i].attached = 1;
+	}
+
+      return 0;
+    }
+
+  desc->next = attach_hooks;
+  attach_hooks = desc;
+
+  grub_usb_iterate (usb_iterate);
+}
+
+void
+grub_usb_unregister_attach_hook_class (struct grub_usb_attach_desc *desc)
+{
+  grub_list_remove (GRUB_AS_LIST_P (&attach_hooks), GRUB_AS_LIST (desc));  
+}

bus/usb/usbhub.c

@@ -21,9 +21,23 @@
 #include <grub/mm.h>
 #include <grub/usb.h>
 #include <grub/misc.h>
+#include <grub/time.h>
+
+#define GRUB_USBHUB_MAX_DEVICES 128
 
 /* USB Supports 127 devices, with device 0 as special case.  */
-static struct grub_usb_device *grub_usb_devs[128];
+static struct grub_usb_device *grub_usb_devs[GRUB_USBHUB_MAX_DEVICES];
+
+struct grub_usb_hub
+{
+  struct grub_usb_hub *next;
+  grub_usb_controller_t controller;
+  int nports;
+  grub_usb_speed_t *speed;
+  grub_usb_device_t dev;
+};
+
+struct grub_usb_hub *hubs;
 
 /* Add a device that currently has device number 0 and resides on
    CONTROLLER, the Hub reported that the device speed is SPEED.  */
@@ -32,6 +46,7 @@ grub_usb_hub_add_dev (grub_usb_controller_t controller, grub_usb_speed_t speed)
 {
   grub_usb_device_t dev;
   int i;
+  grub_usb_err_t err;
 
   dev = grub_zalloc (sizeof (struct grub_usb_device));
   if (! dev)
@@ -40,31 +55,51 @@ grub_usb_hub_add_dev (grub_usb_controller_t controller, grub_usb_speed_t speed)
   dev->controller = *controller;
   dev->speed = speed;
 
-  grub_usb_device_initialize (dev);
+  err = grub_usb_device_initialize (dev);
+  if (err)
+    {
+      grub_free (dev);
+      return NULL;
+    }
 
   /* Assign a new address to the device.  */
-  for (i = 1; i < 128; i++)
+  for (i = 1; i < GRUB_USBHUB_MAX_DEVICES; i++)
     {
       if (! grub_usb_devs[i])
 	break;
     }
-  if (i == 128)
+  if (i == GRUB_USBHUB_MAX_DEVICES)
     {
       grub_error (GRUB_ERR_IO, "can't assign address to USB device");
+      for (i = 0; i < 8; i++)
+        grub_free (dev->config[i].descconf);
+      grub_free (dev);
       return NULL;
     }
 
-  grub_usb_control_msg (dev,
+  err = 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);
+  if (err)
+    {
+      for (i = 0; i < 8; i++)
+        grub_free (dev->config[i].descconf);
+      grub_free (dev);
+      return NULL;
+    }
 
   dev->addr = i;
   dev->initialized = 1;
   grub_usb_devs[i] = dev;
 
+  /* Wait "recovery interval", spec. says 2ms */
+  grub_millisleep (2);
+  
+  grub_usb_device_attach (dev);
+  
   return dev;
 }
 
@@ -75,13 +110,46 @@ grub_usb_add_hub (grub_usb_device_t dev)
   struct grub_usb_usb_hubdesc hubdesc;
   grub_err_t err;
   int i;
+  grub_uint64_t timeout;
+  grub_usb_device_t next_dev;
   
-  grub_usb_control_msg (dev, (GRUB_USB_REQTYPE_IN
+  err = 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);
+  if (err)
+    return err;
+  grub_dprintf ("usb", "Hub descriptor:\n\t\t len:%d, typ:0x%02x, cnt:%d, char:0x%02x, pwg:%d, curr:%d\n",
+                hubdesc.length, hubdesc.type, hubdesc.portcnt,
+                hubdesc.characteristics, hubdesc.pwdgood,
+                hubdesc.current);
+
+  /* Activate the first configuration. Hubs should have only one conf. */
+  grub_dprintf ("usb", "Hub set configuration\n");
+  grub_usb_set_configuration (dev, 1);
+
+  /* Power on all Hub ports.  */
+  for (i = 1; i <= hubdesc.portcnt; i++)
+    {
+      grub_dprintf ("usb", "Power on - port %d\n", i);
+      /* Power on the port and wait for possible device connect */
+      err = grub_usb_control_msg (dev, (GRUB_USB_REQTYPE_OUT
+					| GRUB_USB_REQTYPE_CLASS
+					| GRUB_USB_REQTYPE_TARGET_OTHER),
+				  GRUB_USB_REQ_SET_FEATURE,
+				  GRUB_USB_HUB_FEATURE_PORT_POWER,
+				  i, 0, NULL);
+      /* Just ignore the device if some error happened */
+      if (err)
+	continue;
+    }
+  /* Wait for port power-on */
+  if (hubdesc.pwdgood >= 50)
+    grub_millisleep (hubdesc.pwdgood * 2);
+  else
+    grub_millisleep (100);
     
   /* Iterate over the Hub ports.  */
   for (i = 1; i <= hubdesc.portcnt; i++)
@@ -92,13 +160,13 @@ grub_usb_add_hub (grub_usb_device_t dev)
       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,
+				  GRUB_USB_REQ_GET_STATUS,
 				  0, i, sizeof (status), (char *) &status);
-
       /* Just ignore the device if the Hub does not report the
 	 status.  */
       if (err)
 	continue;
+      grub_dprintf ("usb", "Hub port %d status: 0x%02x\n", i, status);
 
       /* If connected, reset and enable the port.  */
       if (status & GRUB_USB_HUB_STATUS_CONNECTED)
@@ -116,70 +184,298 @@ grub_usb_add_hub (grub_usb_device_t dev)
 		speed = GRUB_USB_SPEED_FULL;
 	    }
 
-	  /* A device is actually connected to this port, not enable
+	  /* A device is actually connected to this port.
-	     the port.  XXX: Why 0x03?  According to some docs it
+	   * Now do reset of port. */
-	     should be 0x0.  Check the specification!  */
+          grub_dprintf ("usb", "Reset hub port - port %d\n", i);
 	  err = grub_usb_control_msg (dev, (GRUB_USB_REQTYPE_OUT
 					    | GRUB_USB_REQTYPE_CLASS
 					    | GRUB_USB_REQTYPE_TARGET_OTHER),
-				      0x3, 0x4, i, 0, 0);
+				      GRUB_USB_REQ_SET_FEATURE,
-
+				      GRUB_USB_HUB_FEATURE_PORT_RESET,
+				      i, 0, 0);
 	  /* If the Hub does not cooperate for this port, just skip
 	     the port.  */
 	  if (err)
 	    continue;
 
+          /* Wait for reset procedure done */
+          timeout = grub_get_time_ms () + 1000;
+          do
+            {
+              /* 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_GET_STATUS,
+				          0, i, sizeof (status), (char *) &status);
+            }
+          while (!err &&
+                 !(status & GRUB_USB_HUB_STATUS_C_PORT_RESET) &&
+                 (grub_get_time_ms() < timeout) );
+          if (err || !(status & GRUB_USB_HUB_STATUS_C_PORT_RESET) )
+            continue;
+
+          /* Wait a recovery time after reset, spec. says 10ms */
+          grub_millisleep (10);
+   
+          /* Do reset of connection change bit */
+          err = grub_usb_control_msg (dev, (GRUB_USB_REQTYPE_OUT
+                                            | GRUB_USB_REQTYPE_CLASS
+                                            | GRUB_USB_REQTYPE_TARGET_OTHER),
+                                      GRUB_USB_REQ_CLEAR_FEATURE,
+				      GRUB_USB_HUB_FEATURE_C_CONNECTED,
+				      i, 0, 0);
+          /* Just ignore the device if the Hub reports some error */
+          if (err)
+	     continue;
+          grub_dprintf ("usb", "Hub port - cleared connection change\n");
+
 	  /* Add the device and assign a device address to it.  */
-	  grub_usb_hub_add_dev (&dev->controller, speed);
+          grub_dprintf ("usb", "Call hub_add_dev - port %d\n", i);
+	  next_dev = grub_usb_hub_add_dev (&dev->controller, speed);
+          if (! next_dev)
+            continue;
+
+          /* If the device is a Hub, scan it for more devices.  */
+          if (next_dev->descdev.class == 0x09)
+            grub_usb_add_hub (next_dev);
 	}
     }
 
   return GRUB_ERR_NONE;
 }
 
-grub_usb_err_t
+static void
-grub_usb_root_hub (grub_usb_controller_t controller)
+attach_root_port (grub_usb_controller_t controller, int portno,
-{
+		  grub_usb_speed_t speed)
-  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;
+  grub_err_t err;
+
+  /* Disable the port. XXX: Why? */
+  err = controller->dev->portstatus (controller, portno, 0);
+  if (err)
+    return;
 
   /* Enable the port.  */
-	  err = controller->dev->portstatus (controller, i, 1);
+  err = controller->dev->portstatus (controller, portno, 1);
   if (err)
-	    continue;
+    return;
 
   /* Enable the port and create a device.  */
   dev = grub_usb_hub_add_dev (controller, speed);
   if (! dev)
-	    continue;
+    return;
 
   /* If the device is a Hub, scan it for more devices.  */
   if (dev->descdev.class == 0x09)
     grub_usb_add_hub (dev);
 }
+
+grub_usb_err_t
+grub_usb_root_hub (grub_usb_controller_t controller)
+{
+  int i;
+  struct grub_usb_hub *hub;
+  int changed=0;
+
+  hub = grub_malloc (sizeof (*hub));
+  if (!hub)
+    return GRUB_USB_ERR_INTERNAL;
+
+  hub->next = hubs;
+  hubs = hub;
+  hub->controller = grub_malloc (sizeof (*controller));
+  if (!hub->controller)
+    {
+      grub_free (hub);
+      return GRUB_USB_ERR_INTERNAL;
+    }
+
+  grub_memcpy (hub->controller, controller, sizeof (*controller));
+  hub->dev = 0;
+
+  /* Query the number of ports the root Hub has.  */
+  hub->nports = controller->dev->hubports (controller);
+  hub->speed = grub_malloc (sizeof (hub->speed[0]) * hub->nports);
+  if (!hub->speed)
+    {
+      grub_free (hub->controller);
+      grub_free (hub);
+      return GRUB_USB_ERR_INTERNAL;
+    }
+
+  for (i = 0; i < hub->nports; i++)
+    {
+      hub->speed[i] = controller->dev->detect_dev (hub->controller, i,
+                                                   &changed);
+
+      if (hub->speed[i] != GRUB_USB_SPEED_NONE)
+	attach_root_port (hub->controller, i, hub->speed[i]);
     }
 
   return GRUB_USB_ERR_NONE;
 }
 
+static void
+poll_nonroot_hub (grub_usb_device_t dev)
+{
+  struct grub_usb_usb_hubdesc hubdesc;
+  grub_err_t err;
+  int i;
+  grub_uint64_t timeout;
+  grub_usb_device_t next_dev;
+  
+  err = 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);
+  if (err)
+    return;
+    
+  /* 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_GET_STATUS,
+				  0, i, sizeof (status), (char *) &status);
+      /* Just ignore the device if the Hub does not report the
+	 status.  */
+      if (err)
+	continue;
+      	    
+      /* Connected and status of connection changed ? */
+      if ((status & GRUB_USB_HUB_STATUS_CONNECTED)
+          && (status & GRUB_USB_HUB_STATUS_C_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.
+	   * Now do reset of port. */
+	  err = grub_usb_control_msg (dev, (GRUB_USB_REQTYPE_OUT
+					    | GRUB_USB_REQTYPE_CLASS
+					    | GRUB_USB_REQTYPE_TARGET_OTHER),
+				      GRUB_USB_REQ_SET_FEATURE,
+				      GRUB_USB_HUB_FEATURE_PORT_RESET,
+				      i, 0, 0);
+	  /* If the Hub does not cooperate for this port, just skip
+	     the port.  */
+	  if (err)
+	    continue;
+
+          /* Wait for reset procedure done */
+          timeout = grub_get_time_ms () + 1000;
+          do
+            {
+              /* 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_GET_STATUS,
+				          0, i, sizeof (status), (char *) &status);
+            }
+          while (!err &&
+                 !(status & GRUB_USB_HUB_STATUS_C_PORT_RESET) &&
+                 (grub_get_time_ms() < timeout) );
+          if (err || !(status & GRUB_USB_HUB_STATUS_C_PORT_RESET) )
+            continue;
+
+          /* Wait a recovery time after reset, spec. says 10ms */
+          grub_millisleep (10);
+
+          /* Do reset of connection change bit */
+          err = grub_usb_control_msg (dev, (GRUB_USB_REQTYPE_OUT
+                                            | GRUB_USB_REQTYPE_CLASS
+                                            | GRUB_USB_REQTYPE_TARGET_OTHER),
+                                      GRUB_USB_REQ_CLEAR_FEATURE,
+				      GRUB_USB_HUB_FEATURE_C_CONNECTED,
+				      i, 0, 0);
+          /* Just ignore the device if the Hub reports some error */
+          if (err)
+	     continue;
+
+	  /* Add the device and assign a device address to it.  */
+	  next_dev = grub_usb_hub_add_dev (&dev->controller, speed);
+          if (! next_dev)
+            continue;
+
+          /* If the device is a Hub, scan it for more devices.  */
+          if (next_dev->descdev.class == 0x09)
+            grub_usb_add_hub (next_dev);
+	}
+    }
+
+  return;
+}
+
+void
+grub_usb_poll_devices (void)
+{
+  struct grub_usb_hub *hub;
+  int i;
+
+  for (hub = hubs; hub; hub = hub->next)
+    {
+      int changed=0;
+      /* Do we have to recheck number of ports?  */
+      /* No, it should be never changed, it should be constant. */
+      for (i = 0; i < hub->nports; i++)
+	{
+	  grub_usb_speed_t speed;
+
+	  speed = hub->controller->dev->detect_dev (hub->controller, i,
+	                                            &changed);
+
+	  if (speed != GRUB_USB_SPEED_NONE)
+	    {
+              if (changed)
+                attach_root_port (hub->controller, i, speed);
+	    }
+
+          /* XXX: There should be also handling
+           * of disconnected devices. */
+           
+	  hub->speed[i] = speed;
+	}
+    }
+
+  /* We should check changes of non-root hubs too. */
+  for (i = 0; i < GRUB_USBHUB_MAX_DEVICES; i++)
+    {
+      grub_usb_device_t dev = grub_usb_devs[i];
+
+      if (dev && dev->descdev.class == 0x09)
+	{
+          poll_nonroot_hub (dev);
+	}
+    }
+
+}
+
 int
 grub_usb_iterate (int (*hook) (grub_usb_device_t dev))
 {
   int i;
 
-  for (i = 0; i < 128; i++)
+  for (i = 0; i < GRUB_USBHUB_MAX_DEVICES; i++)
     {
       if (grub_usb_devs[i])
 	{

bus/usb/usbtrans.c

@@ -81,7 +81,7 @@ grub_usb_control_msg (grub_usb_device_t dev,
   else
     max = 64;
 
-  grub_dprintf ("usb", "transfer = %p, dev = %p\n", transfer, dev);
+  grub_dprintf ("usb", "control: transfer = %p, dev = %p\n", transfer, dev);
 
   datablocks = (size + max - 1) / max;
 
@@ -146,6 +146,7 @@ grub_usb_control_msg (grub_usb_device_t dev,
   transfer->transactions[datablocks + 1].toggle = 1;
 
   err = dev->controller.dev->transfer (&dev->controller, transfer);
+  grub_dprintf ("usb", "control: err=%d\n", err);
 
   grub_free (transfer->transactions);
   
@@ -174,6 +175,8 @@ grub_usb_bulk_readwrite (grub_usb_device_t dev,
   struct grub_pci_dma_chunk *data_chunk;
   grub_size_t size = size0;
 
+  grub_dprintf ("usb", "bulk: size=0x%02x type=%d\n", size, type);
+
   /* FIXME: avoid allocation any kind of buffer in a first place.  */
   data_chunk = grub_memalign_dma32 (128, size);
   if (!data_chunk)
@@ -248,7 +251,7 @@ grub_usb_bulk_readwrite (grub_usb_device_t dev,
     toggle = transfer->transactions[transfer->last_trans].toggle ? 0 : 1;
   else
     toggle = dev->toggle[endpoint]; /* Nothing done, take original */
-  grub_dprintf ("usb", "toggle=%d\n", toggle);
+  grub_dprintf ("usb", "bulk: err=%d, toggle=%d\n", err, toggle);
   dev->toggle[endpoint] = toggle;
 
   grub_free (transfer->transactions);

commands/cat.c

@@ -23,19 +23,28 @@
 #include <grub/term.h>
 #include <grub/misc.h>
 #include <grub/gzio.h>
-#include <grub/command.h>
+#include <grub/extcmd.h>
 #include <grub/i18n.h>
 
-static grub_err_t
+static const struct grub_arg_option options[] =
-grub_cmd_cat (grub_command_t cmd __attribute__ ((unused)),
-	      int argc, char **args)
-
   {
+    {"dos", -1, 0, N_("Accept DOS-style CR/NL line endings."), 0, 0},
+    {0, 0, 0, 0, 0, 0}
+  };
+
+static grub_err_t
+grub_cmd_cat (grub_extcmd_context_t ctxt, int argc, char **args)
+{
+  struct grub_arg_list *state = ctxt->state;
+  int dos = 0;
   grub_file_t file;
   char buf[GRUB_DISK_SECTOR_SIZE];
   grub_ssize_t size;
   int key = 0;
 
+  if (state[0].set)
+    dos = 1;
+
   if (argc != 1)
     return grub_error (GRUB_ERR_BAD_ARGUMENT, "file name required");
 
@@ -53,7 +62,12 @@ grub_cmd_cat (grub_command_t cmd __attribute__ ((unused)),
 	  unsigned char c = buf[i];
 
 	  if ((grub_isprint (c) || grub_isspace (c)) && c != '\r')
-	    grub_putchar (c);
+	    grub_printf ("%c", c);
+	  else if (dos && c == '\r' && i + 1 < size && buf[i + 1] == '\n')
+	    {
+	      grub_printf ("\n");
+	      i++;
+	    }
 	  else
 	    {
 	      grub_setcolorstate (GRUB_TERM_COLOR_HIGHLIGHT);
@@ -67,22 +81,23 @@ grub_cmd_cat (grub_command_t cmd __attribute__ ((unused)),
 	;
     }
 
-  grub_putchar ('\n');
+  grub_xputs ("\n");
   grub_refresh ();
   grub_file_close (file);
 
   return 0;
 }
 
-static grub_command_t cmd;
+static grub_extcmd_t cmd;
 
 GRUB_MOD_INIT(cat)
 {
-  cmd = grub_register_command_p1 ("cat", grub_cmd_cat,
+  cmd = grub_register_extcmd ("cat", grub_cmd_cat, GRUB_COMMAND_FLAG_BOTH,
-				  N_("FILE"), N_("Show the contents of a file."));
+			      N_("FILE"), N_("Show the contents of a file."),
+			      options);
 }
 
 GRUB_MOD_FINI(cat)
 {
-  grub_unregister_command (cmd);
+  grub_unregister_extcmd (cmd);
 }

commands/handler.c

@@ -1,101 +0,0 @@
-/* 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);
-}

commands/help.c

@@ -33,10 +33,10 @@ grub_cmd_help (grub_extcmd_context_t ctxt __attribute__ ((unused)), int argc,
   int cnt = 0;
   char *currarg;
 
-  auto int print_command_info (grub_command_t cmd);
+  if (argc == 0)
-  auto int print_command_help (grub_command_t cmd);
+    {
-
+      grub_command_t cmd;
-  int print_command_info (grub_command_t cmd)
+      FOR_COMMANDS(cmd)
       {
 	if ((cmd->prio & GRUB_PRIO_LIST_FLAG_ACTIVE) &&
 	    (cmd->flags & GRUB_COMMAND_FLAG_CMDLINE))
@@ -49,7 +49,7 @@ grub_cmd_help (grub_extcmd_context_t ctxt __attribute__ ((unused)), int argc,
 	  			      
 	    command_help = grub_xasprintf ("%s %s", cmd->name, summary_translated);
 	    if (!command_help)
-	    return 1;
+	      break;
 
 	    grub_utf8_to_ucs4_alloc (command_help, &unicode_command_help,
 				     &unicode_last_position);
@@ -66,18 +66,24 @@ grub_cmd_help (grub_extcmd_context_t ctxt __attribute__ ((unused)), int argc,
 	      while (unicode_last_screen_position < unicode_last_position && 
 		     stringwidth < ((grub_term_width (term) / 2) - 2))
 		{
+		  struct grub_unicode_glyph glyph;
+		  unicode_last_screen_position 
+		    += grub_unicode_aglomerate_comb (unicode_last_screen_position,
+						     unicode_last_position
+						     - unicode_last_screen_position,
+						     &glyph);
+
 		  stringwidth
-		  += grub_term_getcharwidth (term,
+		    += grub_term_getcharwidth (term, &glyph);
-					     *unicode_last_screen_position);
-		unicode_last_screen_position++;
 		}
 
 	      grub_print_ucs4 (unicode_command_help,
-			     unicode_last_screen_position, term);
+			       unicode_last_screen_position, 0, 0, term);
 	      if (!(cnt % 2))
 		grub_print_spaces (term, grub_term_width (term) / 2
 				   - stringwidth);
 	    }
+
 	    if (cnt % 2)
 	      grub_printf ("\n");
 	    cnt++;
@@ -85,10 +91,19 @@ grub_cmd_help (grub_extcmd_context_t ctxt __attribute__ ((unused)), int argc,
 	    grub_free (command_help);
 	    grub_free (unicode_command_help);
 	  }
-      return 0;
       }
+      if (!(cnt % 2))
+	grub_printf ("\n");
+    }
+  else
+    {
+      int i;
+      grub_command_t cmd;
 
-  int print_command_help (grub_command_t cmd)
+      for (i = 0; i < argc; i++)
+	{
+	  currarg = args[i];
+	  FOR_COMMANDS(cmd)
 	  {
 	    if (cmd->prio & GRUB_PRIO_LIST_FLAG_ACTIVE)
 	      {
@@ -104,23 +119,7 @@ grub_cmd_help (grub_extcmd_context_t ctxt __attribute__ ((unused)), int argc,
 				   _(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);
 	}
     }
 

commands/ls.c

@@ -57,7 +57,7 @@ grub_ls_list_devices (int longlist)
     }
 
   grub_device_iterate (grub_ls_print_devices);
-  grub_putchar ('\n');
+  grub_xputs ("\n");
   grub_refresh ();
 
   return 0;
@@ -233,7 +233,7 @@ grub_ls_list_files (char *dirname, int longlist, int all, int human)
 	}
 
       if (grub_errno == GRUB_ERR_NONE)
-	grub_putchar ('\n');
+	grub_xputs ("\n");
 
       grub_refresh ();
     }

commands/minicmd.c

@@ -54,7 +54,7 @@ grub_mini_cmd_cat (struct grub_command *cmd __attribute__ ((unused)),
 	  unsigned char c = buf[i];
 
 	  if ((grub_isprint (c) || grub_isspace (c)) && c != '\r')
-	    grub_putchar (c);
+	    grub_printf ("%c", c);
 	  else
 	    {
 	      grub_setcolorstate (GRUB_TERM_COLOR_HIGHLIGHT);
@@ -64,7 +64,7 @@ grub_mini_cmd_cat (struct grub_command *cmd __attribute__ ((unused)),
 	}
     }
 
-  grub_putchar ('\n');
+  grub_xputs ("\n");
   grub_refresh ();
   grub_file_close (file);
 
@@ -301,9 +301,10 @@ 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);
+  grub_dl_t mod;
 
-  int print_module (grub_dl_t mod)
+  grub_printf ("Name\tRef Count\tDependencies\n");
+  FOR_DL_MODULES (mod)
   {
     grub_dl_dep_t dep;
 
@@ -311,18 +312,13 @@ grub_mini_cmd_lsmod (struct grub_command *cmd __attribute__ ((unused)),
     for (dep = mod->dep; dep; dep = dep->next)
       {
 	if (dep != mod->dep)
-	    grub_putchar (',');
+	  grub_xputs (",");
 
 	grub_printf ("%s", dep->mod->name);
       }
-      grub_putchar ('\n');
+    grub_xputs ("\n");
-
-      return 0;
   }
 
-  grub_printf ("Name\tRef Count\tDependencies\n");
-  grub_dl_iterate (print_module);
-
   return 0;
 }
 
@@ -336,19 +332,8 @@ grub_mini_cmd_exit (struct grub_command *cmd __attribute__ ((unused)),
   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)
 {
@@ -373,9 +358,6 @@ GRUB_MOD_INIT(minicmd)
   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)
@@ -387,5 +369,4 @@ GRUB_MOD_FINI(minicmd)
   grub_unregister_command (cmd_rmmod);
   grub_unregister_command (cmd_lsmod);
   grub_unregister_command (cmd_exit);
-  grub_unregister_command (cmd_clear);
 }

commands/mips/yeeloong/lsspd.c

@@ -0,0 +1,92 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 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/types.h>
+#include <grub/misc.h>
+#include <grub/mm.h>
+#include <grub/err.h>
+#include <grub/dl.h>
+#include <grub/command.h>
+#include <grub/cs5536.h>
+
+static grub_err_t
+grub_cmd_lsspd (grub_command_t cmd __attribute__ ((unused)),
+		int argc __attribute__ ((unused)),
+		char **args __attribute__ ((unused)))
+{
+  grub_pci_device_t dev;
+  grub_port_t smbbase;
+  int i;
+  grub_err_t err;
+
+  if (!grub_cs5536_find (&dev))
+    {
+      grub_printf ("No CS5536 found\n");
+      return GRUB_ERR_NONE;
+    }
+  grub_printf ("CS5536 at %d:%d.%d\n", grub_pci_get_bus (dev),
+	       grub_pci_get_device (dev), grub_pci_get_function (dev));
+  
+  err = grub_cs5536_init_smbus (dev, 0x7fff, &smbbase);
+  if (err)
+    return err;
+
+  grub_printf ("SMB base = 0x%x\n", smbbase);
+
+  for (i = GRUB_SMB_RAM_START_ADDR;
+       i < GRUB_SMB_RAM_START_ADDR + GRUB_SMB_RAM_NUM_MAX; i++)
+    {
+      struct grub_smbus_spd spd;
+      grub_memset (&spd, 0, sizeof (spd));
+      grub_printf ("Device %d\n", i);
+      err = grub_cs5536_read_spd (smbbase, i, &spd);
+      if (err)
+	{
+	  grub_print_error ();
+	  continue;
+	}
+      grub_printf ("Written SPD bytes: %d B.\n", spd.written_size);
+      grub_printf ("Total flash size: %d B.\n", 1 << spd.log_total_flash_size);
+      if (spd.memory_type == GRUB_SMBUS_SPD_MEMORY_TYPE_DDR2)
+	{
+	  char str[sizeof (spd.ddr2.part_number) + 1];
+	  grub_printf ("Memory type: DDR2.\n");
+	  grub_memcpy (str, spd.ddr2.part_number,
+		       sizeof (spd.ddr2.part_number));
+	  str[sizeof (spd.ddr2.part_number)] = 0;
+	  grub_printf ("Part no: %s.\n", str);
+	}
+      else
+	grub_printf ("Memory type: Unknown.\n");
+    }
+
+  return GRUB_ERR_NONE;
+}
+
+static grub_command_t cmd;
+
+GRUB_MOD_INIT(lsspd)
+{
+  cmd = grub_register_command ("lsspd", grub_cmd_lsspd, 0,
+			       "Print Memory information.");
+}
+
+GRUB_MOD_FINI(lsspd)
+{
+  grub_unregister_command (cmd);
+}

commands/read.c

@@ -47,7 +47,7 @@ grub_getline (void)
 
       line[i] = c;
       if (grub_isprint (c))
-	grub_putchar (c);
+	grub_printf ("%c", c);
       i++;
       tmp = grub_realloc (line, 1 + i + sizeof('\0'));
       if (! tmp)

commands/terminal.c

@@ -30,8 +30,8 @@ struct abstract_terminal
 {
   struct abstract_terminal *next;
   const char *name;
-  grub_err_t (*init) (void);
+  grub_err_t (*init) (struct abstract_terminal *term);
-  grub_err_t (*fini) (void);
+  grub_err_t (*fini) (struct abstract_terminal *term);
 };
 
 static grub_err_t
@@ -123,7 +123,7 @@ handle_command (int argc, char **args, struct abstract_terminal **enabled,
              break;
          if (term)
            {
-              if (term->init && term->init () != GRUB_ERR_NONE)
+              if (term->init && term->init (term) != GRUB_ERR_NONE)
                 return grub_errno;
 
              grub_list_remove (GRUB_AS_LIST_P (disabled), GRUB_AS_LIST (term));
@@ -147,7 +147,7 @@ handle_command (int argc, char **args, struct abstract_terminal **enabled,
                                   "can't remove the last terminal");
              grub_list_remove (GRUB_AS_LIST_P (enabled), GRUB_AS_LIST (term));
              if (term->fini)
-               term->fini ();
+               term->fini (term);
              grub_list_push (GRUB_AS_LIST_P (disabled), GRUB_AS_LIST (term));
            }
        }
@@ -160,7 +160,7 @@ handle_command (int argc, char **args, struct abstract_terminal **enabled,
          break;
       if (term)
        {
-         if (term->init && term->init () != GRUB_ERR_NONE)
+         if (term->init && term->init (term) != GRUB_ERR_NONE)
            return grub_errno;
 
          grub_list_remove (GRUB_AS_LIST_P (disabled), GRUB_AS_LIST (term));
@@ -183,7 +183,7 @@ handle_command (int argc, char **args, struct abstract_terminal **enabled,
                                 "can't remove the last terminal");
            grub_list_remove (GRUB_AS_LIST_P (enabled), GRUB_AS_LIST (term));
            if (term->fini)
-             term->fini ();
+             term->fini (term);
            grub_list_push (GRUB_AS_LIST_P (disabled), GRUB_AS_LIST (term));
          }
       }

commands/usbtest.c

@@ -194,6 +194,8 @@ grub_cmd_usbtest (grub_command_t cmd __attribute__ ((unused)),
 		  int argc __attribute__ ((unused)),
 		  char **args __attribute__ ((unused)))
 {
+  grub_usb_poll_devices ();
+
   grub_printf ("USB devices:\n\n");
   grub_usb_iterate (usb_iterate);
 

commands/videotest.c

@@ -25,6 +25,7 @@
 #include <grub/term.h>
 #include <grub/command.h>
 #include <grub/i18n.h>
+#include <grub/gfxmenu_view.h>
 
 static grub_err_t
 grub_cmd_videotest (grub_command_t cmd __attribute__ ((unused)),
@@ -38,15 +39,8 @@ grub_cmd_videotest (grub_command_t cmd __attribute__ ((unused)),
   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)
@@ -54,21 +48,22 @@ grub_cmd_videotest (grub_command_t cmd __attribute__ ((unused)),
 
   grub_video_get_viewport (&x, &y, &width, &height);
 
+  {
+    const char *str;
+    int texty;
+    grub_font_t sansbig;
+    grub_font_t sans;
+    grub_font_t sanssmall;
+    grub_font_t fixed;
+    struct grub_font_glyph *glyph;
+
     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);
+    grub_video_set_active_render_target (text_layer);
-
-  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");
@@ -79,13 +74,6 @@ grub_cmd_videotest (grub_command_t cmd __attribute__ ((unused)),
     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;
@@ -147,9 +135,28 @@ grub_cmd_videotest (grub_command_t cmd __attribute__ ((unused)),
 	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 < 2; i++)
+    {
+      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);
+
+      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_swap_buffers ();
+    }
+
   for (i = 0; i < 5; i++)
     {
       color = grub_video_map_rgb (i, 33, 77);

conf/any-emu.rmk

@@ -3,7 +3,7 @@
 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/err.c kern/list.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			\

conf/common.rmk

@@ -1,7 +1,7 @@
 # -*- makefile -*-
 
 # Used by various components.  These rules need to precede them.
-script/lexer.c_DEPENDENCIES = grub_script.tab.h
+script/lexer.c_DEPENDENCIES = grub_script.tab.h grub_script.yy.h
 
 sbin_UTILITIES += grub-mkdevicemap
 grub_mkdevicemap_SOURCES = gnulib/progname.c util/grub-mkdevicemap.c \
@@ -27,7 +27,7 @@ util/grub-probe.c_DEPENDENCIES = grub_probe_init.h
 grub_probe_SOURCES = gnulib/progname.c util/grub-probe.c	\
 	kern/emu/hostdisk.c util/misc.c kern/emu/misc.c kern/emu/getroot.c kern/emu/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	\
+	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	\
@@ -38,7 +38,8 @@ grub_probe_SOURCES = gnulib/progname.c util/grub-probe.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
+	disk/raid.c disk/raid5_recover.c disk/raid6_recover.c	\
+	disk/mdraid_linux.c disk/lvm.c grub_probe_init.c
 
 ifeq ($(enable_grub_fstest), yes)
 bin_UTILITIES += grub-fstest
@@ -69,7 +70,8 @@ grub_fstest_SOURCES = gnulib/progname.c util/grub-fstest.c kern/emu/hostfs.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 kern/emu/misc.c
+grub_mkfont_SOURCES = gnulib/progname.c util/grub-mkfont.c util/misc.c \
+	unidata.c kern/emu/misc.c
 grub_mkfont_CFLAGS = $(freetype_cflags)
 grub_mkfont_LDFLAGS = $(freetype_libs)
 endif
@@ -88,21 +90,21 @@ 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 kern/emu/misc.c kern/emu/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/err.c kern/list.c \
-	kern/misc.c kern/env.c grub_script_check_init.c grub_script.tab.c \
+	kern/misc.c kern/env.c grub_script.tab.c \
 	grub_script.yy.c
 grub_script_check_CFLAGS = $(GNULIB_UTIL_CFLAGS)
+grub_script_check_DEPENDENCIES = grub_script.tab.h
 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
+	list.h command.h i18n.h env_private.h libgcc.h
 
 ifneq ($(platform), emu)
 kernel_img_HEADERS += machine/memory.h machine/loader.h
@@ -119,19 +121,6 @@ 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 > $@
@@ -215,10 +204,13 @@ 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
+grub-mkconfig_SCRIPTS = 00_header 30_os-prober 40_custom 41_custom
 ifneq (, $(host_kernel))
 grub-mkconfig_SCRIPTS += 10_$(host_kernel)
 endif
+ifeq (linux, $(host_kernel))
+grub-mkconfig_SCRIPTS += 20_linux_xen
+endif
 
 CLEANFILES += $(grub-mkconfig_SCRIPTS)
 
@@ -448,12 +440,12 @@ scsi_mod_CFLAGS = $(COMMON_CFLAGS)
 scsi_mod_LDFLAGS = $(COMMON_LDFLAGS)
 
 # Commands.
-pkglib_MODULES += minicmd.mod extcmd.mod hello.mod handler.mod	\
+pkglib_MODULES += minicmd.mod extcmd.mod hello.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		\
+	test.mod blocklist.mod hexdump.mod		\
 	read.mod sleep.mod loadenv.mod crc.mod parttool.mod	\
-	msdospart.mod memrw.mod normal.mod sh.mod 		\
+	msdospart.mod memrw.mod normal.mod 			\
 	gptsync.mod true.mod probe.mod password.mod		\
 	keystatus.mod
 
@@ -500,7 +492,8 @@ gfxmenu_mod_SOURCES = \
 	gfxmenu/gui_progress_bar.c \
 	gfxmenu/gui_util.c \
 	gfxmenu/gui_string_util.c \
-	gfxmenu/named_colors.c
+	gfxmenu/named_colors.c \
+	gfxmenu/font.c
 gfxmenu_mod_CFLAGS = $(COMMON_CFLAGS)
 gfxmenu_mod_LDFLAGS = $(COMMON_LDFLAGS)
 
@@ -514,11 +507,6 @@ 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)
@@ -581,10 +569,13 @@ configfile_mod_SOURCES = commands/configfile.c
 configfile_mod_CFLAGS = $(COMMON_CFLAGS)
 configfile_mod_LDFLAGS = $(COMMON_LDFLAGS)
 
+ifneq ($(platform), ieee1275)
 # For terminfo.mod.
+pkglib_MODULES += terminfo.mod
 terminfo_mod_SOURCES = term/terminfo.c term/tparm.c
 terminfo_mod_CFLAGS = $(COMMON_CFLAGS)
 terminfo_mod_LDFLAGS = $(COMMON_LDFLAGS)
+endif
 
 # For blocklist.mod.
 blocklist_mod_SOURCES = commands/blocklist.c
@@ -637,19 +628,18 @@ keystatus_mod_CFLAGS = $(COMMON_CFLAGS)
 keystatus_mod_LDFLAGS = $(COMMON_LDFLAGS)
 
 # For normal.mod.
+ifneq (, $(FONT_SOURCE))
+normal/charset.c_DEPENDENCIES = widthspec.h
+endif
 normal_mod_SOURCES = normal/main.c normal/cmdline.c normal/dyncmd.c \
-	normal/auth.c normal/autofs.c normal/handler.c \
+	normal/auth.c normal/autofs.c  \
 	normal/color.c normal/completion.c normal/datetime.c normal/menu.c \
-	normal/menu_entry.c normal/menu_text.c \
+	normal/menu_entry.c normal/menu_text.c normal/charset.c \
-	normal/misc.c normal/crypto.c normal/term.c normal/context.c
+	normal/misc.c normal/crypto.c normal/term.c normal/context.c \
-normal_mod_CFLAGS = $(COMMON_CFLAGS)
+	script/main.c script/script.c script/execute.c script/argv.c unidata.c \
-normal_mod_LDFLAGS = $(COMMON_LDFLAGS)
-
-# For sh.mod.
-sh_mod_SOURCES = script/main.c script/script.c script/argv.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
+normal_mod_CFLAGS = $(COMMON_CFLAGS) $(POSIX_CFLAGS) -Wno-error
-sh_mod_LDFLAGS = $(COMMON_LDFLAGS)
+normal_mod_LDFLAGS = $(COMMON_LDFLAGS)
 
 ifneq (, $(FONT_SOURCE))
 font/font.c_DEPENDENCIES = ascii.h
@@ -720,7 +710,6 @@ png_mod_SOURCES = video/readers/png.c
 png_mod_CFLAGS = $(COMMON_CFLAGS)
 png_mod_LDFLAGS = $(COMMON_LDFLAGS)
 
-
 # Misc.
 pkglib_MODULES += gzio.mod elf.mod
 
@@ -774,11 +763,6 @@ 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)

conf/i386-coreboot.rmk

@@ -14,7 +14,7 @@ kernel_img_SOURCES = kern/i386/coreboot/startup.S \
 	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/time.c kern/list.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 \

conf/i386-ieee1275.rmk

@@ -18,13 +18,14 @@ kernel_img_SOURCES = kern/i386/ieee1275/startup.S \
 	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/time.c kern/list.c  kern/command.c kern/corecmd.c \
 	kern/generic/millisleep.c \
 	kern/ieee1275/ieee1275.c \
 	term/ieee1275/ofconsole.c \
+	term/terminfo.c term/tparm.c 	\
 	disk/ieee1275/ofdisk.c \
 	symlist.c
-kernel_img_HEADERS += ieee1275/ieee1275.h
+kernel_img_HEADERS += ieee1275/ieee1275.h terminfo.h
 kernel_img_CFLAGS = $(COMMON_CFLAGS)
 kernel_img_ASFLAGS = $(COMMON_ASFLAGS)
 kernel_img_LDFLAGS += $(COMMON_LDFLAGS) -Wl,-N,-S,-Ttext,0x10000,-Bstatic

conf/i386-pc.rmk

@@ -43,7 +43,7 @@ kernel_img_SOURCES = kern/i386/pc/startup.S \
 	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/time.c kern/list.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 \
@@ -66,7 +66,7 @@ util/i386/pc/grub-setup.c_DEPENDENCIES = grub_setup_init.h
 grub_setup_SOURCES = gnulib/progname.c util/i386/pc/grub-setup.c	\
 	util/misc.c kern/emu/misc.c kern/emu/getroot.c			\
 	kern/emu/hostdisk.c kern/device.c kern/disk.c kern/err.c	\
-	kern/misc.c kern/parser.c kern/partition.c kern/file.c		\
+	kern/misc.c kern/partition.c kern/file.c			\
 	kern/emu/mm.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			\
@@ -78,7 +78,8 @@ grub_setup_SOURCES = gnulib/progname.c util/i386/pc/grub-setup.c	\
 	partmap/msdos.c partmap/bsdlabel.c partmap/sunpc.c		\
 	partmap/gpt.c							\
 									\
-	disk/raid.c disk/mdraid_linux.c disk/lvm.c			\
+	disk/raid.c disk/raid5_recover.c disk/raid6_recover.c		\
+	disk/mdraid_linux.c disk/lvm.c					\
 	util/raid.c util/lvm.c						\
 	grub_setup_init.c
 
@@ -147,7 +148,7 @@ 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 \
+xnu_mod_SOURCES = loader/xnu_resume.c loader/i386/xnu.c \
 	 loader/macho32.c loader/macho64.c loader/macho.c loader/xnu.c
 xnu_mod_CFLAGS = $(COMMON_CFLAGS)
 xnu_mod_LDFLAGS = $(COMMON_LDFLAGS)

conf/i386-qemu.rmk

@@ -13,24 +13,28 @@ boot_img_ASFLAGS = $(COMMON_ASFLAGS) -DGRUB_BOOT_MACHINE_LINK_ADDR=$(GRUB_BOOT_M
 boot_img_LDFLAGS = $(COMMON_LDFLAGS) $(TARGET_IMG_LDFLAGS)$(GRUB_BOOT_MACHINE_LINK_ADDR)
 boot_img_FORMAT = binary
 
+kern/i386/qemu/init.c_DEPENDENCIES = ascii.h
+
 pkglib_PROGRAMS += kernel.img
 kernel_img_SOURCES = kern/i386/qemu/startup.S \
 	kern/i386/misc.S \
 	kern/i386/coreboot/init.c \
+	kern/i386/qemu/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/time.c kern/list.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 \
+	term/i386/pc/vga_text.c term/i386/vga_common.c bus/pci.c \
 	symlist.c
+kernel_img_HEADERS += pci.h
 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)

conf/i386.rmk

@@ -15,6 +15,16 @@ 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 += video_cirrus.mod
+video_cirrus_mod_SOURCES = video/cirrus.c
+video_cirrus_mod_CFLAGS = $(COMMON_CFLAGS)
+video_cirrus_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
+pkglib_MODULES += video_bochs.mod
+video_bochs_mod_SOURCES = video/bochs.c
+video_bochs_mod_CFLAGS = $(COMMON_CFLAGS)
+video_bochs_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)
@@ -50,11 +60,14 @@ serial_mod_SOURCES = term/serial.c
 serial_mod_CFLAGS = $(COMMON_CFLAGS)
 serial_mod_LDFLAGS = $(COMMON_LDFLAGS)
 
+# On qemu it's compiled in
+ifneq ($(platform), qemu)
 # For pci.mod
 pkglib_MODULES += pci.mod
 pci_mod_SOURCES = bus/pci.c
 pci_mod_CFLAGS = $(COMMON_CFLAGS)
 pci_mod_LDFLAGS = $(COMMON_LDFLAGS)
+endif
 
 # For cs5536.mod
 pkglib_MODULES += cs5536.mod

conf/mips-qemu-mips.rmk

@@ -12,7 +12,7 @@ kernel_img_SOURCES = kern/$(target_cpu)/startup.S \
 	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/list.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
@@ -20,3 +20,9 @@ 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
+
+# For serial.mod.
+pkglib_MODULES += serial.mod
+serial_mod_SOURCES = term/serial.c
+serial_mod_CFLAGS = $(COMMON_CFLAGS)
+serial_mod_LDFLAGS = $(COMMON_LDFLAGS)

conf/mips-yeeloong.rmk

@@ -16,7 +16,7 @@ kernel_img_SOURCES = kern/$(target_cpu)/startup.S \
 	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/list.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 \
@@ -27,13 +27,21 @@ kernel_img_SOURCES = kern/$(target_cpu)/startup.S \
 	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 \
-	bus/cs5536.c \
+	bus/cs5536.c term/serial.c term/terminfo.c term/tparm.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
 
+pkglib_IMAGES += fwstart.img
+fwstart_img_SOURCES = boot/$(target_cpu)/$(target_machine)/fwstart.S
+fwstart_img_CFLAGS = $(COMMON_CFLAGS)
+fwstart_img_ASFLAGS = $(COMMON_ASFLAGS)
+fwstart_img_LDFLAGS = $(COMMON_LDFLAGS) -static-libgcc -lgcc \
+	-Wl,-N,-S,-Ttext,0xbfc00000,-Bstatic
+fwstart_img_FORMAT = binary
+
 # For ata.mod.
 pkglib_MODULES += ata.mod
 ata_mod_SOURCES = disk/ata.c
@@ -65,12 +73,24 @@ datetime_mod_SOURCES = lib/cmos_datetime.c
 datetime_mod_CFLAGS = $(COMMON_CFLAGS)
 datetime_mod_LDFLAGS = $(COMMON_LDFLAGS)
 
+# For lsspd.mod
+pkglib_MODULES += lsspd.mod
+lsspd_mod_SOURCES = commands/mips/yeeloong/lsspd.c
+lsspd_mod_CFLAGS = $(COMMON_CFLAGS)
+lsspd_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)
 
+# For halt.mod.
+pkglib_MODULES += halt.mod
+halt_mod_SOURCES = commands/halt.c
+halt_mod_CFLAGS = $(COMMON_CFLAGS)
+halt_mod_LDFLAGS = $(COMMON_LDFLAGS)
+
 # For usb.mod
 pkglib_MODULES += usb.mod
 usb_mod_SOURCES = bus/usb/usb.c bus/usb/usbtrans.c bus/usb/usbhub.c

conf/mips.rmk

@@ -10,12 +10,6 @@ kernel_img_HEADERS += cpu/cache.h
 sbin_SCRIPTS = 
 bin_SCRIPTS = 
 
-# 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

conf/powerpc-ieee1275.rmk

@@ -13,10 +13,10 @@ kernel_img_SOURCES = kern/powerpc/ieee1275/startup.S kern/ieee1275/cmain.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/list.c  kern/command.c kern/corecmd.c	\
 	kern/ieee1275/init.c 						\
 	kern/ieee1275/mmap.c						\
-	term/ieee1275/ofconsole.c 		\
+	term/ieee1275/ofconsole.c term/terminfo.c term/tparm.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                            \

conf/sparc64-ieee1275.rmk

@@ -26,12 +26,13 @@ kernel_img_SOURCES = kern/sparc64/ieee1275/crt0.S kern/ieee1275/cmain.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/list.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/ieee1275/openfw.c term/terminfo.c term/tparm.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
@@ -48,7 +49,7 @@ util/sparc64/ieee1275/grub-setup.c_DEPENDENCIES = grub_setup_init.h
 grub_setup_SOURCES = util/sparc64/ieee1275/grub-setup.c			\
 	util/ieee1275/ofpath.c util/misc.c kern/emu/hostdisk.c		\
 	kern/emu/misc.c kern/emu/getroot.c kern/emu/mm.c kern/device.c	\
-	kern/disk.c kern/err.c kern/misc.c kern/parser.c		\
+	kern/disk.c kern/err.c kern/misc.c 				\
 	kern/partition.c kern/file.c kern/fs.c kern/env.c kern/list.c	\
 	fs/fshelp.c							\
 									\
@@ -61,7 +62,8 @@ grub_setup_SOURCES = util/sparc64/ieee1275/grub-setup.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		\
+	disk/raid.c disk/raid5_recover.c disk/raid6_recover.c		\
+	disk/mdraid_linux.c disk/lvm.c util/raid.c			\
 	util/lvm.c gnulib/progname.c grub_setup_init.c
 
 # For grub-ofpathname.

conf/x86-efi.rmk

@@ -25,7 +25,7 @@ kernel_img_SOURCES = kern/$(target_cpu)/efi/startup.S kern/main.c kern/device.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/time.c kern/list.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
@@ -102,7 +102,7 @@ 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 \
+xnu_mod_SOURCES = loader/xnu_resume.c loader/i386/xnu.c \
 	loader/macho32.c loader/macho64.c loader/macho.c loader/xnu.c
 xnu_mod_CFLAGS = $(COMMON_CFLAGS)
 xnu_mod_LDFLAGS = $(COMMON_LDFLAGS)

configure.ac

@@ -179,15 +179,23 @@ if test "x$YACC" = x; then
   AC_MSG_ERROR([bison is not found])
 fi
 
+FONT_SOURCE=
+
 for ext in pcf pcf.gz bdf bdf.gz ttf ttf.gz; do
   for dir in . /usr/src /usr/share/fonts/X11/misc /usr/share/fonts/unifont; do
     if test -f "$dir/unifont.$ext"; then
-      AC_SUBST([FONT_SOURCE], [$dir/unifont.$ext])
+      FONT_SOURCE="$dir/unifont.$ext"
       break 2
     fi
   done
 done
 
+if test "x$FONT_SOURCE" = x && ( test "x$platform" = xqemu || test "x$platform" = xyeeloong ); then
+   AC_MSG_ERROR([qemu and yeeloong ports need unifont])
+fi
+
+AC_SUBST([FONT_SOURCE])	
+
 AC_PROG_INSTALL
 AC_PROG_AWK
 AC_PROG_LEX

disk/ata.c

@@ -24,10 +24,13 @@
 #include <grub/time.h>
 #include <grub/pci.h>
 #include <grub/scsi.h>
+#include <grub/cs5536.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_ioaddress[] = { GRUB_ATA_CH0_PORT1,
-static const grub_port_t grub_ata_ioaddress2[] = { 0x3f6, 0x376 };
+						  GRUB_ATA_CH1_PORT1 };
+static const grub_port_t grub_ata_ioaddress2[] = { GRUB_ATA_CH0_PORT2, 
+						   GRUB_ATA_CH1_PORT2 };
 
 static struct grub_ata_device *grub_ata_devices;
 
@@ -331,11 +334,38 @@ grub_ata_identify (struct grub_ata_device *dev)
   return 0;
 }
 
+static grub_err_t
+check_device (struct grub_ata_device *dev)
+{
+  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)
+    return grub_error (GRUB_ERR_UNKNOWN_DEVICE, "no device connected");
+
+  /* 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.  */
+  return grub_ata_identify (dev);
+}
+
 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_err_t err;
 
   grub_dprintf ("ata", "detecting device %d,%d (0x%x, 0x%x)\n",
 		port, device, addr, addr2);
@@ -351,39 +381,14 @@ grub_ata_device_initialize (int port, int device, int addr, int addr2)
   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;
 
+  err = check_device (dev);
+  if (err)
+    grub_print_error ();
+
   return 0;
 }
 
@@ -408,7 +413,7 @@ grub_ata_pciinit (grub_pci_device_t dev,
   class = grub_pci_read (addr);
 
   /* AMD CS5536 Southbridge.  */
-  if (pciid == 0x208f1022)
+  if (pciid == GRUB_CS5536_PCIID)
     {
       cs5536 = 1;
       nports = 1;
@@ -666,6 +671,14 @@ grub_ata_iterate (int (*hook) (const char *name))
   for (dev = grub_ata_devices; dev; dev = dev->next)
     {
       char devname[10];
+      grub_err_t err;
+
+      err = check_device (dev);
+      if (err)
+	{
+	  grub_errno = GRUB_ERR_NONE;
+	  continue;
+	}
 
       if (dev->atapi)
 	continue;
@@ -684,6 +697,7 @@ static grub_err_t
 grub_ata_open (const char *name, grub_disk_t disk)
 {
   struct grub_ata_device *dev;
+  grub_err_t err;
 
   for (dev = grub_ata_devices; dev; dev = dev->next)
     {
@@ -700,6 +714,11 @@ grub_ata_open (const char *name, grub_disk_t disk)
   if (dev->atapi)
     return grub_error (GRUB_ERR_UNKNOWN_DEVICE, "not an ATA harddisk");
 
+  err = check_device (dev);
+
+  if (err)
+    return err;
+
   disk->total_sectors = dev->size;
 
   disk->id = (unsigned long) dev;
@@ -749,20 +768,25 @@ static struct grub_disk_dev grub_atadisk_dev =
 /* ATAPI code.  */
 
 static int
-grub_atapi_iterate (int (*hook) (const char *name, int luns))
+grub_atapi_iterate (int (*hook) (int bus, int luns))
 {
   struct grub_ata_device *dev;
 
   for (dev = grub_ata_devices; dev; dev = dev->next)
     {
-      char devname[10];
+      grub_err_t err;
-      grub_snprintf (devname, sizeof (devname),
+
-		     "ata%d", dev->port * 2 + dev->device);
+      err = check_device (dev);
+      if (err)
+	{
+	  grub_errno = GRUB_ERR_NONE;
+	  continue;
+	}
 
       if (! dev->atapi)
 	continue;
 
-      if (hook (devname, 1))
+      if (hook (dev->port * 2 + dev->device, 1))
 	return 1;
     }
 
@@ -822,46 +846,45 @@ grub_atapi_write (struct grub_scsi *scsi __attribute__((unused)),
 }
 
 static grub_err_t
-grub_atapi_open (const char *name, struct grub_scsi *scsi)
+grub_atapi_open (int devnum, struct grub_scsi *scsi)
 {
   struct grub_ata_device *dev;
   struct grub_ata_device *devfnd = 0;
+  grub_err_t err;
 
   for (dev = grub_ata_devices; dev; dev = dev->next)
     {
-      char devname[10];
+      if (dev->port * 2 + dev->device == devnum)
-      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);
+  grub_dprintf ("ata", "opening ATAPI dev `ata%d'\n", devnum);
 
   if (! devfnd)
     return grub_error (GRUB_ERR_UNKNOWN_DEVICE, "no such ATAPI device");
 
+  err = check_device (devfnd);
+  if (err)
+    return err;
+
+  if (! devfnd->atapi)
+    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",
+    .name = "ata",
+    .id = GRUB_SCSI_SUBSYSTEM_ATAPI,
     .iterate = grub_atapi_iterate,
     .open = grub_atapi_open,
-    .close = grub_atapi_close,
     .read = grub_atapi_read,
     .write = grub_atapi_write
   };

disk/lvm.c

@@ -45,6 +45,52 @@ grub_lvm_getvalue (char **p, char *str)
   return grub_strtoul (*p, NULL, 10);
 }
 
+static int
+grub_lvm_checkvalue (char **p, char *str, char *tmpl)
+{
+  int tmpllen = grub_strlen (tmpl);
+  *p = grub_strstr (*p, str);
+  if (! *p)
+    return 0;
+  *p += grub_strlen (str);
+  if (**p != '"')
+    return 0;
+  return (grub_memcmp (*p + 1, tmpl, tmpllen) == 0 && (*p)[tmpllen + 1] == '"');
+}
+
+static int
+grub_lvm_check_flag (char *p, char *str, char *flag)
+{
+  int len_str = grub_strlen (str), len_flag = grub_strlen (flag);
+  while (1)
+    {
+      char *q;
+      p = grub_strstr (p, str);
+      if (! p)
+	return 0;
+      p += len_str;
+      if (grub_memcmp (p, " = [", sizeof (" = [") - 1) != 0)
+	continue;
+      q = p + sizeof (" = [") - 1;
+      while (1)
+	{
+	  while (grub_isspace (*q))
+	    q++;
+	  if (*q != '"')
+	    return 0;
+	  q++;
+	  if (grub_memcmp (q, flag, len_flag) == 0 && q[len_flag] == '"')
+	    return 1;
+	  while (*q != '"')
+	    q++;
+	  q++;
+	  if (*q == ']')
+	    return 0;
+	  q++;
+	}
+    }
+}
+
 static int
 grub_lvm_iterate (int (*hook) (const char *name))
 {
@@ -421,6 +467,7 @@ grub_lvm_scan_device (const char *name)
 	  while (1)
 	    {
 	      int s;
+	      int skip_lv = 0;
 	      struct grub_lvm_lv *lv;
 	      struct grub_lvm_segment *seg;
 
@@ -445,6 +492,12 @@ grub_lvm_scan_device (const char *name)
 
 	      lv->size = 0;
 
+	      if (!grub_lvm_check_flag (p, "status", "VISIBLE"))
+		{
+		  skip_lv = 1;
+		  goto lv_parsed;
+		}
+
 	      lv->segment_count = grub_lvm_getvalue (&p, "segment_count = ");
 	      if (p == NULL)
 		goto lvs_fail;
@@ -465,6 +518,14 @@ grub_lvm_scan_device (const char *name)
 		  seg->extent_count = grub_lvm_getvalue (&p, "extent_count = ");
 		  if (p == NULL)
 		    goto lvs_segment_fail;
+
+		  if (grub_lvm_checkvalue (&p, "type = ", "snapshot"))
+		    {
+		      /* Found a snapshot, give up and move on. */
+		      skip_lv = 1;
+		      break;
+		    }
+
 		  seg->stripe_count = grub_lvm_getvalue (&p, "stripe_count = ");
 		  if (p == NULL)
 		    goto lvs_segment_fail;
@@ -531,12 +592,20 @@ grub_lvm_scan_device (const char *name)
 		  goto fail4;
 		}
 
+	    lv_parsed:
 	      if (p != NULL)
 		p = grub_strchr (p, '}');
 	      if (p == NULL)
 		goto lvs_fail;
 	      p += 3;
 
+	      if (skip_lv)
+		{
+		  grub_free (lv->name);
+		  grub_free (lv);
+		  continue;
+		}
+
 	      lv->number = lv_count++;
 	      lv->vg = vg;
 	      lv->next = vg->lvs;

disk/scsi.c

@@ -318,15 +318,24 @@ grub_scsi_iterate (int (*hook) (const char *name))
 {
   grub_scsi_dev_t p;
 
-  auto int scsi_iterate (const char *name, int luns);
+  auto int scsi_iterate (int bus, int luns);
 
-  int scsi_iterate (const char *name, int luns)
+  int scsi_iterate (int bus, int luns)
     {
       int i;
 
       /* In case of a single LUN, just return `usbX'.  */
       if (luns == 1)
-	return hook (name);
+	{
+	  char *sname;
+	  int ret;
+	  sname = grub_xasprintf ("%s%d", p->name, bus);
+	  if (!sname)
+	    return 1;
+	  ret = hook (sname);
+	  grub_free (sname);
+	  return ret;
+	}
 
       /* In case of multiple LUNs, every LUN will get a prefix to
 	 distinguish it.  */
@@ -334,7 +343,7 @@ grub_scsi_iterate (int (*hook) (const char *name))
 	{
 	  char *sname;
 	  int ret;
-	  sname = grub_xasprintf ("%s%c", name, 'a' + i);
+	  sname = grub_xasprintf ("%s%d%c", p->name, bus, 'a' + i);
 	  if (!sname)
 	    return 1;
 	  ret = hook (sname);
@@ -358,37 +367,46 @@ grub_scsi_open (const char *name, grub_disk_t disk)
   grub_scsi_dev_t p;
   grub_scsi_t scsi;
   grub_err_t err;
-  int len;
+  int lun, bus;
-  int lun;
   grub_uint64_t maxtime;
+  const char *nameend;
+
+  nameend = name + grub_strlen (name) - 1;
+  /* Try to detect a LUN ('a'-'z'), otherwise just use the first
+     LUN.  */
+  if (nameend >= name && *nameend >= 'a' && *nameend <= 'z')
+    {
+      lun = *nameend - 'a';
+      nameend--;
+    }
+  else
+    lun = 0;
+
+  while (nameend >= name && grub_isdigit (*nameend))
+    nameend--;
+
+  if (!nameend[1] || !grub_isdigit (nameend[1]))
+    return grub_error (GRUB_ERR_UNKNOWN_DEVICE, "not a SCSI disk");
+
+  bus = grub_strtoul (nameend + 1, 0, 0);
 
   scsi = grub_malloc (sizeof (*scsi));
   if (! scsi)
     return grub_errno;
 
-  len = grub_strlen (name);
-  lun = name[len - 1] - 'a';
-
-  /* Try to detect a LUN ('a'-'z'), otherwise just use the first
-     LUN.  */
-  if (lun < 0 || lun > 26)
-    lun = 0;
-
   for (p = grub_scsi_dev_list; p; p = p->next)
     {
-      if (p->open (name, scsi))
+      if (grub_strncmp (p->name, name, nameend - name) != 0)
 	continue;
 
-      disk->id = (unsigned long) "scsi"; /* XXX */
+      if (p->open (bus, scsi))
+	continue;
+
+      disk->id = grub_make_scsi_id (p->id, bus, lun);
       disk->data = scsi;
       scsi->dev = p;
       scsi->lun = lun;
-      scsi->name = grub_strdup (name);
+      scsi->bus = bus;
-      if (! scsi->name)
-	{
-	  grub_free (scsi);
-	  return grub_errno;
-	}
 
       grub_dprintf ("scsi", "dev opened\n");
 
@@ -476,6 +494,7 @@ grub_scsi_close (grub_disk_t disk)
   grub_scsi_t scsi;
 
   scsi = disk->data;
+  if (scsi->dev->close)
     scsi->dev->close (scsi);
   grub_free (scsi);
 }

disk/usbms.c

@@ -52,20 +52,19 @@ struct grub_usbms_dev
 
   int luns;
 
+  int config;
   int interface;
   struct grub_usb_desc_endp *in;
   struct grub_usb_desc_endp *out;
 
   int in_maxsz;
   int out_maxsz;
-
-  struct grub_usbms_dev *next;
 };
 typedef struct grub_usbms_dev *grub_usbms_dev_t;
 
-static grub_usbms_dev_t grub_usbms_dev_list;
+/* FIXME: remove limit.  */
-
+#define MAX_USBMS_DEVICES 128
-static int devcnt;
+static grub_usbms_dev_t grub_usbms_devices[MAX_USBMS_DEVICES];
 
 static grub_err_t
 grub_usbms_reset (grub_usb_device_t dev, int interface)
@@ -74,58 +73,53 @@ grub_usbms_reset (grub_usb_device_t dev, int interface)
 }
 
 static void
-grub_usbms_finddevs (void)
+grub_usbms_detach (grub_usb_device_t usbdev, int config, int interface)
 {
-  auto int usb_iterate (grub_usb_device_t dev);
+  unsigned i;
-
+  for (i = 0; i < ARRAY_SIZE (grub_usbms_devices); i++)
-  int usb_iterate (grub_usb_device_t usbdev)
+    if (grub_usbms_devices[i] && grub_usbms_devices[i]->dev == usbdev
+	&& grub_usbms_devices[i]->interface == interface
+	&& grub_usbms_devices[i]->config == config)
       {
-      grub_usb_err_t err;
+	grub_free (grub_usbms_devices[i]);
-      struct grub_usb_desc_device *descdev = &usbdev->descdev;
+	grub_usbms_devices[i] = 0;
-      int i;
+      }
-
-      if (descdev->class != 0 || descdev->subclass || descdev->protocol != 0
-	  || descdev->configcnt == 0)
-	return 0;
-
-      /* XXX: Just check configuration 0 for now.  */
-      for (i = 0; i < usbdev->config[0].descconf->numif; i++)
-	{
-	  struct grub_usbms_dev *usbms;
-	  struct grub_usb_desc_if *interf;
-	  int j;
-	  grub_uint8_t luns = 0;
-
-	  grub_dprintf ("usbms", "alive\n");
-
-	  interf = usbdev->config[0].interf[i].descif;
-
-	  /* If this is not a USB Mass Storage device with a supported
-	     protocol, just skip it.  */
-	  grub_dprintf ("usbms", "iterate: interf=%d, class=%d, subclass=%d, protocol=%d\n",
-	                i, interf->class, interf->subclass, interf->protocol);
-
-	  if (interf->class != GRUB_USB_CLASS_MASS_STORAGE
-	      || ( interf->subclass != GRUB_USBMS_SUBCLASS_BULK &&
-	    /* Experimental support of RBC, MMC-2, UFI, SFF-8070i devices */
-	           interf->subclass != GRUB_USBMS_SUBCLASS_RBC &&
-	           interf->subclass != GRUB_USBMS_SUBCLASS_MMC2 &&
-	           interf->subclass != GRUB_USBMS_SUBCLASS_UFI &&
-	           interf->subclass != GRUB_USBMS_SUBCLASS_SFF8070 )
-	      || interf->protocol != GRUB_USBMS_PROTOCOL_BULK)
-	    {
-	      continue;
 }
 
-	  grub_dprintf ("usbms", "alive\n");
+static int
+grub_usbms_attach (grub_usb_device_t usbdev, int configno, int interfno)
+{
+  struct grub_usb_desc_if *interf
+    = usbdev->config[configno].interf[interfno].descif;
+  int j;
+  grub_uint8_t luns = 0;
+  unsigned curnum;
+  grub_usb_err_t err;
 
-	  devcnt++;
+  for (curnum = 0; curnum < ARRAY_SIZE (grub_usbms_devices); curnum++)
-	  usbms = grub_zalloc (sizeof (struct grub_usbms_dev));
+    if (!grub_usbms_devices[curnum])
-	  if (! usbms)
+      break;
-	    return 1;
 
-	  usbms->dev = usbdev;
+  if (curnum == ARRAY_SIZE (grub_usbms_devices))
-	  usbms->interface = i;
+    return 0;
+
+  interf = usbdev->config[configno].interf[interfno].descif;
+
+  if ((interf->subclass != GRUB_USBMS_SUBCLASS_BULK
+       /* Experimental support of RBC, MMC-2, UFI, SFF-8070i devices */
+       && interf->subclass != GRUB_USBMS_SUBCLASS_RBC
+       && interf->subclass != GRUB_USBMS_SUBCLASS_MMC2
+       && interf->subclass != GRUB_USBMS_SUBCLASS_UFI 
+       && interf->subclass != GRUB_USBMS_SUBCLASS_SFF8070 )
+      || interf->protocol != GRUB_USBMS_PROTOCOL_BULK)
+    return 0;
+
+  grub_usbms_devices[curnum] = grub_zalloc (sizeof (struct grub_usbms_dev));
+  if (! grub_usbms_devices[curnum])
+    return 0;
+
+  grub_usbms_devices[curnum]->dev = usbdev;
+  grub_usbms_devices[curnum]->interface = interfno;
 
   grub_dprintf ("usbms", "alive\n");
 
@@ -134,29 +128,30 @@ grub_usbms_finddevs (void)
   for (j = 0; j < interf->endpointcnt; j++)
     {
       struct grub_usb_desc_endp *endp;
-	      endp = &usbdev->config[0].interf[i].descendp[j];
+      endp = &usbdev->config[0].interf[interfno].descendp[j];
 
       if ((endp->endp_addr & 128) && (endp->attrib & 3) == 2)
 	{
 	  /* Bulk IN endpoint.  */
-		  usbms->in = endp;
+	  grub_usbms_devices[curnum]->in = endp;
 	  /* Clear Halt is not possible yet! */
 	  /* grub_usb_clear_halt (usbdev, endp->endp_addr); */
-		  usbms->in_maxsz = endp->maxpacket;
+	  grub_usbms_devices[curnum]->in_maxsz = endp->maxpacket;
 	}
       else if (!(endp->endp_addr & 128) && (endp->attrib & 3) == 2)
 	{
 	  /* Bulk OUT endpoint.  */
-		  usbms->out = endp;
+	  grub_usbms_devices[curnum]->out = endp;
 	  /* Clear Halt is not possible yet! */
 	  /* grub_usb_clear_halt (usbdev, endp->endp_addr); */
-		  usbms->out_maxsz = endp->maxpacket;
+	  grub_usbms_devices[curnum]->out_maxsz = endp->maxpacket;
 	}
     }
 
-	  if (!usbms->in || !usbms->out)
+  if (!grub_usbms_devices[curnum]->in || !grub_usbms_devices[curnum]->out)
     {
-	      grub_free (usbms);
+      grub_free (grub_usbms_devices[curnum]);
+      grub_usbms_devices[curnum] = 0;
       return 0;
     }
 
@@ -166,32 +161,30 @@ grub_usbms_finddevs (void)
   grub_usb_set_configuration (usbdev, 1);
 
   /* Query the amount of LUNs.  */
-	  err = grub_usb_control_msg (usbdev, 0xA1, 254,
+  err = grub_usb_control_msg (usbdev, 0xA1, 254, 0, interfno, 1, (char *) &luns);
-				      0, i, 1, (char *) &luns);
 		
   if (err)
     {
       /* In case of a stall, clear the stall.  */
       if (err == GRUB_USB_ERR_STALL)
 	{
-		  grub_usb_clear_halt (usbdev, usbms->in->endp_addr);
+	  grub_usb_clear_halt (usbdev, grub_usbms_devices[curnum]->in->endp_addr);
-		  grub_usb_clear_halt (usbdev, usbms->out->endp_addr);
+	  grub_usb_clear_halt (usbdev, grub_usbms_devices[curnum]->out->endp_addr);
 	}
       /* Just set the amount of LUNs to one.  */
       grub_errno = GRUB_ERR_NONE;
-	      usbms->luns = 1;
+      grub_usbms_devices[curnum]->luns = 1;
     }
   else
     /* luns = 0 means one LUN with ID 0 present ! */
     /* We get from device not number of LUNs but highest
      * LUN number. LUNs are numbered from 0, 
      * i.e. number of LUNs is luns+1 ! */
-	    usbms->luns = luns + 1;
+    grub_usbms_devices[curnum]->luns = luns + 1;
 
   grub_dprintf ("usbms", "alive\n");
 
-	  usbms->next = grub_usbms_dev_list;
+  usbdev->config[configno].interf[interfno].detach_hook = grub_usbms_detach;
-	  grub_usbms_dev_list = usbms;
 
 #if 0 /* All this part should be probably deleted.
        * This make trouble on some devices if they are not in
@@ -206,40 +199,24 @@ grub_usbms_finddevs (void)
   grub_usb_clear_halt (usbdev, usbms->out->endp_addr);
 #endif
 
-	  return 0;
+  return 1;
-	}
-
-      grub_dprintf ("usbms", "alive\n");
-      return 0;
-    }
-  grub_dprintf ("usbms", "alive\n");
-
-  grub_usb_iterate (usb_iterate);
-  grub_dprintf ("usbms", "alive\n");
-
 }
 
 
 
 static int
-grub_usbms_iterate (int (*hook) (const char *name, int luns))
+grub_usbms_iterate (int (*hook) (int bus, int luns))
 {
-  grub_usbms_dev_t p;
+  unsigned i;
-  int cnt = 0;
 
-  for (p = grub_usbms_dev_list; p; p = p->next)
+  grub_usb_poll_devices ();
-    {
-      char *devname;
-      devname = grub_xasprintf ("usb%d", cnt);
 
-      if (hook (devname, p->luns))
+  for (i = 0; i < ARRAY_SIZE (grub_usbms_devices); i++)
+    if (grub_usbms_devices[i])
       {
-	  grub_free (devname);
+	if (hook (i, grub_usbms_devices[i]->luns))
 	  return 1;
       }
-      grub_free (devname);
-      cnt++;
-    }
 
   return 0;
 }
@@ -255,7 +232,6 @@ grub_usbms_transfer (struct grub_scsi *scsi, grub_size_t cmdsize, char *cmd,
   grub_usb_err_t err = GRUB_USB_ERR_NONE;
   grub_usb_err_t errCSW = GRUB_USB_ERR_NONE;
   int retrycnt = 3 + 1;
-  grub_size_t i;
 
  retry:
   retrycnt--;
@@ -311,8 +287,11 @@ grub_usbms_transfer (struct grub_scsi *scsi, grub_size_t cmdsize, char *cmd,
       /* Debug print of received data. */
       grub_dprintf ("usb", "buf:\n");
       if (size <= 64)
+	{
+	  unsigned i;
 	  for (i = 0; i < size; i++)
 	    grub_dprintf ("usb", "0x%02x: 0x%02x\n", i, buf[i]);
+	}
       else
           grub_dprintf ("usb", "Too much data for debug print...\n");
     }
@@ -320,7 +299,11 @@ grub_usbms_transfer (struct grub_scsi *scsi, grub_size_t cmdsize, char *cmd,
     {
       err = grub_usb_bulk_write (dev->dev, dev->out->endp_addr, size, buf);
       grub_dprintf ("usb", "write: %d %d\n", err, GRUB_USB_ERR_STALL);
-      grub_dprintf ("usb", "buf:\n");
+      grub_dprintf ("usb", "First 16 bytes of sent data:\n %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
+  	buf[ 0], buf[ 1], buf[ 2], buf[ 3],
+  	buf[ 4], buf[ 5], buf[ 6], buf[ 7],
+  	buf[ 8], buf[ 9], buf[10], buf[11],
+  	buf[12], buf[13], buf[14], buf[15]);
       if (err)
         {
           if (err == GRUB_USB_ERR_STALL)
@@ -329,8 +312,11 @@ grub_usbms_transfer (struct grub_scsi *scsi, grub_size_t cmdsize, char *cmd,
         }
       /* Debug print of sent data. */
       if (size <= 256)
+	{
+	  unsigned i;
 	  for (i=0; i<size; i++)
 	    grub_dprintf ("usb", "0x%02x: 0x%02x\n", i, buf[i]);
+	}
       else
           grub_dprintf ("usb", "Too much data for debug print...\n");
     }
@@ -398,61 +384,52 @@ grub_usbms_write (struct grub_scsi *scsi, grub_size_t cmdsize, char *cmd,
 }
 
 static grub_err_t
-grub_usbms_open (const char *name, struct grub_scsi *scsi)
+grub_usbms_open (int devnum, struct grub_scsi *scsi)
 {
-  grub_usbms_dev_t p;
+  grub_usb_poll_devices ();
-  int devnum;
-  int i = 0;
 
-  if (grub_strncmp (name, "usb", 3))
+  if (!grub_usbms_devices[devnum])
     return grub_error (GRUB_ERR_UNKNOWN_DEVICE,
-		       "not a USB Mass Storage device");
+		       "unknown USB Mass Storage device");
 
-  devnum = grub_strtoul (name + 3, NULL, 10);
+  scsi->data = grub_usbms_devices[devnum];
-  for (p = grub_usbms_dev_list; p; p = p->next)
+  scsi->luns = grub_usbms_devices[devnum]->luns;
-    {
-      /* Check if this is the devnumth device.  */
-      if (devnum == i)
-	{
-	  scsi->data = p;
-	  scsi->name = grub_strdup (name);
-	  scsi->luns = p->luns;
-	  if (! scsi->name)
-	    return grub_errno;
 
   return GRUB_ERR_NONE;
 }
 
-      i++;
-    }
-
-  return grub_error (GRUB_ERR_UNKNOWN_DEVICE,
-		     "not a USB Mass Storage device");
-}
-
-static void
-grub_usbms_close (struct grub_scsi *scsi)
-{
-  grub_free (scsi->name);
-}
-
 static struct grub_scsi_dev grub_usbms_dev =
   {
     .name = "usb",
+    .id = GRUB_SCSI_SUBSYSTEM_USBMS,
     .iterate = grub_usbms_iterate,
     .open = grub_usbms_open,
-    .close = grub_usbms_close,
     .read = grub_usbms_read,
     .write = grub_usbms_write
   };
 
+struct grub_usb_attach_desc attach_hook =
+{
+  .class = GRUB_USB_CLASS_MASS_STORAGE,
+  .hook = grub_usbms_attach
+};
+
 GRUB_MOD_INIT(usbms)
 {
-  grub_usbms_finddevs ();
+  grub_usb_register_attach_hook_class (&attach_hook);
   grub_scsi_dev_register (&grub_usbms_dev);
 }
 
 GRUB_MOD_FINI(usbms)
 {
+  unsigned i;
+  for (i = 0; i < ARRAY_SIZE (grub_usbms_devices); i++)
+    {
+      grub_usbms_devices[i]->dev->config[grub_usbms_devices[i]->config]
+	.interf[grub_usbms_devices[i]->interface].detach_hook = 0;
+      grub_usbms_devices[i]->dev->config[grub_usbms_devices[i]->config]
+	.interf[grub_usbms_devices[i]->interface].attached = 0;
+    }
+  grub_usb_unregister_attach_hook_class (&attach_hook);
   grub_scsi_dev_unregister (&grub_usbms_dev);
 }

docs/grub.texi

@@ -80,7 +80,6 @@ This edition documents version @value{VERSION}.
 * Network::                     Downloading OS images from a network
 * Serial terminal::             Using GRUB via a serial line
 * Vendor power-on keys::        Changing GRUB behaviour on vendor power-on keys
-* Preset Menu::                 Embedding a configuration file into GRUB
 * Images::                      GRUB image files
 * Filesystem::                  Filesystem syntax and semantics
 * Interface::                   The menu and the command-line
@@ -107,6 +106,7 @@ This edition documents version @value{VERSION}.
 * Overview::                    What exactly GRUB is and how to use it
 * History::                     From maggot to house fly
 * Features::                    GRUB features
+* Changes from GRUB Legacy::    Differences from previous versions
 * Role of a boot loader::       The role of a boot loader
 @end menu
 
@@ -191,6 +191,74 @@ extents, and by the end of 2009 multiple major distributions were installing
 it by default.
 
 
+@node Changes from GRUB Legacy
+@section Differences from previous versions
+
+GRUB 2 is a rewrite of GRUB (@pxref{History}), although it shares many
+characteristics with the previous version, now known as GRUB Legacy.  Users
+of GRUB Legacy may need some guidance to find their way around this new
+version.
+
+@itemize @bullet
+@item
+The configuration file has a new name (@file{grub.cfg} rather than
+@file{menu.lst} or @file{grub.conf}), new syntax (@pxref{Configuration}) and
+many new commands (@pxref{Commands}).  Configuration cannot be copied over
+directly, although most GRUB Legacy users should not find the syntax too
+surprising.
+
+@item
+@file{grub.cfg} is typically automatically generated by
+@command{grub-mkconfig} (@pxref{Simple configuration}).  This makes it
+easier to handle versioned kernel upgrades.
+
+@item
+Partition numbers in GRUB device names now start at 1, not 0 (@pxref{Naming
+convention}).
+
+@item
+The configuration file is now written in something closer to a full
+scripting language: variables, conditionals, and loops are available.
+
+@item
+A small amount of persistent storage is available across reboots, using the
+@command{save_env} and @command{load_env} commands in GRUB and the
+@command{grub-editenv} utility.
+
+@item
+GRUB 2 has more reliable ways to find its own files and those of target
+kernels on multiple-disk systems, and has commands (@pxref{search}) to find
+devices using file system labels or Universally Unique Identifiers (UUIDs).
+
+@item
+GRUB 2 is available for several other types of system in addition to the PC
+BIOS systems supported by GRUB Legacy: PC EFI, PC coreboot, PowerPC, SPARC,
+and MIPS Lemote Yeeloong are all supported.
+
+@item
+Many more file systems are supported, including but not limited to ext4,
+HFS+, and NTFS.
+
+@item
+GRUB 2 can read files directly from LVM and RAID devices.
+
+@item
+A graphical terminal and a graphical menu system are available.
+
+@item
+GRUB 2's interface can be translated, including menu entry names.
+
+@item
+The image files (@pxref{Images}) that make up GRUB have been reorganised;
+Stage 1, Stage 1.5, and Stage 2 are no more.
+
+@item
+GRUB 2 puts many facilities in dynamically loaded modules, allowing the core
+image to be smaller, and allowing the core image to be built in more
+flexible ways.
+@end itemize
+
+
 @node Features
 @section GRUB features
 
@@ -264,10 +332,12 @@ devices, partitions, and files in a directory depending on context.
 
 @item Support multiple filesystem types
 Support multiple filesystem types transparently, plus a useful explicit
-blocklist notation. The currently supported filesystem types are
+blocklist notation. The currently supported filesystem types are @dfn{Amiga
-@dfn{BSD FFS}, @dfn{DOS FAT16 and FAT32}, @dfn{Minix fs}, @dfn{Linux
+Fast FileSystem (AFFS)}, @dfn{AtheOS fs}, @dfn{BeFS}, @dfn{cpio}, @dfn{Linux
-ext2fs}, @dfn{ReiserFS}, @dfn{JFS}, @dfn{XFS}, and @dfn{VSTa
+ext2/ext3/ext4}, @dfn{DOS FAT12/FAT16/FAT32}, @dfn{HFS}, @dfn{HFS+},
-fs}. @xref{Filesystem}, for more information.
+@dfn{ISO9660}, @dfn{JFS}, @dfn{Minix fs}, @dfn{nilfs2}, @dfn{NTFS},
+@dfn{ReiserFS}, @dfn{Amiga Smart FileSystem (SFS)}, @dfn{tar}, @dfn{UDF},
+@dfn{BSD UFS/UFS2}, and @dfn{XFS}. @xref{Filesystem}, for more information.
 
 @item Support automatic decompression
 Can decompress files which were compressed by @command{gzip}. This
@@ -471,6 +541,7 @@ the @dfn{boot directory}.
 @menu
 * Installing GRUB using grub-install::
 * Making a GRUB bootable CD-ROM::
+* Device map::
 @end menu
 
 
@@ -615,6 +686,50 @@ to @samp{(cd)} when booted from a CD-ROM. It is only necessary to refer to
 @samp{(cd)} if you want to access other drives as well.
 
 
+@node Device map
+@section The map between BIOS drives and OS devices
+
+The @command{grub-mkdevicemap} program can be used to create the @dfn{device
+map file}.  It is often run automatically by tools such as
+@command{grub-install} if the device map file does not already exist.  The
+file name @file{/boot/grub/device.map} is preferred.
+
+If the device map file exists, the GRUB utilities (@command{grub-probe},
+@command{grub-setup}, etc.) read it to map BIOS drives to OS devices.  This
+file consists of lines like this:
+
+@example
+@var{device} @var{file}
+@end example
+
+@var{device} is a drive specified in the GRUB syntax (@pxref{Device
+syntax}), and @var{file} is an OS file, which is normally a device file.
+
+Historically, the device map file was used because GRUB device names had to
+be used in the configuration file, and they were derived from BIOS drive
+numbers.  The map between BIOS drives and OS devices cannot always be
+guessed correctly: for example, GRUB will get the order wrong if you
+exchange the boot sequence between IDE and SCSI in your BIOS.
+
+Unfortunately, even OS device names are not always stable.  Modern versions
+of the Linux kernel may probe drives in a different order from boot to boot,
+and the prefix (@file{/dev/hd*} versus @file{/dev/sd*}) may change depending
+on the driver subsystem in use.  As a result, the device map file required
+frequent editing on some systems.
+
+GRUB avoids this problem nowadays by using UUIDs or file system labels when
+generating @file{grub.cfg}, and we advise that you do the same for any
+custom menu entries you write.  If the device map file does not exist, then
+the GRUB utilities will assume a temporary device map on the fly.  This is
+often good enough, particularly in the common case of single-disk systems.
+
+However, the device map file is not entirely obsolete yet, and there are
+still some situations that require it to exist.  If necessary, you may edit
+the file if @command{grub-mkdevicemap} makes a mistake.  You can put any
+comments in the file if needed, as the GRUB utilities assume that a line is
+just a comment if the first character is @samp{#}.
+
+
 @node Booting
 @chapter Booting
 
@@ -729,11 +844,36 @@ Run the command @command{boot} (@pxref{boot}).
 It is relatively easy to boot GNU/Linux from GRUB, because it somewhat
 resembles to boot a Multiboot-compliant OS.
 
-FIXME: this section is incomplete.
-
 @enumerate
 @item
-Set GRUB's root device to the same drive as GNU/Linux's.
+Set GRUB's root device to the same drive as GNU/Linux's.  The command
+@code{search --file --set /vmlinuz} or similar may help you
+(@pxref{search}).
+
+@item
+Load the kernel using the command @command{linux} (@pxref{linux}):
+
+@example
+grub> @kbd{linux /vmlinuz root=/dev/sda1}
+@end example
+
+If you need to specify some kernel parameters, just append them to the
+command.  For example, to set @option{acpi} to @samp{off}, do this:
+
+@example
+grub> @kbd{linux /vmlinuz root=/dev/sda1 acpi=off}
+@end example
+
+See the documentation in the Linux source tree for complete information on
+the available options.
+
+@item
+If you use an initrd, execute the command @command{initrd} (@pxref{initrd})
+after @command{linux}:
+
+@example
+grub> @kbd{initrd /initrd}
+@end example
 
 @item
 Finally, run the command @command{boot} (@pxref{boot}).
@@ -805,6 +945,8 @@ need to write the whole thing by hand.
 @menu
 * Simple configuration::        Recommended for most users
 * Shell-like scripting::        For power users and developers
+* Embedded configuration::      Embedding a configuration file into GRUB
+* Themes::                      Graphical menu themes
 @end menu
 
 
@@ -911,10 +1053,11 @@ A command to configure the serial port when using the serial console.
 Command-line arguments to add to menu entries for the Linux kernel.
 
 @item GRUB_CMDLINE_LINUX_DEFAULT
-Unless @samp{GRUB_DISABLE_LINUX_RECOVERY} is set, two menu entries will be
+Unless @samp{GRUB_DISABLE_LINUX_RECOVERY} is set to @samp{true}, two menu
-generated for each Linux kernel: one default entry and one entry for
+entries will be generated for each Linux kernel: one default entry and one
-recovery mode.  This option lists command-line arguments to add only to the
+entry for recovery mode.  This option lists command-line arguments to add
-default menu entry, after those listed in @samp{GRUB_CMDLINE_LINUX}.
+only to the default menu entry, after those listed in
+@samp{GRUB_CMDLINE_LINUX}.
 
 @item GRUB_CMDLINE_NETBSD
 @itemx GRUB_CMDLINE_NETBSD_DEFAULT
@@ -929,10 +1072,22 @@ usually more reliable, but in some cases it may not be appropriate.  To
 disable the use of UUIDs, set this option to @samp{true}.
 
 @item GRUB_DISABLE_LINUX_RECOVERY
-Disable the generation of recovery mode menu entries for Linux.
+If this option is set to @samp{true}, disable the generation of recovery
+mode menu entries for Linux.
 
 @item GRUB_DISABLE_NETBSD_RECOVERY
-Disable the generation of recovery mode menu entries for NetBSD.
+If this option is set to @samp{true}, disable the generation of recovery
+mode menu entries for NetBSD.
+
+@item GRUB_VIDEO_BACKEND
+If graphical video support is required, either because the @samp{gfxterm}
+graphical terminal is in use or because @samp{GRUB_GFXPAYLOAD_LINUX} is set,
+then @command{grub-mkconfig} will normally load all available GRUB video
+drivers and use the one most appropriate for your hardware.  If you need to
+override this for some reason, then you can set this option.
+
+After @command{grub-install} has been run, the available video drivers are
+listed in @file{/boot/grub/video.lst}.
 
 @item GRUB_GFXMODE
 Set the resolution used on the @samp{gfxterm} graphical terminal.  Note that
@@ -973,6 +1128,11 @@ for them.  Set this option to @samp{true} to disable this.
 Play a tune on the speaker when GRUB starts.  This is particularly useful
 for users unable to see the screen.  The value of this option is passed
 directly to @ref{play}.
+
+@item GRUB_BADRAM
+If this option is set, GRUB will issue a @ref{badram} command to filter
+out specified regions of RAM.
+
 @end table
 
 For more detailed customisation of @command{grub-mkconfig}'s output, you may
@@ -986,6 +1146,78 @@ that file, making sure to leave at least the first two lines intact.
 @section Writing full configuration files directly
 
 
+@node Embedded configuration
+@section Embedding a configuration file into GRUB
+
+GRUB supports embedding a configuration file directly into the core image,
+so that it is loaded before entering normal mode.  This is useful, for
+example, when it is not straightforward to find the real configuration file,
+or when you need to debug problems with loading that file.
+@command{grub-install} uses this feature when it is not using BIOS disk
+functions or when installing to a different disk from the one containing
+@file{/boot/grub}, in which case it needs to use the @command{search}
+command (@pxref{search}) to find @file{/boot/grub}.
+
+To embed a configuration file, use the @option{-c} option to
+@command{grub-mkimage}.  The file is copied into the core image, so it may
+reside anywhere on the file system, and may be removed after running
+@command{grub-mkimage}.
+
+After the embedded configuration file (if any) is executed, GRUB will load
+the @samp{normal} module, which will then read the real configuration file
+from @file{$prefix/grub.cfg}.  By this point, the @code{root} variable will
+also have been set to the root device name.  For example, @code{prefix}
+might be set to @samp{(hd0,1)/boot/grub}, and @code{root} might be set to
+@samp{hd0,1}.  Thus, in most cases, the embedded configuration file only
+needs to set the @code{prefix} and @code{root} variables, and then drop
+through to GRUB's normal processing.  A typical example of this might look
+like this:
+
+@example
+@group
+search.fs_uuid 01234567-89ab-cdef-0123-456789abcdef root
+set prefix=($root)/boot/grub
+@end group
+@end example
+
+(The @samp{search_fs_uuid} module must be included in the core image for this
+example to work.)
+
+In more complex cases, it may be useful to read other configuration files
+directly from the embedded configuration file.  This allows such things as
+reading files not called @file{grub.cfg}, or reading files from a directory
+other than that where GRUB's loadable modules are installed.  To do this,
+include the @samp{configfile} and @samp{normal} modules in the core image,
+and embed a configuration file that uses the @command{configfile} command to
+load another file.  The following example of this also requires the
+@command{echo}, @command{search_label}, and @command{test} modules to be
+included in the core image:
+
+@example
+@group
+search.fs_label grub root
+if [ -e /boot/grub/example/test1.cfg ]; then
+    set prefix=($root)/boot/grub
+    configfile /boot/grub/example/test1.cfg
+else
+    if [ -e /boot/grub/example/test2.cfg ]; then
+        set prefix=($root)/boot/grub
+        configfile /boot/grub/example/test2.cfg
+    else
+        echo "Could not find an example configuration file!"
+    fi
+fi
+@end group
+@end example
+
+The embedded configuration file may not contain menu entries directly, but
+may only read them from elsewhere using @command{configfile}.
+
+
+@node Themes
+@section Graphical menu themes
+
+
 @node Network
 @chapter Booting GRUB from the network
 
@@ -1073,18 +1305,13 @@ minicom. Refer to a manual of your operating system, for more
 information.
 
 As for GRUB, the instruction to set up a serial terminal is quite
-simple. First of all, make sure that you haven't specified the option
+simple.  Here is an example:
-@option{--disable-serial} to the configure script when you built your
-GRUB images. If you get them in binary form, probably they have serial
-terminal support already.
-
-Then, initialize your serial terminal after GRUB starts up. Here is an
-example:
 
 @example
 @group
 grub> @kbd{serial --unit=0 --speed=9600}
-grub> @kbd{terminal serial}
+grub> @kbd{terminal_input serial}
+grub> @kbd{terminal_output serial}
 @end group
 @end example
 
@@ -1109,23 +1336,165 @@ implements few VT100 escape sequences. If you specify this option then
 GRUB provides you with an alternative menu interface, because the normal
 menu requires several fancy features of your terminal.
 
+
 @node Vendor power-on keys
 @chapter Using GRUB with vendor power-on keys
-Some laptop vendor provide an additional power-on button which boots another OS.
+
-GRUB supports such buttons with GRUB_TIMEOUT_BUTTON, GRUB_DEFAULT_BUTTON,
+Some laptop vendors provide an additional power-on button which boots another
-GRUB_HIDDEN_TIMEOUT_BUTTON and GRUB_BUTTON_CMOS_ADDRESS variables in
+OS.  GRUB supports such buttons with the @samp{GRUB_TIMEOUT_BUTTON},
-default/grub. GRUB_TIMEOUT_BUTTON, GRUB_DEFAULT_BUTTON and 
+@samp{GRUB_DEFAULT_BUTTON}, @samp{GRUB_HIDDEN_TIMEOUT_BUTTON} and
-GRUB_HIDDEN_TIMEOUT_BUTTON are used instead of corresponding variables without
+@samp{GRUB_BUTTON_CMOS_ADDRESS} variables in default/grub (@pxref{Simple
-_BUTTON suffix when powered using special button.
+configuration}).  @samp{GRUB_TIMEOUT_BUTTON}, @samp{GRUB_DEFAULT_BUTTON} and
-GRUB_BUTTON_CMOS_ADDRESS is vendor specific and partially model-specific.
+@samp{GRUB_HIDDEN_TIMEOUT_BUTTON} are used instead of the corresponding
-Values known to GRUB team are:
+variables without the @samp{_BUTTON} suffix when powered on using the special
+button.  @samp{GRUB_BUTTON_CMOS_ADDRESS} is vendor-specific and partially
+model-specific.  Values known to the GRUB team are:
 
 @table @key
 @item Dell XPS M1530
 85:3
+@item Asus EeePC 1005PE 
+84:1 (unconfirmed)
+@end table
+
+To take full advantage of this function, install GRUB into the MBR
+(@pxref{Installing GRUB using grub-install}).
+
+
+@node Images
+@chapter GRUB image files
+
+@c FIXME: parts of this section are specific to PC BIOS right now.
+
+GRUB consists of several images: a variety of bootstrap images for starting
+GRUB in various ways, a kernel image, and a set of modules which are
+combined with the kernel image to form a core image.  Here is a short
+overview of them.
+
+@table @file
+@item boot.img
+On PC BIOS systems, this image is the first part of GRUB to start.  It is
+written to a master boot record (MBR) or to the boot sector of a partition.
+Because a PC boot sector is 512 bytes, the size of this image is exactly 512
+bytes.
+
+The sole function of @file{boot.img} is to read the first sector of the core
+image from a local disk and jump to it.  Because of the size restriction,
+@file{boot.img} cannot understand any file system structure, so
+@command{grub-setup} hardcodes the location of the first sector of the core
+image into @file{boot.img} when installing GRUB.
+
+@item diskboot.img
+This image is used as the first sector of the core image when booting from a
+hard disk.  It reads the rest of the core image into memory and starts the
+kernel.  Since file system handling is not yet available, it encodes the
+location of the core image using a block list format.
+
+@item cdboot.img
+This image is used as the first sector of the core image when booting from a
+CD-ROM drive.  It performs a similar function to @file{diskboot.img}.
+
+@item pxeboot.img
+This image is used as the start of the core image when booting from the
+network using PXE.  @xref{Network}.
+
+@item lnxboot.img
+This image may be placed at the start of the core image in order to make
+GRUB look enough like a Linux kernel that it can be booted by LILO using an
+@samp{image=} section.
+
+@item kernel.img
+This image contains GRUB's basic run-time facilities: frameworks for device
+and file handling, environment variables, the rescue mode command-line
+parser, and so on.  It is rarely used directly, but is built into all core
+images.
+
+@item core.img
+This is the core image of GRUB.  It is built dynamically from the kernel
+image and an arbitrary list of modules by the @command{grub-mkimage}
+program.  Usually, it contains enough modules to access @file{/boot/grub},
+and loads everything else (including menu handling, the ability to load
+target operating systems, and so on) from the file system at run-time.  The
+modular design allows the core image to be kept small, since the areas of
+disk where it must be installed are often as small as 32KB.
+
+On PC systems using the traditional MBR partition table format, the core
+image is usually installed in the "MBR gap" between the master boot record
+and the first partition, or sometimes it is installed in a file system and
+read directly from that.  The latter is not recommended because GRUB needs
+to encode the location of all the core image sectors in @file{diskboot.img},
+and if the file system ever moves the core image around (as it is entitled
+to do) then GRUB must be reinstalled; it also means that GRUB will not be
+able to reliably find the core image if it resides on a different disk than
+the one to which @file{boot.img} was installed.
+
+On PC systems using the more recent GUID Partition Table (GPT) format, the
+core image should be installed to a BIOS Boot Partition.  This may be
+created by GNU Parted using a command such as the following:
+
+@example
+# @kbd{parted /dev/@var{disk} set @var{partition-number} bios_grub on}
+@end example
+
+@strong{Caution:} Be very careful which partition you select!  When GRUB
+finds a BIOS Boot Partition during installation, it will automatically
+overwrite part of it.  Make sure that the partition does not contain any
+other data.
+
+@item *.mod
+Everything else in GRUB resides in dynamically loadable modules.  These are
+often loaded automatically, or built into the core image if they are
+essential, but may also be loaded manually using the @command{insmod}
+command (@pxref{insmod}).
+@end table
+
+@heading For GRUB Legacy users
+
+GRUB 2 has a different design from GRUB Legacy, and so correspondences with
+the images it used cannot be exact.  Nevertheless, GRUB Legacy users often
+ask questions in the terms they are familiar with, and so here is a brief
+guide to how GRUB 2's images relate to that.
+
+@table @file
+@item stage1
+Stage 1 from GRUB Legacy was very similar to @file{boot.img} in GRUB 2, and
+they serve the same function.
+
+@item *_stage1_5
+In GRUB Legacy, Stage 1.5's function was to include enough filesystem code
+to allow the much larger Stage 2 to be read from an ordinary filesystem.  In
+this respect, its function was similar to @file{core.img} in GRUB 2.
+However, @file{core.img} is much more capable than Stage 1.5 was; since it
+offers a rescue shell, it is sometimes possible to recover manually in the
+event that it is unable to load any other modules, for example if partition
+numbers have changed.  @file{core.img} is built in a more flexible way,
+allowing GRUB 2 to support reading modules from advanced disk types such as
+LVM and RAID.
+
+GRUB Legacy could run with only Stage 1 and Stage 2 in some limited
+configurations, while GRUB 2 requires @file{core.img} and cannot work
+without it.
+
+@item stage2
+GRUB 2 has no single Stage 2 image.  Instead, it loads modules from
+@file{/boot/grub} at run-time.
+
+@item stage2_eltorito
+In GRUB 2, images for booting from CD-ROM drives are now constructed using
+@file{cdboot.img} and @file{core.img}, making sure that the core image
+contains the @samp{iso9660} module.  It is usually best to use the
+@command{grub-mkrescue} program for this.
+
+@item nbgrub
+There is as yet no equivalent for @file{nbgrub} in GRUB 2; it was used by
+Etherboot and some other network boot loaders.
+
+@item pxegrub
+In GRUB 2, images for PXE network booting are now constructed using
+@file{pxeboot.img} and @file{core.img}, making sure that the core image
+contains the @samp{pxe} and @samp{pxecmd} modules.  @xref{Network}.
 @end table
 
-To take full advantage of this function install GRUB into MBR.
 
 @node Filesystem
 @chapter Filesystem syntax and semantics
@@ -1351,19 +1720,12 @@ of entry names.
 If an @key{ESC} is pressed in the editor, it aborts all the changes made
 to the configuration entry and returns to the main menu interface.
 
-When a particular line is selected, the editor places the user in a
+Each line in the menu entry can be edited freely, and you can add new lines
-special version of the GRUB command-line to edit that line.  When the
+by pressing @key{RET} at the end of a line.  To boot the edited entry, press
-user hits @key{RET}, GRUB replaces the line in question in the boot
+@key{Ctrl-x}.
-entry with the changes (unless it was aborted via @key{ESC},
-in which case the changes are thrown away).
 
-If you want to add a new line to the menu entry, press @key{o} if adding
+Although GRUB unfortunately does not support @dfn{undo}, you can do almost
-a line after the current line or press @key{O} if before the current
+the same thing by just returning to the main menu using @key{ESC}.
-line.
-
-To delete a line, hit the key @key{d}. Although GRUB unfortunately
-does not support @dfn{undo}, you can do almost the same thing by just
-returning to the main menu.
 
 
 @node Commands
@@ -1376,6 +1738,10 @@ the global section of the configuration file (or ``menu''); most
 of them can be entered on the command-line and can be used either
 anywhere in the menu or specifically in the menu entries.
 
+In rescue mode, only the @command{insmod} (@pxref{insmod}), @command{ls}
+(@pxref{ls}), @command{set} (@pxref{set}), and @command{unset}
+(@pxref{unset}) commands are normally available.
+
 @menu
 * Menu-specific commands::
 * General commands::
@@ -1508,16 +1874,23 @@ names active.
 @node terminfo
 @subsection terminfo
 
-@deffn Command terminfo [term]
+@deffn Command terminfo [-a|-u|-v] [term]
 Define the capabilities of your terminal by giving the name of an entry in
 the terminfo database, which should correspond roughly to a @samp{TERM}
 environment variable in Unix.
 
-At the moment, only @samp{vt100} is supported in GRUB 2.  If you need other
+The currently available terminal types are @samp{vt100}, @samp{vt100-color},
-terminal types, please contact us to discuss the best way to include support
+@samp{ieee1275}, and @samp{dumb}.  If you need other terminal types, please
-for these in GRUB.
+contact us to discuss the best way to include support for these in GRUB.
 
-If no option is specified, the current terminal type is printed.
+The @option{-a} (@option{--ascii}), @option{-u} (@option{--utf8}), and
+@option{-v} (@option{--visual-utf8}) options control how non-ASCII text is
+displayed.  @option{-a} specifies an ASCII-only terminal; @option{-u}
+specifies logically-ordered UTF-8; and @option{-v} specifies
+visually-ordered UTF-8.
+
+If no option or terminal type is specified, the current terminal type is
+printed.
 @end deffn
 
 
@@ -1530,12 +1903,14 @@ you forget a command, you can run the command @command{help}
 
 @menu
 * acpi::                        Load ACPI tables
+* badram::                      Filter out bad regions of RAM
 * blocklist::                   Print a block list
 * boot::                        Start up your operating system
 * cat::                         Show the contents of a file
 * chainloader::                 Chain-load another boot loader
 * cmp::                         Compare two files
 * configfile::                  Load a configuration file
+* cpuid::                       Check for CPU features
 * crc::                         Calculate CRC32 checksums
 * date::                        Display or set current date and time
 * drivemap::                    Map a drive to another
@@ -1545,8 +1920,12 @@ you forget a command, you can run the command @command{help}
 * gptsync::                     Fill an MBR based on GPT entries
 * halt::                        Shut down your computer
 * help::                        Show help messages
+* initrd::                      Load a Linux initrd
+* initrd16::                    Load a Linux initrd (16-bit mode)
 * insmod::                      Insert a module
 * keystatus::                   Check key modifier status
+* linux::                       Load a Linux kernel
+* linux16::                     Load a Linux kernel (16-bit mode)
 * ls::                          List devices or files
 * parttool::                    Modify partition table entries
 * password::                    Set a clear-text password
@@ -1582,6 +1961,27 @@ Normally, this command will replace the Root System Description Pointer
 GRUB, but may be used by GRUB's EFI emulation.
 @end deffn
 
+@node badram
+@subsection badram
+
+@deffn Command badram addr,mask[,addr,mask...]
+Filter out bad RAM.
+@end deffn
+
+This command notifies the memory manager that specified regions of
+RAM ought to be filtered out (usually, because they're damaged).  This
+remains in effect after a payload kernel has been loaded by GRUB, as
+long as the loaded kernel obtains its memory map from GRUB.  Kernels that
+support this include Linux, GNU Mach, the kernel of FreeBSD and Multiboot
+kernels in general.
+
+Syntax is the same as provided by the @uref{http://www.memtest.org/,
+Memtest86+ utility}: a list of address/mask pairs.  Given a page-aligned
+address and a base address / mask pair, if all the bits of the page-aligned
+address that are enabled by the mask match with the base address, it means
+this page is to be filtered.  This syntax makes it easy to represent patterns
+that are often result of memory damage, due to physical distribution of memory
+cells.
 
 @node blocklist
 @subsection blocklist
@@ -1604,13 +2004,19 @@ a menu entry).
 @node cat
 @subsection cat
 
-@deffn Command cat file
+@deffn Command cat [@option{--dos}] file
 Display the contents of the file @var{file}. This command may be useful
 to remind you of your OS's root partition:
 
 @example
 grub> @kbd{cat /etc/fstab}
 @end example
+
+If the @option{--dos} option is used, then carriage return / new line pairs
+will be displayed as a simple new line.  Otherwise, the carriage return will
+be displayed as a control character (@samp{<d>}) to make it easier to see
+when boot problems are caused by a file formatted using DOS-style line
+endings.
 @end deffn
 
 
@@ -1653,7 +2059,22 @@ If they are completely identical, nothing will be printed.
 @subsection configfile
 
 @deffn Command configfile file
-Load @var{file} as a configuration file.
+Load @var{file} as a configuration file.  If @var{file} defines any menu
+entries, then show a menu containing them immediately.
+@end deffn
+
+
+@node cpuid
+@subsection cpuid
+
+@deffn Command cpuid [-l]
+Check for CPU features.  This command is only available on x86 systems.
+
+With the @option{-l} option, return true if the CPU supports long mode
+(64-bit).
+
+If invoked without options, this command currently behaves as if it had been
+invoked with @option{-l}.  This may change in the future.
 @end deffn
 
 
@@ -1811,6 +2232,30 @@ about each of the commands whose names begin with those @var{patterns}.
 @end deffn
 
 
+@node initrd
+@subsection initrd
+
+@deffn Command initrd file
+Load an initial ramdisk for a Linux kernel image, and set the appropriate
+parameters in the Linux setup area in memory.  This may only be used after
+the @command{linux} command (@pxref{linux}) has been run.  See also
+@ref{GNU/Linux}.
+@end deffn
+
+
+@node initrd16
+@subsection initrd16
+
+@deffn Command initrd16 file
+Load an initial ramdisk for a Linux kernel image to be booted in 16-bit
+mode, and set the appropriate parameters in the Linux setup area in memory.
+This may only be used after the @command{linux16} command (@pxref{linux16})
+has been run.  See also @ref{GNU/Linux}.
+
+This command is only available on x86 systems.
+@end deffn
+
+
 @node insmod
 @subsection insmod
 
@@ -1833,6 +2278,42 @@ only if checking key modifier status is supported.
 @end deffn
 
 
+@node linux
+@subsection linux
+
+@deffn Command linux file @dots{}
+Load a Linux kernel image from @var{file}.  The rest of the line is passed
+verbatim as the @dfn{kernel command-line}.  Any initrd must be reloaded
+after using this command (@pxref{initrd}).
+
+On x86 systems, the kernel will be booted using the 32-bit boot protocol.
+Note that this means that the @samp{vga=} boot option will not work; if you
+want to set a special video mode, you will need to use GRUB commands such as
+@samp{set gfxpayload=1024x768} or @samp{set gfxpayload=keep} (to keep the
+same mode as used in GRUB) instead.  GRUB can automatically detect some uses
+of @samp{vga=} and translate them to appropriate settings of
+@samp{gfxpayload}.  The @command{linux16} command (@pxref{linux16}) avoids
+this restriction.
+@end deffn
+
+
+@node linux16
+@subsection linux16
+
+@deffn Command linux16 file @dots{}
+Load a Linux kernel image from @var{file} in 16-bit mode.  The rest of the
+line is passed verbatim as the @dfn{kernel command-line}.  Any initrd must
+be reloaded after using this command (@pxref{initrd16}).
+
+The kernel will be booted using the traditional 16-bit boot protocol.  As
+well as bypassing problems with @samp{vga=} described in @ref{linux}, this
+permits booting some other programs that implement the Linux boot protocol
+for the sake of convenience.
+
+This command is only available on x86 systems.
+@end deffn
+
+
 @node ls
 @subsection ls
 
@@ -1945,7 +2426,7 @@ Reboot the computer.
 
 @deffn Command search @
  [@option{--file}|@option{--label}|@option{--fs-uuid}] @
- [@option{--set} var] [@option{--no-floppy}] name
+ [@option{--set} [var]] [@option{--no-floppy}] name
 Search devices by file (@option{-f}, @option{--file}), filesystem label
 (@option{-l}, @option{--label}), or filesystem UUID (@option{-u},
 @option{--fs-uuid}).
@@ -2101,6 +2582,9 @@ grub-install}).  When doing this, there are a few things to remember:
 Drive ordering in your operating system may not be the same as the boot
 drive ordering used by your firmware.  Do not assume that your first hard
 drive (e.g. @samp{/dev/sda}) is the one that your firmware will boot from.
+@file{device.map} (@pxref{Device map}) can be used to override this, but it
+is usually better to use UUIDs or file system labels and avoid depending on
+drive ordering entirely.
 
 @item
 At least on BIOS systems, if you tell @command{grub-install} to install GRUB
@@ -2332,7 +2816,7 @@ Once we get your report, we will try to fix the bugs.
 We started the next generation of GRUB, GRUB 2. GRUB 2 includes
 internationalization, dynamic module loading, real memory management,
 multiple architecture support, a scripting language, and many other
-nice feature. If you are interested in the development of GRUB 2, take
+nice features. If you are interested in the development of GRUB 2, take
 a look at @uref{http://www.gnu.org/software/grub/grub.html, the
 homepage}.
 

docs/man/grub-bin2h.h2m

@@ -0,0 +1,2 @@
+[NAME]
+grub-bin2h \- convert a binary file to a C header

docs/man/grub-editenv.h2m

@@ -0,0 +1,2 @@
+[NAME]
+grub-editenv \- edit GRUB environment block

docs/man/grub-emu.h2m

@@ -0,0 +1,2 @@
+[NAME]
+grub-emu \- GRUB emulator

docs/man/grub-fstest.h2m

@@ -0,0 +1,2 @@
+[NAME]
+grub-fstest \- debug tool for GRUB filesystem drivers

docs/man/grub-install.h2m

@@ -0,0 +1,2 @@
+[NAME]
+grub-install \- install GRUB to a device

docs/man/grub-macho2img.h2m

@@ -0,0 +1,2 @@
+[NAME]
+grub-macho2img \- convert Mach-O to raw image

docs/man/grub-mkconfig.h2m

@@ -0,0 +1,2 @@
+[NAME]
+grub-mkconfig \- generate a GRUB configuration file

docs/man/grub-mkdevicemap.h2m

@@ -0,0 +1,2 @@
+[NAME]
+grub-mkdevicemap \- generate a GRUB device map file automatically

docs/man/grub-mkfont.h2m

@@ -0,0 +1,2 @@
+[NAME]
+grub-mkfont \- make GRUB font files

docs/man/grub-mkimage.h2m

@@ -0,0 +1,2 @@
+[NAME]
+grub-mkimage \- make a bootable image of GRUB

docs/man/grub-mkpasswd-pbkdf2.h2m

@@ -0,0 +1,2 @@
+[NAME]
+grub-mkpasswd-pbkdf2 \- generate hashed password for GRUB

docs/man/grub-mkrelpath.h2m

@@ -0,0 +1,2 @@
+[NAME]
+grub-mkrelpath \- make a system path relative to its root

docs/man/grub-mkrescue.h2m

@@ -0,0 +1,2 @@
+[NAME]
+grub-mkrescue \- make a GRUB rescue image

docs/man/grub-ofpathname.h2m

@@ -0,0 +1,2 @@
+[NAME]
+grub-ofpathname \- find OpenBOOT path for a device

docs/man/grub-pe2elf.h2m

@@ -0,0 +1,2 @@
+[NAME]
+grub-pe2elf \- convert PE image to ELF

docs/man/grub-probe.h2m

@@ -0,0 +1,2 @@
+[NAME]
+grub-probe \- probe device information for GRUB

docs/man/grub-reboot.h2m

@@ -0,0 +1,2 @@
+[NAME]
+grub-reboot \- set the default boot entry for GRUB, for the next boot only

docs/man/grub-script-check.h2m

@@ -0,0 +1,2 @@
+[NAME]
+grub-script-check \- check grub.cfg for syntax errors

docs/man/grub-set-default.h2m

@@ -0,0 +1,2 @@
+[NAME]
+grub-set-default \- set the default boot entry for GRUB

docs/man/grub-setup.h2m

@@ -0,0 +1,2 @@
+[NAME]
+grub-setup \- set up a device to boot using GRUB

font/font.c

@@ -26,6 +26,8 @@
 #include <grub/types.h>
 #include <grub/video.h>
 #include <grub/bitmap.h>
+#include <grub/charset.h>
+#include <grub/unicode.h>
 #include <grub/fontformat.h>
 
 #ifdef USE_ASCII_FAILBACK
@@ -133,7 +135,7 @@ ascii_glyph_lookup (grub_uint32_t code)
   static int ascii_failback_initialized = 0;
 
   if (code >= 0x80)
-    return unknown_glyph;
+    return NULL;
 
   if (ascii_failback_initialized == 0)
     {
@@ -148,9 +150,10 @@ ascii_glyph_lookup (grub_uint32_t code)
 	  ascii_font_glyph[current]->offset_x = 0;
 	  ascii_font_glyph[current]->offset_y = -2;
 	  ascii_font_glyph[current]->device_width = 8;
+	  ascii_font_glyph[current]->font = NULL;
 
 	  grub_memcpy (ascii_font_glyph[current]->bitmap,
-		       &ascii_bitmaps[(0x7f - current) * ASCII_BITMAP_SIZE],
+		       &ascii_bitmaps[current * ASCII_BITMAP_SIZE],
 		       ASCII_BITMAP_SIZE);
 	}
 
@@ -160,7 +163,7 @@ ascii_glyph_lookup (grub_uint32_t code)
   return ascii_font_glyph[code];
 #else
   (void) code;
-  return unknown_glyph;
+  return NULL;
 #endif
 }
 
@@ -900,6 +903,13 @@ grub_font_get_descent (grub_font_t font)
   return font->descent;
 }
 
+/* FIXME: not correct for all fonts.  */
+int
+grub_font_get_xheight (grub_font_t font)
+{
+  return font->ascent / 2;
+}
+
 /* Get the *standard leading* of the font in pixel, which is the spacing
    between two lines of text.  Specifically, it is the space between the
    descent of one line and the ascent of the next line.  This is included
@@ -917,27 +927,6 @@ grub_font_get_height (grub_font_t font)
   return font->ascent + font->descent + font->leading;
 }
 
-/* Get the width in pixels of the specified UTF-8 string, when rendered in
-   in the specified font (but falling back on other fonts for glyphs that
-   are missing).  */
-int
-grub_font_get_string_width (grub_font_t font, const char *str)
-{
-  int width;
-  struct grub_font_glyph *glyph;
-  grub_uint32_t code;
-  const grub_uint8_t *ptr;
-
-  for (ptr = (const grub_uint8_t *) str, width = 0;
-       grub_utf8_to_ucs4 (&code, 1, ptr, -1, &ptr) > 0;)
-    {
-      glyph = grub_font_get_glyph_with_fallback (font, code);
-      width += glyph->device_width;
-    }
-
-  return width;
-}
-
 /* Get the glyph for FONT corresponding to the Unicode code point CODE.
    Returns the ASCII glyph for the code if no other fonts are available. 
    The glyphs are cached once loaded.  */
@@ -1029,6 +1018,8 @@ grub_font_get_glyph_with_fallback (grub_font_t font, grub_uint32_t code)
       next = node->next;
 
       glyph = grub_font_get_glyph_internal (curfont, code);
+      if (glyph && !font)
+	return glyph;
       if (glyph)
 	{
 	  int d;
@@ -1042,13 +1033,457 @@ grub_font_get_glyph_with_fallback (grub_font_t font, grub_uint32_t code)
 	}
     }
 
-  if (best_glyph)
   return best_glyph;
-  else
-    /* Glyph not available in any font.  Return ASCII failback.  */
-    return ascii_glyph_lookup (code);
 }
 
+static struct grub_font_glyph *
+grub_font_dup_glyph (struct grub_font_glyph *glyph)
+{
+  static struct grub_font_glyph *ret;
+  ret = grub_malloc (sizeof (*ret) + (glyph->width * glyph->height + 7) / 8);
+  if (!ret)
+    return NULL;
+  grub_memcpy (ret, glyph, sizeof (*ret)
+	       + (glyph->width * glyph->height + 7) / 8);
+  return ret;
+}
+
+/* FIXME: suboptimal.  */
+static void
+grub_font_blit_glyph (struct grub_font_glyph *target,
+		      struct grub_font_glyph *src, unsigned dx, unsigned dy)
+{
+  unsigned src_bit, tgt_bit, src_byte, tgt_byte;
+  unsigned i, j;
+  for (i = 0; i < src->height; i++)
+    {
+      src_bit = (src->width * i) % 8;
+      src_byte = (src->width * i) / 8;
+      tgt_bit = (target->width * (dy + i) + dx) % 8;
+      tgt_byte = (target->width * (dy + i) + dx) / 8;
+      for (j = 0; j < src->width; j++)
+	{
+	  target->bitmap[tgt_byte] |= ((src->bitmap[src_byte] << src_bit)
+				       & 0x80) >> tgt_bit;
+	  src_bit++;
+	  tgt_bit++;
+	  if (src_bit == 8)
+	    {
+	      src_byte++;
+	      src_bit = 0;
+	    }
+	  if (tgt_bit == 8)
+	    {
+	      tgt_byte++;
+	      tgt_bit = 0;
+	    }
+	}
+    }
+}
+
+static void
+grub_font_blit_glyph_mirror (struct grub_font_glyph *target,
+			     struct grub_font_glyph *src,
+			     unsigned dx, unsigned dy)
+{
+  unsigned tgt_bit, src_byte, tgt_byte;
+  signed src_bit;
+  unsigned i, j;
+  for (i = 0; i < src->height; i++)
+    {
+      src_bit = (src->width * i + src->width - 1) % 8;
+      src_byte = (src->width * i + src->width - 1) / 8;
+      tgt_bit = (target->width * (dy + i) + dx) % 8;
+      tgt_byte = (target->width * (dy + i) + dx) / 8;
+      for (j = 0; j < src->width; j++)
+	{
+	  target->bitmap[tgt_byte] |= ((src->bitmap[src_byte] << src_bit)
+				       & 0x80) >> tgt_bit;
+	  src_bit--;
+	  tgt_bit++;
+	  if (src_bit == -1)
+	    {
+	      src_byte--;
+	      src_bit = 7;
+	    }
+	  if (tgt_bit == 8)
+	    {
+	      tgt_byte++;
+	      tgt_bit = 0;
+	    }
+	}
+    }
+}
+
+static void
+blit_comb (const struct grub_unicode_glyph *glyph_id,
+	   struct grub_font_glyph *glyph,
+	   struct grub_video_signed_rect *bounds_out,
+	   struct grub_font_glyph *main_glyph,
+	   struct grub_font_glyph **combining_glyphs, int *device_width)
+{
+  struct grub_video_signed_rect bounds;
+  unsigned i;
+  signed above_rightx, above_righty;
+  signed above_leftx, above_lefty;
+  signed below_rightx, below_righty;
+  signed min_devwidth = 0;
+  auto void NESTED_FUNC_ATTR do_blit (struct grub_font_glyph *src,
+				      signed dx, signed dy);
+  void NESTED_FUNC_ATTR do_blit (struct grub_font_glyph *src,
+				 signed dx, signed dy)
+  {
+    if (glyph)
+      grub_font_blit_glyph (glyph, src, dx - glyph->offset_x,
+			    (glyph->height + glyph->offset_y) + dy);
+    if (dx < bounds.x)
+      {
+	bounds.width += bounds.x - dx;
+	bounds.x = dx;
+      }
+    if (bounds.y > -src->height - dy)
+      {
+	bounds.height += bounds.y - (-src->height - dy);
+	bounds.y = (-src->height - dy);
+      }
+    if (dx + src->width - bounds.x >= (signed) bounds.width)
+      bounds.width = dx + src->width - bounds.x + 1;
+    if ((signed) bounds.height < src->height + (-src->height - dy) - bounds.y)
+      bounds.height = src->height + (-src->height - dy) - bounds.y;
+  }
+
+  auto void add_device_width (int val);
+  void add_device_width (int val)
+  {
+    if (glyph)
+      glyph->device_width += val;
+    if (device_width)
+      *device_width += val;
+  }
+
+  if (glyph)
+    glyph->device_width = main_glyph->device_width;
+  if (device_width)
+    *device_width = main_glyph->device_width;
+
+  bounds.x = main_glyph->offset_x;
+  bounds.y = main_glyph->offset_y;
+  bounds.width = main_glyph->width;
+  bounds.height = main_glyph->height;
+
+  above_rightx = main_glyph->offset_x + main_glyph->width;
+  above_righty = bounds.y + bounds.height;
+
+  above_leftx = main_glyph->offset_x;
+  above_lefty = bounds.y + bounds.height;
+
+  below_rightx = bounds.x + bounds.width;
+  below_righty = bounds.y;
+
+  for (i = 0; i < glyph_id->ncomb; i++)
+    {
+      grub_int16_t space = 0;
+      /* Center by default.  */
+      grub_int16_t targetx;
+
+      if (!combining_glyphs[i])
+	continue;
+      targetx = (bounds.width - combining_glyphs[i]->width) / 2 + bounds.x;
+      /* CGJ is to avoid diacritics reordering. */
+      if (glyph_id->combining[i].code
+	  == GRUB_UNICODE_COMBINING_GRAPHEME_JOINER)
+	continue;
+      switch (glyph_id->combining[i].type)
+	{
+	case GRUB_UNICODE_COMB_OVERLAY:
+	  do_blit (combining_glyphs[i],
+		   targetx,
+		   (bounds.height - combining_glyphs[i]->height) / 2
+		   - (bounds.height + bounds.y));
+	  if (min_devwidth < combining_glyphs[i]->width)
+	    min_devwidth = combining_glyphs[i]->width;
+	  break;
+
+	case GRUB_UNICODE_COMB_ATTACHED_ABOVE_RIGHT:
+	  do_blit (combining_glyphs[i], above_rightx, -above_righty);
+	  above_rightx += combining_glyphs[i]->width;
+	  break;
+
+	case GRUB_UNICODE_COMB_ABOVE_RIGHT:
+	  do_blit (combining_glyphs[i], above_rightx,
+		   -(above_righty + combining_glyphs[i]->height));
+	  above_rightx += combining_glyphs[i]->width;
+	  break;
+
+	case GRUB_UNICODE_COMB_ABOVE_LEFT:
+	  above_leftx -= combining_glyphs[i]->width;
+	  do_blit (combining_glyphs[i], above_leftx,
+		   -(above_lefty + combining_glyphs[i]->height));
+	  break;
+
+	case GRUB_UNICODE_COMB_BELOW_RIGHT:
+	  do_blit (combining_glyphs[i], below_rightx, below_righty);
+	  below_rightx += combining_glyphs[i]->width;
+	  break;
+
+	case GRUB_UNICODE_COMB_HEBREW_HOLAM:
+	  if (glyph_id->base != GRUB_UNICODE_HEBREW_WAW)
+	    targetx =
+	      main_glyph->offset_x - combining_glyphs[i]->width -
+	      (combining_glyphs[i]->width + 3) / 4;
+	  goto above_on_main;
+
+	case GRUB_UNICODE_COMB_HEBREW_SIN_DOT:
+	  targetx = main_glyph->offset_x + combining_glyphs[i]->width / 4;
+	  goto above_on_main;
+
+	case GRUB_UNICODE_COMB_HEBREW_SHIN_DOT:
+	  targetx =
+	    main_glyph->width + main_glyph->offset_x -
+	    combining_glyphs[i]->width;
+	above_on_main:
+	  space = combining_glyphs[i]->offset_y
+	    - grub_font_get_xheight (combining_glyphs[i]->font) - 1;
+	  if (space <= 0)
+	    space = 1 + (grub_font_get_xheight (main_glyph->font)) / 8;
+	  do_blit (combining_glyphs[i], targetx,
+		   -(main_glyph->height + main_glyph->offset_y + space
+		     + combining_glyphs[i]->height));
+	  if (min_devwidth < combining_glyphs[i]->width)
+	    min_devwidth = combining_glyphs[i]->width;
+	  break;
+
+	  /* TODO: Put dammah, fathah and alif nearer to shadda.  */
+	case GRUB_UNICODE_COMB_SYRIAC_SUPERSCRIPT_ALAPH:
+	case GRUB_UNICODE_COMB_ARABIC_DAMMAH:
+	case GRUB_UNICODE_COMB_ARABIC_DAMMATAN:
+	case GRUB_UNICODE_COMB_ARABIC_FATHATAN:
+	case GRUB_UNICODE_COMB_ARABIC_FATHAH:
+	case GRUB_UNICODE_COMB_ARABIC_SUPERSCRIPT_ALIF:
+	case GRUB_UNICODE_COMB_ARABIC_SUKUN:
+	case GRUB_UNICODE_COMB_ARABIC_SHADDA:
+	case GRUB_UNICODE_COMB_HEBREW_RAFE:
+	case GRUB_UNICODE_STACK_ABOVE:
+	stacked_above:
+	  space = combining_glyphs[i]->offset_y
+	    - grub_font_get_xheight (combining_glyphs[i]->font) - 1;
+	  if (space <= 0)
+	    space = 1 + (grub_font_get_xheight (main_glyph->font)) / 8;
+
+	case GRUB_UNICODE_STACK_ATTACHED_ABOVE:
+	  do_blit (combining_glyphs[i], targetx,
+		   -(bounds.height + bounds.y + space
+		     + combining_glyphs[i]->height));
+	  if (min_devwidth < combining_glyphs[i]->width)
+	    min_devwidth = combining_glyphs[i]->width;
+	  break;
+
+	case GRUB_UNICODE_COMB_HEBREW_SHEVA:
+	case GRUB_UNICODE_COMB_HEBREW_HIRIQ:
+	case GRUB_UNICODE_COMB_HEBREW_QAMATS:
+	case GRUB_UNICODE_COMB_HEBREW_TSERE:
+	case GRUB_UNICODE_COMB_HEBREW_SEGOL:
+	  /* TODO: placement in final kaf and under reish.  */
+
+	case GRUB_UNICODE_COMB_HEBREW_HATAF_SEGOL:
+	case GRUB_UNICODE_COMB_HEBREW_HATAF_PATAH:
+	case GRUB_UNICODE_COMB_HEBREW_HATAF_QAMATS:
+	case GRUB_UNICODE_COMB_HEBREW_PATAH:
+	case GRUB_UNICODE_COMB_HEBREW_QUBUTS:
+	case GRUB_UNICODE_COMB_HEBREW_METEG:
+	  /* TODO: Put kasra and kasratan under shadda.  */
+	case GRUB_UNICODE_COMB_ARABIC_KASRA:
+	case GRUB_UNICODE_COMB_ARABIC_KASRATAN:
+	  /* I don't know how ypogegrammeni differs from subscript. */
+	case GRUB_UNICODE_COMB_YPOGEGRAMMENI:
+	case GRUB_UNICODE_STACK_BELOW:
+	stacked_below:
+	  space = -(combining_glyphs[i]->offset_y
+		    + combining_glyphs[i]->height);
+	  if (space <= 0)
+	    space = 1 + (grub_font_get_xheight (main_glyph->font)) / 8;
+
+	case GRUB_UNICODE_STACK_ATTACHED_BELOW:
+	  do_blit (combining_glyphs[i], targetx, -(bounds.y - space));
+	  if (min_devwidth < combining_glyphs[i]->width)
+	    min_devwidth = combining_glyphs[i]->width;
+	  break;
+
+	case GRUB_UNICODE_COMB_MN:
+	  switch (glyph_id->combining[i].code)
+	    {
+	    case GRUB_UNICODE_THAANA_ABAFILI:
+	    case GRUB_UNICODE_THAANA_AABAAFILI:
+	    case GRUB_UNICODE_THAANA_UBUFILI:
+	    case GRUB_UNICODE_THAANA_OOBOOFILI:
+	    case GRUB_UNICODE_THAANA_EBEFILI:
+	    case GRUB_UNICODE_THAANA_EYBEYFILI:
+	    case GRUB_UNICODE_THAANA_OBOFILI:
+	    case GRUB_UNICODE_THAANA_OABOAFILI:
+	    case GRUB_UNICODE_THAANA_SUKUN:
+	      goto stacked_above;
+	    case GRUB_UNICODE_THAANA_IBIFILI:
+	    case GRUB_UNICODE_THAANA_EEBEEFILI:
+	      goto stacked_below;
+	    }
+	  /* Fall through.  */
+	default:
+	  {
+	    /* Default handling. Just draw combining character on top
+	       of base character.
+	       FIXME: support more unicode types correctly.
+	     */
+	    do_blit (combining_glyphs[i],
+		     main_glyph->device_width
+		     + combining_glyphs[i]->offset_x,
+		     -(combining_glyphs[i]->height
+		       + combining_glyphs[i]->offset_y));
+	    add_device_width (combining_glyphs[i]->device_width);
+	  }
+	}
+    }
+  add_device_width ((above_rightx >
+		     below_rightx ? above_rightx : below_rightx) -
+		    (main_glyph->offset_x + main_glyph->width));
+  add_device_width (above_leftx - main_glyph->offset_x);
+  if (glyph && glyph->device_width < min_devwidth)
+    glyph->device_width = min_devwidth;
+  if (device_width && *device_width < min_devwidth)
+    *device_width = min_devwidth;
+
+  if (bounds_out)
+    *bounds_out = bounds;
+}
+
+static struct grub_font_glyph *
+grub_font_construct_dry_run (grub_font_t hinted_font,
+			     const struct grub_unicode_glyph *glyph_id,
+			     struct grub_video_signed_rect *bounds,
+			     struct grub_font_glyph ***combining_glyphs_out,
+			     int *device_width)
+{
+  struct grub_font_glyph *main_glyph = NULL;
+  struct grub_font_glyph **combining_glyphs;
+  grub_uint32_t desired_attributes = 0;
+
+  if (combining_glyphs_out)
+    *combining_glyphs_out = NULL;
+
+  if (glyph_id->attributes & GRUB_UNICODE_GLYPH_ATTRIBUTE_RIGHT_JOINED)
+    desired_attributes |= GRUB_FONT_CODE_RIGHT_JOINED;
+
+  if (glyph_id->attributes & GRUB_UNICODE_GLYPH_ATTRIBUTE_LEFT_JOINED)
+    desired_attributes |= GRUB_FONT_CODE_LEFT_JOINED;
+
+  main_glyph = grub_font_get_glyph_with_fallback (hinted_font, glyph_id->base
+						  | desired_attributes);
+
+  if (!main_glyph)
+    main_glyph = grub_font_get_glyph_with_fallback (hinted_font,
+						    glyph_id->base);
+
+  /* Glyph not available in any font.  Use ASCII fallback.  */
+  if (!main_glyph)
+    main_glyph = ascii_glyph_lookup (glyph_id->base);
+
+  /* Glyph not available in any font.  Return unknown glyph.  */
+  if (!main_glyph)
+    return NULL;
+
+  if (device_width)
+    *device_width = main_glyph->device_width;
+
+  if (!glyph_id->ncomb && !glyph_id->attributes)
+    return main_glyph;
+
+  combining_glyphs = grub_malloc (sizeof (combining_glyphs[0])
+				  * glyph_id->ncomb);
+  if (glyph_id->ncomb && !combining_glyphs)
+    {
+      grub_errno = GRUB_ERR_NONE;
+      return main_glyph;
+    }
+
+  {
+    unsigned i;
+    for (i = 0; i < glyph_id->ncomb; i++)
+      combining_glyphs[i]
+	= grub_font_get_glyph_with_fallback (main_glyph->font,
+					     glyph_id->combining[i].code);
+  }
+
+  blit_comb (glyph_id, NULL, bounds, main_glyph, combining_glyphs,
+	     device_width);
+  if (combining_glyphs_out)
+    *combining_glyphs_out = combining_glyphs;
+  else
+    grub_free (combining_glyphs);
+
+  return main_glyph;
+}
+
+int
+grub_font_get_constructed_device_width (grub_font_t hinted_font,
+					const struct grub_unicode_glyph
+					*glyph_id)
+{
+  int ret;
+  struct grub_font_glyph *main_glyph;
+  main_glyph = grub_font_construct_dry_run (hinted_font, glyph_id, NULL,
+					    NULL, &ret);
+  if (!main_glyph)
+    return unknown_glyph->device_width;
+  return ret;
+}
+
+struct grub_font_glyph *
+grub_font_construct_glyph (grub_font_t hinted_font,
+			   const struct grub_unicode_glyph *glyph_id)
+{
+  struct grub_font_glyph *main_glyph;
+  struct grub_video_signed_rect bounds;
+  struct grub_font_glyph *glyph;
+  struct grub_font_glyph **combining_glyphs;
+
+  main_glyph = grub_font_construct_dry_run (hinted_font, glyph_id,
+					    &bounds, &combining_glyphs, NULL);
+
+  if (!main_glyph)
+    return grub_font_dup_glyph (unknown_glyph);
+
+  if (!combining_glyphs)
+    return grub_font_dup_glyph (main_glyph);
+
+  glyph =
+    grub_zalloc (sizeof (*glyph) + (bounds.width * bounds.height + 7) / 8);
+  if (!glyph)
+    {
+      grub_errno = GRUB_ERR_NONE;
+      return grub_font_dup_glyph (main_glyph);
+    }
+
+  glyph->font = main_glyph->font;
+  glyph->width = bounds.width;
+  glyph->height = bounds.height;
+  glyph->offset_x = bounds.x;
+  glyph->offset_y = bounds.y;
+
+  if (glyph_id->attributes & GRUB_UNICODE_GLYPH_ATTRIBUTE_MIRROR)
+    grub_font_blit_glyph_mirror (glyph, main_glyph,
+				 main_glyph->offset_x - glyph->offset_x,
+				 (glyph->height + glyph->offset_y)
+				 - (main_glyph->height +
+				    main_glyph->offset_y));
+  else
+    grub_font_blit_glyph (glyph, main_glyph,
+			  main_glyph->offset_x - glyph->offset_x,
+			  (glyph->height + glyph->offset_y)
+			  - (main_glyph->height + main_glyph->offset_y));
+
+  blit_comb (glyph_id, glyph, NULL, main_glyph, combining_glyphs, NULL);
+
+  return glyph;
+}
 
 /* Draw the specified glyph at (x, y).  The y coordinate designates the
    baseline of the character, while the x coordinate designates the left
@@ -1065,8 +1500,8 @@ grub_font_draw_glyph (struct grub_font_glyph * glyph,
 
   glyph_bitmap.mode_info.width = glyph->width;
   glyph_bitmap.mode_info.height = glyph->height;
-  glyph_bitmap.mode_info.mode_type =
+  glyph_bitmap.mode_info.mode_type
-    (1 << GRUB_VIDEO_MODE_TYPE_DEPTH_POS) | GRUB_VIDEO_MODE_TYPE_1BIT_BITMAP;
+    = (1 << GRUB_VIDEO_MODE_TYPE_DEPTH_POS) | GRUB_VIDEO_MODE_TYPE_1BIT_BITMAP;
   glyph_bitmap.mode_info.blit_format = GRUB_VIDEO_BLIT_FORMAT_1BIT_PACKED;
   glyph_bitmap.mode_info.bpp = 1;
 
@@ -1096,29 +1531,3 @@ grub_font_draw_glyph (struct grub_font_glyph * glyph,
 				 bitmap_left, bitmap_top,
 				 0, 0, glyph->width, glyph->height);
 }
-
-/* Draw a UTF-8 string of text on the current video render target.
-   The x coordinate specifies the starting x position for the first character,
-   while the y coordinate specifies the baseline position.
-   If the string contains a character that FONT does not contain, then
-   a glyph from another loaded font may be used instead.  */
-grub_err_t
-grub_font_draw_string (const char *str, grub_font_t font,
-		       grub_video_color_t color, int left_x, int baseline_y)
-{
-  int x;
-  struct grub_font_glyph *glyph;
-  grub_uint32_t code;
-  const grub_uint8_t *ptr;
-
-  for (ptr = (const grub_uint8_t *) str, x = left_x;
-       grub_utf8_to_ucs4 (&code, 1, ptr, -1, &ptr) > 0;)
-    {
-      glyph = grub_font_get_glyph_with_fallback (font, code);
-      if (grub_font_draw_glyph (glyph, color, x, baseline_y) != GRUB_ERR_NONE)
-	return grub_errno;
-      x += glyph->device_width;
-    }
-
-  return GRUB_ERR_NONE;
-}

fs/nilfs2.c

@@ -52,9 +52,9 @@
 /* nilfs 1st super block posission from beginning of the partition
    in 512 block size */
 #define NILFS_1ST_SUPER_BLOCK	2
-/* nilfs 2nd super block posission from end of the partition
+/* nilfs 2nd super block posission from beginning of the partition
    in 512 block size */
-#define NILFS_2ND_SUPER_BLOCK	8
+#define NILFS_2ND_SUPER_BLOCK(devsize)	(((devsize >> 3) - 1) << 3)
 
 struct grub_nilfs2_inode
 {
@@ -729,7 +729,7 @@ grub_nilfs2_load_sb (struct grub_nilfs2_data *data)
   if (partition_size != GRUB_DISK_SIZE_UNKNOWN)
     {
       /* Read second super block. */
-      grub_disk_read (disk, partition_size - NILFS_2ND_SUPER_BLOCK, 0,
+      grub_disk_read (disk, NILFS_2ND_SUPER_BLOCK (partition_size), 0,
 		      sizeof (struct grub_nilfs2_super_block), &sb2);
       /* Make sure if 2nd super block is valid.  */
       valid[1] = grub_nilfs2_valid_sb (&sb2);

fs/reiserfs.c

@@ -929,7 +929,7 @@ grub_reiserfs_iterate_dir (grub_fshelp_node_t item,
                                       "Warning : %s has no stat block !\n",
                                       entry_name);
                       grub_free (entry_item);
-                      continue;
+                      goto next;
                     }
                 }
               if (hook (entry_name, entry_type, entry_item))
@@ -940,6 +940,7 @@ grub_reiserfs_iterate_dir (grub_fshelp_node_t item,
                   goto found;
                 }
 
+next:
               *entry_name = 0; /* Make sure next entry name (which is just
                                   before this one in disk order) stops before
                                   the current one.  */

genmk.rb

@@ -228,7 +228,7 @@ VIDEOFILES += #{video}
 
 #{fs}: #{src} $(#{src}_DEPENDENCIES) genfslist.sh
 	set -e; \
-	  $(TARGET_CC) -I#{dir} -I$(srcdir)/#{dir} $(TARGET_CPPFLAGS) #{extra_flags} $(TARGET_#{flag}) $(#{prefix}_#{flag}) -E $< \
+	  $(TARGET_CC) -I#{dir} -I$(srcdir)/#{dir} $(TARGET_CPPFLAGS) #{extra_flags} -DGRUB_LST_GENERATOR $(TARGET_#{flag}) $(#{prefix}_#{flag}) -E $< \
 	  | sh $(srcdir)/genfslist.sh #{symbolic_name} > $@ || (rm -f $@; exit 1)
 
 #{parttool}: #{src} $(#{src}_DEPENDENCIES) genparttoollist.sh
@@ -238,7 +238,7 @@ VIDEOFILES += #{video}
 
 #{partmap}: #{src} $(#{src}_DEPENDENCIES) genpartmaplist.sh
 	set -e; \
-	  $(TARGET_CC) -I#{dir} -I$(srcdir)/#{dir} $(TARGET_CPPFLAGS) #{extra_flags} $(TARGET_#{flag}) $(#{prefix}_#{flag}) -E $< \
+	  $(TARGET_CC) -I#{dir} -I$(srcdir)/#{dir} $(TARGET_CPPFLAGS) #{extra_flags} -DGRUB_LST_GENERATOR $(TARGET_#{flag}) $(#{prefix}_#{flag}) -E $< \
 	  | sh $(srcdir)/genpartmaplist.sh #{symbolic_name} > $@ || (rm -f $@; exit 1)
 
 #{handler}: #{src} $(#{src}_DEPENDENCIES) genhandlerlist.sh
@@ -253,7 +253,7 @@ VIDEOFILES += #{video}
 
 #{video}: #{src} $(#{src}_DEPENDENCIES) genvideolist.sh
 	set -e; \
-	  $(TARGET_CC) -I#{dir} -I$(srcdir)/#{dir} $(TARGET_CPPFLAGS) #{extra_flags} $(TARGET_#{flag}) $(#{prefix}_#{flag}) -E $< \
+	  $(TARGET_CC) -I#{dir} -I$(srcdir)/#{dir} $(TARGET_CPPFLAGS) #{extra_flags} -DGRUB_LST_GENERATOR $(TARGET_#{flag}) $(#{prefix}_#{flag}) -E $< \
 	  | sh $(srcdir)/genvideolist.sh #{symbolic_name} > $@ || (rm -f $@; exit 1)
 
 "

gettext/gettext.c

@@ -309,14 +309,10 @@ grub_gettext_init_ext (const char *lang)
 static void
 grub_gettext_delete_list (void)
 {
-  struct grub_gettext_msg *item;
+  while (grub_gettext_msg_list)
-
-  while ((item =
-	  grub_list_pop (GRUB_AS_LIST_P (&grub_gettext_msg_list))) != 0)
     {
-      char *original = (char *) ((struct grub_gettext_msg *) item)->name;
+      grub_free ((char *) grub_gettext_msg_list->name);
-      grub_free (original);
+      grub_gettext_msg_list = grub_gettext_msg_list->next;
-
       /* Don't delete the translated message because could be in use.  */
     }
 }

gfxmenu/font.c

@@ -0,0 +1,109 @@
+/* font.c - Font API and font file loader.  */
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 2003,2005,2006,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/bufio.h>
+#include <grub/dl.h>
+#include <grub/file.h>
+#include <grub/font.h>
+#include <grub/misc.h>
+#include <grub/mm.h>
+#include <grub/types.h>
+#include <grub/video.h>
+#include <grub/bitmap.h>
+#include <grub/charset.h>
+#include <grub/unicode.h>
+#include <grub/fontformat.h>
+#include <grub/gfxmenu_view.h>
+
+/* Draw a UTF-8 string of text on the current video render target.
+   The x coordinate specifies the starting x position for the first character,
+   while the y coordinate specifies the baseline position.
+   If the string contains a character that FONT does not contain, then
+   a glyph from another loaded font may be used instead.  */
+grub_err_t
+grub_font_draw_string (const char *str, grub_font_t font,
+                       grub_video_color_t color,
+                       int left_x, int baseline_y)
+{
+  int x;
+  struct grub_font_glyph *glyph;
+  grub_uint32_t *logical;
+  grub_ssize_t logical_len, visual_len;
+  struct grub_unicode_glyph *visual, *ptr;
+
+  logical_len = grub_utf8_to_ucs4_alloc (str, &logical, 0);
+  if (logical_len < 0)
+    return grub_errno;
+
+  visual_len = grub_bidi_logical_to_visual (logical, logical_len, &visual,
+					    0, 0, 0);
+  grub_free (logical);
+  if (visual_len < 0)
+    return grub_errno;
+
+  for (ptr = visual, x = left_x; ptr < visual + visual_len; ptr++)
+    {
+      grub_err_t err;
+      glyph = grub_font_construct_glyph (font, ptr);
+      if (!glyph)
+	return grub_errno;
+      err = grub_font_draw_glyph (glyph, color, x, baseline_y);
+      x += glyph->device_width;
+      grub_free (glyph);
+      if (err)
+	return err;
+    }
+
+  grub_free (visual);
+
+  return GRUB_ERR_NONE;
+}
+
+/* Get the width in pixels of the specified UTF-8 string, when rendered in
+   in the specified font (but falling back on other fonts for glyphs that
+   are missing).  */
+int
+grub_font_get_string_width (grub_font_t font, const char *str)
+{
+  int width = 0;
+  grub_uint32_t *ptr;
+  grub_ssize_t logical_len;
+  grub_uint32_t *logical;
+
+  logical_len = grub_utf8_to_ucs4_alloc (str, &logical, 0);
+  if (logical_len < 0)
+    {
+      grub_errno = GRUB_ERR_NONE;
+      return 0;
+    }
+
+  for (ptr = logical; ptr < logical + logical_len;)
+    {
+      struct grub_unicode_glyph glyph;
+
+      ptr += grub_unicode_aglomerate_comb (ptr,
+					   logical_len - (ptr - logical),
+					   &glyph);
+      width += grub_font_get_constructed_device_width (font, &glyph);
+
+      grub_free (glyph.combining);
+    }
+
+  return width;
+}

gfxmenu/gui_list.c

@@ -210,7 +210,7 @@ draw_scrollbar (list_impl_t self,
 
 /* Draw the list of items.  */
 static void
-draw_menu (list_impl_t self, int width, int num_shown_items)
+draw_menu (list_impl_t self, int num_shown_items)
 {
   if (! self->menu_box || ! self->selected_item_box)
     return;
@@ -227,10 +227,18 @@ draw_menu (list_impl_t self, int width, int num_shown_items)
 
   grub_gfxmenu_box_t selbox = self->selected_item_box;
   int sel_leftpad = selbox->get_left_pad (selbox);
-  int item_top = boxpad;
+  int sel_toppad = selbox->get_top_pad (selbox);
-  int item_left = boxpad + sel_leftpad;
+  int item_top = sel_toppad;
   int menu_index;
   int visible_index;
+  struct grub_video_rect oviewport;
+
+  grub_video_get_viewport (&oviewport.x, &oviewport.y,
+			   &oviewport.width, &oviewport.height);
+  grub_video_set_viewport (oviewport.x + boxpad, 
+			   oviewport.y + boxpad,
+			   oviewport.width - 2 * boxpad,
+			   oviewport.height - 2 * boxpad);
 
   for (visible_index = 0, menu_index = self->first_shown_index;
        visible_index < num_shown_items && menu_index < self->view->menu->size;
@@ -240,16 +248,16 @@ draw_menu (list_impl_t self, int width, int num_shown_items)
 
       if (is_selected)
         {
-          int sel_toppad = selbox->get_top_pad (selbox);
+          selbox->set_content_size (selbox, oviewport.width - 2 * boxpad - 2,
-          selbox->set_content_size (selbox, (width - 2 * boxpad), item_height);
+				    item_height - 1);
-          selbox->draw (selbox, item_left - sel_leftpad,
+          selbox->draw (selbox, 0,
                         item_top - sel_toppad);
         }
 
       struct grub_video_bitmap *icon;
       if ((icon = get_item_icon (self, menu_index)) != 0)
         grub_video_blit_bitmap (icon, GRUB_VIDEO_BLIT_BLEND,
-                                item_left,
+                                sel_leftpad,
                                 item_top + (item_height - self->icon_height) / 2,
                                 0, 0, self->icon_width, self->icon_height);
 
@@ -266,12 +274,16 @@ draw_menu (list_impl_t self, int width, int num_shown_items)
       grub_font_draw_string (item_title,
                              font,
                              grub_gui_map_color (text_color),
-                             item_left + self->icon_width + icon_text_space,
+                             sel_leftpad + self->icon_width + icon_text_space,
                              (item_top + (item_height - (ascent + descent))
                               / 2 + ascent));
 
       item_top += item_height + item_vspace;
     }
+  grub_video_set_viewport (oviewport.x,
+			   oviewport.y,
+			   oviewport.width,
+			   oviewport.height);
 }
 
 static void
@@ -313,7 +325,7 @@ list_paint (void *vself, const grub_video_rect_t *region)
     box->draw (box, 0, 0);
 
     grub_gui_set_viewport (&content_rect, &vpsave2);
-    draw_menu (self, content_rect.width, num_shown_items);
+    draw_menu (self, num_shown_items);
     grub_gui_restore_viewport (&vpsave2);
 
     if (drawing_scrollbar)
@@ -322,7 +334,7 @@ list_paint (void *vself, const grub_video_rect_t *region)
 		      0, self->view->menu->size,
 		      self->bounds.width - box_right_pad
 		      + self->scrollbar_width,
-		      box_top_pad + self->item_padding,
+		      box_top_pad,
 		      self->bounds.height - box_top_pad - box_bottom_pad);
   }
 
@@ -376,6 +388,9 @@ list_get_minimal_size (void *vself, unsigned *width, unsigned *height)
       int box_bottom_pad = box->get_bottom_pad (box);
       unsigned width_s;
 
+      grub_gfxmenu_box_t selbox = self->selected_item_box;
+      int sel_toppad = selbox->get_top_pad (selbox);
+      
       *width = grub_font_get_string_width (self->item_font, "Typical OS");
       width_s = grub_font_get_string_width (self->selected_item_font,
 					    "Typical OS");
@@ -388,7 +403,7 @@ list_get_minimal_size (void *vself, unsigned *width, unsigned *height)
       *height = (item_height * num_items
                  + item_vspace * (num_items - 1)
                  + 2 * boxpad
-                 + box_top_pad + box_bottom_pad);
+                 + box_top_pad + box_bottom_pad + sel_toppad);
     }
   else
     {

include/grub/ata.h

@@ -32,6 +32,12 @@ typedef enum
     GRUB_ATA_LBA48
   } grub_ata_addressing_t;
 
+#define GRUB_ATA_CH0_PORT1 0x1f0
+#define GRUB_ATA_CH1_PORT1 0x170
+
+#define GRUB_ATA_CH0_PORT2 0x3f6
+#define GRUB_ATA_CH1_PORT2 0x376
+
 #define GRUB_ATA_REG_DATA	0
 #define GRUB_ATA_REG_ERROR	1
 #define GRUB_ATA_REG_FEATURES	1

include/grub/bsdlabel.h

@@ -63,6 +63,8 @@
 #define	GRUB_PC_PARTITION_OPENBSD_TYPE_NTFS	18
 #define	GRUB_PC_PARTITION_OPENBSD_TYPE_RAID	19
 
+#define GRUB_PC_PARTITION_BSD_LABEL_WHOLE_DISK_PARTITION 2
+
 /* The BSD partition entry.  */
 struct grub_partition_bsd_entry
 {

include/grub/charset.h

@@ -117,5 +117,11 @@ grub_is_valid_utf8 (const grub_uint8_t *src, grub_size_t srcsize);
 
 int grub_utf8_to_ucs4_alloc (const char *msg, grub_uint32_t **unicode_msg,
 			     grub_uint32_t **last_position);
+void
+grub_ucs4_to_utf8 (grub_uint32_t *src, grub_size_t size,
+		   grub_uint8_t *dest, grub_size_t destsize);
+grub_size_t grub_utf8_to_ucs4 (grub_uint32_t *dest, grub_size_t destsize,
+			       const grub_uint8_t *src, grub_size_t srcsize,
+			       const grub_uint8_t **srcend);
 
 #endif

include/grub/command.h

@@ -117,12 +117,7 @@ grub_command_execute (const char *name, int argc, char **argv)
   return (cmd) ? cmd->func (cmd, argc, argv) : GRUB_ERR_FILE_NOT_FOUND;
 }
 
-static inline int
+#define FOR_COMMANDS(var) FOR_LIST_ELEMENTS((var), grub_command_list)
-grub_command_iterate (int (*func) (grub_command_t))
-{
-  return grub_list_iterate (GRUB_AS_LIST (grub_command_list),
-			    (grub_list_hook_t) func);
-}
 
 void grub_register_core_commands (void);
 

include/grub/dl.h

@@ -82,6 +82,7 @@ struct grub_dl
   Elf_Sym *symtab;
   void (*init) (struct grub_dl *mod);
   void (*fini) (void);
+  struct grub_dl *next;
 };
 typedef struct grub_dl *grub_dl_t;
 
@@ -98,7 +99,10 @@ void grub_dl_unload_all (void);
 #endif
 int EXPORT_FUNC(grub_dl_ref) (grub_dl_t mod);
 int EXPORT_FUNC(grub_dl_unref) (grub_dl_t mod);
-void EXPORT_FUNC(grub_dl_iterate) (int (*hook) (grub_dl_t mod));
+extern grub_dl_t EXPORT_VAR(grub_dl_head);
+
+#define FOR_DL_MODULES(var) FOR_LIST_ELEMENTS ((var), (grub_dl_head))
+
 grub_dl_t EXPORT_FUNC(grub_dl_get) (const char *name);
 grub_err_t grub_dl_register_symbol (const char *name, void *addr,
 				    grub_dl_t mod);

include/grub/efi/uga_draw.h

@@ -32,7 +32,7 @@ enum grub_efi_uga_blt_operation
   GRUB_EFI_UGA_VIDEO_TO_BLT,
   GRUB_EFI_UGA_BLT_TO_VIDEO,
   GRUB_EFI_UGA_VIDEO_TO_VIDEO,
-  GRUB_EFI_UGA_GLT_MAX
+  GRUB_EFI_UGA_BLT_MAX
 };
 
 struct grub_efi_uga_pixel

include/grub/font.h

@@ -22,6 +22,7 @@
 #include <grub/types.h>
 #include <grub/video.h>
 #include <grub/file.h>
+#include <grub/unicode.h>
 
 /* Forward declaration of opaque structure grub_font.
    Users only pass struct grub_font pointers to the font module functions,
@@ -69,6 +70,11 @@ struct grub_font_glyph
   grub_uint8_t bitmap[0];
 };
 
+/* Part of code field which is really used as such.  */
+#define GRUB_FONT_CODE_CHAR_MASK     0x001fffff
+#define GRUB_FONT_CODE_RIGHT_JOINED  0x80000000
+#define GRUB_FONT_CODE_LEFT_JOINED   0x40000000
+
 /* Initialize the font loader.
    Must be called before any fonts are loaded or used.  */
 void grub_font_loader_init (void);
@@ -97,8 +103,7 @@ int EXPORT_FUNC (grub_font_get_leading) (grub_font_t font);
 
 int EXPORT_FUNC (grub_font_get_height) (grub_font_t font);
 
-int EXPORT_FUNC (grub_font_get_string_width) (grub_font_t font,
+int EXPORT_FUNC (grub_font_get_xheight) (grub_font_t font);
-					      const char *str);
 
 struct grub_font_glyph *EXPORT_FUNC (grub_font_get_glyph) (grub_font_t font,
 							   grub_uint32_t code);
@@ -110,9 +115,11 @@ grub_err_t EXPORT_FUNC (grub_font_draw_glyph) (struct grub_font_glyph *glyph,
 					       grub_video_color_t color,
 					       int left_x, int baseline_y);
 
-grub_err_t EXPORT_FUNC (grub_font_draw_string) (const char *str,
+int
-						grub_font_t font,
+EXPORT_FUNC (grub_font_get_constructed_device_width) (grub_font_t hinted_font,
-						grub_video_color_t color,
+					const struct grub_unicode_glyph *glyph_id);
-						int left_x, int baseline_y);
+struct grub_font_glyph *
+EXPORT_FUNC (grub_font_construct_glyph) (grub_font_t hinted_font,
+			   const struct grub_unicode_glyph *glyph_id);
 
 #endif /* ! GRUB_FONT_HEADER */

include/grub/fs.h

@@ -24,6 +24,8 @@
 #include <grub/symbol.h>
 #include <grub/types.h>
 
+#include <grub/list.h>
+
 /* Forward declaration is required, because of mutual reference.  */
 struct grub_file;
 
@@ -38,6 +40,9 @@ struct grub_dirhook_info
 /* Filesystem descriptor.  */
 struct grub_fs
 {
+  /* The next filesystem.  */
+  struct grub_fs *next;
+
   /* My name.  */
   const char *name;
 
@@ -72,9 +77,6 @@ struct grub_fs
   /* Whether this filesystem reserves first sector for DOS-style boot.  */
   int reserved_first_sector;
 #endif
-
-  /* The next filesystem.  */
-  struct grub_fs *next;
 };
 typedef struct grub_fs *grub_fs_t;
 
@@ -87,10 +89,24 @@ extern struct grub_fs grub_fs_blocklist;
    the linked list GRUB_FS_LIST through the function grub_fs_register.  */
 typedef int (*grub_fs_autoload_hook_t) (void);
 extern grub_fs_autoload_hook_t EXPORT_VAR(grub_fs_autoload_hook);
+extern grub_fs_t EXPORT_VAR (grub_fs_list);
+
+#ifndef GRUB_LST_GENERATOR
+static inline void
+grub_fs_register (grub_fs_t fs)
+{
+  grub_list_push (GRUB_AS_LIST_P (&grub_fs_list), GRUB_AS_LIST (fs));
+}
+#endif
+
+static inline void
+grub_fs_unregister (grub_fs_t fs)
+{
+  grub_list_remove (GRUB_AS_LIST_P (&grub_fs_list), GRUB_AS_LIST (fs));
+}
+
+#define FOR_FILESYSTEMS(var) FOR_LIST_ELEMENTS((var), (grub_fs_list))
 
-void EXPORT_FUNC(grub_fs_register) (grub_fs_t fs);
-void EXPORT_FUNC(grub_fs_unregister) (grub_fs_t fs);
-void EXPORT_FUNC(grub_fs_iterate) (int (*hook) (const grub_fs_t fs));
 grub_fs_t EXPORT_FUNC(grub_fs_probe) (grub_device_t device);
 
 #endif /* ! GRUB_FS_HEADER */

include/grub/gfxmenu_view.h

@@ -62,6 +62,14 @@ grub_gfxmenu_print_timeout (int timeout, void *data);
 void
 grub_gfxmenu_set_chosen_entry (int entry, void *data);
 
+grub_err_t grub_font_draw_string (const char *str,
+				  grub_font_t font,
+				  grub_video_color_t color,
+				  int left_x, int baseline_y);
+int grub_font_get_string_width (grub_font_t font,
+				const char *str);
+
+
 /* Implementation details -- this should not be used outside of the
    view itself.  */
 

include/grub/handler.h

@@ -1,60 +0,0 @@
-/* handler.h - header for grub handler */
-/*
- *  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/>.
- */
-
-#ifndef GRUB_HANDLER_HEADER
-#define GRUB_HANDLER_HEADER 1
-
-#include <grub/list.h>
-#include <grub/err.h>
-
-struct grub_handler
-{
-  struct grub_handler *next;
-  const char *name;
-  grub_err_t (*init) (void);
-  grub_err_t (*fini) (void);
-};
-typedef struct grub_handler *grub_handler_t;
-
-struct grub_handler_class
-{
-  struct grub_handler_class *next;
-  const char *name;
-  grub_handler_t handler_list;
-  grub_handler_t cur_handler;
-};
-typedef struct grub_handler_class *grub_handler_class_t;
-
-extern grub_handler_class_t EXPORT_VAR(grub_handler_class_list);
-
-void EXPORT_FUNC(grub_handler_register) (grub_handler_class_t class,
-					 grub_handler_t handler);
-void EXPORT_FUNC(grub_handler_unregister) (grub_handler_class_t class,
-					   grub_handler_t handler);
-grub_err_t EXPORT_FUNC(grub_handler_set_current) (grub_handler_class_t class,
-						  grub_handler_t handler);
-
-#define GRUB_AS_HANDLER(ptr) \
-  ((GRUB_FIELD_MATCH (ptr, grub_handler_t, next) && \
-    GRUB_FIELD_MATCH (ptr, grub_handler_t, name) && \
-    GRUB_FIELD_MATCH (ptr, grub_handler_t, init) && \
-    GRUB_FIELD_MATCH (ptr, grub_handler_t, fini)) ? \
-   (grub_handler_t) ptr : grub_bad_type_cast ())
-
-#endif /* ! GRUB_HANDLER_HEADER */

include/grub/i386/pc/console.h

@@ -40,12 +40,15 @@
 #include <grub/i386/vga_common.h>
 
 /* These are global to share code between C and asm.  */
-int grub_console_checkkey (void);
+int grub_console_checkkey (struct grub_term_input *term);
-int grub_console_getkey (void);
+int grub_console_getkey (struct grub_term_input *term);
-grub_uint16_t grub_console_getxy (void);
+grub_uint16_t grub_console_getxy (struct grub_term_output *term);
-void grub_console_gotoxy (grub_uint8_t x, grub_uint8_t y);
+void grub_console_gotoxy (struct grub_term_output *term,
-void grub_console_cls (void);
+			  grub_uint8_t x, grub_uint8_t y);
-void grub_console_setcursor (int on);
+void grub_console_cls (struct grub_term_output *term);
+void grub_console_setcursor (struct grub_term_output *term, int on);
+void grub_console_putchar (struct grub_term_output *term,
+			   const struct grub_unicode_glyph *c);
 
 /* Initialize the console system.  */
 void grub_console_init (void);

include/grub/i386/qemu/kernel.h

@@ -34,6 +34,8 @@ extern grub_int32_t grub_kernel_image_size;
 /* The total size of module images following the kernel.  */
 extern grub_int32_t grub_total_module_size;
 
+void grub_qemu_init_cirrus (void);
+
 #endif /* ! ASM_FILE */
 
 #endif /* ! GRUB_KERNEL_MACHINE_HEADER */

include/grub/i386/vga_common.h

@@ -25,16 +25,8 @@
 
 extern grub_uint8_t grub_console_cur_color;
 
-void grub_console_putchar (grub_uint32_t c);
+grub_uint16_t grub_console_getwh (struct grub_term_output *term);
-grub_ssize_t grub_console_getcharwidth (grub_uint32_t c);
+void grub_console_setcolorstate (struct grub_term_output *term,
-grub_uint16_t grub_console_getwh (void);
+				 grub_term_color_state state);
-void grub_console_setcolorstate (grub_term_color_state state);
-void grub_console_setcolor (grub_uint8_t normal_color, grub_uint8_t highlight_color);
-void grub_console_getcolor (grub_uint8_t *normal_color, grub_uint8_t *highlight_color);
-
-/* Implemented in both kern/i386/pc/startup.S and vga_text.c;  this symbol
-   is not exported, so there's no collision, but vga_common.c expects this
-   prototype to be the same.  */
-void grub_console_real_putchar (int c);
 
 #endif /* ! GRUB_VGA_COMMON_CPU_HEADER */

include/grub/i386/xnu.h

@@ -114,8 +114,6 @@ extern grub_uint32_t grub_xnu_stack;
 extern grub_uint32_t grub_xnu_arg1;
 extern char grub_xnu_cmdline[1024];
 grub_err_t grub_xnu_boot (void);
-grub_err_t grub_xnu_set_video (struct grub_xnu_boot_params *bootparams_relloc);
+grub_err_t grub_cpu_xnu_fill_devicetree (void);
-grub_err_t
-grub_cpu_xnu_fill_devicetree (void);
 extern grub_uint32_t grub_xnu_heap_will_be_at;
 #endif

include/grub/ieee1275/console.h

@@ -22,7 +22,8 @@
 #include <grub/symbol.h>
 
 /* Initialize the console system.  */
-void grub_console_init (void);
+void grub_console_init_early (void);
+void grub_console_init_lately (void);
 
 /* Finish the console system.  */
 void grub_console_fini (void);

include/grub/list.h

@@ -30,15 +30,10 @@ struct grub_list
 };
 typedef struct grub_list *grub_list_t;
 
-typedef int (*grub_list_hook_t) (grub_list_t item);
-typedef int (*grub_list_test_t) (grub_list_t new_item, grub_list_t item);
-
 void EXPORT_FUNC(grub_list_push) (grub_list_t *head, grub_list_t item);
-void * EXPORT_FUNC(grub_list_pop) (grub_list_t *head);
 void EXPORT_FUNC(grub_list_remove) (grub_list_t *head, grub_list_t item);
-int EXPORT_FUNC(grub_list_iterate) (grub_list_t head, grub_list_hook_t hook);
+
-void EXPORT_FUNC(grub_list_insert) (grub_list_t *head, grub_list_t item,
+#define FOR_LIST_ELEMENTS(var, list) for ((var) = (list); (var); (var) = (var)->next)
-				    grub_list_test_t test);
 
 static inline void *
 grub_bad_type_cast_real (int line, const char *file)

include/grub/mips/loongson.h

@@ -0,0 +1,90 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 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/>.
+ */
+
+#ifndef GRUB_LOONGSON_CPU_HEADER
+#define GRUB_LOONGSON_CPU_HEADER	1
+
+#ifdef ASM_FILE
+#define GRUB_CPU_REGISTER_WRAP(x) x
+#else
+#define GRUB_CPU_REGISTER_WRAP(x) #x
+#endif
+
+#define GRUB_CPU_LOONGSON_FLASH_START            0xbfc00000
+#define GRUB_CPU_LOONGSON_FLASH_TLB_REFILL       0xbfc00200
+#define GRUB_CPU_LOONGSON_FLASH_CACHE_ERROR      0xbfc00300
+#define GRUB_CPU_LOONGSON_FLASH_OTHER_EXCEPTION  0xbfc00380
+
+#define GRUB_CPU_LOONGSON_DDR2_BASE              0xaffffe00
+#define GRUB_CPU_LOONGSON_DDR2_REG1_HI_8BANKS    0x00000001
+#define GRUB_CPU_LOONGSON_DDR2_REG_SIZE          0x8
+#define GRUB_CPU_LOONGSON_DDR2_REG_STEP          0x10
+
+#define GRUB_CPU_LOONGSON_COP0_CACHE_CONFIG GRUB_CPU_REGISTER_WRAP($16)
+#define GRUB_CPU_LOONGSON_COP0_CACHE_CONFIG_ILINESIZE 0x10
+#define GRUB_CPU_LOONGSON_COP0_CACHE_CONFIG_DLINESIZE 0x8
+#define GRUB_CPU_LOONGSON_COP0_CACHE_DSIZE_SHIFT 6
+#define GRUB_CPU_LOONGSON_COP0_CACHE_ISIZE_SHIFT 9
+#define GRUB_CPU_LOONGSON_COP0_CACHE_SIZE_MASK  0x7
+#define GRUB_CPU_LOONGSON_COP0_CACHE_SIZE_OFFSET 12
+
+#define GRUB_CPU_LOONGSON_COP0_I_INDEX_INVALIDATE 0
+#define GRUB_CPU_LOONGSON_COP0_D_INDEX_TAG_STORE  9
+#define GRUB_CPU_LOONGSON_COP0_S_INDEX_TAG_STORE  11
+
+#define GRUB_CPU_LOONGSON_COP0_I_INDEX_BIT_OFFSET 5
+#define GRUB_CPU_LOONGSON_COP0_D_INDEX_BIT_OFFSET 5
+#define GRUB_CPU_LOONGSON_COP0_S_INDEX_BIT_OFFSET 5
+
+#define GRUB_CPU_LOONGSON_CACHE_ACCELERATED 7
+#define GRUB_CPU_LOONGSON_CACHE_UNCACHED 2
+#define GRUB_CPU_LOONGSON_CACHE_CACHED 3
+#define GRUB_CPU_LOONGSON_CACHE_TYPE_MASK 7
+#define GRUB_CPU_LOONGSON_CACHE_LINE_SIZE_LOG_SMALL 4
+#define GRUB_CPU_LOONGSON_CACHE_LINE_SIZE_LOG_BIG 5
+#define GRUB_CPU_LOONGSON_CACHE_LINE_SIZE_SMALL 16
+#define GRUB_CPU_LOONGSON_CACHE_LINE_SIZE_BIG 32
+
+#define GRUB_CPU_LOONGSON_I_CACHE_LOG_WAYS 2
+#define GRUB_CPU_LOONGSON_D_CACHE_LOG_WAYS 2
+#define GRUB_CPU_LOONGSON_S_CACHE_LOG_WAYS 2
+
+/* FIXME: determine dynamically.  */
+#define GRUB_CPU_LOONGSON_SECONDARY_CACHE_LOG_SIZE 19
+
+#define GRUB_CPU_LOONGSON_COP0_BADVADDR GRUB_CPU_REGISTER_WRAP($8)
+#define GRUB_CPU_LOONGSON_COP0_TIMER_COUNT GRUB_CPU_REGISTER_WRAP($9)
+#define GRUB_CPU_LOONGSON_COP0_CAUSE GRUB_CPU_REGISTER_WRAP($13)
+#define GRUB_CPU_LOONGSON_COP0_EPC GRUB_CPU_REGISTER_WRAP($14)
+#define GRUB_CPU_LOONGSON_COP0_CACHE_TAGLO GRUB_CPU_REGISTER_WRAP($28)
+#define GRUB_CPU_LOONGSON_COP0_CACHE_TAGHI GRUB_CPU_REGISTER_WRAP($29)
+
+#define GRUB_CPU_LOONGSON_LIOCFG   0xbfe00108
+#define GRUB_CPU_LOONGSON_ROM_DELAY_OFFSET 2
+#define GRUB_CPU_LOONGSON_ROM_DELAY_MASK 0x1f
+#define GRUB_CPU_LOONGSON_CORECFG   0xbfe00180
+#define GRUB_CPU_LOONGSON_CORECFG_DISABLE_DDR2_SPACE 0x100
+#define GRUB_CPU_LOONGSON_CORECFG_BUFFER_CPU 0x200
+
+#define GRUB_CPU_LOONGSON_PCI_HIT1_SEL_LO   0xbfe00150
+#define GRUB_CPU_LOONGSON_PCI_HIT1_SEL_HI   0xbfe00154
+
+#define GRUB_CPU_LOONGSON_GPIOCFG  0xbfe00120
+#define GRUB_CPU_LOONGSON_SHUTDOWN_GPIO 1
+
+#endif

include/grub/mips/yeeloong/ec.h

@@ -0,0 +1,41 @@
+/*
+ *  GRUB  --  GRand Unified Bootloader
+ *  Copyright (C) 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/>.
+ */
+
+#ifndef GRUB_EC_MACHINE_HEADER
+#define GRUB_EC_MACHINE_HEADER	1
+
+#define GRUB_MACHINE_EC_MAGIC_PORT1 0x381
+#define GRUB_MACHINE_EC_MAGIC_PORT2 0x382
+#define GRUB_MACHINE_EC_DATA_PORT 0x383
+
+#define GRUB_MACHINE_EC_MAGIC_VAL1 0xf4
+#define GRUB_MACHINE_EC_MAGIC_VAL2 0xec
+
+#define GRUB_MACHINE_EC_COMMAND_REBOOT 1
+
+static inline void
+grub_write_ec (grub_uint8_t value)
+{
+  grub_outb (GRUB_MACHINE_EC_MAGIC_VAL1,
+	     GRUB_MACHINE_PCI_IO_BASE + GRUB_MACHINE_EC_MAGIC_PORT1);
+  grub_outb (GRUB_MACHINE_EC_MAGIC_VAL2,
+	     GRUB_MACHINE_PCI_IO_BASE + GRUB_MACHINE_EC_MAGIC_PORT2);
+  grub_outb (value, GRUB_MACHINE_PCI_IO_BASE + GRUB_MACHINE_EC_DATA_PORT);
+}
+
+#endif

include/grub/mips/yeeloong/serial.h

@@ -19,6 +19,12 @@
 #ifndef GRUB_MACHINE_SERIAL_HEADER
 #define GRUB_MACHINE_SERIAL_HEADER	1
 
-#define GRUB_MACHINE_SERIAL_PORTS { 0xbff003f8 }
+#define GRUB_MACHINE_SERIAL_DIVISOR_115200 2
+#define GRUB_MACHINE_SERIAL_PORT  0xbff003f8
+
+#ifndef ASM_FILE
+#define GRUB_MACHINE_SERIAL_PORTS { GRUB_MACHINE_SERIAL_PORT }
+#else
+#endif
 
 #endif 

include/grub/misc.h

@@ -237,7 +237,19 @@ void *EXPORT_FUNC(grub_memset) (void *s, int c, grub_size_t n);
 grub_size_t EXPORT_FUNC(grub_strlen) (const char *s);
 int EXPORT_FUNC(grub_printf) (const char *fmt, ...) __attribute__ ((format (printf, 1, 2)));
 int EXPORT_FUNC(grub_printf_) (const char *fmt, ...) __attribute__ ((format (printf, 1, 2)));
-int EXPORT_FUNC(grub_puts) (const char *s);
+
+extern void (*EXPORT_VAR (grub_xputs)) (const char *str);
+
+static inline int
+grub_puts (const char *s)
+{
+  const char nl[2] = "\n";
+  grub_xputs (s);
+  grub_xputs (nl);
+
+  return 1;	/* Cannot fail.  */
+}
+
 int EXPORT_FUNC(grub_puts_) (const char *s);
 void EXPORT_FUNC(grub_real_dprintf) (const char *file,
                                      const int line,
@@ -253,11 +265,6 @@ char *EXPORT_FUNC(grub_xasprintf) (const char *fmt, ...)
 char *EXPORT_FUNC(grub_xvasprintf) (const char *fmt, va_list args);
 void EXPORT_FUNC(grub_exit) (void) __attribute__ ((noreturn));
 void EXPORT_FUNC(grub_abort) (void) __attribute__ ((noreturn));
-grub_size_t EXPORT_FUNC(grub_utf8_to_ucs4) (grub_uint32_t *dest,
-					    grub_size_t destsize,
-					    const grub_uint8_t *src,
-					    grub_size_t srcsize,
-					    const grub_uint8_t **srcend);
 grub_uint64_t EXPORT_FUNC(grub_divmod64) (grub_uint64_t n,
 					  grub_uint32_t d, grub_uint32_t *r);
 
@@ -298,14 +305,14 @@ grub_div_roundup (unsigned int x, unsigned int y)
 }
 
 /* Reboot the machine.  */
-void EXPORT_FUNC (grub_reboot) (void);
+void EXPORT_FUNC (grub_reboot) (void) __attribute__ ((noreturn));
 
 #ifdef GRUB_MACHINE_PCBIOS
 /* Halt the system, using APM if possible. If NO_APM is true, don't
  * use APM even if it is available.  */
-void EXPORT_FUNC (grub_halt) (int no_apm);
+void EXPORT_FUNC (grub_halt) (int no_apm) __attribute__ ((noreturn));
 #else
-void EXPORT_FUNC (grub_halt) (void);
+void EXPORT_FUNC (grub_halt) (void) __attribute__ ((noreturn));
 #endif
 
 #endif /* ! GRUB_MISC_HEADER */

include/grub/normal.h

@@ -77,8 +77,10 @@ void grub_parse_color_name_pair (grub_uint8_t *ret, const char *name);
 
 /* Defined in `menu_text.c'.  */
 void grub_wait_after_message (void);
-void grub_print_ucs4 (const grub_uint32_t * str,
+void
+grub_print_ucs4 (const grub_uint32_t * str,
 		 const grub_uint32_t * last_position,
+		 int margin_left, int margin_right,
 		 struct grub_term_output *term);
 grub_ssize_t grub_getstringwidth (grub_uint32_t * str,
 				  const grub_uint32_t * last_position,
@@ -110,7 +112,9 @@ void read_terminal_list (const char *prefix);
 
 void grub_set_more (int onoff);
 
-int grub_normal_get_line_counter (void);
+int grub_normal_get_char_counter (void);
-void grub_install_newline_hook (void);
+void grub_normal_reset_more (void);
+
+void grub_xputs_normal (const char *str);
 
 #endif /* ! GRUB_NORMAL_HEADER */

include/grub/parser.h

@@ -22,7 +22,6 @@
 
 #include <grub/types.h>
 #include <grub/err.h>
-#include <grub/handler.h>
 #include <grub/reader.h>
 
 /* All the states for the command line.  */
@@ -84,36 +83,9 @@ struct grub_parser
 };
 typedef struct grub_parser *grub_parser_t;
 
-extern struct grub_handler_class EXPORT_VAR(grub_parser_class);
+grub_err_t grub_parser_execute (char *source);
-grub_err_t EXPORT_FUNC(grub_parser_execute) (char *source);
 
-static inline void
+grub_err_t
-grub_parser_register (const char *name __attribute__ ((unused)),
+grub_rescue_parse_line (char *line, grub_reader_getline_t getline);
-		      /* `name' is ignored here, but used by genhandlerlist.sh.  */
-		      grub_parser_t parser)
-{
-  grub_handler_register (&grub_parser_class, GRUB_AS_HANDLER (parser));
-}
-
-static inline void
-grub_parser_unregister (grub_parser_t parser)
-{
-  grub_handler_unregister (&grub_parser_class, GRUB_AS_HANDLER (parser));
-}
-
-static inline grub_parser_t
-grub_parser_get_current (void)
-{
-  return (grub_parser_t) grub_parser_class.cur_handler;
-}
-
-static inline grub_err_t
-grub_parser_set_current (grub_parser_t parser)
-{
-  return grub_handler_set_current (&grub_parser_class,
-				   GRUB_AS_HANDLER (parser));
-}
-
-void grub_register_rescue_parser (void);
 
 #endif /* ! GRUB_PARSER_HEADER */

include/grub/partition.h

@@ -48,7 +48,7 @@ struct grub_partition
   /* The partition number.  */
   int number;
 
-  /* The start sector.  */
+  /* The start sector (relative to parent).  */
   grub_disk_addr_t start;
 
   /* The length in sector units.  */
@@ -60,7 +60,7 @@ struct grub_partition
   /* The index of this partition in the partition table.  */
   int index;
 
-  /* Parent partition map.  */
+  /* Parent partition (physically contains this partition).  */
   struct grub_partition *parent;
 
   /* The type partition map.  */
@@ -77,12 +77,14 @@ char *EXPORT_FUNC(grub_partition_get_name) (const grub_partition_t partition);
 
 extern grub_partition_map_t EXPORT_VAR(grub_partition_map_list);
 
+#ifndef GRUB_LST_GENERATOR
 static inline void
 grub_partition_map_register (grub_partition_map_t partmap)
 {
   grub_list_push (GRUB_AS_LIST_P (&grub_partition_map_list),
 		  GRUB_AS_LIST (partmap));
 }
+#endif
 
 static inline void
 grub_partition_map_unregister (grub_partition_map_t partmap)
@@ -91,7 +93,7 @@ grub_partition_map_unregister (grub_partition_map_t partmap)
 		    GRUB_AS_LIST (partmap));
 }
 
-#define FOR_PARTITION_MAPS(var) for (var = grub_partition_map_list; var; var = var->next)
+#define FOR_PARTITION_MAPS(var) FOR_LIST_ELEMENTS((var), (grub_partition_map_list))
 
 
 static inline grub_disk_addr_t

include/grub/powerpc/ieee1275/console.h

@@ -1,28 +0,0 @@
-/*
- *  GRUB  --  GRand Unified Bootloader
- *  Copyright (C) 2002,2004,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/>.
- */
-
-#ifndef GRUB_CONSOLE_MACHINE_HEADER
-#define GRUB_CONSOLE_MACHINE_HEADER	1
-
-/* Initialize the console system.  */
-void grub_console_init (void);
-
-/* Finish the console system.  */
-void grub_console_fini (void);
-
-#endif /* ! GRUB_CONSOLE_MACHINE_HEADER */

include/grub/script_sh.h

@@ -324,11 +324,15 @@ struct grub_script_function
 };
 typedef struct grub_script_function *grub_script_function_t;
 
+extern grub_script_function_t grub_script_function_list;
+
+#define FOR_SCRIPT_FUNCTIONS(var) for((var) = grub_script_function_list; \
+				      (var); (var) = (var)->next)
+
 grub_script_function_t grub_script_function_create (struct grub_script_arg *functionname,
 						    struct grub_script *cmd);
 void grub_script_function_remove (const char *name);
 grub_script_function_t grub_script_function_find (char *functionname);
-int grub_script_function_iterate (int (*iterate) (grub_script_function_t));
 grub_err_t grub_script_function_call (grub_script_function_t func,
 				      int argc, char **args);
 
@@ -351,4 +355,7 @@ grub_script_put (struct grub_script *script)
     script->refcnt--;
 }
 
+grub_err_t
+grub_normal_parse_line (char *line, grub_reader_getline_t getline);
+
 #endif /* ! GRUB_NORMAL_PARSER_HEADER */

include/grub/scsi.h

@@ -26,16 +26,35 @@ void grub_scsi_dev_unregister (grub_scsi_dev_t dev);
 
 struct grub_scsi;
 
+enum
+  {
+    GRUB_SCSI_SUBSYSTEM_USBMS,
+    GRUB_SCSI_SUBSYSTEM_ATAPI
+  };
+
+#define GRUB_SCSI_ID_SUBSYSTEM_SHIFT 24
+#define GRUB_SCSI_ID_BUS_SHIFT 8
+#define GRUB_SCSI_ID_LUN_SHIFT 0
+
+static inline grub_uint32_t
+grub_make_scsi_id (int subsystem, int bus, int lun)
+{
+  return (subsystem << GRUB_SCSI_ID_SUBSYSTEM_SHIFT)
+    | (bus << GRUB_SCSI_ID_BUS_SHIFT) | (lun << GRUB_SCSI_ID_BUS_SHIFT);
+}
+
 struct grub_scsi_dev
 {
   /* The device name.  */
   const char *name;
 
+  grub_uint8_t id;
+
   /* Call HOOK with each device name, until HOOK returns non-zero.  */
-  int (*iterate) (int (*hook) (const char *name, int luns));
+  int (*iterate) (int (*hook) (int bus, int luns));
 
   /* Open the device named NAME, and set up SCSI.  */
-  grub_err_t (*open) (const char *name, struct grub_scsi *scsi);
+  grub_err_t (*open) (int bus, struct grub_scsi *scsi);
 
   /* Close the scsi device SCSI.  */
   void (*close) (struct grub_scsi *scsi);
@@ -56,15 +75,14 @@ struct grub_scsi_dev
 
 struct grub_scsi
 {
-  /* The scsi device name.  */
-  char *name;
-
   /* The underlying scsi device.  */
   grub_scsi_dev_t dev;
 
   /* Type of SCSI device.  XXX: Make enum.  */
   grub_uint8_t devtype;
 
+  int bus;
+
   /* Number of LUNs.  */
   int luns;
 

include/grub/serial.h

@@ -59,9 +59,15 @@
 #define UART_DLAB	0x80
 
 /* Enable the FIFO.  */
-#define UART_ENABLE_FIFO	0xC7
+#define UART_ENABLE_FIFO_TRIGGER14	0xC7
+
+/* Enable the FIFO.  */
+#define UART_ENABLE_FIFO_TRIGGER1       0x07
 
 /* Turn on DTR, RTS, and OUT2.  */
-#define UART_ENABLE_MODEM	0x0B
+#define UART_ENABLE_DTRRTS	0x03
+
+/* Turn on DTR, RTS, and OUT2.  */
+#define UART_ENABLE_OUT2	0x08
 
 #endif /* ! GRUB_SERIAL_MACHINE_HEADER */

include/grub/sparc64/ieee1275/console.h

@@ -1,28 +0,0 @@
-/*
- *  GRUB  --  GRand Unified Bootloader
- *  Copyright (C) 2002,2004,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/>.
- */
-
-#ifndef GRUB_CONSOLE_MACHINE_HEADER
-#define GRUB_CONSOLE_MACHINE_HEADER	1
-
-/* Initialize the console system.  */
-void grub_console_init (void);
-
-/* Finish the console system.  */
-void grub_console_fini (void);
-
-#endif /* ! GRUB_CONSOLE_MACHINE_HEADER */

include/grub/term.h

@@ -38,7 +38,8 @@
 #include <grub/err.h>
 #include <grub/symbol.h>
 #include <grub/types.h>
-#include <grub/handler.h>
+#include <grub/unicode.h>
+#include <grub/list.h>
 
 /* These are used to represent the various color states we use.  */
 typedef enum
@@ -68,6 +69,20 @@ grub_term_color_state;
 #define GRUB_TERM_NO_EDIT	        (1 << 1)
 /* Set when the terminal cannot do fancy things.  */
 #define GRUB_TERM_DUMB		        (1 << 2)
+/* Which encoding does terminal expect stream to be.  */
+#define GRUB_TERM_CODE_TYPE_SHIFT       3
+#define GRUB_TERM_CODE_TYPE_MASK	        (7 << GRUB_TERM_CODE_TYPE_SHIFT)
+/* Only ASCII characters accepted.  */
+#define GRUB_TERM_CODE_TYPE_ASCII	        (0 << GRUB_TERM_CODE_TYPE_SHIFT)
+/* Expects CP-437 characters (ASCII + pseudographics).  */
+#define GRUB_TERM_CODE_TYPE_CP437	                (1 << GRUB_TERM_CODE_TYPE_SHIFT)
+/* UTF-8 stream in logical order. Usually used for terminals
+   which just forward the stream to another computer.  */
+#define GRUB_TERM_CODE_TYPE_UTF8_LOGICAL	(2 << GRUB_TERM_CODE_TYPE_SHIFT)
+/* UTF-8 in visual order. Like UTF-8 logical but for buggy endpoints.  */
+#define GRUB_TERM_CODE_TYPE_UTF8_VISUAL	        (3 << GRUB_TERM_CODE_TYPE_SHIFT)
+/* Glyph description in visual order.  */
+#define GRUB_TERM_CODE_TYPE_VISUAL_GLYPHS       (4 << GRUB_TERM_CODE_TYPE_SHIFT)
 
 
 /* Bitmasks for modifier keys returned by grub_getkeystatus.  */
@@ -75,20 +90,6 @@ grub_term_color_state;
 #define GRUB_TERM_STATUS_CTRL	(1 << 1)
 #define GRUB_TERM_STATUS_ALT	(1 << 2)
 
-
-/* Unicode characters for fancy graphics.  */
-#define GRUB_TERM_DISP_LEFT	0x2190
-#define GRUB_TERM_DISP_UP	0x2191
-#define GRUB_TERM_DISP_RIGHT	0x2192
-#define GRUB_TERM_DISP_DOWN	0x2193
-#define GRUB_TERM_DISP_HLINE	0x2501
-#define GRUB_TERM_DISP_VLINE	0x2503
-#define GRUB_TERM_DISP_UL	0x250F
-#define GRUB_TERM_DISP_UR	0x2513
-#define GRUB_TERM_DISP_LL	0x2517
-#define GRUB_TERM_DISP_LR	0x251B
-
-
 /* Menu-related geometrical constants.  */
 
 /* The number of lines of "GRUB version..." at the top.  */
@@ -122,19 +123,21 @@ struct grub_term_input
   const char *name;
 
   /* Initialize the terminal.  */
-  grub_err_t (*init) (void);
+  grub_err_t (*init) (struct grub_term_input *term);
 
   /* Clean up the terminal.  */
-  grub_err_t (*fini) (void);
+  grub_err_t (*fini) (struct grub_term_input *term);
 
   /* Check if any input character is available.  */
-  int (*checkkey) (void);
+  int (*checkkey) (struct grub_term_input *term);
 
   /* Get a character.  */
-  int (*getkey) (void);
+  int (*getkey) (struct grub_term_input *term);
 
   /* Get keyboard modifier status.  */
-  int (*getkeystatus) (void);
+  int (*getkeystatus) (struct grub_term_input *term);
+
+  void *data;
 };
 typedef struct grub_term_input *grub_term_input_t;
 
@@ -147,52 +150,58 @@ struct grub_term_output
   const char *name;
 
   /* Initialize the terminal.  */
-  grub_err_t (*init) (void);
+  grub_err_t (*init) (struct grub_term_output *term);
 
   /* Clean up the terminal.  */
-  grub_err_t (*fini) (void);
+  grub_err_t (*fini) (struct grub_term_output *term);
 
   /* Put a character. C is encoded in Unicode.  */
-  void (*putchar) (grub_uint32_t c);
+  void (*putchar) (struct grub_term_output *term,
+		   const struct grub_unicode_glyph *c);
 
   /* Get the number of columns occupied by a given character C. C is
      encoded in Unicode.  */
-  grub_ssize_t (*getcharwidth) (grub_uint32_t c);
+  grub_ssize_t (*getcharwidth) (struct grub_term_output *term,
+				const struct grub_unicode_glyph *c);
 
   /* Get the screen size. The return value is ((Width << 8) | Height).  */
-  grub_uint16_t (*getwh) (void);
+  grub_uint16_t (*getwh) (struct grub_term_output *term);
 
   /* Get the cursor position. The return value is ((X << 8) | Y).  */
-  grub_uint16_t (*getxy) (void);
+  grub_uint16_t (*getxy) (struct grub_term_output *term);
 
   /* Go to the position (X, Y).  */
-  void (*gotoxy) (grub_uint8_t x, grub_uint8_t y);
+  void (*gotoxy) (struct grub_term_output *term,
+		  grub_uint8_t x, grub_uint8_t y);
 
   /* Clear the screen.  */
-  void (*cls) (void);
+  void (*cls) (struct grub_term_output *term);
 
   /* Set the current color to be used */
-  void (*setcolorstate) (grub_term_color_state state);
+  void (*setcolorstate) (struct grub_term_output *term,
-
+			 grub_term_color_state state);
-  /* Set the normal color and the highlight color. The format of each
-     color is VGA's.  */
-  void (*setcolor) (grub_uint8_t normal_color, grub_uint8_t highlight_color);
-
-  /* Get the normal color and the highlight color. The format of each
-     color is VGA's.  */
-  void (*getcolor) (grub_uint8_t *normal_color, grub_uint8_t *highlight_color);
 
   /* Turn on/off the cursor.  */
-  void (*setcursor) (int on);
+  void (*setcursor) (struct grub_term_output *term, int on);
 
   /* Update the screen.  */
-  void (*refresh) (void);
+  void (*refresh) (struct grub_term_output *term);
 
   /* The feature flags defined above.  */
   grub_uint32_t flags;
+
+  /* Current color state.  */
+  grub_uint8_t normal_color;
+  grub_uint8_t highlight_color;
+
+  void *data;
 };
 typedef struct grub_term_output *grub_term_output_t;
 
+#define GRUB_TERM_DEFAULT_NORMAL_COLOR 0x07
+#define GRUB_TERM_DEFAULT_HIGHLIGHT_COLOR 0x70
+#define GRUB_TERM_DEFAULT_STANDARD_COLOR 0x07
+
 extern struct grub_term_output *EXPORT_VAR(grub_term_outputs_disabled);
 extern struct grub_term_input *EXPORT_VAR(grub_term_inputs_disabled);
 extern struct grub_term_output *EXPORT_VAR(grub_term_outputs);
@@ -208,11 +217,19 @@ grub_term_register_input (const char *name __attribute__ ((unused)),
   else
     {
       /* If this is the first terminal, enable automatically.  */
-      if (! term->init || term->init () == GRUB_ERR_NONE)
+      if (! term->init || term->init (term) == GRUB_ERR_NONE)
 	grub_list_push (GRUB_AS_LIST_P (&grub_term_inputs), GRUB_AS_LIST (term));
     }
 }
 
+static inline void
+grub_term_register_input_active (const char *name __attribute__ ((unused)),
+				 grub_term_input_t term)
+{
+  if (! term->init || term->init (term) == GRUB_ERR_NONE)
+    grub_list_push (GRUB_AS_LIST_P (&grub_term_inputs), GRUB_AS_LIST (term));
+}
+
 static inline void
 grub_term_register_output (const char *name __attribute__ ((unused)),
 			   grub_term_output_t term)
@@ -223,12 +240,21 @@ grub_term_register_output (const char *name __attribute__ ((unused)),
   else
     {
       /* If this is the first terminal, enable automatically.  */
-      if (! term->init || term->init () == GRUB_ERR_NONE)
+      if (! term->init || term->init (term) == GRUB_ERR_NONE)
 	grub_list_push (GRUB_AS_LIST_P (&grub_term_outputs),
 			GRUB_AS_LIST (term));
     }
 }
 
+static inline void
+grub_term_register_output_active (const char *name __attribute__ ((unused)),
+				  grub_term_output_t term)
+{
+  if (! term->init || term->init (term) == GRUB_ERR_NONE)
+    grub_list_push (GRUB_AS_LIST_P (&grub_term_outputs),
+		    GRUB_AS_LIST (term));
+}
+
 static inline void
 grub_term_unregister_input (grub_term_input_t term)
 {
@@ -245,19 +271,16 @@ grub_term_unregister_output (grub_term_output_t term)
 		    GRUB_AS_LIST (term));
 }
 
-#define FOR_ACTIVE_TERM_INPUTS(var) for (var = grub_term_inputs; var; var = var->next)
+#define FOR_ACTIVE_TERM_INPUTS(var) FOR_LIST_ELEMENTS((var), (grub_term_inputs))
-#define FOR_DISABLED_TERM_INPUTS(var) for (var = grub_term_inputs_disabled; var; var = var->next)
+#define FOR_DISABLED_TERM_INPUTS(var) FOR_LIST_ELEMENTS((var), (grub_term_inputs_disabled))
-#define FOR_ACTIVE_TERM_OUTPUTS(var) for (var = grub_term_outputs; var; var = var->next)
+#define FOR_ACTIVE_TERM_OUTPUTS(var) FOR_LIST_ELEMENTS((var), (grub_term_outputs))
-#define FOR_DISABLED_TERM_OUTPUTS(var) for (var = grub_term_outputs_disabled; var; var = var->next)
+#define FOR_DISABLED_TERM_OUTPUTS(var) FOR_LIST_ELEMENTS((var), (grub_term_outputs_disabled))
 
-void EXPORT_FUNC(grub_putchar) (int c);
+void grub_putcode (grub_uint32_t code, struct grub_term_output *term);
-void EXPORT_FUNC(grub_putcode) (grub_uint32_t code,
-				struct grub_term_output *term);
 int EXPORT_FUNC(grub_getkey) (void);
 int EXPORT_FUNC(grub_checkkey) (void);
 int EXPORT_FUNC(grub_getkeystatus) (void);
-void EXPORT_FUNC(grub_cls) (void);
+void grub_cls (void);
-void EXPORT_FUNC(grub_setcolorstate) (grub_term_color_state state);
 void EXPORT_FUNC(grub_refresh) (void);
 void grub_puts_terminal (const char *str, struct grub_term_output *term);
 grub_uint16_t *grub_term_save_pos (void);
@@ -265,12 +288,12 @@ void grub_term_restore_pos (grub_uint16_t *pos);
 
 static inline unsigned grub_term_width (struct grub_term_output *term)
 {
-  return ((term->getwh()&0xFF00)>>8);
+  return ((term->getwh(term)&0xFF00)>>8);
 }
 
 static inline unsigned grub_term_height (struct grub_term_output *term)
 {
-  return (term->getwh()&0xFF);
+  return (term->getwh(term)&0xFF);
 }
 
 /* The width of the border.  */
@@ -314,20 +337,20 @@ grub_term_cursor_x (struct grub_term_output *term)
 static inline grub_uint16_t
 grub_term_getxy (struct grub_term_output *term)
 {
-  return term->getxy ();
+  return term->getxy (term);
 }
 
 static inline void
 grub_term_refresh (struct grub_term_output *term)
 {
   if (term->refresh)
-    term->refresh ();
+    term->refresh (term);
 }
 
 static inline void
 grub_term_gotoxy (struct grub_term_output *term, grub_uint8_t x, grub_uint8_t y)
 {
-  term->gotoxy (x, y);
+  term->gotoxy (term, x, y);
 }
 
 static inline void 
@@ -335,7 +358,16 @@ grub_term_setcolorstate (struct grub_term_output *term,
 			 grub_term_color_state state)
 {
   if (term->setcolorstate)
-    term->setcolorstate (state);
+    term->setcolorstate (term, state);
+}
+
+static inline void
+grub_setcolorstate (grub_term_color_state state)
+{
+  struct grub_term_output *term;
+  
+  FOR_ACTIVE_TERM_OUTPUTS(term)
+    grub_term_setcolorstate (term, state);
 }
 
 /* Set the normal color and the highlight color. The format of each
@@ -344,8 +376,8 @@ static inline void
 grub_term_setcolor (struct grub_term_output *term,
 		    grub_uint8_t normal_color, grub_uint8_t highlight_color)
 {
-  if (term->setcolor)
+  term->normal_color = normal_color;
-    term->setcolor (normal_color, highlight_color);
+  term->highlight_color = highlight_color;
 }
 
 /* Turn on/off the cursor.  */
@@ -353,14 +385,14 @@ static inline void
 grub_term_setcursor (struct grub_term_output *term, int on)
 {
   if (term->setcursor)
-    term->setcursor (on);
+    term->setcursor (term, on);
 }
 
 static inline void 
 grub_term_cls (struct grub_term_output *term)
 {
   if (term->cls)
-    (term->cls) ();
+    (term->cls) (term);
   else
     {
       grub_putcode ('\n', term);
@@ -368,11 +400,36 @@ grub_term_cls (struct grub_term_output *term)
     }
 }
 
+#ifdef HAVE_UNIFONT_WIDTHSPEC
+
+grub_ssize_t
+grub_unicode_estimate_width (const struct grub_unicode_glyph *c);
+
+#else
+
 static inline grub_ssize_t
-grub_term_getcharwidth (struct grub_term_output *term, grub_uint32_t c)
+grub_unicode_estimate_width (const struct grub_unicode_glyph *c __attribute__ ((unused)))
+{
+  if (grub_unicode_get_comb_type (c->base))
+    return 0;
+  return 1;
+}
+
+#endif
+
+static inline grub_ssize_t 
+grub_term_getcharwidth (struct grub_term_output *term,
+			const struct grub_unicode_glyph *c)
 {
   if (term->getcharwidth)
-    return term->getcharwidth (c);
+    return term->getcharwidth (term, c);
+  else if (((term->flags & GRUB_TERM_CODE_TYPE_MASK)
+	    == GRUB_TERM_CODE_TYPE_UTF8_LOGICAL)
+	   || ((term->flags & GRUB_TERM_CODE_TYPE_MASK)
+	       == GRUB_TERM_CODE_TYPE_UTF8_VISUAL)
+	   || ((term->flags & GRUB_TERM_CODE_TYPE_MASK)
+	       == GRUB_TERM_CODE_TYPE_VISUAL_GLYPHS))
+    return grub_unicode_estimate_width (c);
   else
     return 1;
 }
@@ -381,16 +438,9 @@ static inline void
 grub_term_getcolor (struct grub_term_output *term, 
 		    grub_uint8_t *normal_color, grub_uint8_t *highlight_color)
 {
-  if (term->getcolor)
+  *normal_color = term->normal_color;
-    term->getcolor (normal_color, highlight_color);
+  *highlight_color = term->highlight_color;
-  else
-    {
-      *normal_color = 0x07;
-      *highlight_color = 0x07;
 }
-}
-
-extern void (*EXPORT_VAR (grub_newline_hook)) (void);
 
 struct grub_term_autoload
 {

include/grub/terminfo.h

@@ -23,15 +23,55 @@
 #include <grub/types.h>
 #include <grub/term.h>
 
-char *grub_terminfo_get_current (void);
+char *EXPORT_FUNC(grub_terminfo_get_current) (struct grub_term_output *term);
-grub_err_t grub_terminfo_set_current (const char *);
+grub_err_t EXPORT_FUNC(grub_terminfo_set_current) (struct grub_term_output *term,
+												const char *);
 
-void grub_terminfo_gotoxy (grub_uint8_t x, grub_uint8_t y,
+#define GRUB_TERMINFO_READKEY_MAX_LEN 4
-			   grub_term_output_t oterm);
+struct grub_terminfo_input_state
-void grub_terminfo_cls (grub_term_output_t oterm);
+{
-void grub_terminfo_reverse_video_on (grub_term_output_t oterm);
+  int input_buf[GRUB_TERMINFO_READKEY_MAX_LEN];
-void grub_terminfo_reverse_video_off (grub_term_output_t oterm);
+  int npending;
-void grub_terminfo_cursor_on (grub_term_output_t oterm);
+  int (*readkey) (void);
-void grub_terminfo_cursor_off (grub_term_output_t oterm);
+};
+
+struct grub_terminfo_output_state
+{
+  struct grub_term_output *next;
+
+  char *name;
+
+  char *gotoxy;
+  char *cls;
+  char *reverse_video_on;
+  char *reverse_video_off;
+  char *cursor_on;
+  char *cursor_off;
+  char *setcolor;
+
+  unsigned int xpos, ypos;
+
+  void (*put) (const int c);
+};
+
+void EXPORT_FUNC(grub_terminfo_gotoxy) (grub_term_output_t term,
+					grub_uint8_t x, grub_uint8_t y);
+void EXPORT_FUNC(grub_terminfo_cls) (grub_term_output_t term);
+grub_uint16_t EXPORT_FUNC (grub_terminfo_getxy) (struct grub_term_output *term);
+void EXPORT_FUNC (grub_terminfo_setcursor) (struct grub_term_output *term,
+					    const int on);
+void EXPORT_FUNC (grub_terminfo_setcolorstate) (struct grub_term_output *term,
+				  const grub_term_color_state state);
+
+
+int EXPORT_FUNC (grub_terminfo_checkkey) (struct grub_term_input *term);
+grub_err_t EXPORT_FUNC (grub_terminfo_input_init) (struct grub_term_input *term);
+int EXPORT_FUNC (grub_terminfo_getkey) (struct grub_term_input *term);
+void EXPORT_FUNC (grub_terminfo_putchar) (struct grub_term_output *term,
+					  const struct grub_unicode_glyph *c);
+
+grub_err_t EXPORT_FUNC (grub_terminfo_output_register) (struct grub_term_output *term,
+							const char *type);
+grub_err_t EXPORT_FUNC (grub_terminfo_output_unregister) (struct grub_term_output *term);
 
 #endif /* ! GRUB_TERMINFO_HEADER */

include/grub/types.h

@@ -60,7 +60,7 @@
 typedef signed char		grub_int8_t;
 typedef short			grub_int16_t;
 typedef int			grub_int32_t;
-#if GRUB_CPU_SIZEOF_VOID_P == 8
+#if GRUB_CPU_SIZEOF_LONG == 8
 typedef long			grub_int64_t;
 #else
 typedef long long		grub_int64_t;
@@ -69,7 +69,7 @@ typedef long long		grub_int64_t;
 typedef unsigned char		grub_uint8_t;
 typedef unsigned short		grub_uint16_t;
 typedef unsigned		grub_uint32_t;
-#if GRUB_CPU_SIZEOF_VOID_P == 8
+#if GRUB_CPU_SIZEOF_LONG == 8
 typedef unsigned long		grub_uint64_t;
 #else
 typedef unsigned long long	grub_uint64_t;
@@ -92,13 +92,21 @@ typedef grub_int32_t	grub_target_ssize_t;
 typedef grub_uint64_t	grub_addr_t;
 typedef grub_uint64_t	grub_size_t;
 typedef grub_int64_t	grub_ssize_t;
+
+# if GRUB_CPU_SIZEOF_LONG == 8
+#  define PRIxGRUB_SIZE	"lx"
+# else
+#  define PRIxGRUB_SIZE	"llx"
+# endif
 #else
 typedef grub_uint32_t	grub_addr_t;
 typedef grub_uint32_t	grub_size_t;
 typedef grub_int32_t	grub_ssize_t;
+
+# define PRIxGRUB_SIZE	"x"
 #endif
 
-#if GRUB_CPU_SIZEOF_VOID_P == 8
+#if GRUB_CPU_SIZEOF_LONG == 8
 # define GRUB_ULONG_MAX 18446744073709551615UL
 # define GRUB_LONG_MAX 9223372036854775807L
 # define GRUB_LONG_MIN (-9223372036854775807L - 1)