262 files changed, 7831 insertions, 4993 deletions

diff --git a/Documentation/kernel-parameters.txt b/Documentation/kernel-parameters.txt
index 5fbe07706ae9..fb80e9ffea68 100644
--- a/Documentation/kernel-parameters.txt
+++ b/Documentation/kernel-parameters.txt
@@ -1882,7 +1882,7 @@ and is between 256 and 4096 characters. It is defined in the file
         usbhid.mousepoll=
                         [USBHID] The interval which mice are to be polled at.
 
-        vdso=           [IA-32,SH]
+        vdso=           [IA-32,SH,x86-64]
                         vdso=2: enable compat VDSO (default with COMPAT_VDSO)
                         vdso=1: enable VDSO (default)
                         vdso=0: disable VDSO mapping
diff --git a/Documentation/power/freezing-of-tasks.txt b/Documentation/power/freezing-of-tasks.txt
index af1a282c71a3..04dc1cf9d215 100644
--- a/Documentation/power/freezing-of-tasks.txt
+++ b/Documentation/power/freezing-of-tasks.txt
@@ -155,6 +155,8 @@ Suppose, however, that the firmware file is located on a filesystem accessible
 only through another device that hasn't been resumed yet.  In that case,
 request_firmware() will fail regardless of whether or not the freezing of tasks
 is used.  Consequently, the problem is not really related to the freezing of
-tasks, since it generally exists anyway.  [The solution to this particular
-problem is to keep the firmware in memory after it's loaded for the first time
-and upload if from memory to the device whenever necessary.]
+tasks, since it generally exists anyway.
+
+A driver must have all firmwares it may need in RAM before suspend() is called.
+If keeping them is not practical, for example due to their size, they must be
+requested early enough using the suspend notifier API described in notifiers.txt.
diff --git a/Documentation/x86_64/boot-options.txt b/Documentation/x86_64/boot-options.txt
index 6177d881983f..945311840a10 100644
--- a/Documentation/x86_64/boot-options.txt
+++ b/Documentation/x86_64/boot-options.txt
@@ -14,9 +14,11 @@ Machine check
    mce=nobootlog
                 Disable boot machine check logging.
    mce=tolerancelevel (number)
-                0: always panic, 1: panic if deadlock possible,
-                2: try to avoid panic, 3: never panic or exit (for testing)
-                default is 1
+                0: always panic on uncorrected errors, log corrected errors
+                1: panic or SIGBUS on uncorrected errors, log corrected errors
+                2: SIGBUS or log uncorrected errors, log corrected errors
+                3: never panic or SIGBUS, log all errors (for testing only)
+                Default is 1
                 Can be also set using sysfs which is preferable.
 
    nomce (for compatibility with i386): same as mce=off
@@ -134,12 +136,6 @@ Non Executable Mappings
 
 SMP
 
-  nosmp Only use a single CPU
-
-  maxcpus=NUMBER only use upto NUMBER CPUs
-
-  cpumask=MASK   only use cpus with bits set in mask
-
   additional_cpus=NUM Allow NUM more CPUs for hotplug
                  (defaults are specified by the BIOS, see Documentation/x86_64/cpu-hotplug-spec)
 
diff --git a/Documentation/x86_64/machinecheck b/Documentation/x86_64/machinecheck
index feaeaf6f6e4d..a05e58e7b159 100644
--- a/Documentation/x86_64/machinecheck
+++ b/Documentation/x86_64/machinecheck
@@ -49,12 +49,14 @@ tolerant
         Since machine check exceptions can happen any time it is sometimes
         risky for the kernel to kill a process because it defies
         normal kernel locking rules. The tolerance level configures
-        how hard the kernel tries to recover even at some risk of deadlock.
-
-        0: always panic,
-        1: panic if deadlock possible,
-        2: try to avoid panic,
-        3: never panic or exit (for testing only)
+        how hard the kernel tries to recover even at some risk of
+        deadlock.  Higher tolerant values trade potentially better uptime
+        with the risk of a crash or even corruption (for tolerant >= 3).
+
+        0: always panic on uncorrected errors, log corrected errors
+        1: panic or SIGBUS on uncorrected errors, log corrected errors
+        2: SIGBUS or log uncorrected errors, log corrected errors
+        3: never panic or SIGBUS, log all errors (for testing only)
 
         Default: 1
 
diff --git a/MAINTAINERS b/MAINTAINERS
index f49c5563f060..773c732b4177 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -651,7 +651,12 @@ W:	http://linux-atm.sourceforge.net
 S:      Maintained
 
 ATMEL AT91 MCI DRIVER
-S:      Orphan
+P:      Nicolas Ferre
+M:      nicolas.ferre@rfo.atmel.com
+L:      linux-arm-kernel@lists.arm.linux.org.uk (subscribers-only)
+W:      http://www.atmel.com/products/AT91/
+W:      http://www.at91.com/
+S:      Maintained
 
 ATMEL MACB ETHERNET DRIVER
 P:      Haavard Skinnemoen
diff --git a/arch/arm/mach-davinci/time.c b/arch/arm/mach-davinci/time.c
index 4d8425de6922..e96a3dcdc1a7 100644
--- a/arch/arm/mach-davinci/time.c
+++ b/arch/arm/mach-davinci/time.c
@@ -285,6 +285,8 @@ static void davinci_set_mode(enum clock_event_mode mode,
         case CLOCK_EVT_MODE_SHUTDOWN:
                 t->opts = TIMER_OPTS_DISABLED;
                 break;
+        case CLOCK_EVT_MODE_RESUME:
+                break;
         }
 }
 
diff --git a/arch/arm/mach-imx/time.c b/arch/arm/mach-imx/time.c
index 010f6fa984a6..d86d124aea22 100644
--- a/arch/arm/mach-imx/time.c
+++ b/arch/arm/mach-imx/time.c
@@ -159,6 +159,7 @@ static void imx_set_mode(enum clock_event_mode mode, struct clock_event_device *
                 break;
         case CLOCK_EVT_MODE_SHUTDOWN:
         case CLOCK_EVT_MODE_UNUSED:
+        case CLOCK_EVT_MODE_RESUME:
                 /* Left event sources disabled, no more interrupts appears */
                 break;
         }
diff --git a/arch/arm/mach-ixp4xx/common.c b/arch/arm/mach-ixp4xx/common.c
index 8112f726ffa0..23e7fba6d3e1 100644
--- a/arch/arm/mach-ixp4xx/common.c
+++ b/arch/arm/mach-ixp4xx/common.c
@@ -459,6 +459,8 @@ static void ixp4xx_set_mode(enum clock_event_mode mode,
         default:
                 osrt = opts = 0;
                 break;
+        case CLOCK_EVT_MODE_RESUME:
+                break;
         }
 
         *IXP4XX_OSRT1 = osrt | opts;
diff --git a/arch/arm/mach-omap1/time.c b/arch/arm/mach-omap1/time.c
index 3705d20c4e5c..237651ebae5d 100644
--- a/arch/arm/mach-omap1/time.c
+++ b/arch/arm/mach-omap1/time.c
@@ -156,6 +156,7 @@ static void omap_mpu_set_mode(enum clock_event_mode mode,
                 break;
         case CLOCK_EVT_MODE_UNUSED:
         case CLOCK_EVT_MODE_SHUTDOWN:
+        case CLOCK_EVT_MODE_RESUME:
                 break;
         }
 }
diff --git a/arch/arm/plat-omap/timer32k.c b/arch/arm/plat-omap/timer32k.c
index 2feceec8eccd..b0af014b0e2c 100644
--- a/arch/arm/plat-omap/timer32k.c
+++ b/arch/arm/plat-omap/timer32k.c
@@ -156,6 +156,8 @@ static void omap_32k_timer_set_mode(enum clock_event_mode mode,
         case CLOCK_EVT_MODE_SHUTDOWN:
                 omap_32k_timer_stop();
                 break;
+        case CLOCK_EVT_MODE_RESUME:
+                break;
         }
 }
 
diff --git a/arch/i386/Kconfig b/arch/i386/Kconfig
index 7a11b905ef49..abb582bc218f 100644
--- a/arch/i386/Kconfig
+++ b/arch/i386/Kconfig
@@ -18,6 +18,10 @@ config GENERIC_TIME
         bool
         default y
 
+config GENERIC_CMOS_UPDATE
+        bool
+        default y
+
 config CLOCKSOURCE_WATCHDOG
         bool
         default y
@@ -544,6 +548,7 @@ config HIGHMEM4G
 config HIGHMEM64G
         bool "64GB"
         depends on !M386 && !M486
+        select X86_PAE
         help
           Select this if you have a 32-bit processor and more than 4
           gigabytes of physical RAM.
@@ -573,12 +578,12 @@ choice
         config VMSPLIT_3G
                 bool "3G/1G user/kernel split"
         config VMSPLIT_3G_OPT
-                depends on !HIGHMEM
+                depends on !X86_PAE
                 bool "3G/1G user/kernel split (for full 1G low memory)"
         config VMSPLIT_2G
                 bool "2G/2G user/kernel split"
         config VMSPLIT_2G_OPT
-                depends on !HIGHMEM
+                depends on !X86_PAE
                 bool "2G/2G user/kernel split (for full 2G low memory)"
         config VMSPLIT_1G
                 bool "1G/3G user/kernel split"
@@ -598,10 +603,15 @@ config HIGHMEM
         default y
 
 config X86_PAE
-        bool
-        depends on HIGHMEM64G
-        default y
+        bool "PAE (Physical Address Extension) Support"
+        default n
+        depends on !HIGHMEM4G
         select RESOURCES_64BIT
+        help
+          PAE is required for NX support, and furthermore enables
+          larger swapspace support for non-overcommit purposes. It
+          has the cost of more pagetable lookup overhead, and also
+          consumes more pagetable space per process.
 
 # Common NUMA Features
 config NUMA
@@ -817,6 +827,7 @@ config CRASH_DUMP
 
 config PHYSICAL_START
         hex "Physical address where the kernel is loaded" if (EMBEDDED || CRASH_DUMP)
+        default "0x1000000" if X86_NUMAQ
         default "0x100000"
         help
           This gives the physical address where the kernel is loaded.
diff --git a/arch/i386/defconfig b/arch/i386/defconfig
index 0ac62cdcd3b7..54ee1764fdae 100644
--- a/arch/i386/defconfig
+++ b/arch/i386/defconfig
@@ -1,7 +1,7 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.22-rc2
-# Mon May 21 13:23:44 2007
+# Linux kernel version: 2.6.22-git14
+# Fri Jul 20 09:53:15 2007
 #
 CONFIG_X86_32=y
 CONFIG_GENERIC_TIME=y
@@ -37,19 +37,18 @@ CONFIG_LOCALVERSION=""
 CONFIG_LOCALVERSION_AUTO=y
 CONFIG_SWAP=y
 CONFIG_SYSVIPC=y
-# CONFIG_IPC_NS is not set
 CONFIG_SYSVIPC_SYSCTL=y
 CONFIG_POSIX_MQUEUE=y
 # CONFIG_BSD_PROCESS_ACCT is not set
 # CONFIG_TASKSTATS is not set
-# CONFIG_UTS_NS is not set
+# CONFIG_USER_NS is not set
 # CONFIG_AUDIT is not set
 CONFIG_IKCONFIG=y
 CONFIG_IKCONFIG_PROC=y
 CONFIG_LOG_BUF_SHIFT=18
 # CONFIG_CPUSETS is not set
 CONFIG_SYSFS_DEPRECATED=y
-# CONFIG_RELAY is not set
+CONFIG_RELAY=y
 CONFIG_BLK_DEV_INITRD=y
 CONFIG_INITRAMFS_SOURCE=""
 CONFIG_CC_OPTIMIZE_FOR_SIZE=y
@@ -73,16 +72,13 @@ CONFIG_TIMERFD=y
 CONFIG_EVENTFD=y
 CONFIG_SHMEM=y
 CONFIG_VM_EVENT_COUNTERS=y
-CONFIG_SLAB=y
-# CONFIG_SLUB is not set
+CONFIG_SLUB_DEBUG=y
+# CONFIG_SLAB is not set
+CONFIG_SLUB=y
 # CONFIG_SLOB is not set
 CONFIG_RT_MUTEXES=y
 # CONFIG_TINY_SHMEM is not set
 CONFIG_BASE_SMALL=0
-
-#
-# Loadable module support
-#
 CONFIG_MODULES=y
 CONFIG_MODULE_UNLOAD=y
 CONFIG_MODULE_FORCE_UNLOAD=y
@@ -90,14 +86,11 @@ CONFIG_MODULE_FORCE_UNLOAD=y
 # CONFIG_MODULE_SRCVERSION_ALL is not set
 # CONFIG_KMOD is not set
 CONFIG_STOP_MACHINE=y
-
-#
-# Block layer
-#
 CONFIG_BLOCK=y
 CONFIG_LBD=y
 # CONFIG_BLK_DEV_IO_TRACE is not set
 # CONFIG_LSF is not set
+# CONFIG_BLK_DEV_BSG is not set
 
 #
 # IO Schedulers
@@ -201,6 +194,7 @@ CONFIG_X86_CPUID=y
 # CONFIG_EDD is not set
 # CONFIG_DELL_RBU is not set
 # CONFIG_DCDBAS is not set
+CONFIG_DMIID=y
 # CONFIG_NOHIGHMEM is not set
 CONFIG_HIGHMEM4G=y
 # CONFIG_HIGHMEM64G is not set
@@ -217,7 +211,9 @@ CONFIG_FLAT_NODE_MEM_MAP=y
 CONFIG_SPLIT_PTLOCK_CPUS=4
 CONFIG_RESOURCES_64BIT=y
 CONFIG_ZONE_DMA_FLAG=1
+CONFIG_BOUNCE=y
 CONFIG_NR_QUICK=1
+CONFIG_VIRT_TO_BUS=y
 # CONFIG_HIGHPTE is not set
 # CONFIG_MATH_EMULATION is not set
 CONFIG_MTRR=y
@@ -244,7 +240,6 @@ CONFIG_ARCH_ENABLE_MEMORY_HOTPLUG=y
 CONFIG_PM=y
 CONFIG_PM_LEGACY=y
 # CONFIG_PM_DEBUG is not set
-# CONFIG_PM_SYSFS_DEPRECATED is not set
 
 #
 # ACPI (Advanced Configuration and Power Interface) Support
@@ -284,7 +279,7 @@ CONFIG_CPU_FREQ_GOV_PERFORMANCE=y
 # CONFIG_CPU_FREQ_GOV_POWERSAVE is not set
 CONFIG_CPU_FREQ_GOV_USERSPACE=y
 CONFIG_CPU_FREQ_GOV_ONDEMAND=y
-# CONFIG_CPU_FREQ_GOV_CONSERVATIVE is not set
+CONFIG_CPU_FREQ_GOV_CONSERVATIVE=y
 
 #
 # CPUFreq processor drivers
@@ -325,7 +320,7 @@ CONFIG_PCI_MMCONFIG=y
 CONFIG_ARCH_SUPPORTS_MSI=y
 CONFIG_PCI_MSI=y
 # CONFIG_PCI_DEBUG is not set
-CONFIG_HT_IRQ=y
+# CONFIG_HT_IRQ is not set
 CONFIG_ISA_DMA_API=y
 # CONFIG_ISA is not set
 # CONFIG_MCA is not set
@@ -381,7 +376,7 @@ CONFIG_IP_PNP_DHCP=y
 CONFIG_INET_TUNNEL=y
 CONFIG_INET_XFRM_MODE_TRANSPORT=y
 CONFIG_INET_XFRM_MODE_TUNNEL=y
-CONFIG_INET_XFRM_MODE_BEET=y
+# CONFIG_INET_XFRM_MODE_BEET is not set
 CONFIG_INET_DIAG=y
 CONFIG_INET_TCP_DIAG=y
 # CONFIG_TCP_CONG_ADVANCED is not set
@@ -400,27 +395,15 @@ CONFIG_IPV6=y
 # CONFIG_INET6_TUNNEL is not set
 CONFIG_INET6_XFRM_MODE_TRANSPORT=y
 CONFIG_INET6_XFRM_MODE_TUNNEL=y
-CONFIG_INET6_XFRM_MODE_BEET=y
+# CONFIG_INET6_XFRM_MODE_BEET is not set
 # CONFIG_INET6_XFRM_MODE_ROUTEOPTIMIZATION is not set
 CONFIG_IPV6_SIT=y
 # CONFIG_IPV6_TUNNEL is not set
 # CONFIG_IPV6_MULTIPLE_TABLES is not set
 # CONFIG_NETWORK_SECMARK is not set
 # CONFIG_NETFILTER is not set
-
-#
-# DCCP Configuration (EXPERIMENTAL)
-#
 # CONFIG_IP_DCCP is not set
-
-#
-# SCTP Configuration (EXPERIMENTAL)
-#
 # CONFIG_IP_SCTP is not set
-
-#
-# TIPC Configuration (EXPERIMENTAL)
-#
 # CONFIG_TIPC is not set
 # CONFIG_ATM is not set
 # CONFIG_BRIDGE is not set
@@ -457,6 +440,7 @@ CONFIG_IPV6_SIT=y
 # CONFIG_MAC80211 is not set
 # CONFIG_IEEE80211 is not set
 # CONFIG_RFKILL is not set
+# CONFIG_NET_9P is not set
 
 #
 # Device Drivers
@@ -471,21 +455,9 @@ CONFIG_FW_LOADER=y
 # CONFIG_DEBUG_DRIVER is not set
 # CONFIG_DEBUG_DEVRES is not set
 # CONFIG_SYS_HYPERVISOR is not set
-
-#
-# Connector - unified userspace <-> kernelspace linker
-#
 # CONFIG_CONNECTOR is not set
 # CONFIG_MTD is not set
-
-#
-# Parallel port support
-#
 # CONFIG_PARPORT is not set
-
-#
-# Plug and Play support
-#
 CONFIG_PNP=y
 # CONFIG_PNP_DEBUG is not set
 
@@ -493,10 +465,7 @@ CONFIG_PNP=y
 # Protocols
 #
 CONFIG_PNPACPI=y
-
-#
-# Block devices
-#
+CONFIG_BLK_DEV=y
 CONFIG_BLK_DEV_FD=y
 # CONFIG_BLK_CPQ_DA is not set
 # CONFIG_BLK_CPQ_CISS_DA is not set
@@ -514,17 +483,14 @@ CONFIG_BLK_DEV_RAM_SIZE=4096
 CONFIG_BLK_DEV_RAM_BLOCKSIZE=1024
 # CONFIG_CDROM_PKTCDVD is not set
 # CONFIG_ATA_OVER_ETH is not set
-
-#
-# Misc devices
-#
+CONFIG_MISC_DEVICES=y
 # CONFIG_IBM_ASM is not set
 # CONFIG_PHANTOM is not set
+# CONFIG_EEPROM_93CX6 is not set
 # CONFIG_SGI_IOC4 is not set
 # CONFIG_TIFM_CORE is not set
 # CONFIG_SONY_LAPTOP is not set
 # CONFIG_THINKPAD_ACPI is not set
-# CONFIG_BLINK is not set
 CONFIG_IDE=y
 CONFIG_BLK_DEV_IDE=y
 
@@ -596,6 +562,7 @@ CONFIG_BLK_DEV_IDEDMA=y
 #
 # CONFIG_RAID_ATTRS is not set
 CONFIG_SCSI=y
+CONFIG_SCSI_DMA=y
 # CONFIG_SCSI_TGT is not set
 CONFIG_SCSI_NETLINK=y
 # CONFIG_SCSI_PROC_FS is not set
@@ -606,8 +573,9 @@ CONFIG_SCSI_NETLINK=y
 CONFIG_BLK_DEV_SD=y
 # CONFIG_CHR_DEV_ST is not set
 # CONFIG_CHR_DEV_OSST is not set
-# CONFIG_BLK_DEV_SR is not set
-# CONFIG_CHR_DEV_SG is not set
+CONFIG_BLK_DEV_SR=y
+# CONFIG_BLK_DEV_SR_VENDOR is not set
+CONFIG_CHR_DEV_SG=y
 # CONFIG_CHR_DEV_SCH is not set
 
 #
@@ -667,6 +635,7 @@ CONFIG_AIC79XX_DEBUG_MASK=0
 # CONFIG_SCSI_INIA100 is not set
 # CONFIG_SCSI_STEX is not set
 # CONFIG_SCSI_SYM53C8XX_2 is not set
+# CONFIG_SCSI_IPR is not set
 # CONFIG_SCSI_QLOGIC_1280 is not set
 # CONFIG_SCSI_QLA_FC is not set
 # CONFIG_SCSI_QLA_ISCSI is not set
@@ -675,14 +644,73 @@ CONFIG_AIC79XX_DEBUG_MASK=0
 # CONFIG_SCSI_DC390T is not set
 # CONFIG_SCSI_NSP32 is not set
 # CONFIG_SCSI_DEBUG is not set
-# CONFIG_SCSI_ESP_CORE is not set
 # CONFIG_SCSI_SRP is not set
-# CONFIG_ATA is not set
-
-#
-# Multi-device support (RAID and LVM)
-#
-# CONFIG_MD is not set
+CONFIG_ATA=y
+# CONFIG_ATA_NONSTANDARD is not set
+CONFIG_ATA_ACPI=y
+CONFIG_SATA_AHCI=y
+CONFIG_SATA_SVW=y
+CONFIG_ATA_PIIX=y
+# CONFIG_SATA_MV is not set
+CONFIG_SATA_NV=y
+# CONFIG_PDC_ADMA is not set
+# CONFIG_SATA_QSTOR is not set
+# CONFIG_SATA_PROMISE is not set
+# CONFIG_SATA_SX4 is not set
+CONFIG_SATA_SIL=y
+# CONFIG_SATA_SIL24 is not set
+# CONFIG_SATA_SIS is not set
+# CONFIG_SATA_ULI is not set
+CONFIG_SATA_VIA=y
+# CONFIG_SATA_VITESSE is not set
+# CONFIG_SATA_INIC162X is not set
+# CONFIG_PATA_ALI is not set
+# CONFIG_PATA_AMD is not set
+# CONFIG_PATA_ARTOP is not set
+# CONFIG_PATA_ATIIXP is not set
+# CONFIG_PATA_CMD640_PCI is not set
+# CONFIG_PATA_CMD64X is not set
+# CONFIG_PATA_CS5520 is not set
+# CONFIG_PATA_CS5530 is not set
+# CONFIG_PATA_CS5535 is not set
+# CONFIG_PATA_CYPRESS is not set
+# CONFIG_PATA_EFAR is not set
+# CONFIG_ATA_GENERIC is not set
+# CONFIG_PATA_HPT366 is not set
+# CONFIG_PATA_HPT37X is not set
+# CONFIG_PATA_HPT3X2N is not set
+# CONFIG_PATA_HPT3X3 is not set
+# CONFIG_PATA_IT821X is not set
+# CONFIG_PATA_IT8213 is not set
+# CONFIG_PATA_JMICRON is not set
+# CONFIG_PATA_TRIFLEX is not set
+# CONFIG_PATA_MARVELL is not set
+# CONFIG_PATA_MPIIX is not set
+# CONFIG_PATA_OLDPIIX is not set
+# CONFIG_PATA_NETCELL is not set
+# CONFIG_PATA_NS87410 is not set
+# CONFIG_PATA_OPTI is not set
+# CONFIG_PATA_OPTIDMA is not set
+# CONFIG_PATA_PDC_OLD is not set
+# CONFIG_PATA_RADISYS is not set
+# CONFIG_PATA_RZ1000 is not set
+# CONFIG_PATA_SC1200 is not set
+# CONFIG_PATA_SERVERWORKS is not set
+# CONFIG_PATA_PDC2027X is not set
+# CONFIG_PATA_SIL680 is not set
+# CONFIG_PATA_SIS is not set
+# CONFIG_PATA_VIA is not set
+# CONFIG_PATA_WINBOND is not set
+CONFIG_MD=y
+# CONFIG_BLK_DEV_MD is not set
+CONFIG_BLK_DEV_DM=y
+# CONFIG_DM_DEBUG is not set
+# CONFIG_DM_CRYPT is not set
+# CONFIG_DM_SNAPSHOT is not set
+# CONFIG_DM_MIRROR is not set
+# CONFIG_DM_ZERO is not set
+# CONFIG_DM_MULTIPATH is not set
+# CONFIG_DM_DELAY is not set
 
 #
 # Fusion MPT device support
@@ -723,42 +751,27 @@ CONFIG_IEEE1394_OHCI1394=y
 # CONFIG_IEEE1394_ETH1394 is not set
 # CONFIG_IEEE1394_DV1394 is not set
 CONFIG_IEEE1394_RAWIO=y
-
-#
-# I2O device support
-#
 # CONFIG_I2O is not set
-# CONFIG_MACINTOSH_DRIVERS is not set
-
-#
-# Network device support
-#
+CONFIG_MACINTOSH_DRIVERS=y
+# CONFIG_MAC_EMUMOUSEBTN is not set
 CONFIG_NETDEVICES=y
+CONFIG_NETDEVICES_MULTIQUEUE=y
 # CONFIG_DUMMY is not set
 # CONFIG_BONDING is not set
+# CONFIG_MACVLAN is not set
 # CONFIG_EQUALIZER is not set
 # CONFIG_TUN is not set
 # CONFIG_NET_SB1000 is not set
-
-#
-# ARCnet devices
-#
 # CONFIG_ARCNET is not set
 # CONFIG_PHYLIB is not set
-
-#
-# Ethernet (10 or 100Mbit)
-#
 CONFIG_NET_ETHERNET=y
 CONFIG_MII=y
 # CONFIG_HAPPYMEAL is not set
 # CONFIG_SUNGEM is not set
 # CONFIG_CASSINI is not set
-# CONFIG_NET_VENDOR_3COM is not set
-
-#
-# Tulip family network device support
-#
+CONFIG_NET_VENDOR_3COM=y
+CONFIG_VORTEX=y
+# CONFIG_TYPHOON is not set
 CONFIG_NET_TULIP=y
 # CONFIG_DE2104X is not set
 CONFIG_TULIP=y
@@ -809,7 +822,6 @@ CONFIG_R8169=y
 # CONFIG_SIS190 is not set
 # CONFIG_SKGE is not set
 CONFIG_SKY2=y
-# CONFIG_SK98LIN is not set
 # CONFIG_VIA_VELOCITY is not set
 CONFIG_TIGON3=y
 CONFIG_BNX2=y
@@ -823,10 +835,6 @@ CONFIG_NETDEV_10000=y
 # CONFIG_MYRI10GE is not set
 # CONFIG_NETXEN_NIC is not set
 # CONFIG_MLX4_CORE is not set
-
-#
-# Token Ring devices
-#
 # CONFIG_TR is not set
 
 #
@@ -855,15 +863,7 @@ CONFIG_NETCONSOLE=y
 CONFIG_NETPOLL=y
 # CONFIG_NETPOLL_TRAP is not set
 CONFIG_NET_POLL_CONTROLLER=y
-
-#
-# ISDN subsystem
-#
 # CONFIG_ISDN is not set
-
-#
-# Telephony Support
-#
 # CONFIG_PHONE is not set
 
 #
@@ -871,6 +871,7 @@ CONFIG_NET_POLL_CONTROLLER=y
 #
 CONFIG_INPUT=y
 # CONFIG_INPUT_FF_MEMLESS is not set
+# CONFIG_INPUT_POLLDEV is not set
 
 #
 # Userland interfaces
@@ -936,6 +937,7 @@ CONFIG_HW_CONSOLE=y
 #
 CONFIG_SERIAL_8250=y
 CONFIG_SERIAL_8250_CONSOLE=y
+CONFIG_FIX_EARLYCON_MEM=y
 CONFIG_SERIAL_8250_PCI=y
 CONFIG_SERIAL_8250_PNP=y
 CONFIG_SERIAL_8250_NR_UARTS=4
@@ -951,10 +953,6 @@ CONFIG_SERIAL_CORE_CONSOLE=y
 CONFIG_UNIX98_PTYS=y
 CONFIG_LEGACY_PTYS=y
 CONFIG_LEGACY_PTY_COUNT=256
-
-#
-# IPMI
-#
 # CONFIG_IPMI_HANDLER is not set
 # CONFIG_WATCHDOG is not set
 CONFIG_HW_RANDOM=y
@@ -988,11 +986,7 @@ CONFIG_MAX_RAW_DEVS=256
 CONFIG_HPET=y
 # CONFIG_HPET_RTC_IRQ is not set
 CONFIG_HPET_MMAP=y
-CONFIG_HANGCHECK_TIMER=y
-
-#
-# TPM devices
-#
+# CONFIG_HANGCHECK_TIMER is not set
 # CONFIG_TCG_TPM is not set
 # CONFIG_TELCLOCK is not set
 CONFIG_DEVPORT=y
@@ -1003,11 +997,8 @@ CONFIG_DEVPORT=y
 #
 # CONFIG_SPI is not set
 # CONFIG_SPI_MASTER is not set
-
-#
-# Dallas's 1-wire bus
-#
 # CONFIG_W1 is not set
+# CONFIG_POWER_SUPPLY is not set
 # CONFIG_HWMON is not set
 
 #
@@ -1041,7 +1032,7 @@ CONFIG_DAB=y
 CONFIG_VGA_CONSOLE=y
 CONFIG_VGACON_SOFT_SCROLLBACK=y
 CONFIG_VGACON_SOFT_SCROLLBACK_SIZE=128
-# CONFIG_VIDEO_SELECT is not set
+CONFIG_VIDEO_SELECT=y
 CONFIG_DUMMY_CONSOLE=y
 
 #
@@ -1058,15 +1049,11 @@ CONFIG_SOUND=y
 # Open Sound System
 #
 CONFIG_SOUND_PRIME=y
-# CONFIG_OSS_OBSOLETE is not set
 # CONFIG_SOUND_TRIDENT is not set
 # CONFIG_SOUND_MSNDCLAS is not set
 # CONFIG_SOUND_MSNDPIN is not set
 # CONFIG_SOUND_OSS is not set
-
-#
-# HID Devices
-#
+CONFIG_HID_SUPPORT=y
 CONFIG_HID=y
 # CONFIG_HID_DEBUG is not set
 
@@ -1077,10 +1064,7 @@ CONFIG_USB_HID=y
 # CONFIG_USB_HIDINPUT_POWERBOOK is not set
 # CONFIG_HID_FF is not set
 # CONFIG_USB_HIDDEV is not set
-
-#
-# USB support
-#
+CONFIG_USB_SUPPORT=y
 CONFIG_USB_ARCH_HAS_HCD=y
 CONFIG_USB_ARCH_HAS_OHCI=y
 CONFIG_USB_ARCH_HAS_EHCI=y
@@ -1094,6 +1078,7 @@ CONFIG_USB_DEVICEFS=y
 # CONFIG_USB_DEVICE_CLASS is not set
 # CONFIG_USB_DYNAMIC_MINORS is not set
 # CONFIG_USB_SUSPEND is not set
+# CONFIG_USB_PERSIST is not set
 # CONFIG_USB_OTG is not set
 
 #
@@ -1103,7 +1088,6 @@ CONFIG_USB_EHCI_HCD=y
 # CONFIG_USB_EHCI_SPLIT_ISO is not set
 # CONFIG_USB_EHCI_ROOT_HUB_TT is not set
 # CONFIG_USB_EHCI_TT_NEWSCHED is not set
-# CONFIG_USB_EHCI_BIG_ENDIAN_MMIO is not set
 # CONFIG_USB_ISP116X_HCD is not set
 CONFIG_USB_OHCI_HCD=y
 # CONFIG_USB_OHCI_BIG_ENDIAN_DESC is not set
@@ -1111,6 +1095,7 @@ CONFIG_USB_OHCI_HCD=y
 CONFIG_USB_OHCI_LITTLE_ENDIAN=y
 CONFIG_USB_UHCI_HCD=y
 # CONFIG_USB_SL811_HCD is not set
+# CONFIG_USB_R8A66597_HCD is not set
 
 #
 # USB Device Class drivers
@@ -1201,15 +1186,7 @@ CONFIG_USB_MON=y
 #
 # LED Triggers
 #
-
-#
-# InfiniBand support
-#
 # CONFIG_INFINIBAND is not set
-
-#
-# EDAC - error detection and reporting (RAS) (EXPERIMENTAL)
-#
 # CONFIG_EDAC is not set
 
 #
@@ -1229,11 +1206,13 @@ CONFIG_USB_MON=y
 #
 # DMA Devices
 #
+CONFIG_VIRTUALIZATION=y
+# CONFIG_KVM is not set
 
 #
-# Virtualization
+# Userspace I/O
 #
-# CONFIG_KVM is not set
+# CONFIG_UIO is not set
 
 #
 # File systems
@@ -1271,6 +1250,7 @@ CONFIG_DNOTIFY=y
 # CONFIG_AUTOFS_FS is not set
 CONFIG_AUTOFS4_FS=y
 # CONFIG_FUSE_FS is not set
+CONFIG_GENERIC_ACL=y
 
 #
 # CD-ROM/DVD Filesystems
@@ -1298,7 +1278,7 @@ CONFIG_PROC_KCORE=y
 CONFIG_PROC_SYSCTL=y
 CONFIG_SYSFS=y
 CONFIG_TMPFS=y
-# CONFIG_TMPFS_POSIX_ACL is not set
+CONFIG_TMPFS_POSIX_ACL=y
 CONFIG_HUGETLBFS=y
 CONFIG_HUGETLB_PAGE=y
 CONFIG_RAMFS=y
@@ -1348,7 +1328,6 @@ CONFIG_SUNRPC=y
 # CONFIG_NCP_FS is not set
 # CONFIG_CODA_FS is not set
 # CONFIG_AFS_FS is not set
-# CONFIG_9P_FS is not set
 
 #
 # Partition Types
@@ -1404,10 +1383,7 @@ CONFIG_NLS_UTF8=y
 # Distributed Lock Manager
 #
 # CONFIG_DLM is not set
-
-#
-# Instrumentation Support
-#
+CONFIG_INSTRUMENTATION=y
 CONFIG_PROFILING=y
 CONFIG_OPROFILE=y
 CONFIG_KPROBES=y
@@ -1417,7 +1393,7 @@ CONFIG_KPROBES=y
 #
 CONFIG_TRACE_IRQFLAGS_SUPPORT=y
 # CONFIG_PRINTK_TIME is not set
-CONFIG_ENABLE_MUST_CHECK=y
+# CONFIG_ENABLE_MUST_CHECK is not set
 CONFIG_MAGIC_SYSRQ=y
 CONFIG_UNUSED_SYMBOLS=y
 # CONFIG_DEBUG_FS is not set
@@ -1425,15 +1401,17 @@ CONFIG_UNUSED_SYMBOLS=y
 CONFIG_DEBUG_KERNEL=y
 # CONFIG_DEBUG_SHIRQ is not set
 CONFIG_DETECT_SOFTLOCKUP=y
+# CONFIG_SCHED_DEBUG is not set
 # CONFIG_SCHEDSTATS is not set
-# CONFIG_TIMER_STATS is not set
-# CONFIG_DEBUG_SLAB is not set
+CONFIG_TIMER_STATS=y
+# CONFIG_SLUB_DEBUG_ON is not set
 # CONFIG_DEBUG_RT_MUTEXES is not set
 # CONFIG_RT_MUTEX_TESTER is not set
 # CONFIG_DEBUG_SPINLOCK is not set
 # CONFIG_DEBUG_MUTEXES is not set
 # CONFIG_DEBUG_LOCK_ALLOC is not set
 # CONFIG_PROVE_LOCKING is not set
+# CONFIG_LOCK_STAT is not set
 # CONFIG_DEBUG_SPINLOCK_SLEEP is not set
 # CONFIG_DEBUG_LOCKING_API_SELFTESTS is not set
 # CONFIG_DEBUG_KOBJECT is not set
@@ -1443,7 +1421,6 @@ CONFIG_DEBUG_BUGVERBOSE=y
 # CONFIG_DEBUG_VM is not set
 # CONFIG_DEBUG_LIST is not set
 # CONFIG_FRAME_POINTER is not set
-# CONFIG_UNWIND_INFO is not set
 # CONFIG_FORCED_INLINING is not set
 # CONFIG_RCU_TORTURE_TEST is not set
 # CONFIG_LKDTM is not set
@@ -1462,10 +1439,6 @@ CONFIG_DOUBLEFAULT=y
 #
 # CONFIG_KEYS is not set
 # CONFIG_SECURITY is not set
-
-#
-# Cryptographic options
-#
 # CONFIG_CRYPTO is not set
 
 #
@@ -1476,6 +1449,7 @@ CONFIG_BITREVERSE=y
 # CONFIG_CRC16 is not set
 # CONFIG_CRC_ITU_T is not set
 CONFIG_CRC32=y
+# CONFIG_CRC7 is not set
 # CONFIG_LIBCRC32C is not set
 CONFIG_ZLIB_INFLATE=y
 CONFIG_PLIST=y
diff --git a/arch/i386/kernel/Makefile b/arch/i386/kernel/Makefile
index 06da59f6f837..dbe5e87e0d66 100644
--- a/arch/i386/kernel/Makefile
+++ b/arch/i386/kernel/Makefile
@@ -40,6 +40,7 @@ obj-$(CONFIG_VM86)		+= vm86.o
 obj-$(CONFIG_EARLY_PRINTK)      += early_printk.o
 obj-$(CONFIG_HPET_TIMER)        += hpet.o
 obj-$(CONFIG_K8_NB)             += k8.o
+obj-$(CONFIG_MGEODE_LX)         += geode.o
 
 obj-$(CONFIG_VMI)               += vmi.o vmiclock.o
 obj-$(CONFIG_PARAVIRT)          += paravirt.o
diff --git a/arch/i386/kernel/acpi/boot.c b/arch/i386/kernel/acpi/boot.c
index a574cd2c8b61..b87cedeaf59b 100644
--- a/arch/i386/kernel/acpi/boot.c
+++ b/arch/i386/kernel/acpi/boot.c
@@ -618,6 +618,8 @@ static int __init acpi_parse_sbf(struct acpi_table_header *table)
 #ifdef CONFIG_HPET_TIMER
 #include <asm/hpet.h>
 
+static struct __initdata resource *hpet_res;
+
 static int __init acpi_parse_hpet(struct acpi_table_header *table)
 {
         struct acpi_table_hpet *hpet_tbl;
@@ -638,8 +640,42 @@ static int __init acpi_parse_hpet(struct acpi_table_header *table)
         printk(KERN_INFO PREFIX "HPET id: %#x base: %#lx\n",
                hpet_tbl->id, hpet_address);
 
+        /*
+         * Allocate and initialize the HPET firmware resource for adding into
+         * the resource tree during the lateinit timeframe.
+         */
+#define HPET_RESOURCE_NAME_SIZE 9
+        hpet_res = alloc_bootmem(sizeof(*hpet_res) + HPET_RESOURCE_NAME_SIZE);
+
+        if (!hpet_res)
+                return 0;
+
+        memset(hpet_res, 0, sizeof(*hpet_res));
+        hpet_res->name = (void *)&hpet_res[1];
+        hpet_res->flags = IORESOURCE_MEM;
+        snprintf((char *)hpet_res->name, HPET_RESOURCE_NAME_SIZE, "HPET %u",
+                 hpet_tbl->sequence);
+
+        hpet_res->start = hpet_address;
+        hpet_res->end = hpet_address + (1 * 1024) - 1;
+
         return 0;
 }
+
+/*
+ * hpet_insert_resource inserts the HPET resources used into the resource
+ * tree.
+ */
+static __init int hpet_insert_resource(void)
+{
+        if (!hpet_res)
+                return 1;
+
+        return insert_resource(&iomem_resource, hpet_res);
+}
+
+late_initcall(hpet_insert_resource);
+
 #else
 #define acpi_parse_hpet NULL
 #endif
diff --git a/arch/i386/kernel/alternative.c b/arch/i386/kernel/alternative.c
index d8cda14fff8b..0695be538de5 100644
--- a/arch/i386/kernel/alternative.c
+++ b/arch/i386/kernel/alternative.c
@@ -5,9 +5,8 @@
 #include <asm/alternative.h>
 #include <asm/sections.h>
 
-static int noreplace_smp     = 0;
-static int smp_alt_once      = 0;
-static int debug_alternative = 0;
+#ifdef CONFIG_HOTPLUG_CPU
+static int smp_alt_once;
 
 static int __init bootonly(char *str)
 {
@@ -15,6 +14,11 @@ static int __init bootonly(char *str)
         return 1;
 }
 __setup("smp-alt-boot", bootonly);
+#else
+#define smp_alt_once 1
+#endif
+
+static int debug_alternative;
 
 static int __init debug_alt(char *str)
 {
@@ -23,6 +27,8 @@ static int __init debug_alt(char *str)
 }
 __setup("debug-alternative", debug_alt);
 
+static int noreplace_smp;
+
 static int __init setup_noreplace_smp(char *str)
 {
         noreplace_smp = 1;
@@ -376,8 +382,6 @@ void __init alternative_instructions(void)
 #ifdef CONFIG_HOTPLUG_CPU
         if (num_possible_cpus() < 2)
                 smp_alt_once = 1;
-#else
-        smp_alt_once = 1;
 #endif
 
 #ifdef CONFIG_SMP
diff --git a/arch/i386/kernel/apic.c b/arch/i386/kernel/apic.c
index 67824f3bb974..bfc6cb7df7e7 100644
--- a/arch/i386/kernel/apic.c
+++ b/arch/i386/kernel/apic.c
@@ -263,6 +263,9 @@ static void lapic_timer_setup(enum clock_event_mode mode,
                 v |= (APIC_LVT_MASKED | LOCAL_TIMER_VECTOR);
                 apic_write_around(APIC_LVTT, v);
                 break;
+        case CLOCK_EVT_MODE_RESUME:
+                /* Nothing to do here */
+                break;
         }
 
         local_irq_restore(flags);
@@ -315,7 +318,7 @@ static void __devinit setup_APIC_timer(void)
 
 #define LAPIC_CAL_LOOPS         (HZ/10)
 
-static __initdata volatile int lapic_cal_loops = -1;
+static __initdata int lapic_cal_loops = -1;
 static __initdata long lapic_cal_t1, lapic_cal_t2;
 static __initdata unsigned long long lapic_cal_tsc1, lapic_cal_tsc2;
 static __initdata unsigned long lapic_cal_pm1, lapic_cal_pm2;
@@ -485,7 +488,7 @@ void __init setup_boot_APIC_clock(void)
                 /* Let the interrupts run */
                 local_irq_enable();
 
-                while(lapic_cal_loops <= LAPIC_CAL_LOOPS)
+                while (lapic_cal_loops <= LAPIC_CAL_LOOPS)
                         cpu_relax();
 
                 local_irq_disable();
@@ -521,6 +524,9 @@ void __init setup_boot_APIC_clock(void)
                  */
                 if (nmi_watchdog != NMI_IO_APIC)
                         lapic_clockevent.features &= ~CLOCK_EVT_FEAT_DUMMY;
+                else
+                        printk(KERN_WARNING "APIC timer registered as dummy,"
+                               " due to nmi_watchdog=1!\n");
         }
 
         /* Setup the lapic or request the broadcast */
diff --git a/arch/i386/kernel/cpu/Makefile b/arch/i386/kernel/cpu/Makefile
index 0b6a8551e9e2..778396c78d65 100644
--- a/arch/i386/kernel/cpu/Makefile
+++ b/arch/i386/kernel/cpu/Makefile
@@ -9,7 +9,6 @@ obj-y	+=	cyrix.o
 obj-y   +=      centaur.o
 obj-y   +=      transmeta.o
 obj-y   +=      intel.o intel_cacheinfo.o addon_cpuid_features.o
-obj-y   +=      rise.o
 obj-y   +=      nexgen.o
 obj-y   +=      umc.o
 
diff --git a/arch/i386/kernel/cpu/amd.c b/arch/i386/kernel/cpu/amd.c
index 6f47eeeb93ea..815a5f0aa474 100644
--- a/arch/i386/kernel/cpu/amd.c
+++ b/arch/i386/kernel/cpu/amd.c
@@ -272,8 +272,12 @@ static void __cpuinit init_amd(struct cpuinfo_x86 *c)
         }
 #endif
 
-        if (cpuid_eax(0x80000000) >= 0x80000006)
-                num_cache_leaves = 3;
+        if (cpuid_eax(0x80000000) >= 0x80000006) {
+                if ((c->x86 == 0x10) && (cpuid_edx(0x80000006) & 0xf000))
+                        num_cache_leaves = 4;
+                else
+                        num_cache_leaves = 3;
+        }
 
         if (amd_apic_timer_broken())
                 set_bit(X86_FEATURE_LAPIC_TIMER_BROKEN, c->x86_capability);
diff --git a/arch/i386/kernel/cpu/common.c b/arch/i386/kernel/cpu/common.c
index e5419a9dec88..d506201d397c 100644
--- a/arch/i386/kernel/cpu/common.c
+++ b/arch/i386/kernel/cpu/common.c
@@ -606,7 +606,6 @@ extern int nsc_init_cpu(void);
 extern int amd_init_cpu(void);
 extern int centaur_init_cpu(void);
 extern int transmeta_init_cpu(void);
-extern int rise_init_cpu(void);
 extern int nexgen_init_cpu(void);
 extern int umc_init_cpu(void);
 
@@ -618,7 +617,6 @@ void __init early_cpu_init(void)
         amd_init_cpu();
         centaur_init_cpu();
         transmeta_init_cpu();
-        rise_init_cpu();
         nexgen_init_cpu();
         umc_init_cpu();
         early_cpu_detect();
diff --git a/arch/i386/kernel/cpu/intel_cacheinfo.c b/arch/i386/kernel/cpu/intel_cacheinfo.c
index e5be819492ef..d5a456d27d82 100644
--- a/arch/i386/kernel/cpu/intel_cacheinfo.c
+++ b/arch/i386/kernel/cpu/intel_cacheinfo.c
@@ -4,7 +4,7 @@
  *      Changes:
  *      Venkatesh Pallipadi     : Adding cache identification through cpuid(4)
  *              Ashok Raj <ashok.raj@intel.com>: Work with CPU hotplug infrastructure.
- *      Andi Kleen              : CPUID4 emulation on AMD.
+ *      Andi Kleen / Andreas Herrmann   : CPUID4 emulation on AMD.
  */
 
 #include <linux/init.h>
@@ -135,7 +135,7 @@ unsigned short			num_cache_leaves;
 
 /* AMD doesn't have CPUID4. Emulate it here to report the same
    information to the user.  This makes some assumptions about the machine:
-   No L3, L2 not shared, no SMT etc. that is currently true on AMD CPUs.
+   L2 not shared, no SMT etc. that is currently true on AMD CPUs.
 
    In theory the TLBs could be reported as fake type (they are in "dummy").
    Maybe later */
@@ -159,13 +159,26 @@ union l2_cache {
         unsigned val;
 };
 
+union l3_cache {
+        struct {
+                unsigned line_size : 8;
+                unsigned lines_per_tag : 4;
+                unsigned assoc : 4;
+                unsigned res : 2;
+                unsigned size_encoded : 14;
+        };
+        unsigned val;
+};
+
 static const unsigned short assocs[] = {
         [1] = 1, [2] = 2, [4] = 4, [6] = 8,
-        [8] = 16,
+        [8] = 16, [0xa] = 32, [0xb] = 48,
+        [0xc] = 64,
         [0xf] = 0xffff // ??
-        };
-static const unsigned char levels[] = { 1, 1, 2 };
-static const unsigned char types[] = { 1, 2, 3 };
+};
+
+static const unsigned char levels[] = { 1, 1, 2, 3 };
+static const unsigned char types[] = { 1, 2, 3, 3 };
 
 static void __cpuinit amd_cpuid4(int leaf, union _cpuid4_leaf_eax *eax,
                        union _cpuid4_leaf_ebx *ebx,
@@ -175,37 +188,58 @@ static void __cpuinit amd_cpuid4(int leaf, union _cpuid4_leaf_eax *eax,
         unsigned line_size, lines_per_tag, assoc, size_in_kb;
         union l1_cache l1i, l1d;
         union l2_cache l2;
+        union l3_cache l3;
+        union l1_cache *l1 = &l1d;
 
         eax->full = 0;
         ebx->full = 0;
         ecx->full = 0;
 
         cpuid(0x80000005, &dummy, &dummy, &l1d.val, &l1i.val);
-        cpuid(0x80000006, &dummy, &dummy, &l2.val, &dummy);
-
-        if (leaf > 2 || !l1d.val || !l1i.val || !l2.val)
-                return;
-
-        eax->split.is_self_initializing = 1;
-        eax->split.type = types[leaf];
-        eax->split.level = levels[leaf];
-        eax->split.num_threads_sharing = 0;
-        eax->split.num_cores_on_die = current_cpu_data.x86_max_cores - 1;
-
-        if (leaf <= 1) {
-                union l1_cache *l1 = leaf == 0 ? &l1d : &l1i;
+        cpuid(0x80000006, &dummy, &dummy, &l2.val, &l3.val);
+
+        switch (leaf) {
+        case 1:
+                l1 = &l1i;
+        case 0:
+                if (!l1->val)
+                        return;
                 assoc = l1->assoc;
                 line_size = l1->line_size;
                 lines_per_tag = l1->lines_per_tag;
                 size_in_kb = l1->size_in_kb;
-        } else {
+                break;
+        case 2:
+                if (!l2.val)
+                        return;
                 assoc = l2.assoc;
                 line_size = l2.line_size;
                 lines_per_tag = l2.lines_per_tag;
                 /* cpu_data has errata corrections for K7 applied */
                 size_in_kb = current_cpu_data.x86_cache_size;
+                break;
+        case 3:
+                if (!l3.val)
+                        return;
+                assoc = l3.assoc;
+                line_size = l3.line_size;
+                lines_per_tag = l3.lines_per_tag;
+                size_in_kb = l3.size_encoded * 512;
+                break;
+        default:
+                return;
         }
 
+        eax->split.is_self_initializing = 1;
+        eax->split.type = types[leaf];
+        eax->split.level = levels[leaf];
+        if (leaf == 3)
+                eax->split.num_threads_sharing = current_cpu_data.x86_max_cores - 1;
+        else
+                eax->split.num_threads_sharing = 0;
+        eax->split.num_cores_on_die = current_cpu_data.x86_max_cores - 1;
+
+
         if (assoc == 0xf)
                 eax->split.is_fully_associative = 1;
         ebx->split.coherency_line_size = line_size - 1;
@@ -239,8 +273,7 @@ static int __cpuinit cpuid4_cache_lookup(int index, struct _cpuid4_info *this_le
         return 0;
 }
 
-/* will only be called once; __init is safe here */
-static int __init find_num_cache_leaves(void)
+static int __cpuinit find_num_cache_leaves(void)
 {
         unsigned int            eax, ebx, ecx, edx;
         union _cpuid4_leaf_eax  cache_eax;
@@ -710,7 +743,7 @@ static int __cpuinit cache_add_dev(struct sys_device * sys_dev)
         return retval;
 }
 
-static void __cpuexit cache_remove_dev(struct sys_device * sys_dev)
+static void __cpuinit cache_remove_dev(struct sys_device * sys_dev)
 {
         unsigned int cpu = sys_dev->id;
         unsigned long i;
diff --git a/arch/i386/kernel/cpu/mcheck/non-fatal.c b/arch/i386/kernel/cpu/mcheck/non-fatal.c
index 6b5d3518a1c0..bf39409b3838 100644
--- a/arch/i386/kernel/cpu/mcheck/non-fatal.c
+++ b/arch/i386/kernel/cpu/mcheck/non-fatal.c
@@ -57,7 +57,7 @@ static DECLARE_DELAYED_WORK(mce_work, mce_work_fn);
 static void mce_work_fn(struct work_struct *work)
 { 
         on_each_cpu(mce_checkregs, NULL, 1, 1);
-        schedule_delayed_work(&mce_work, MCE_RATE);
+        schedule_delayed_work(&mce_work, round_jiffies_relative(MCE_RATE));
 } 
 
 static int __init init_nonfatal_mce_checker(void)
@@ -82,7 +82,7 @@ static int __init init_nonfatal_mce_checker(void)
         /*
          * Check for non-fatal errors every MCE_RATE s
          */
-        schedule_delayed_work(&mce_work, MCE_RATE);
+        schedule_delayed_work(&mce_work, round_jiffies_relative(MCE_RATE));
         printk(KERN_INFO "Machine check exception polling timer started.\n");
         return 0;
 }
diff --git a/arch/i386/kernel/cpu/mtrr/generic.c b/arch/i386/kernel/cpu/mtrr/generic.c
index f6e46943e6ef..56f64e34829f 100644
--- a/arch/i386/kernel/cpu/mtrr/generic.c
+++ b/arch/i386/kernel/cpu/mtrr/generic.c
@@ -79,7 +79,7 @@ static void print_fixed(unsigned base, unsigned step, const mtrr_type*types)
 }
 
 /*  Grab all of the MTRR state for this CPU into *state  */
-void get_mtrr_state(void)
+void __init get_mtrr_state(void)
 {
         unsigned int i;
         struct mtrr_var_range *vrs;
diff --git a/arch/i386/kernel/cpu/mtrr/main.c b/arch/i386/kernel/cpu/mtrr/main.c
index 75dc6d5214bc..c48b6fea5ab4 100644
--- a/arch/i386/kernel/cpu/mtrr/main.c
+++ b/arch/i386/kernel/cpu/mtrr/main.c
@@ -643,7 +643,7 @@ static struct sysdev_driver mtrr_sysdev_driver = {
  * initialized (i.e. before smp_init()).
  * 
  */
-__init void mtrr_bp_init(void)
+void __init mtrr_bp_init(void)
 {
         init_ifs();
 
diff --git a/arch/i386/kernel/cpu/perfctr-watchdog.c b/arch/i386/kernel/cpu/perfctr-watchdog.c
index 4d26d514c56f..30b5e48aa76b 100644
--- a/arch/i386/kernel/cpu/perfctr-watchdog.c
+++ b/arch/i386/kernel/cpu/perfctr-watchdog.c
@@ -599,8 +599,8 @@ static struct wd_ops intel_arch_wd_ops = {
         .setup = setup_intel_arch_watchdog,
         .rearm = p6_rearm,
         .stop = single_msr_stop_watchdog,
-        .perfctr = MSR_ARCH_PERFMON_PERFCTR0,
-        .evntsel = MSR_ARCH_PERFMON_EVENTSEL0,
+        .perfctr = MSR_ARCH_PERFMON_PERFCTR1,
+        .evntsel = MSR_ARCH_PERFMON_EVENTSEL1,
 };
 
 static void probe_nmi_watchdog(void)
diff --git a/arch/i386/kernel/cpu/rise.c b/arch/i386/kernel/cpu/rise.c
deleted file mode 100644
index 50076f22e90f..000000000000
--- a/arch/i386/kernel/cpu/rise.c
+++ /dev/null
@@ -1,52 +0,0 @@
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/bitops.h>
-#include <asm/processor.h>
-
-#include "cpu.h"
-
-static void __cpuinit init_rise(struct cpuinfo_x86 *c)
-{
-        printk("CPU: Rise iDragon");
-        if (c->x86_model > 2)
-                printk(" II");
-        printk("\n");
-
-        /* Unhide possibly hidden capability flags
-           The mp6 iDragon family don't have MSRs.
-           We switch on extra features with this cpuid weirdness: */
-        __asm__ (
-                "movl $0x6363452a, %%eax\n\t"
-                "movl $0x3231206c, %%ecx\n\t"
-                "movl $0x2a32313a, %%edx\n\t"
-                "cpuid\n\t"
-                "movl $0x63634523, %%eax\n\t"
-                "movl $0x32315f6c, %%ecx\n\t"
-                "movl $0x2333313a, %%edx\n\t"
-                "cpuid\n\t" : : : "eax", "ebx", "ecx", "edx"
-        );
-        set_bit(X86_FEATURE_CX8, c->x86_capability);
-}
-
-static struct cpu_dev rise_cpu_dev __cpuinitdata = {
-        .c_vendor       = "Rise",
-        .c_ident        = { "RiseRiseRise" },
-        .c_models = {
-                { .vendor = X86_VENDOR_RISE, .family = 5, .model_names = 
-                  { 
-                          [0] = "iDragon", 
-                          [2] = "iDragon", 
-                          [8] = "iDragon II", 
-                          [9] = "iDragon II"
-                  }
-                },
-        },
-        .c_init         = init_rise,
-};
-
-int __init rise_init_cpu(void)
-{
-        cpu_devs[X86_VENDOR_RISE] = &rise_cpu_dev;
-        return 0;
-}
-
diff --git a/arch/i386/kernel/e820.c b/arch/i386/kernel/e820.c
index fc822a46897a..e60cddbc4cfb 100644
--- a/arch/i386/kernel/e820.c
+++ b/arch/i386/kernel/e820.c
@@ -10,6 +10,7 @@
 #include <linux/efi.h>
 #include <linux/pfn.h>
 #include <linux/uaccess.h>
+#include <linux/suspend.h>
 
 #include <asm/pgtable.h>
 #include <asm/page.h>
@@ -320,6 +321,37 @@ static int __init request_standard_resources(void)
 
 subsys_initcall(request_standard_resources);
 
+#if defined(CONFIG_PM) && defined(CONFIG_SOFTWARE_SUSPEND)
+/**
+ * e820_mark_nosave_regions - Find the ranges of physical addresses that do not
+ * correspond to e820 RAM areas and mark the corresponding pages as nosave for
+ * hibernation.
+ *
+ * This function requires the e820 map to be sorted and without any
+ * overlapping entries and assumes the first e820 area to be RAM.
+ */
+void __init e820_mark_nosave_regions(void)
+{
+        int i;
+        unsigned long pfn;
+
+        pfn = PFN_DOWN(e820.map[0].addr + e820.map[0].size);
+        for (i = 1; i < e820.nr_map; i++) {
+                struct e820entry *ei = &e820.map[i];
+
+                if (pfn < PFN_UP(ei->addr))
+                        register_nosave_region(pfn, PFN_UP(ei->addr));
+
+                pfn = PFN_DOWN(ei->addr + ei->size);
+                if (ei->type != E820_RAM)
+                        register_nosave_region(PFN_UP(ei->addr), pfn);
+
+                if (pfn >= max_low_pfn)
+                        break;
+        }
+}
+#endif
+
 void __init add_memory_region(unsigned long long start,
                               unsigned long long size, int type)
 {
diff --git a/arch/i386/kernel/geode.c b/arch/i386/kernel/geode.c
new file mode 100644
index 000000000000..41e8aec4c61d
--- /dev/null
+++ b/arch/i386/kernel/geode.c
@@ -0,0 +1,155 @@
+/*
+ * AMD Geode southbridge support code
+ * Copyright (C) 2006, Advanced Micro Devices, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public License
+ * as published by the Free Software Foundation.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/ioport.h>
+#include <linux/io.h>
+#include <asm/msr.h>
+#include <asm/geode.h>
+
+static struct {
+        char *name;
+        u32 msr;
+        int size;
+        u32 base;
+} lbars[] = {
+        { "geode-pms",   MSR_LBAR_PMS, LBAR_PMS_SIZE, 0 },
+        { "geode-acpi",  MSR_LBAR_ACPI, LBAR_ACPI_SIZE, 0 },
+        { "geode-gpio",  MSR_LBAR_GPIO, LBAR_GPIO_SIZE, 0 },
+        { "geode-mfgpt", MSR_LBAR_MFGPT, LBAR_MFGPT_SIZE, 0 }
+};
+
+static void __init init_lbars(void)
+{
+        u32 lo, hi;
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(lbars); i++) {
+                rdmsr(lbars[i].msr, lo, hi);
+                if (hi & 0x01)
+                        lbars[i].base = lo & 0x0000ffff;
+
+                if (lbars[i].base == 0)
+                        printk(KERN_ERR "geode:  Couldn't initialize '%s'\n",
+                                        lbars[i].name);
+        }
+}
+
+int geode_get_dev_base(unsigned int dev)
+{
+        BUG_ON(dev >= ARRAY_SIZE(lbars));
+        return lbars[dev].base;
+}
+EXPORT_SYMBOL_GPL(geode_get_dev_base);
+
+/* === GPIO API === */
+
+void geode_gpio_set(unsigned int gpio, unsigned int reg)
+{
+        u32 base = geode_get_dev_base(GEODE_DEV_GPIO);
+
+        if (!base)
+                return;
+
+        if (gpio < 16)
+                outl(1 << gpio, base + reg);
+        else
+                outl(1 << (gpio - 16), base + 0x80 + reg);
+}
+EXPORT_SYMBOL_GPL(geode_gpio_set);
+
+void geode_gpio_clear(unsigned int gpio, unsigned int reg)
+{
+        u32 base = geode_get_dev_base(GEODE_DEV_GPIO);
+
+        if (!base)
+                return;
+
+        if (gpio < 16)
+                outl(1 << (gpio + 16), base + reg);
+        else
+                outl(1 << gpio, base + 0x80 + reg);
+}
+EXPORT_SYMBOL_GPL(geode_gpio_clear);
+
+int geode_gpio_isset(unsigned int gpio, unsigned int reg)
+{
+        u32 base = geode_get_dev_base(GEODE_DEV_GPIO);
+
+        if (!base)
+                return 0;
+
+        if (gpio < 16)
+                return (inl(base + reg) & (1 << gpio)) ? 1 : 0;
+        else
+                return (inl(base + 0x80 + reg) & (1 << (gpio - 16))) ? 1 : 0;
+}
+EXPORT_SYMBOL_GPL(geode_gpio_isset);
+
+void geode_gpio_set_irq(unsigned int group, unsigned int irq)
+{
+        u32 lo, hi;
+
+        if (group > 7 || irq > 15)
+                return;
+
+        rdmsr(MSR_PIC_ZSEL_HIGH, lo, hi);
+
+        lo &= ~(0xF << (group * 4));
+        lo |= (irq & 0xF) << (group * 4);
+
+        wrmsr(MSR_PIC_ZSEL_HIGH, lo, hi);
+}
+EXPORT_SYMBOL_GPL(geode_gpio_set_irq);
+
+void geode_gpio_setup_event(unsigned int gpio, int pair, int pme)
+{
+        u32 base = geode_get_dev_base(GEODE_DEV_GPIO);
+        u32 offset, shift, val;
+
+        if (gpio >= 24)
+                offset = GPIO_MAP_W;
+        else if (gpio >= 16)
+                offset = GPIO_MAP_Z;
+        else if (gpio >= 8)
+                offset = GPIO_MAP_Y;
+        else
+                offset = GPIO_MAP_X;
+
+        shift = (gpio % 8) * 4;
+
+        val = inl(base + offset);
+
+        /* Clear whatever was there before */
+        val &= ~(0xF << shift);
+
+        /* And set the new value */
+
+        val |= ((pair & 7) << shift);
+
+        /* Set the PME bit if this is a PME event */
+
+        if (pme)
+                val |= (1 << (shift + 3));
+
+        outl(val, base + offset);
+}
+EXPORT_SYMBOL_GPL(geode_gpio_setup_event);
+
+static int __init geode_southbridge_init(void)
+{
+        if (!is_geode())
+                return -ENODEV;
+
+        init_lbars();
+        return 0;
+}
+
+postcore_initcall(geode_southbridge_init);
diff --git a/arch/i386/kernel/hpet.c b/arch/i386/kernel/hpet.c
index 17d73459fc5f..533d4932bc79 100644
--- a/arch/i386/kernel/hpet.c
+++ b/arch/i386/kernel/hpet.c
@@ -5,6 +5,7 @@
 #include <linux/init.h>
 #include <linux/sysdev.h>
 #include <linux/pm.h>
+#include <linux/delay.h>
 
 #include <asm/hpet.h>
 #include <asm/io.h>
@@ -187,6 +188,10 @@ static void hpet_set_mode(enum clock_event_mode mode,
                 cfg &= ~HPET_TN_ENABLE;
                 hpet_writel(cfg, HPET_T0_CFG);
                 break;
+
+        case CLOCK_EVT_MODE_RESUME:
+                hpet_enable_int();
+                break;
         }
 }
 
@@ -217,6 +222,7 @@ static struct clocksource clocksource_hpet = {
         .mask           = HPET_MASK,
         .shift          = HPET_SHIFT,
         .flags          = CLOCK_SOURCE_IS_CONTINUOUS,
+        .resume         = hpet_start_counter,
 };
 
 /*
@@ -226,7 +232,8 @@ int __init hpet_enable(void)
 {
         unsigned long id;
         uint64_t hpet_freq;
-        u64 tmp;
+        u64 tmp, start, now;
+        cycle_t t1;
 
         if (!is_hpet_capable())
                 return 0;
@@ -273,6 +280,27 @@ int __init hpet_enable(void)
         /* Start the counter */
         hpet_start_counter();
 
+        /* Verify whether hpet counter works */
+        t1 = read_hpet();
+        rdtscll(start);
+
+        /*
+         * We don't know the TSC frequency yet, but waiting for
+         * 200000 TSC cycles is safe:
+         * 4 GHz == 50us
+         * 1 GHz == 200us
+         */
+        do {
+                rep_nop();
+                rdtscll(now);
+        } while ((now - start) < 200000UL);
+
+        if (t1 == read_hpet()) {
+                printk(KERN_WARNING
+                       "HPET counter not counting. HPET disabled\n");
+                goto out_nohpet;
+        }
+
         /* Initialize and register HPET clocksource
          *
          * hpet period is in femto seconds per cycle
@@ -291,7 +319,6 @@ int __init hpet_enable(void)
 
         clocksource_register(&clocksource_hpet);
 
-
         if (id & HPET_ID_LEGSUP) {
                 hpet_enable_int();
                 hpet_reserve_platform_timers(id);
@@ -299,7 +326,7 @@ int __init hpet_enable(void)
                  * Start hpet with the boot cpu mask and make it
                  * global after the IO_APIC has been initialized.
                  */
-                hpet_clockevent.cpumask =cpumask_of_cpu(0);
+                hpet_clockevent.cpumask = cpumask_of_cpu(smp_processor_id());
                 clockevents_register_device(&hpet_clockevent);
                 global_clock_event = &hpet_clockevent;
                 return 1;
@@ -524,68 +551,3 @@ irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 #endif
-
-
-/*
- * Suspend/resume part
- */
-
-#ifdef CONFIG_PM
-
-static int hpet_suspend(struct sys_device *sys_device, pm_message_t state)
-{
-        unsigned long cfg = hpet_readl(HPET_CFG);
-
-        cfg &= ~(HPET_CFG_ENABLE|HPET_CFG_LEGACY);
-        hpet_writel(cfg, HPET_CFG);
-
-        return 0;
-}
-
-static int hpet_resume(struct sys_device *sys_device)
-{
-        unsigned int id;
-
-        hpet_start_counter();
-
-        id = hpet_readl(HPET_ID);
-
-        if (id & HPET_ID_LEGSUP)
-                hpet_enable_int();
-
-        return 0;
-}
-
-static struct sysdev_class hpet_class = {
-        set_kset_name("hpet"),
-        .suspend        = hpet_suspend,
-        .resume         = hpet_resume,
-};
-
-static struct sys_device hpet_device = {
-        .id             = 0,
-        .cls            = &hpet_class,
-};
-
-
-static __init int hpet_register_sysfs(void)
-{
-        int err;
-
-        if (!is_hpet_capable())
-                return 0;
-
-        err = sysdev_class_register(&hpet_class);
-
-        if (!err) {
-                err = sysdev_register(&hpet_device);
-                if (err)
-                        sysdev_class_unregister(&hpet_class);
-        }
-
-        return err;
-}
-
-device_initcall(hpet_register_sysfs);
-
-#endif
diff --git a/arch/i386/kernel/i8253.c b/arch/i386/kernel/i8253.c
index f8a3c4054c70..6d839f2f1b1a 100644
--- a/arch/i386/kernel/i8253.c
+++ b/arch/i386/kernel/i8253.c
@@ -3,18 +3,17 @@
  *
  */
 #include <linux/clockchips.h>
-#include <linux/spinlock.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
 #include <linux/jiffies.h>
-#include <linux/sysdev.h>
 #include <linux/module.h>
-#include <linux/init.h>
+#include <linux/spinlock.h>
 
 #include <asm/smp.h>
 #include <asm/delay.h>
 #include <asm/i8253.h>
 #include <asm/io.h>
-
-#include "io_ports.h"
+#include <asm/timer.h>
 
 DEFINE_SPINLOCK(i8253_lock);
 EXPORT_SYMBOL(i8253_lock);
@@ -41,26 +40,27 @@ static void init_pit_timer(enum clock_event_mode mode,
         case CLOCK_EVT_MODE_PERIODIC:
                 /* binary, mode 2, LSB/MSB, ch 0 */
                 outb_p(0x34, PIT_MODE);
-                udelay(10);
                 outb_p(LATCH & 0xff , PIT_CH0); /* LSB */
-                udelay(10);
                 outb(LATCH >> 8 , PIT_CH0);     /* MSB */
                 break;
 
-        /*
-         * Avoid unnecessary state transitions, as it confuses
-         * Geode / Cyrix based boxen.
-         */
         case CLOCK_EVT_MODE_SHUTDOWN:
-                if (evt->mode == CLOCK_EVT_MODE_UNUSED)
-                        break;
         case CLOCK_EVT_MODE_UNUSED:
-                if (evt->mode == CLOCK_EVT_MODE_SHUTDOWN)
-                        break;
+                if (evt->mode == CLOCK_EVT_MODE_PERIODIC ||
+                    evt->mode == CLOCK_EVT_MODE_ONESHOT) {
+                        outb_p(0x30, PIT_MODE);
+                        outb_p(0, PIT_CH0);
+                        outb_p(0, PIT_CH0);
+                }
+                break;
+
         case CLOCK_EVT_MODE_ONESHOT:
                 /* One shot setup */
                 outb_p(0x38, PIT_MODE);
-                udelay(10);
+                break;
+
+        case CLOCK_EVT_MODE_RESUME:
+                /* Nothing to do here */
                 break;
         }
         spin_unlock_irqrestore(&i8253_lock, flags);
diff --git a/arch/i386/kernel/io_apic.c b/arch/i386/kernel/io_apic.c
index 21db8f56c9a1..893df8280756 100644
--- a/arch/i386/kernel/io_apic.c
+++ b/arch/i386/kernel/io_apic.c
@@ -353,14 +353,6 @@ static void set_ioapic_affinity_irq(unsigned int irq, cpumask_t cpumask)
 # include <linux/slab.h>                /* kmalloc() */
 # include <linux/timer.h>       /* time_after() */
  
-#ifdef CONFIG_BALANCED_IRQ_DEBUG
-#  define TDprintk(x...) do { printk("<%ld:%s:%d>: ", jiffies, __FILE__, __LINE__); printk(x); } while (0)
-#  define Dprintk(x...) do { TDprintk(x); } while (0)
-# else
-#  define TDprintk(x...) 
-#  define Dprintk(x...) 
-# endif
-
 #define IRQBALANCE_CHECK_ARCH -999
 #define MAX_BALANCED_IRQ_INTERVAL       (5*HZ)
 #define MIN_BALANCED_IRQ_INTERVAL       (HZ/2)
@@ -443,7 +435,7 @@ static inline void balance_irq(int cpu, int irq)
 static inline void rotate_irqs_among_cpus(unsigned long useful_load_threshold)
 {
         int i, j;
-        Dprintk("Rotating IRQs among CPUs.\n");
+
         for_each_online_cpu(i) {
                 for (j = 0; j < NR_IRQS; j++) {
                         if (!irq_desc[j].action)
@@ -560,19 +552,11 @@ tryanothercpu:
         max_loaded = tmp_loaded;        /* processor */
         imbalance = (max_cpu_irq - min_cpu_irq) / 2;
         
-        Dprintk("max_loaded cpu = %d\n", max_loaded);
-        Dprintk("min_loaded cpu = %d\n", min_loaded);
-        Dprintk("max_cpu_irq load = %ld\n", max_cpu_irq);
-        Dprintk("min_cpu_irq load = %ld\n", min_cpu_irq);
-        Dprintk("load imbalance = %lu\n", imbalance);
-
         /* if imbalance is less than approx 10% of max load, then
          * observe diminishing returns action. - quit
          */
-        if (imbalance < (max_cpu_irq >> 3)) {
-                Dprintk("Imbalance too trivial\n");
+        if (imbalance < (max_cpu_irq >> 3))
                 goto not_worth_the_effort;
-        }
 
 tryanotherirq:
         /* if we select an IRQ to move that can't go where we want, then
@@ -629,9 +613,6 @@ tryanotherirq:
         cpus_and(tmp, target_cpu_mask, allowed_mask);
 
         if (!cpus_empty(tmp)) {
-
-                Dprintk("irq = %d moved to cpu = %d\n",
-                                selected_irq, min_loaded);
                 /* mark for change destination */
                 set_pending_irq(selected_irq, cpumask_of_cpu(min_loaded));
 
@@ -651,7 +632,6 @@ not_worth_the_effort:
          */
         balanced_irq_interval = min((long)MAX_BALANCED_IRQ_INTERVAL,
                 balanced_irq_interval + BALANCED_IRQ_MORE_DELTA);       
-        Dprintk("IRQ worth rotating not found\n");
         return;
 }
 
@@ -1902,7 +1882,7 @@ __setup("no_timer_check", notimercheck);
  *      - if this function detects that timer IRQs are defunct, then we fall
  *        back to ISA timer IRQs
  */
-int __init timer_irq_works(void)
+static int __init timer_irq_works(void)
 {
         unsigned long t1 = jiffies;
 
diff --git a/arch/i386/kernel/irq.c b/arch/i386/kernel/irq.c
index ba44d40b066d..dd2b97fc00b2 100644
--- a/arch/i386/kernel/irq.c
+++ b/arch/i386/kernel/irq.c
@@ -149,15 +149,11 @@ fastcall unsigned int do_IRQ(struct pt_regs *regs)
 
 #ifdef CONFIG_4KSTACKS
 
-/*
- * These should really be __section__(".bss.page_aligned") as well, but
- * gcc's 3.0 and earlier don't handle that correctly.
- */
 static char softirq_stack[NR_CPUS * THREAD_SIZE]
-                __attribute__((__aligned__(THREAD_SIZE)));
+                __attribute__((__section__(".bss.page_aligned")));
 
 static char hardirq_stack[NR_CPUS * THREAD_SIZE]
-                __attribute__((__aligned__(THREAD_SIZE)));
+                __attribute__((__section__(".bss.page_aligned")));
 
 /*
  * allocate per-cpu stacks for hardirq and for softirq processing
diff --git a/arch/i386/kernel/process.c b/arch/i386/kernel/process.c
index 6c49acb96982..84664710b784 100644
--- a/arch/i386/kernel/process.c
+++ b/arch/i386/kernel/process.c
@@ -300,6 +300,7 @@ early_param("idle", idle_setup);
 void show_regs(struct pt_regs * regs)
 {
         unsigned long cr0 = 0L, cr2 = 0L, cr3 = 0L, cr4 = 0L;
+        unsigned long d0, d1, d2, d3, d6, d7;
 
         printk("\n");
         printk("Pid: %d, comm: %20s\n", current->pid, current->comm);
@@ -324,6 +325,17 @@ void show_regs(struct pt_regs * regs)
         cr3 = read_cr3();
         cr4 = read_cr4_safe();
         printk("CR0: %08lx CR2: %08lx CR3: %08lx CR4: %08lx\n", cr0, cr2, cr3, cr4);
+
+        get_debugreg(d0, 0);
+        get_debugreg(d1, 1);
+        get_debugreg(d2, 2);
+        get_debugreg(d3, 3);
+        printk("DR0: %08lx DR1: %08lx DR2: %08lx DR3: %08lx\n",
+                        d0, d1, d2, d3);
+        get_debugreg(d6, 6);
+        get_debugreg(d7, 7);
+        printk("DR6: %08lx DR7: %08lx\n", d6, d7);
+
         show_trace(NULL, regs, &regs->esp);
 }
 
diff --git a/arch/i386/kernel/reboot.c b/arch/i386/kernel/reboot.c
index 5513f8d5b5be..0d796248866c 100644
--- a/arch/i386/kernel/reboot.c
+++ b/arch/i386/kernel/reboot.c
@@ -113,6 +113,15 @@ static struct dmi_system_id __initdata reboot_dmi_table[] = {
                         DMI_MATCH(DMI_PRODUCT_NAME, "PowerEdge 300/"),
                 },
         },
+        {       /* Handle problems with rebooting on Dell Optiplex 745's SFF*/
+                .callback = set_bios_reboot,
+                .ident = "Dell OptiPlex 745",
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "OptiPlex 745"),
+                        DMI_MATCH(DMI_BOARD_NAME, "0WF810"),
+                },
+        },
         {       /* Handle problems with rebooting on Dell 2400's */
                 .callback = set_bios_reboot,
                 .ident = "Dell PowerEdge 2400",
diff --git a/arch/i386/kernel/setup.c b/arch/i386/kernel/setup.c
index 74871d066c2b..d474cd639bcb 100644
--- a/arch/i386/kernel/setup.c
+++ b/arch/i386/kernel/setup.c
@@ -273,18 +273,18 @@ unsigned long __init find_max_low_pfn(void)
                 printk(KERN_WARNING "Warning only %ldMB will be used.\n",
                                         MAXMEM>>20);
                 if (max_pfn > MAX_NONPAE_PFN)
-                        printk(KERN_WARNING "Use a PAE enabled kernel.\n");
+                        printk(KERN_WARNING "Use a HIGHMEM64G enabled kernel.\n");
                 else
                         printk(KERN_WARNING "Use a HIGHMEM enabled kernel.\n");
                 max_pfn = MAXMEM_PFN;
 #else /* !CONFIG_HIGHMEM */
-#ifndef CONFIG_X86_PAE
+#ifndef CONFIG_HIGHMEM64G
                 if (max_pfn > MAX_NONPAE_PFN) {
                         max_pfn = MAX_NONPAE_PFN;
                         printk(KERN_WARNING "Warning only 4GB will be used.\n");
-                        printk(KERN_WARNING "Use a PAE enabled kernel.\n");
+                        printk(KERN_WARNING "Use a HIGHMEM64G enabled kernel.\n");
                 }
-#endif /* !CONFIG_X86_PAE */
+#endif /* !CONFIG_HIGHMEM64G */
 #endif /* !CONFIG_HIGHMEM */
         } else {
                 if (highmem_pages == -1)
@@ -466,7 +466,7 @@ void __init setup_bootmem_allocator(void)
  *
  * This should all compile down to nothing when NUMA is off.
  */
-void __init remapped_pgdat_init(void)
+static void __init remapped_pgdat_init(void)
 {
         int nid;
 
@@ -640,6 +640,7 @@ void __init setup_arch(char **cmdline_p)
 #endif
 
         e820_register_memory();
+        e820_mark_nosave_regions();
 
 #ifdef CONFIG_VT
 #if defined(CONFIG_VGA_CONSOLE)
diff --git a/arch/i386/kernel/sysenter.c b/arch/i386/kernel/sysenter.c
index ff4ee6f3326b..6deb159d08e0 100644
--- a/arch/i386/kernel/sysenter.c
+++ b/arch/i386/kernel/sysenter.c
@@ -336,7 +336,9 @@ struct vm_area_struct *get_gate_vma(struct task_struct *tsk)
 
 int in_gate_area(struct task_struct *task, unsigned long addr)
 {
-        return 0;
+        const struct vm_area_struct *vma = get_gate_vma(task);
+
+        return vma && addr >= vma->vm_start && addr < vma->vm_end;
 }
 
 int in_gate_area_no_task(unsigned long addr)
diff --git a/arch/i386/kernel/time.c b/arch/i386/kernel/time.c
index a665df61f08c..19a6c678d02e 100644
--- a/arch/i386/kernel/time.c
+++ b/arch/i386/kernel/time.c
@@ -207,55 +207,9 @@ unsigned long read_persistent_clock(void)
         return retval;
 }
 
-static void sync_cmos_clock(unsigned long dummy);
-
-static DEFINE_TIMER(sync_cmos_timer, sync_cmos_clock, 0, 0);
-int no_sync_cmos_clock;
-
-static void sync_cmos_clock(unsigned long dummy)
-{
-        struct timeval now, next;
-        int fail = 1;
-
-        /*
-         * If we have an externally synchronized Linux clock, then update
-         * CMOS clock accordingly every ~11 minutes. Set_rtc_mmss() has to be
-         * called as close as possible to 500 ms before the new second starts.
-         * This code is run on a timer.  If the clock is set, that timer
-         * may not expire at the correct time.  Thus, we adjust...
-         */
-        if (!ntp_synced())
-                /*
-                 * Not synced, exit, do not restart a timer (if one is
-                 * running, let it run out).
-                 */
-                return;
-
-        do_gettimeofday(&now);
-        if (now.tv_usec >= USEC_AFTER - ((unsigned) TICK_SIZE) / 2 &&
-            now.tv_usec <= USEC_BEFORE + ((unsigned) TICK_SIZE) / 2)
-                fail = set_rtc_mmss(now.tv_sec);
-
-        next.tv_usec = USEC_AFTER - now.tv_usec;
-        if (next.tv_usec <= 0)
-                next.tv_usec += USEC_PER_SEC;
-
-        if (!fail)
-                next.tv_sec = 659;
-        else
-                next.tv_sec = 0;
-
-        if (next.tv_usec >= USEC_PER_SEC) {
-                next.tv_sec++;
-                next.tv_usec -= USEC_PER_SEC;
-        }
-        mod_timer(&sync_cmos_timer, jiffies + timeval_to_jiffies(&next));
-}
-
-void notify_arch_cmos_timer(void)
+int update_persistent_clock(struct timespec now)
 {
-        if (!no_sync_cmos_clock)
-                mod_timer(&sync_cmos_timer, jiffies + 1);
+        return set_rtc_mmss(now.tv_sec);
 }
 
 extern void (*late_time_init)(void);
diff --git a/arch/i386/kernel/traps.c b/arch/i386/kernel/traps.c
index 3e7753c78b9b..57772a18c394 100644
--- a/arch/i386/kernel/traps.c
+++ b/arch/i386/kernel/traps.c
@@ -152,7 +152,7 @@ void dump_trace(struct task_struct *task, struct pt_regs *regs,
         if (!stack) {
                 unsigned long dummy;
                 stack = &dummy;
-                if (task && task != current)
+                if (task != current)
                         stack = (unsigned long *)task->thread.esp;
         }
 
@@ -211,6 +211,7 @@ static void print_trace_address(void *data, unsigned long addr)
 {
         printk("%s [<%08lx>] ", (char *)data, addr);
         print_symbol("%s\n", addr);
+        touch_nmi_watchdog();
 }
 
 static struct stacktrace_ops print_trace_ops = {
diff --git a/arch/i386/kernel/vmiclock.c b/arch/i386/kernel/vmiclock.c
index f9b845f4e692..b1b5ab08b26e 100644
--- a/arch/i386/kernel/vmiclock.c
+++ b/arch/i386/kernel/vmiclock.c
@@ -32,6 +32,7 @@
 #include <asm/apicdef.h>
 #include <asm/apic.h>
 #include <asm/timer.h>
+#include <asm/i8253.h>
 
 #include <irq_vectors.h>
 #include "io_ports.h"
@@ -142,6 +143,7 @@ static void vmi_timer_set_mode(enum clock_event_mode mode,
 
         switch (mode) {
         case CLOCK_EVT_MODE_ONESHOT:
+        case CLOCK_EVT_MODE_RESUME:
                 break;
         case CLOCK_EVT_MODE_PERIODIC:
                 cycles_per_hz = vmi_timer_ops.get_cycle_frequency();
diff --git a/arch/i386/lib/Makefile b/arch/i386/lib/Makefile
index 22d8ac5815f0..4d105fdfe817 100644
--- a/arch/i386/lib/Makefile
+++ b/arch/i386/lib/Makefile
@@ -4,7 +4,7 @@
 
 
 lib-y = checksum.o delay.o usercopy.o getuser.o putuser.o memcpy.o strstr.o \
-        bitops.o semaphore.o
+        bitops.o semaphore.o string.o
 
 lib-$(CONFIG_X86_USE_3DNOW) += mmx.o
 
diff --git a/arch/i386/lib/string.c b/arch/i386/lib/string.c
new file mode 100644
index 000000000000..2c773fefa3dd
--- /dev/null
+++ b/arch/i386/lib/string.c
@@ -0,0 +1,257 @@
+/*
+ * Most of the string-functions are rather heavily hand-optimized,
+ * see especially strsep,strstr,str[c]spn. They should work, but are not
+ * very easy to understand. Everything is done entirely within the register
+ * set, making the functions fast and clean. String instructions have been
+ * used through-out, making for "slightly" unclear code :-)
+ *
+ * AK: On P4 and K7 using non string instruction implementations might be faster
+ * for large memory blocks. But most of them are unlikely to be used on large
+ * strings.
+ */
+
+#include <linux/string.h>
+#include <linux/module.h>
+
+#ifdef __HAVE_ARCH_STRCPY
+char *strcpy(char * dest,const char *src)
+{
+        int d0, d1, d2;
+        asm volatile( "1:\tlodsb\n\t"
+                "stosb\n\t"
+                "testb %%al,%%al\n\t"
+                "jne 1b"
+                : "=&S" (d0), "=&D" (d1), "=&a" (d2)
+                :"0" (src),"1" (dest) : "memory");
+        return dest;
+}
+EXPORT_SYMBOL(strcpy);
+#endif
+
+#ifdef __HAVE_ARCH_STRNCPY
+char *strncpy(char * dest,const char *src,size_t count)
+{
+        int d0, d1, d2, d3;
+        asm volatile( "1:\tdecl %2\n\t"
+                "js 2f\n\t"
+                "lodsb\n\t"
+                "stosb\n\t"
+                "testb %%al,%%al\n\t"
+                "jne 1b\n\t"
+                "rep\n\t"
+                "stosb\n"
+                "2:"
+                : "=&S" (d0), "=&D" (d1), "=&c" (d2), "=&a" (d3)
+                :"0" (src),"1" (dest),"2" (count) : "memory");
+        return dest;
+}
+EXPORT_SYMBOL(strncpy);
+#endif
+
+#ifdef __HAVE_ARCH_STRCAT
+char *strcat(char * dest,const char * src)
+{
+        int d0, d1, d2, d3;
+        asm volatile( "repne\n\t"
+                "scasb\n\t"
+                "decl %1\n"
+                "1:\tlodsb\n\t"
+                "stosb\n\t"
+                "testb %%al,%%al\n\t"
+                "jne 1b"
+                : "=&S" (d0), "=&D" (d1), "=&a" (d2), "=&c" (d3)
+                : "0" (src), "1" (dest), "2" (0), "3" (0xffffffffu): "memory");
+        return dest;
+}
+EXPORT_SYMBOL(strcat);
+#endif
+
+#ifdef __HAVE_ARCH_STRNCAT
+char *strncat(char * dest,const char * src,size_t count)
+{
+        int d0, d1, d2, d3;
+        asm volatile( "repne\n\t"
+                "scasb\n\t"
+                "decl %1\n\t"
+                "movl %8,%3\n"
+                "1:\tdecl %3\n\t"
+                "js 2f\n\t"
+                "lodsb\n\t"
+                "stosb\n\t"
+                "testb %%al,%%al\n\t"
+                "jne 1b\n"
+                "2:\txorl %2,%2\n\t"
+                "stosb"
+                : "=&S" (d0), "=&D" (d1), "=&a" (d2), "=&c" (d3)
+                : "0" (src),"1" (dest),"2" (0),"3" (0xffffffffu), "g" (count)
+                : "memory");
+        return dest;
+}
+EXPORT_SYMBOL(strncat);
+#endif
+
+#ifdef __HAVE_ARCH_STRCMP
+int strcmp(const char * cs,const char * ct)
+{
+        int d0, d1;
+        int res;
+        asm volatile( "1:\tlodsb\n\t"
+                "scasb\n\t"
+                "jne 2f\n\t"
+                "testb %%al,%%al\n\t"
+                "jne 1b\n\t"
+                "xorl %%eax,%%eax\n\t"
+                "jmp 3f\n"
+                "2:\tsbbl %%eax,%%eax\n\t"
+                "orb $1,%%al\n"
+                "3:"
+                :"=a" (res), "=&S" (d0), "=&D" (d1)
+                :"1" (cs),"2" (ct)
+                :"memory");
+        return res;
+}
+EXPORT_SYMBOL(strcmp);
+#endif
+
+#ifdef __HAVE_ARCH_STRNCMP
+int strncmp(const char * cs,const char * ct,size_t count)
+{
+        int res;
+        int d0, d1, d2;
+        asm volatile( "1:\tdecl %3\n\t"
+                "js 2f\n\t"
+                "lodsb\n\t"
+                "scasb\n\t"
+                "jne 3f\n\t"
+                "testb %%al,%%al\n\t"
+                "jne 1b\n"
+                "2:\txorl %%eax,%%eax\n\t"
+                "jmp 4f\n"
+                "3:\tsbbl %%eax,%%eax\n\t"
+                "orb $1,%%al\n"
+                "4:"
+                :"=a" (res), "=&S" (d0), "=&D" (d1), "=&c" (d2)
+                :"1" (cs),"2" (ct),"3" (count)
+                :"memory");
+        return res;
+}
+EXPORT_SYMBOL(strncmp);
+#endif
+
+#ifdef __HAVE_ARCH_STRCHR
+char *strchr(const char * s, int c)
+{
+        int d0;
+        char * res;
+        asm volatile( "movb %%al,%%ah\n"
+                "1:\tlodsb\n\t"
+                "cmpb %%ah,%%al\n\t"
+                "je 2f\n\t"
+                "testb %%al,%%al\n\t"
+                "jne 1b\n\t"
+                "movl $1,%1\n"
+                "2:\tmovl %1,%0\n\t"
+                "decl %0"
+                :"=a" (res), "=&S" (d0)
+                :"1" (s),"0" (c)
+                :"memory");
+        return res;
+}
+EXPORT_SYMBOL(strchr);
+#endif
+
+#ifdef __HAVE_ARCH_STRRCHR
+char *strrchr(const char * s, int c)
+{
+        int d0, d1;
+        char * res;
+        asm volatile( "movb %%al,%%ah\n"
+                "1:\tlodsb\n\t"
+                "cmpb %%ah,%%al\n\t"
+                "jne 2f\n\t"
+                "leal -1(%%esi),%0\n"
+                "2:\ttestb %%al,%%al\n\t"
+                "jne 1b"
+                :"=g" (res), "=&S" (d0), "=&a" (d1)
+                :"0" (0),"1" (s),"2" (c)
+                :"memory");
+        return res;
+}
+EXPORT_SYMBOL(strrchr);
+#endif
+
+#ifdef __HAVE_ARCH_STRLEN
+size_t strlen(const char * s)
+{
+        int d0;
+        int res;
+        asm volatile( "repne\n\t"
+                "scasb\n\t"
+                "notl %0\n\t"
+                "decl %0"
+                :"=c" (res), "=&D" (d0)
+                :"1" (s),"a" (0), "0" (0xffffffffu)
+                :"memory");
+        return res;
+}
+EXPORT_SYMBOL(strlen);
+#endif
+
+#ifdef __HAVE_ARCH_MEMCHR
+void *memchr(const void *cs,int c,size_t count)
+{
+        int d0;
+        void *res;
+        if (!count)
+                return NULL;
+        asm volatile( "repne\n\t"
+                "scasb\n\t"
+                "je 1f\n\t"
+                "movl $1,%0\n"
+                "1:\tdecl %0"
+                :"=D" (res), "=&c" (d0)
+                :"a" (c),"0" (cs),"1" (count)
+                :"memory");
+        return res;
+}
+EXPORT_SYMBOL(memchr);
+#endif
+
+#ifdef __HAVE_ARCH_MEMSCAN
+void *memscan(void * addr, int c, size_t size)
+{
+        if (!size)
+                return addr;
+        asm volatile("repnz; scasb\n\t"
+            "jnz 1f\n\t"
+            "dec %%edi\n"
+            "1:"
+            : "=D" (addr), "=c" (size)
+            : "0" (addr), "1" (size), "a" (c)
+            : "memory");
+        return addr;
+}
+EXPORT_SYMBOL(memscan);
+#endif
+
+#ifdef __HAVE_ARCH_STRNLEN
+size_t strnlen(const char *s, size_t count)
+{
+        int d0;
+        int res;
+        asm volatile( "movl %2,%0\n\t"
+                "jmp 2f\n"
+                "1:\tcmpb $0,(%0)\n\t"
+                "je 3f\n\t"
+                "incl %0\n"
+                "2:\tdecl %1\n\t"
+                "cmpl $-1,%1\n\t"
+                "jne 1b\n"
+                "3:\tsubl %2,%0"
+                :"=a" (res), "=&d" (d0)
+                :"c" (s),"1" (count)
+                :"memory");
+        return res;
+}
+EXPORT_SYMBOL(strnlen);
+#endif
diff --git a/arch/i386/mm/init.c b/arch/i386/mm/init.c
index 6e72f22e6bbd..e1a9a805c445 100644
--- a/arch/i386/mm/init.c
+++ b/arch/i386/mm/init.c
@@ -471,6 +471,10 @@ void zap_low_mappings (void)
         flush_tlb_all();
 }
 
+int nx_enabled = 0;
+
+#ifdef CONFIG_X86_PAE
+
 static int disable_nx __initdata = 0;
 u64 __supported_pte_mask __read_mostly = ~_PAGE_NX;
 EXPORT_SYMBOL_GPL(__supported_pte_mask);
@@ -500,9 +504,6 @@ static int __init noexec_setup(char *str)
 }
 early_param("noexec", noexec_setup);
 
-int nx_enabled = 0;
-#ifdef CONFIG_X86_PAE
-
 static void __init set_nx(void)
 {
         unsigned int v[4], l, h;
diff --git a/arch/i386/mm/ioremap.c b/arch/i386/mm/ioremap.c
index fff08ae7b5ed..0b278315d737 100644
--- a/arch/i386/mm/ioremap.c
+++ b/arch/i386/mm/ioremap.c
@@ -196,7 +196,7 @@ void iounmap(volatile void __iomem *addr)
         /* Reset the direct mapping. Can block */
         if ((p->flags >> 20) && p->phys_addr < virt_to_phys(high_memory) - 1) {
                 change_page_attr(virt_to_page(__va(p->phys_addr)),
-                                 p->size >> PAGE_SHIFT,
+                                 get_vm_area_size(p) >> PAGE_SHIFT,
                                  PAGE_KERNEL);
                 global_flush_tlb();
         } 
diff --git a/arch/i386/mm/pageattr.c b/arch/i386/mm/pageattr.c
index 37992ffb1633..8927222b3ab2 100644
--- a/arch/i386/mm/pageattr.c
+++ b/arch/i386/mm/pageattr.c
@@ -82,7 +82,7 @@ static void flush_kernel_map(void *arg)
         struct page *p;
 
         /* High level code is not ready for clflush yet */
-        if (0 && cpu_has_clflush) {
+        if (cpu_has_clflush) {
                 list_for_each_entry (p, lh, lru)
                         cache_flush_page(p);
         } else if (boot_cpu_data.x86_model >= 4)
@@ -136,6 +136,12 @@ static inline void revert_page(struct page *kpte_page, unsigned long address)
                             ref_prot));
 }
 
+static inline void save_page(struct page *kpte_page)
+{
+        if (!test_and_set_bit(PG_arch_1, &kpte_page->flags))
+                list_add(&kpte_page->lru, &df_list);
+}
+
 static int
 __change_page_attr(struct page *page, pgprot_t prot)
 { 
@@ -150,6 +156,9 @@ __change_page_attr(struct page *page, pgprot_t prot)
         if (!kpte)
                 return -EINVAL;
         kpte_page = virt_to_page(kpte);
+        BUG_ON(PageLRU(kpte_page));
+        BUG_ON(PageCompound(kpte_page));
+
         if (pgprot_val(prot) != pgprot_val(PAGE_KERNEL)) { 
                 if (!pte_huge(*kpte)) {
                         set_pte_atomic(kpte, mk_pte(page, prot)); 
@@ -179,11 +188,11 @@ __change_page_attr(struct page *page, pgprot_t prot)
          * time (not via split_large_page) and in turn we must not
          * replace it with a largepage.
          */
+
+        save_page(kpte_page);
         if (!PageReserved(kpte_page)) {
                 if (cpu_has_pse && (page_private(kpte_page) == 0)) {
-                        ClearPagePrivate(kpte_page);
                         paravirt_release_pt(page_to_pfn(kpte_page));
-                        list_add(&kpte_page->lru, &df_list);
                         revert_page(kpte_page, address);
                 }
         }
@@ -236,6 +245,11 @@ void global_flush_tlb(void)
         spin_unlock_irq(&cpa_lock);
         flush_map(&l);
         list_for_each_entry_safe(pg, next, &l, lru) {
+                list_del(&pg->lru);
+                clear_bit(PG_arch_1, &pg->flags);
+                if (PageReserved(pg) || !cpu_has_pse || page_private(pg) != 0)
+                        continue;
+                ClearPagePrivate(pg);
                 __free_page(pg);
         }
 }
diff --git a/arch/i386/mm/pgtable.c b/arch/i386/mm/pgtable.c
index 8d7c0864cc04..01437c46baae 100644
--- a/arch/i386/mm/pgtable.c
+++ b/arch/i386/mm/pgtable.c
@@ -235,7 +235,7 @@ static inline void pgd_list_del(pgd_t *pgd)
 
 #if (PTRS_PER_PMD == 1)
 /* Non-PAE pgd constructor */
-void pgd_ctor(void *pgd)
+static void pgd_ctor(void *pgd)
 {
         unsigned long flags;
 
@@ -257,7 +257,7 @@ void pgd_ctor(void *pgd)
 }
 #else  /* PTRS_PER_PMD > 1 */
 /* PAE pgd constructor */
-void pgd_ctor(void *pgd)
+static void pgd_ctor(void *pgd)
 {
         /* PAE, kernel PMD may be shared */
 
@@ -276,7 +276,7 @@ void pgd_ctor(void *pgd)
 }
 #endif  /* PTRS_PER_PMD */
 
-void pgd_dtor(void *pgd)
+static void pgd_dtor(void *pgd)
 {
         unsigned long flags; /* can be called from interrupt context */
 
diff --git a/arch/i386/pci/acpi.c b/arch/i386/pci/acpi.c
index b33aea845f58..bc8a44bddaa7 100644
--- a/arch/i386/pci/acpi.c
+++ b/arch/i386/pci/acpi.c
@@ -8,20 +8,42 @@
 struct pci_bus * __devinit pci_acpi_scan_root(struct acpi_device *device, int domain, int busnum)
 {
         struct pci_bus *bus;
+        struct pci_sysdata *sd;
+        int pxm;
+
+        /* Allocate per-root-bus (not per bus) arch-specific data.
+         * TODO: leak; this memory is never freed.
+         * It's arguable whether it's worth the trouble to care.
+         */
+        sd = kzalloc(sizeof(*sd), GFP_KERNEL);
+        if (!sd) {
+                printk(KERN_ERR "PCI: OOM, not probing PCI bus %02x\n", busnum);
+                return NULL;
+        }
 
         if (domain != 0) {
                 printk(KERN_WARNING "PCI: Multiple domains not supported\n");
+                kfree(sd);
                 return NULL;
         }
 
-        bus = pcibios_scan_root(busnum);
+        sd->node = -1;
+
+        pxm = acpi_get_pxm(device->handle);
+#ifdef CONFIG_ACPI_NUMA
+        if (pxm >= 0)
+                sd->node = pxm_to_node(pxm);
+#endif
+
+        bus = pci_scan_bus_parented(NULL, busnum, &pci_root_ops, sd);
+        if (!bus)
+                kfree(sd);
+
 #ifdef CONFIG_ACPI_NUMA
         if (bus != NULL) {
-                int pxm = acpi_get_pxm(device->handle);
                 if (pxm >= 0) {
-                        bus->sysdata = (void *)(unsigned long)pxm_to_node(pxm);
-                        printk("bus %d -> pxm %d -> node %ld\n",
-                                busnum, pxm, (long)(bus->sysdata));
+                        printk("bus %d -> pxm %d -> node %d\n",
+                                busnum, pxm, sd->node);
                 }
         }
 #endif
diff --git a/arch/i386/pci/common.c b/arch/i386/pci/common.c
index 3f78d4d8ecf3..85503deeda46 100644
--- a/arch/i386/pci/common.c
+++ b/arch/i386/pci/common.c
@@ -293,6 +293,7 @@ static struct dmi_system_id __devinitdata pciprobe_dmi_table[] = {
 struct pci_bus * __devinit pcibios_scan_root(int busnum)
 {
         struct pci_bus *bus = NULL;
+        struct pci_sysdata *sd;
 
         dmi_check_system(pciprobe_dmi_table);
 
@@ -303,9 +304,19 @@ struct pci_bus * __devinit pcibios_scan_root(int busnum)
                 }
         }
 
+        /* Allocate per-root-bus (not per bus) arch-specific data.
+         * TODO: leak; this memory is never freed.
+         * It's arguable whether it's worth the trouble to care.
+         */
+        sd = kzalloc(sizeof(*sd), GFP_KERNEL);
+        if (!sd) {
+                printk(KERN_ERR "PCI: OOM, not probing PCI bus %02x\n", busnum);
+                return NULL;
+        }
+
         printk(KERN_DEBUG "PCI: Probing PCI hardware (bus %02x)\n", busnum);
 
-        return pci_scan_bus_parented(NULL, busnum, &pci_root_ops, NULL);
+        return pci_scan_bus_parented(NULL, busnum, &pci_root_ops, sd);
 }
 
 extern u8 pci_cache_line_size;
diff --git a/arch/i386/pci/mmconfig-shared.c b/arch/i386/pci/mmconfig-shared.c
index c7cabeed4d7b..4df637e34f81 100644
--- a/arch/i386/pci/mmconfig-shared.c
+++ b/arch/i386/pci/mmconfig-shared.c
@@ -24,6 +24,9 @@
 
 DECLARE_BITMAP(pci_mmcfg_fallback_slots, 32*PCI_MMCFG_MAX_CHECK_BUS);
 
+/* Indicate if the mmcfg resources have been placed into the resource table. */
+static int __initdata pci_mmcfg_resources_inserted;
+
 /* K8 systems have some devices (typically in the builtin northbridge)
    that are only accessible using type1
    Normally this can be expressed in the MCFG by not listing them
@@ -170,7 +173,7 @@ static int __init pci_mmcfg_check_hostbridge(void)
         return name != NULL;
 }
 
-static void __init pci_mmcfg_insert_resources(void)
+static void __init pci_mmcfg_insert_resources(unsigned long resource_flags)
 {
 #define PCI_MMCFG_RESOURCE_NAME_LEN 19
         int i;
@@ -194,10 +197,13 @@ static void __init pci_mmcfg_insert_resources(void)
                          cfg->pci_segment);
                 res->start = cfg->address;
                 res->end = res->start + (num_buses << 20) - 1;
-                res->flags = IORESOURCE_MEM | IORESOURCE_BUSY;
+                res->flags = IORESOURCE_MEM | resource_flags;
                 insert_resource(&iomem_resource, res);
                 names += PCI_MMCFG_RESOURCE_NAME_LEN;
         }
+
+        /* Mark that the resources have been inserted. */
+        pci_mmcfg_resources_inserted = 1;
 }
 
 static void __init pci_mmcfg_reject_broken(int type)
@@ -267,7 +273,43 @@ void __init pci_mmcfg_init(int type)
                 if (type == 1)
                         unreachable_devices();
                 if (known_bridge)
-                        pci_mmcfg_insert_resources();
+                        pci_mmcfg_insert_resources(IORESOURCE_BUSY);
                 pci_probe = (pci_probe & ~PCI_PROBE_MASK) | PCI_PROBE_MMCONF;
+        } else {
+                /*
+                 * Signal not to attempt to insert mmcfg resources because
+                 * the architecture mmcfg setup could not initialize.
+                 */
+                pci_mmcfg_resources_inserted = 1;
         }
 }
+
+static int __init pci_mmcfg_late_insert_resources(void)
+{
+        /*
+         * If resources are already inserted or we are not using MMCONFIG,
+         * don't insert the resources.
+         */
+        if ((pci_mmcfg_resources_inserted == 1) ||
+            (pci_probe & PCI_PROBE_MMCONF) == 0 ||
+            (pci_mmcfg_config_num == 0) ||
+            (pci_mmcfg_config == NULL) ||
+            (pci_mmcfg_config[0].address == 0))
+                return 1;
+
+        /*
+         * Attempt to insert the mmcfg resources but not with the busy flag
+         * marked so it won't cause request errors when __request_region is
+         * called.
+         */
+        pci_mmcfg_insert_resources(0);
+
+        return 0;
+}
+
+/*
+ * Perform MMCONFIG resource insertion after PCI initialization to allow for
+ * misprogrammed MCFG tables that state larger sizes but actually conflict
+ * with other system resources.
+ */
+late_initcall(pci_mmcfg_late_insert_resources);
diff --git a/arch/i386/xen/time.c b/arch/i386/xen/time.c
index 51fdabf1fd4d..dfd6db69ead5 100644
--- a/arch/i386/xen/time.c
+++ b/arch/i386/xen/time.c
@@ -412,6 +412,7 @@ static void xen_timerop_set_mode(enum clock_event_mode mode,
                 break;
 
         case CLOCK_EVT_MODE_ONESHOT:
+        case CLOCK_EVT_MODE_RESUME:
                 break;
 
         case CLOCK_EVT_MODE_UNUSED:
@@ -474,6 +475,8 @@ static void xen_vcpuop_set_mode(enum clock_event_mode mode,
                     HYPERVISOR_vcpu_op(VCPUOP_stop_periodic_timer, cpu, NULL))
                         BUG();
                 break;
+        case CLOCK_EVT_MODE_RESUME:
+                break;
         }
 }
 
diff --git a/arch/ia64/ia32/binfmt_elf32.c b/arch/ia64/ia32/binfmt_elf32.c
index e1189ba1ca5e..1cfab326fb7e 100644
--- a/arch/ia64/ia32/binfmt_elf32.c
+++ b/arch/ia64/ia32/binfmt_elf32.c
@@ -226,7 +226,7 @@ elf32_set_personality (void)
 }
 
 static unsigned long
-elf32_map (struct file *filep, unsigned long addr, struct elf_phdr *eppnt, int prot, int type, unsigned long unused)
+elf32_map (struct file *filep, unsigned long addr, struct elf_phdr *eppnt, int prot, int type)
 {
         unsigned long pgoff = (eppnt->p_vaddr) & ~IA32_PAGE_MASK;
 
diff --git a/arch/powerpc/boot/ps3-head.S b/arch/powerpc/boot/ps3-head.S
index 1a6d64a68df5..a55c2735f759 100644
--- a/arch/powerpc/boot/ps3-head.S
+++ b/arch/powerpc/boot/ps3-head.S
@@ -20,6 +20,8 @@
 
 #include "ppc_asm.h"
 
+        .machine "ppc64"
+
         .text
 
 /*
diff --git a/arch/powerpc/boot/ps3-hvcall.S b/arch/powerpc/boot/ps3-hvcall.S
index c8b7df3210d1..585965f7e6a8 100644
--- a/arch/powerpc/boot/ps3-hvcall.S
+++ b/arch/powerpc/boot/ps3-hvcall.S
@@ -20,6 +20,8 @@
 
 #include "ppc_asm.h"
 
+        .machine "ppc64"
+
 /*
  * The PS3 hypervisor uses a 64 bit "C" language calling convention.
  * The routines here marshal arguments between the 32 bit wrapper
diff --git a/arch/powerpc/mm/tlb_32.c b/arch/powerpc/mm/tlb_32.c
index 06c7e77e097a..eb4b512d65fa 100644
--- a/arch/powerpc/mm/tlb_32.c
+++ b/arch/powerpc/mm/tlb_32.c
@@ -26,6 +26,8 @@
 #include <linux/mm.h>
 #include <linux/init.h>
 #include <linux/highmem.h>
+#include <linux/pagemap.h>
+
 #include <asm/tlbflush.h>
 #include <asm/tlb.h>
 
diff --git a/arch/powerpc/platforms/cell/spufs/file.c b/arch/powerpc/platforms/cell/spufs/file.c
index 7de4e919687b..c2aaec5289dc 100644
--- a/arch/powerpc/platforms/cell/spufs/file.c
+++ b/arch/powerpc/platforms/cell/spufs/file.c
@@ -941,6 +941,13 @@ static const struct file_operations spufs_signal1_nosched_fops = {
         .mmap = spufs_signal1_mmap,
 };
 
+static const struct file_operations spufs_signal1_nosched_fops = {
+        .open = spufs_signal1_open,
+        .release = spufs_signal1_release,
+        .write = spufs_signal1_write,
+        .mmap = spufs_signal1_mmap,
+};
+
 static int spufs_signal2_open(struct inode *inode, struct file *file)
 {
         struct spufs_inode_info *i = SPUFS_I(inode);
@@ -1076,6 +1083,13 @@ static const struct file_operations spufs_signal2_nosched_fops = {
         .mmap = spufs_signal2_mmap,
 };
 
+static const struct file_operations spufs_signal2_nosched_fops = {
+        .open = spufs_signal2_open,
+        .release = spufs_signal2_release,
+        .write = spufs_signal2_write,
+        .mmap = spufs_signal2_mmap,
+};
+
 static void spufs_signal1_type_set(void *data, u64 val)
 {
         struct spu_context *ctx = data;
@@ -2177,8 +2191,8 @@ struct tree_descr spufs_dir_contents[] = {
         { "mbox_stat", &spufs_mbox_stat_fops, 0444, },
         { "ibox_stat", &spufs_ibox_stat_fops, 0444, },
         { "wbox_stat", &spufs_wbox_stat_fops, 0444, },
-        { "signal1", &spufs_signal1_fops, 0666, },
-        { "signal2", &spufs_signal2_fops, 0666, },
+        { "signal1", &spufs_signal1_nosched_fops, 0222, },
+        { "signal2", &spufs_signal2_nosched_fops, 0222, },
         { "signal1_type", &spufs_signal1_type, 0666, },
         { "signal2_type", &spufs_signal2_type, 0666, },
         { "cntl", &spufs_cntl_fops,  0666, },
diff --git a/arch/powerpc/platforms/ps3/Kconfig b/arch/powerpc/platforms/ps3/Kconfig
index a05079b07696..d4fc74f7bb15 100644
--- a/arch/powerpc/platforms/ps3/Kconfig
+++ b/arch/powerpc/platforms/ps3/Kconfig
@@ -102,4 +102,40 @@ config PS3_STORAGE
         depends on PPC_PS3
         tristate
 
+config PS3_DISK
+        tristate "PS3 Disk Storage Driver"
+        depends on PPC_PS3 && BLOCK
+        select PS3_STORAGE
+        help
+          Include support for the PS3 Disk Storage.
+
+          This support is required to access the PS3 hard disk.
+          In general, all users will say Y or M.
+
+config PS3_ROM
+        tristate "PS3 BD/DVD/CD-ROM Storage Driver"
+        depends on PPC_PS3 && SCSI
+        select PS3_STORAGE
+        help
+          Include support for the PS3 ROM Storage.
+
+          This support is required to access the PS3 BD/DVD/CD-ROM drive.
+          In general, all users will say Y or M.
+          Also make sure to say Y or M to "SCSI CDROM support" later.
+
+config PS3_FLASH
+        tristate "PS3 FLASH ROM Storage Driver"
+        depends on PPC_PS3
+        select PS3_STORAGE
+        help
+          Include support for the PS3 FLASH ROM Storage.
+
+          This support is required to access the PS3 FLASH ROM, which
+          contains the boot loader and some boot options.
+          In general, all users will say Y or M.
+
+          As this driver needs a fixed buffer of 256 KiB of memory, it can
+          be disabled on the kernel command line using "ps3flash=off", to
+          not allocate this fixed buffer.
+
 endmenu
diff --git a/arch/sh/kernel/timers/timer-tmu.c b/arch/sh/kernel/timers/timer-tmu.c
index 097ebd49f1bf..7aca37d79766 100644
--- a/arch/sh/kernel/timers/timer-tmu.c
+++ b/arch/sh/kernel/timers/timer-tmu.c
@@ -80,6 +80,7 @@ static void tmu_set_mode(enum clock_event_mode mode,
                 break;
         case CLOCK_EVT_MODE_UNUSED:
         case CLOCK_EVT_MODE_SHUTDOWN:
+        case CLOCK_EVT_MODE_RESUME:
                 break;
         }
 }
diff --git a/arch/sparc/kernel/entry.S b/arch/sparc/kernel/entry.S
index 831f540251f8..eac38388f5fd 100644
--- a/arch/sparc/kernel/entry.S
+++ b/arch/sparc/kernel/entry.S
@@ -1749,8 +1749,8 @@ fpload:
 __ndelay:
         save    %sp, -STACKFRAME_SZ, %sp
         mov     %i0, %o0
-        call    .umul
-         mov    0x1ad, %o1              ! 2**32 / (1 000 000 000 / HZ)
+        call    .umul                   ! round multiplier up so large ns ok
+         mov    0x1ae, %o1              ! 2**32 / (1 000 000 000 / HZ)
         call    .umul
          mov    %i1, %o1                ! udelay_val
         ba      delay_continue
@@ -1760,11 +1760,17 @@ __ndelay:
 __udelay:
         save    %sp, -STACKFRAME_SZ, %sp
         mov     %i0, %o0
-        sethi   %hi(0x10c6), %o1
+        sethi   %hi(0x10c7), %o1        ! round multiplier up so large us ok
         call    .umul
-         or     %o1, %lo(0x10c6), %o1   ! 2**32 / 1 000 000
+         or     %o1, %lo(0x10c7), %o1   ! 2**32 / 1 000 000
         call    .umul
          mov    %i1, %o1                ! udelay_val
+        sethi   %hi(0x028f4b62), %l0    ! Add in rounding constant * 2**32,
+        or      %g0, %lo(0x028f4b62), %l0
+        addcc   %o0, %l0, %o0           ! 2**32 * 0.009 999
+        bcs,a   3f
+         add    %o1, 0x01, %o1
+3:
         call    .umul
          mov    HZ, %o0                 ! >>32 earlier for wider range
 
diff --git a/arch/sparc/kernel/irq.c b/arch/sparc/kernel/irq.c
index f257a67bcf93..75b2240ad0f9 100644
--- a/arch/sparc/kernel/irq.c
+++ b/arch/sparc/kernel/irq.c
@@ -47,6 +47,8 @@
 #include <asm/cacheflush.h>
 #include <asm/irq_regs.h>
 
+#include "irq.h"
+
 #ifdef CONFIG_SMP
 #define SMP_NOP2 "nop; nop;\n\t"
 #define SMP_NOP3 "nop; nop; nop;\n\t"
@@ -268,7 +270,7 @@ void free_irq(unsigned int irq, void *dev_id)
         kfree(action);
 
         if (!sparc_irq[cpu_irq].action)
-                disable_irq(irq);
+                __disable_irq(irq);
 
 out_unlock:
         spin_unlock_irqrestore(&irq_action_lock, flags);
@@ -464,7 +466,7 @@ int request_fast_irq(unsigned int irq,
 
         sparc_irq[cpu_irq].action = action;
 
-        enable_irq(irq);
+        __enable_irq(irq);
 
         ret = 0;
 out_unlock:
@@ -544,7 +546,7 @@ int request_irq(unsigned int irq,
 
         *actionp = action;
 
-        enable_irq(irq);
+        __enable_irq(irq);
 
         ret = 0;
 out_unlock:
@@ -555,6 +557,25 @@ out:
 
 EXPORT_SYMBOL(request_irq);
 
+void disable_irq_nosync(unsigned int irq)
+{
+        return __disable_irq(irq);
+}
+EXPORT_SYMBOL(disable_irq_nosync);
+
+void disable_irq(unsigned int irq)
+{
+        return __disable_irq(irq);
+}
+EXPORT_SYMBOL(disable_irq);
+
+void enable_irq(unsigned int irq)
+{
+        return __enable_irq(irq);
+}
+
+EXPORT_SYMBOL(enable_irq);
+
 /* We really don't need these at all on the Sparc.  We only have
  * stubs here because they are exported to modules.
  */
diff --git a/arch/sparc/kernel/irq.h b/arch/sparc/kernel/irq.h
new file mode 100644
index 000000000000..32ef3ebd0a88
--- /dev/null
+++ b/arch/sparc/kernel/irq.h
@@ -0,0 +1,68 @@
+#include <asm/btfixup.h>
+
+/* Dave Redman (djhr@tadpole.co.uk)
+ * changed these to function pointers.. it saves cycles and will allow
+ * the irq dependencies to be split into different files at a later date
+ * sun4c_irq.c, sun4m_irq.c etc so we could reduce the kernel size.
+ * Jakub Jelinek (jj@sunsite.mff.cuni.cz)
+ * Changed these to btfixup entities... It saves cycles :)
+ */
+
+BTFIXUPDEF_CALL(void, disable_irq, unsigned int)
+BTFIXUPDEF_CALL(void, enable_irq, unsigned int)
+BTFIXUPDEF_CALL(void, disable_pil_irq, unsigned int)
+BTFIXUPDEF_CALL(void, enable_pil_irq, unsigned int)
+BTFIXUPDEF_CALL(void, clear_clock_irq, void)
+BTFIXUPDEF_CALL(void, clear_profile_irq, int)
+BTFIXUPDEF_CALL(void, load_profile_irq, int, unsigned int)
+
+static inline void __disable_irq(unsigned int irq)
+{
+        BTFIXUP_CALL(disable_irq)(irq);
+}
+
+static inline void __enable_irq(unsigned int irq)
+{
+        BTFIXUP_CALL(enable_irq)(irq);
+}
+
+static inline void disable_pil_irq(unsigned int irq)
+{
+        BTFIXUP_CALL(disable_pil_irq)(irq);
+}
+
+static inline void enable_pil_irq(unsigned int irq)
+{
+        BTFIXUP_CALL(enable_pil_irq)(irq);
+}
+
+static inline void clear_clock_irq(void)
+{
+        BTFIXUP_CALL(clear_clock_irq)();
+}
+
+static inline void clear_profile_irq(int irq)
+{
+        BTFIXUP_CALL(clear_profile_irq)(irq);
+}
+
+static inline void load_profile_irq(int cpu, int limit)
+{
+        BTFIXUP_CALL(load_profile_irq)(cpu, limit);
+}
+
+extern void (*sparc_init_timers)(irq_handler_t lvl10_irq);
+
+extern void claim_ticker14(irq_handler_t irq_handler,
+                           int irq,
+                           unsigned int timeout);
+
+#ifdef CONFIG_SMP
+BTFIXUPDEF_CALL(void, set_cpu_int, int, int)
+BTFIXUPDEF_CALL(void, clear_cpu_int, int, int)
+BTFIXUPDEF_CALL(void, set_irq_udt, int)
+
+#define set_cpu_int(cpu,level) BTFIXUP_CALL(set_cpu_int)(cpu,level)
+#define clear_cpu_int(cpu,level) BTFIXUP_CALL(clear_cpu_int)(cpu,level)
+#define set_irq_udt(cpu) BTFIXUP_CALL(set_irq_udt)(cpu)
+#endif
diff --git a/arch/sparc/kernel/pcic.c b/arch/sparc/kernel/pcic.c
index 791771196905..f2eae457fc9a 100644
--- a/arch/sparc/kernel/pcic.c
+++ b/arch/sparc/kernel/pcic.c
@@ -36,6 +36,7 @@
 #include <asm/uaccess.h>
 #include <asm/irq_regs.h>
 
+#include "irq.h"
 
 /*
  * I studied different documents and many live PROMs both from 2.30
diff --git a/arch/sparc/kernel/smp.c b/arch/sparc/kernel/smp.c
index 4fea3ac7bff0..6724ab90f82b 100644
--- a/arch/sparc/kernel/smp.c
+++ b/arch/sparc/kernel/smp.c
@@ -33,6 +33,8 @@
 #include <asm/tlbflush.h>
 #include <asm/cpudata.h>
 
+#include "irq.h"
+
 int smp_num_cpus = 1;
 volatile unsigned long cpu_callin_map[NR_CPUS] __initdata = {0,};
 unsigned char boot_cpu_id = 0;
diff --git a/arch/sparc/kernel/sparc_ksyms.c b/arch/sparc/kernel/sparc_ksyms.c
index d8e008a04e2b..55bac516dfe2 100644
--- a/arch/sparc/kernel/sparc_ksyms.c
+++ b/arch/sparc/kernel/sparc_ksyms.c
@@ -154,8 +154,6 @@ EXPORT_SYMBOL(BTFIXUP_CALL(___xchg32));
 #else
 EXPORT_SYMBOL(BTFIXUP_CALL(__hard_smp_processor_id));
 #endif
-EXPORT_SYMBOL(BTFIXUP_CALL(enable_irq));
-EXPORT_SYMBOL(BTFIXUP_CALL(disable_irq));
 EXPORT_SYMBOL(BTFIXUP_CALL(mmu_unlockarea));
 EXPORT_SYMBOL(BTFIXUP_CALL(mmu_lockarea));
 EXPORT_SYMBOL(BTFIXUP_CALL(mmu_get_scsi_sgl));
diff --git a/arch/sparc/kernel/sun4c_irq.c b/arch/sparc/kernel/sun4c_irq.c
index 009e891a4329..c6ac9fc52563 100644
--- a/arch/sparc/kernel/sun4c_irq.c
+++ b/arch/sparc/kernel/sun4c_irq.c
@@ -18,6 +18,7 @@
 #include <linux/interrupt.h>
 #include <linux/slab.h>
 #include <linux/init.h>
+#include "irq.h"
 
 #include <asm/ptrace.h>
 #include <asm/processor.h>
@@ -40,6 +41,20 @@ static struct resource sun4c_timer_eb = { "sun4c_timer" };
 static struct resource sun4c_intr_eb = { "sun4c_intr" };
 #endif
 
+/*
+ * Bit field defines for the interrupt registers on various
+ * Sparc machines.
+ */
+
+/* The sun4c interrupt register. */
+#define SUN4C_INT_ENABLE  0x01     /* Allow interrupts. */
+#define SUN4C_INT_E14     0x80     /* Enable level 14 IRQ. */
+#define SUN4C_INT_E10     0x20     /* Enable level 10 IRQ. */
+#define SUN4C_INT_E8      0x10     /* Enable level 8 IRQ. */
+#define SUN4C_INT_E6      0x08     /* Enable level 6 IRQ. */
+#define SUN4C_INT_E4      0x04     /* Enable level 4 IRQ. */
+#define SUN4C_INT_E1      0x02     /* Enable level 1 IRQ. */
+
 /* Pointer to the interrupt enable byte
  *
  * Dave Redman (djhr@tadpole.co.uk)
diff --git a/arch/sparc/kernel/sun4d_irq.c b/arch/sparc/kernel/sun4d_irq.c
index 396797e20c39..e0efab2a6bef 100644
--- a/arch/sparc/kernel/sun4d_irq.c
+++ b/arch/sparc/kernel/sun4d_irq.c
@@ -39,6 +39,8 @@
 #include <asm/cacheflush.h>
 #include <asm/irq_regs.h>
 
+#include "irq.h"
+
 /* If you trust current SCSI layer to handle different SCSI IRQs, enable this. I don't trust it... -jj */
 /* #define DISTRIBUTE_IRQS */
 
@@ -188,7 +190,7 @@ void sun4d_free_irq(unsigned int irq, void *dev_id)
         kfree(action);
 
         if (!(*actionp))
-                disable_irq(irq);
+                __disable_irq(irq);
 
 out_unlock:
         spin_unlock_irqrestore(&irq_action_lock, flags);
@@ -346,7 +348,7 @@ int sun4d_request_irq(unsigned int irq,
         else
                 *actionp = action;
                 
-        enable_irq(irq);
+        __enable_irq(irq);
 
         ret = 0;
 out_unlock:
diff --git a/arch/sparc/kernel/sun4d_smp.c b/arch/sparc/kernel/sun4d_smp.c
index 098c94f1a322..89a6de95070c 100644
--- a/arch/sparc/kernel/sun4d_smp.c
+++ b/arch/sparc/kernel/sun4d_smp.c
@@ -36,6 +36,7 @@
 #include <asm/cacheflush.h>
 #include <asm/cpudata.h>
 
+#include "irq.h"
 #define IRQ_CROSS_CALL          15
 
 extern ctxd_t *srmmu_ctx_table_phys;
diff --git a/arch/sparc/kernel/sun4m_irq.c b/arch/sparc/kernel/sun4m_irq.c
index 91a803ea88be..b92d6d2d5b04 100644
--- a/arch/sparc/kernel/sun4m_irq.c
+++ b/arch/sparc/kernel/sun4m_irq.c
@@ -38,11 +38,85 @@
 #include <asm/sbus.h>
 #include <asm/cacheflush.h>
 
+#include "irq.h"
+
+/* On the sun4m, just like the timers, we have both per-cpu and master
+ * interrupt registers.
+ */
+
+/* These registers are used for sending/receiving irqs from/to
+ * different cpu's.
+ */
+struct sun4m_intreg_percpu {
+        unsigned int tbt;        /* Interrupts still pending for this cpu. */
+
+        /* These next two registers are WRITE-ONLY and are only
+         * "on bit" sensitive, "off bits" written have NO affect.
+         */
+        unsigned int clear;  /* Clear this cpus irqs here. */
+        unsigned int set;    /* Set this cpus irqs here. */
+        unsigned char space[PAGE_SIZE - 12];
+};
+
+/*
+ * djhr
+ * Actually the clear and set fields in this struct are misleading..
+ * according to the SLAVIO manual (and the same applies for the SEC)
+ * the clear field clears bits in the mask which will ENABLE that IRQ
+ * the set field sets bits in the mask to DISABLE the IRQ.
+ *
+ * Also the undirected_xx address in the SLAVIO is defined as
+ * RESERVED and write only..
+ *
+ * DAVEM_NOTE: The SLAVIO only specifies behavior on uniprocessor
+ *             sun4m machines, for MP the layout makes more sense.
+ */
+struct sun4m_intregs {
+        struct sun4m_intreg_percpu cpu_intregs[SUN4M_NCPUS];
+        unsigned int tbt;                /* IRQ's that are still pending. */
+        unsigned int irqs;               /* Master IRQ bits. */
+
+        /* Again, like the above, two these registers are WRITE-ONLY. */
+        unsigned int clear;              /* Clear master IRQ's by setting bits here. */
+        unsigned int set;                /* Set master IRQ's by setting bits here. */
+
+        /* This register is both READ and WRITE. */
+        unsigned int undirected_target;  /* Which cpu gets undirected irqs. */
+};
+
 static unsigned long dummy;
 
 struct sun4m_intregs *sun4m_interrupts;
 unsigned long *irq_rcvreg = &dummy;
 
+/* Dave Redman (djhr@tadpole.co.uk)
+ * The sun4m interrupt registers.
+ */
+#define SUN4M_INT_ENABLE        0x80000000
+#define SUN4M_INT_E14           0x00000080
+#define SUN4M_INT_E10           0x00080000
+
+#define SUN4M_HARD_INT(x)       (0x000000001 << (x))
+#define SUN4M_SOFT_INT(x)       (0x000010000 << (x))
+
+#define SUN4M_INT_MASKALL       0x80000000        /* mask all interrupts */
+#define SUN4M_INT_MODULE_ERR    0x40000000        /* module error */
+#define SUN4M_INT_M2S_WRITE     0x20000000        /* write buffer error */
+#define SUN4M_INT_ECC           0x10000000        /* ecc memory error */
+#define SUN4M_INT_FLOPPY        0x00400000        /* floppy disk */
+#define SUN4M_INT_MODULE        0x00200000        /* module interrupt */
+#define SUN4M_INT_VIDEO         0x00100000        /* onboard video */
+#define SUN4M_INT_REALTIME      0x00080000        /* system timer */
+#define SUN4M_INT_SCSI          0x00040000        /* onboard scsi */
+#define SUN4M_INT_AUDIO         0x00020000        /* audio/isdn */
+#define SUN4M_INT_ETHERNET      0x00010000        /* onboard ethernet */
+#define SUN4M_INT_SERIAL        0x00008000        /* serial ports */
+#define SUN4M_INT_KBDMS         0x00004000        /* keyboard/mouse */
+#define SUN4M_INT_SBUSBITS      0x00003F80        /* sbus int bits */
+
+#define SUN4M_INT_SBUS(x)       (1 << (x+7))
+#define SUN4M_INT_VME(x)        (1 << (x))
+
 /* These tables only apply for interrupts greater than 15..
  * 
  * any intr value below 0x10 is considered to be a soft-int
diff --git a/arch/sparc/kernel/sun4m_smp.c b/arch/sparc/kernel/sun4m_smp.c
index 63ed19bfd028..730eb5796f8e 100644
--- a/arch/sparc/kernel/sun4m_smp.c
+++ b/arch/sparc/kernel/sun4m_smp.c
@@ -31,6 +31,8 @@
 #include <asm/oplib.h>
 #include <asm/cpudata.h>
 
+#include "irq.h"
+
 #define IRQ_RESCHEDULE          13
 #define IRQ_STOP_CPU            14
 #define IRQ_CROSS_CALL          15
diff --git a/arch/sparc/kernel/tick14.c b/arch/sparc/kernel/tick14.c
index f1a7bd19e04f..707bfda86570 100644
--- a/arch/sparc/kernel/tick14.c
+++ b/arch/sparc/kernel/tick14.c
@@ -25,6 +25,8 @@
 #include <asm/irq.h>
 #include <asm/io.h>
 
+#include "irq.h"
+
 extern unsigned long lvl14_save[5];
 static unsigned long *linux_lvl14 = NULL;
 static unsigned long obp_lvl14[4];
@@ -62,7 +64,7 @@ void claim_ticker14(irq_handler_t handler,
 
         /* first we copy the obp handler instructions
          */
-        disable_irq(irq_nr);
+        __disable_irq(irq_nr);
         if (!handler)
                 return;
     
@@ -79,6 +81,6 @@ void claim_ticker14(irq_handler_t handler,
                          NULL)) {
                 install_linux_ticker();
                 load_profile_irq(cpu, timeout);
-                enable_irq(irq_nr);
+                __enable_irq(irq_nr);
         }
 }
diff --git a/arch/sparc/kernel/time.c b/arch/sparc/kernel/time.c
index f2fdbb3664d3..6a2513321620 100644
--- a/arch/sparc/kernel/time.c
+++ b/arch/sparc/kernel/time.c
@@ -44,6 +44,8 @@
 #include <asm/of_device.h>
 #include <asm/irq_regs.h>
 
+#include "irq.h"
+
 DEFINE_SPINLOCK(rtc_lock);
 enum sparc_clock_type sp_clock_typ;
 DEFINE_SPINLOCK(mostek_lock);
diff --git a/arch/sparc/mm/init.c b/arch/sparc/mm/init.c
index a532922e2e35..a1bef07755a9 100644
--- a/arch/sparc/mm/init.c
+++ b/arch/sparc/mm/init.c
@@ -308,6 +308,9 @@ extern void sun4c_paging_init(void);
 extern void srmmu_paging_init(void);
 extern void device_scan(void);
 
+pgprot_t PAGE_SHARED __read_mostly;
+EXPORT_SYMBOL(PAGE_SHARED);
+
 void __init paging_init(void)
 {
         switch(sparc_cpu_model) {
diff --git a/arch/sparc/mm/srmmu.c b/arch/sparc/mm/srmmu.c
index ca26232da7ab..17b485f2825c 100644
--- a/arch/sparc/mm/srmmu.c
+++ b/arch/sparc/mm/srmmu.c
@@ -2154,7 +2154,7 @@ void __init ld_mmu_srmmu(void)
         BTFIXUPSET_SIMM13(ptrs_per_pgd, SRMMU_PTRS_PER_PGD);
 
         BTFIXUPSET_INT(page_none, pgprot_val(SRMMU_PAGE_NONE));
-        BTFIXUPSET_INT(page_shared, pgprot_val(SRMMU_PAGE_SHARED));
+        PAGE_SHARED = pgprot_val(SRMMU_PAGE_SHARED);
         BTFIXUPSET_INT(page_copy, pgprot_val(SRMMU_PAGE_COPY));
         BTFIXUPSET_INT(page_readonly, pgprot_val(SRMMU_PAGE_RDONLY));
         BTFIXUPSET_INT(page_kernel, pgprot_val(SRMMU_PAGE_KERNEL));
diff --git a/arch/sparc/mm/sun4c.c b/arch/sparc/mm/sun4c.c
index bdd835fba02e..a57a366e339a 100644
--- a/arch/sparc/mm/sun4c.c
+++ b/arch/sparc/mm/sun4c.c
@@ -2155,7 +2155,7 @@ void __init ld_mmu_sun4c(void)
         BTFIXUPSET_SIMM13(user_ptrs_per_pgd, KERNBASE / SUN4C_PGDIR_SIZE);
 
         BTFIXUPSET_INT(page_none, pgprot_val(SUN4C_PAGE_NONE));
-        BTFIXUPSET_INT(page_shared, pgprot_val(SUN4C_PAGE_SHARED));
+        PAGE_SHARED = pgprot_val(SUN4C_PAGE_SHARED);
         BTFIXUPSET_INT(page_copy, pgprot_val(SUN4C_PAGE_COPY));
         BTFIXUPSET_INT(page_readonly, pgprot_val(SUN4C_PAGE_READONLY));
         BTFIXUPSET_INT(page_kernel, pgprot_val(SUN4C_PAGE_KERNEL));
diff --git a/arch/sparc64/Kconfig b/arch/sparc64/Kconfig
index f1cc55677ff2..33dabf588bdd 100644
--- a/arch/sparc64/Kconfig
+++ b/arch/sparc64/Kconfig
@@ -23,6 +23,10 @@ config GENERIC_TIME
         bool
         default y
 
+config GENERIC_CMOS_UPDATE
+        bool
+        default y
+
 config GENERIC_CLOCKEVENTS
         bool
         default y
diff --git a/arch/sparc64/kernel/sparc64_ksyms.c b/arch/sparc64/kernel/sparc64_ksyms.c
index 7d36531aa5b9..d270c2f0be0f 100644
--- a/arch/sparc64/kernel/sparc64_ksyms.c
+++ b/arch/sparc64/kernel/sparc64_ksyms.c
@@ -280,6 +280,7 @@ EXPORT_SYMBOL(sys_getgid);
 EXPORT_SYMBOL(svr4_getcontext);
 EXPORT_SYMBOL(svr4_setcontext);
 EXPORT_SYMBOL(compat_sys_ioctl);
+EXPORT_SYMBOL(sys_ioctl);
 EXPORT_SYMBOL(sparc32_open);
 #endif
 
diff --git a/arch/sparc64/kernel/time.c b/arch/sparc64/kernel/time.c
index e340eb401fb9..49063ca2efcd 100644
--- a/arch/sparc64/kernel/time.c
+++ b/arch/sparc64/kernel/time.c
@@ -403,58 +403,9 @@ static struct sparc64_tick_ops hbtick_operations __read_mostly = {
 
 static unsigned long timer_ticks_per_nsec_quotient __read_mostly;
 
-#define TICK_SIZE (tick_nsec / 1000)
-
-#define USEC_AFTER      500000
-#define USEC_BEFORE     500000
-
-static void sync_cmos_clock(unsigned long dummy);
-
-static DEFINE_TIMER(sync_cmos_timer, sync_cmos_clock, 0, 0);
-
-static void sync_cmos_clock(unsigned long dummy)
-{
-        struct timeval now, next;
-        int fail = 1;
-
-        /*
-         * If we have an externally synchronized Linux clock, then update
-         * CMOS clock accordingly every ~11 minutes. Set_rtc_mmss() has to be
-         * called as close as possible to 500 ms before the new second starts.
-         * This code is run on a timer.  If the clock is set, that timer
-         * may not expire at the correct time.  Thus, we adjust...
-         */
-        if (!ntp_synced())
-                /*
-                 * Not synced, exit, do not restart a timer (if one is
-                 * running, let it run out).
-                 */
-                return;
-
-        do_gettimeofday(&now);
-        if (now.tv_usec >= USEC_AFTER - ((unsigned) TICK_SIZE) / 2 &&
-            now.tv_usec <= USEC_BEFORE + ((unsigned) TICK_SIZE) / 2)
-                fail = set_rtc_mmss(now.tv_sec);
-
-        next.tv_usec = USEC_AFTER - now.tv_usec;
-        if (next.tv_usec <= 0)
-                next.tv_usec += USEC_PER_SEC;
-
-        if (!fail)
-                next.tv_sec = 659;
-        else
-                next.tv_sec = 0;
-
-        if (next.tv_usec >= USEC_PER_SEC) {
-                next.tv_sec++;
-                next.tv_usec -= USEC_PER_SEC;
-        }
-        mod_timer(&sync_cmos_timer, jiffies + timeval_to_jiffies(&next));
-}
-
-void notify_arch_cmos_timer(void)
+int update_persistent_clock(struct timespec now)
 {
-        mod_timer(&sync_cmos_timer, jiffies + 1);
+        return set_rtc_mmss(now.tv_sec);
 }
 
 /* Kick start a stopped clock (procedure from the Sun NVRAM/hostid FAQ). */
@@ -931,6 +882,7 @@ static void sparc64_timer_setup(enum clock_event_mode mode,
 {
         switch (mode) {
         case CLOCK_EVT_MODE_ONESHOT:
+        case CLOCK_EVT_MODE_RESUME:
                 break;
 
         case CLOCK_EVT_MODE_SHUTDOWN:
diff --git a/arch/x86_64/Kconfig b/arch/x86_64/Kconfig
index 14bf8ce3ea23..45f82ae6d389 100644
--- a/arch/x86_64/Kconfig
+++ b/arch/x86_64/Kconfig
@@ -32,6 +32,10 @@ config GENERIC_TIME_VSYSCALL
         bool
         default y
 
+config GENERIC_CMOS_UPDATE
+        bool
+        default y
+
 config ZONE_DMA32
         bool
         default y
@@ -56,6 +60,14 @@ config ZONE_DMA
         bool
         default y
 
+config QUICKLIST
+        bool
+        default y
+
+config NR_QUICK
+        int
+        default 2
+
 config ISA
         bool
 
diff --git a/arch/x86_64/Makefile b/arch/x86_64/Makefile
index 29617ae3926d..128561d3e876 100644
--- a/arch/x86_64/Makefile
+++ b/arch/x86_64/Makefile
@@ -76,7 +76,8 @@ head-y := arch/x86_64/kernel/head.o arch/x86_64/kernel/head64.o arch/x86_64/kern
 libs-y                                  += arch/x86_64/lib/
 core-y                                  += arch/x86_64/kernel/ \
                                            arch/x86_64/mm/ \
-                                           arch/x86_64/crypto/
+                                           arch/x86_64/crypto/ \
+                                           arch/x86_64/vdso/
 core-$(CONFIG_IA32_EMULATION)           += arch/x86_64/ia32/
 drivers-$(CONFIG_PCI)                   += arch/x86_64/pci/
 drivers-$(CONFIG_OPROFILE)              += arch/x86_64/oprofile/
diff --git a/arch/x86_64/defconfig b/arch/x86_64/defconfig
index 40178e5c3104..b7c4cd04bfc3 100644
--- a/arch/x86_64/defconfig
+++ b/arch/x86_64/defconfig
@@ -1,19 +1,22 @@
 #
 # Automatically generated make config: don't edit
-# Linux kernel version: 2.6.22-rc2
-# Mon May 21 13:23:40 2007
+# Linux kernel version: 2.6.22-git14
+# Fri Jul 20 09:53:15 2007
 #
 CONFIG_X86_64=y
 CONFIG_64BIT=y
 CONFIG_X86=y
 CONFIG_GENERIC_TIME=y
 CONFIG_GENERIC_TIME_VSYSCALL=y
+CONFIG_GENERIC_CMOS_UPDATE=y
 CONFIG_ZONE_DMA32=y
 CONFIG_LOCKDEP_SUPPORT=y
 CONFIG_STACKTRACE_SUPPORT=y
 CONFIG_SEMAPHORE_SLEEPERS=y
 CONFIG_MMU=y
 CONFIG_ZONE_DMA=y
+CONFIG_QUICKLIST=y
+CONFIG_NR_QUICK=2
 CONFIG_RWSEM_GENERIC_SPINLOCK=y
 CONFIG_GENERIC_HWEIGHT=y
 CONFIG_GENERIC_CALIBRATE_DELAY=y
@@ -44,19 +47,18 @@ CONFIG_LOCALVERSION=""
 CONFIG_LOCALVERSION_AUTO=y
 CONFIG_SWAP=y
 CONFIG_SYSVIPC=y
-# CONFIG_IPC_NS is not set
 CONFIG_SYSVIPC_SYSCTL=y
 CONFIG_POSIX_MQUEUE=y
 # CONFIG_BSD_PROCESS_ACCT is not set
 # CONFIG_TASKSTATS is not set
-# CONFIG_UTS_NS is not set
+# CONFIG_USER_NS is not set
 # CONFIG_AUDIT is not set
 CONFIG_IKCONFIG=y
 CONFIG_IKCONFIG_PROC=y
 CONFIG_LOG_BUF_SHIFT=18
 # CONFIG_CPUSETS is not set
 CONFIG_SYSFS_DEPRECATED=y
-# CONFIG_RELAY is not set
+CONFIG_RELAY=y
 CONFIG_BLK_DEV_INITRD=y
 CONFIG_INITRAMFS_SOURCE=""
 CONFIG_CC_OPTIMIZE_FOR_SIZE=y
@@ -86,10 +88,6 @@ CONFIG_SLAB=y
 CONFIG_RT_MUTEXES=y
 # CONFIG_TINY_SHMEM is not set
 CONFIG_BASE_SMALL=0
-
-#
-# Loadable module support
-#
 CONFIG_MODULES=y
 CONFIG_MODULE_UNLOAD=y
 CONFIG_MODULE_FORCE_UNLOAD=y
@@ -97,12 +95,9 @@ CONFIG_MODULE_FORCE_UNLOAD=y
 # CONFIG_MODULE_SRCVERSION_ALL is not set
 # CONFIG_KMOD is not set
 CONFIG_STOP_MACHINE=y
-
-#
-# Block layer
-#
 CONFIG_BLOCK=y
 # CONFIG_BLK_DEV_IO_TRACE is not set
+# CONFIG_BLK_DEV_BSG is not set
 
 #
 # IO Schedulers
@@ -165,9 +160,12 @@ CONFIG_SPLIT_PTLOCK_CPUS=4
 CONFIG_MIGRATION=y
 CONFIG_RESOURCES_64BIT=y
 CONFIG_ZONE_DMA_FLAG=1
+CONFIG_BOUNCE=y
+CONFIG_VIRT_TO_BUS=y
 CONFIG_HAVE_ARCH_EARLY_PFN_TO_NID=y
 CONFIG_OUT_OF_LINE_PFN_TO_PAGE=y
 CONFIG_NR_CPUS=32
+CONFIG_PHYSICAL_ALIGN=0x200000
 CONFIG_HOTPLUG_CPU=y
 CONFIG_ARCH_ENABLE_MEMORY_HOTPLUG=y
 CONFIG_HPET_TIMER=y
@@ -180,7 +178,7 @@ CONFIG_X86_MCE_INTEL=y
 CONFIG_X86_MCE_AMD=y
 # CONFIG_KEXEC is not set
 # CONFIG_CRASH_DUMP is not set
-CONFIG_RELOCATABLE=y
+# CONFIG_RELOCATABLE is not set
 CONFIG_PHYSICAL_START=0x200000
 CONFIG_SECCOMP=y
 # CONFIG_CC_STACKPROTECTOR is not set
@@ -201,7 +199,6 @@ CONFIG_GENERIC_PENDING_IRQ=y
 CONFIG_PM=y
 # CONFIG_PM_LEGACY is not set
 # CONFIG_PM_DEBUG is not set
-# CONFIG_PM_SYSFS_DEPRECATED is not set
 CONFIG_SOFTWARE_SUSPEND=y
 CONFIG_PM_STD_PARTITION=""
 CONFIG_SUSPEND_SMP=y
@@ -248,7 +245,7 @@ CONFIG_CPU_FREQ_GOV_PERFORMANCE=y
 # CONFIG_CPU_FREQ_GOV_POWERSAVE is not set
 CONFIG_CPU_FREQ_GOV_USERSPACE=y
 CONFIG_CPU_FREQ_GOV_ONDEMAND=y
-# CONFIG_CPU_FREQ_GOV_CONSERVATIVE is not set
+CONFIG_CPU_FREQ_GOV_CONSERVATIVE=y
 
 #
 # CPUFreq processor drivers
@@ -351,20 +348,8 @@ CONFIG_IPV6_SIT=y
 # CONFIG_IPV6_MULTIPLE_TABLES is not set
 # CONFIG_NETWORK_SECMARK is not set
 # CONFIG_NETFILTER is not set
-
-#
-# DCCP Configuration (EXPERIMENTAL)
-#
 # CONFIG_IP_DCCP is not set
-
-#
-# SCTP Configuration (EXPERIMENTAL)
-#
 # CONFIG_IP_SCTP is not set
-
-#
-# TIPC Configuration (EXPERIMENTAL)
-#
 # CONFIG_TIPC is not set
 # CONFIG_ATM is not set
 # CONFIG_BRIDGE is not set
@@ -401,6 +386,7 @@ CONFIG_IPV6_SIT=y
 # CONFIG_MAC80211 is not set
 # CONFIG_IEEE80211 is not set
 # CONFIG_RFKILL is not set
+# CONFIG_NET_9P is not set
 
 #
 # Device Drivers
@@ -415,21 +401,9 @@ CONFIG_FW_LOADER=y
 # CONFIG_DEBUG_DRIVER is not set
 # CONFIG_DEBUG_DEVRES is not set
 # CONFIG_SYS_HYPERVISOR is not set
-
-#
-# Connector - unified userspace <-> kernelspace linker
-#
 # CONFIG_CONNECTOR is not set
 # CONFIG_MTD is not set
-
-#
-# Parallel port support
-#
 # CONFIG_PARPORT is not set
-
-#
-# Plug and Play support
-#
 CONFIG_PNP=y
 # CONFIG_PNP_DEBUG is not set
 
@@ -437,10 +411,7 @@ CONFIG_PNP=y
 # Protocols
 #
 CONFIG_PNPACPI=y
-
-#
-# Block devices
-#
+CONFIG_BLK_DEV=y
 CONFIG_BLK_DEV_FD=y
 # CONFIG_BLK_CPQ_DA is not set
 # CONFIG_BLK_CPQ_CISS_DA is not set
@@ -458,17 +429,14 @@ CONFIG_BLK_DEV_RAM_SIZE=4096
 CONFIG_BLK_DEV_RAM_BLOCKSIZE=1024
 # CONFIG_CDROM_PKTCDVD is not set
 # CONFIG_ATA_OVER_ETH is not set
-
-#
-# Misc devices
-#
+CONFIG_MISC_DEVICES=y
 # CONFIG_IBM_ASM is not set
 # CONFIG_PHANTOM is not set
+# CONFIG_EEPROM_93CX6 is not set
 # CONFIG_SGI_IOC4 is not set
 # CONFIG_TIFM_CORE is not set
 # CONFIG_SONY_LAPTOP is not set
 # CONFIG_THINKPAD_ACPI is not set
-# CONFIG_BLINK is not set
 CONFIG_IDE=y
 CONFIG_BLK_DEV_IDE=y
 
@@ -539,6 +507,7 @@ CONFIG_BLK_DEV_IDEDMA=y
 #
 # CONFIG_RAID_ATTRS is not set
 CONFIG_SCSI=y
+CONFIG_SCSI_DMA=y
 # CONFIG_SCSI_TGT is not set
 CONFIG_SCSI_NETLINK=y
 # CONFIG_SCSI_PROC_FS is not set
@@ -590,11 +559,9 @@ CONFIG_AIC79XX_DEBUG_MASK=0
 # CONFIG_AIC79XX_REG_PRETTY_PRINT is not set
 # CONFIG_SCSI_AIC94XX is not set
 # CONFIG_SCSI_ARCMSR is not set
-CONFIG_MEGARAID_NEWGEN=y
-CONFIG_MEGARAID_MM=y
-CONFIG_MEGARAID_MAILBOX=y
+# CONFIG_MEGARAID_NEWGEN is not set
 # CONFIG_MEGARAID_LEGACY is not set
-CONFIG_MEGARAID_SAS=y
+# CONFIG_MEGARAID_SAS is not set
 # CONFIG_SCSI_HPTIOP is not set
 # CONFIG_SCSI_BUSLOGIC is not set
 # CONFIG_SCSI_DMX3191D is not set
@@ -614,7 +581,6 @@ CONFIG_MEGARAID_SAS=y
 # CONFIG_SCSI_DC395x is not set
 # CONFIG_SCSI_DC390T is not set
 # CONFIG_SCSI_DEBUG is not set
-# CONFIG_SCSI_ESP_CORE is not set
 # CONFIG_SCSI_SRP is not set
 CONFIG_ATA=y
 # CONFIG_ATA_NONSTANDARD is not set
@@ -671,10 +637,6 @@ CONFIG_SATA_VIA=y
 # CONFIG_PATA_SIS is not set
 # CONFIG_PATA_VIA is not set
 # CONFIG_PATA_WINBOND is not set
-
-#
-# Multi-device support (RAID and LVM)
-#
 CONFIG_MD=y
 # CONFIG_BLK_DEV_MD is not set
 CONFIG_BLK_DEV_DM=y
@@ -692,7 +654,7 @@ CONFIG_BLK_DEV_DM=y
 CONFIG_FUSION=y
 CONFIG_FUSION_SPI=y
 # CONFIG_FUSION_FC is not set
-CONFIG_FUSION_SAS=y
+# CONFIG_FUSION_SAS is not set
 CONFIG_FUSION_MAX_SGE=128
 # CONFIG_FUSION_CTL is not set
 
@@ -710,7 +672,10 @@ CONFIG_IEEE1394=y
 #
 # Controllers
 #
-# CONFIG_IEEE1394_PCILYNX is not set
+
+#
+# Texas Instruments PCILynx requires I2C
+#
 CONFIG_IEEE1394_OHCI1394=y
 
 #
@@ -722,32 +687,19 @@ CONFIG_IEEE1394_OHCI1394=y
 # CONFIG_IEEE1394_ETH1394 is not set
 # CONFIG_IEEE1394_DV1394 is not set
 CONFIG_IEEE1394_RAWIO=y
-
-#
-# I2O device support
-#
 # CONFIG_I2O is not set
-# CONFIG_MACINTOSH_DRIVERS is not set
-
-#
-# Network device support
-#
+CONFIG_MACINTOSH_DRIVERS=y
+# CONFIG_MAC_EMUMOUSEBTN is not set
 CONFIG_NETDEVICES=y
+CONFIG_NETDEVICES_MULTIQUEUE=y
 # CONFIG_DUMMY is not set
 # CONFIG_BONDING is not set
+# CONFIG_MACVLAN is not set
 # CONFIG_EQUALIZER is not set
 CONFIG_TUN=y
 # CONFIG_NET_SB1000 is not set
-
-#
-# ARCnet devices
-#
 # CONFIG_ARCNET is not set
 # CONFIG_PHYLIB is not set
-
-#
-# Ethernet (10 or 100Mbit)
-#
 CONFIG_NET_ETHERNET=y
 CONFIG_MII=y
 # CONFIG_HAPPYMEAL is not set
@@ -756,10 +708,6 @@ CONFIG_MII=y
 CONFIG_NET_VENDOR_3COM=y
 CONFIG_VORTEX=y
 # CONFIG_TYPHOON is not set
-
-#
-# Tulip family network device support
-#
 CONFIG_NET_TULIP=y
 # CONFIG_DE2104X is not set
 CONFIG_TULIP=y
@@ -773,7 +721,8 @@ CONFIG_TULIP=y
 # CONFIG_HP100 is not set
 CONFIG_NET_PCI=y
 # CONFIG_PCNET32 is not set
-# CONFIG_AMD8111_ETH is not set
+CONFIG_AMD8111_ETH=y
+# CONFIG_AMD8111E_NAPI is not set
 # CONFIG_ADAPTEC_STARFIRE is not set
 CONFIG_B44=y
 CONFIG_FORCEDETH=y
@@ -808,7 +757,6 @@ CONFIG_E1000=y
 # CONFIG_SIS190 is not set
 # CONFIG_SKGE is not set
 # CONFIG_SKY2 is not set
-# CONFIG_SK98LIN is not set
 # CONFIG_VIA_VELOCITY is not set
 CONFIG_TIGON3=y
 CONFIG_BNX2=y
@@ -823,10 +771,6 @@ CONFIG_S2IO=m
 # CONFIG_MYRI10GE is not set
 # CONFIG_NETXEN_NIC is not set
 # CONFIG_MLX4_CORE is not set
-
-#
-# Token Ring devices
-#
 # CONFIG_TR is not set
 
 #
@@ -855,15 +799,7 @@ CONFIG_NETCONSOLE=y
 CONFIG_NETPOLL=y
 # CONFIG_NETPOLL_TRAP is not set
 CONFIG_NET_POLL_CONTROLLER=y
-
-#
-# ISDN subsystem
-#
 # CONFIG_ISDN is not set
-
-#
-# Telephony Support
-#
 # CONFIG_PHONE is not set
 
 #
@@ -871,6 +807,7 @@ CONFIG_NET_POLL_CONTROLLER=y
 #
 CONFIG_INPUT=y
 # CONFIG_INPUT_FF_MEMLESS is not set
+# CONFIG_INPUT_POLLDEV is not set
 
 #
 # Userland interfaces
@@ -936,6 +873,7 @@ CONFIG_HW_CONSOLE=y
 #
 CONFIG_SERIAL_8250=y
 CONFIG_SERIAL_8250_CONSOLE=y
+CONFIG_FIX_EARLYCON_MEM=y
 CONFIG_SERIAL_8250_PCI=y
 CONFIG_SERIAL_8250_PNP=y
 CONFIG_SERIAL_8250_NR_UARTS=4
@@ -951,16 +889,11 @@ CONFIG_SERIAL_CORE_CONSOLE=y
 CONFIG_UNIX98_PTYS=y
 CONFIG_LEGACY_PTYS=y
 CONFIG_LEGACY_PTY_COUNT=256
-
-#
-# IPMI
-#
 # CONFIG_IPMI_HANDLER is not set
 # CONFIG_WATCHDOG is not set
 CONFIG_HW_RANDOM=y
 CONFIG_HW_RANDOM_INTEL=y
 CONFIG_HW_RANDOM_AMD=y
-# CONFIG_HW_RANDOM_GEODE is not set
 # CONFIG_NVRAM is not set
 CONFIG_RTC=y
 # CONFIG_R3964 is not set
@@ -979,127 +912,19 @@ CONFIG_HPET=y
 # CONFIG_HPET_RTC_IRQ is not set
 CONFIG_HPET_MMAP=y
 # CONFIG_HANGCHECK_TIMER is not set
-
-#
-# TPM devices
-#
 # CONFIG_TCG_TPM is not set
 # CONFIG_TELCLOCK is not set
 CONFIG_DEVPORT=y
-CONFIG_I2C=m
-CONFIG_I2C_BOARDINFO=y
-CONFIG_I2C_CHARDEV=m
-
-#
-# I2C Algorithms
-#
-# CONFIG_I2C_ALGOBIT is not set
-# CONFIG_I2C_ALGOPCF is not set
-# CONFIG_I2C_ALGOPCA is not set
-
-#
-# I2C Hardware Bus support
-#
-# CONFIG_I2C_ALI1535 is not set
-# CONFIG_I2C_ALI1563 is not set
-# CONFIG_I2C_ALI15X3 is not set
-# CONFIG_I2C_AMD756 is not set
-# CONFIG_I2C_AMD8111 is not set
-# CONFIG_I2C_I801 is not set
-# CONFIG_I2C_I810 is not set
-# CONFIG_I2C_PIIX4 is not set
-# CONFIG_I2C_NFORCE2 is not set
-# CONFIG_I2C_OCORES is not set
-# CONFIG_I2C_PARPORT_LIGHT is not set
-# CONFIG_I2C_PROSAVAGE is not set
-# CONFIG_I2C_SAVAGE4 is not set
-# CONFIG_I2C_SIMTEC is not set
-# CONFIG_I2C_SIS5595 is not set
-# CONFIG_I2C_SIS630 is not set
-# CONFIG_I2C_SIS96X is not set
-# CONFIG_I2C_STUB is not set
-# CONFIG_I2C_TINY_USB is not set
-# CONFIG_I2C_VIA is not set
-# CONFIG_I2C_VIAPRO is not set
-# CONFIG_I2C_VOODOO3 is not set
-
-#
-# Miscellaneous I2C Chip support
-#
-# CONFIG_SENSORS_DS1337 is not set
-# CONFIG_SENSORS_DS1374 is not set
-# CONFIG_SENSORS_EEPROM is not set
-# CONFIG_SENSORS_PCF8574 is not set
-# CONFIG_SENSORS_PCA9539 is not set
-# CONFIG_SENSORS_PCF8591 is not set
-# CONFIG_SENSORS_MAX6875 is not set
-# CONFIG_I2C_DEBUG_CORE is not set
-# CONFIG_I2C_DEBUG_ALGO is not set
-# CONFIG_I2C_DEBUG_BUS is not set
-# CONFIG_I2C_DEBUG_CHIP is not set
+# CONFIG_I2C is not set
 
 #
 # SPI support
 #
 # CONFIG_SPI is not set
 # CONFIG_SPI_MASTER is not set
-
-#
-# Dallas's 1-wire bus
-#
 # CONFIG_W1 is not set
-CONFIG_HWMON=y
-# CONFIG_HWMON_VID is not set
-# CONFIG_SENSORS_ABITUGURU is not set
-# CONFIG_SENSORS_AD7418 is not set
-# CONFIG_SENSORS_ADM1021 is not set
-# CONFIG_SENSORS_ADM1025 is not set
-# CONFIG_SENSORS_ADM1026 is not set
-# CONFIG_SENSORS_ADM1029 is not set
-# CONFIG_SENSORS_ADM1031 is not set
-# CONFIG_SENSORS_ADM9240 is not set
-# CONFIG_SENSORS_K8TEMP is not set
-# CONFIG_SENSORS_ASB100 is not set
-# CONFIG_SENSORS_ATXP1 is not set
-# CONFIG_SENSORS_DS1621 is not set
-# CONFIG_SENSORS_F71805F is not set
-# CONFIG_SENSORS_FSCHER is not set
-# CONFIG_SENSORS_FSCPOS is not set
-# CONFIG_SENSORS_GL518SM is not set
-# CONFIG_SENSORS_GL520SM is not set
-CONFIG_SENSORS_CORETEMP=y
-# CONFIG_SENSORS_IT87 is not set
-# CONFIG_SENSORS_LM63 is not set
-# CONFIG_SENSORS_LM75 is not set
-# CONFIG_SENSORS_LM77 is not set
-# CONFIG_SENSORS_LM78 is not set
-# CONFIG_SENSORS_LM80 is not set
-# CONFIG_SENSORS_LM83 is not set
-# CONFIG_SENSORS_LM85 is not set
-# CONFIG_SENSORS_LM87 is not set
-# CONFIG_SENSORS_LM90 is not set
-# CONFIG_SENSORS_LM92 is not set
-# CONFIG_SENSORS_MAX1619 is not set
-# CONFIG_SENSORS_MAX6650 is not set
-# CONFIG_SENSORS_PC87360 is not set
-# CONFIG_SENSORS_PC87427 is not set
-# CONFIG_SENSORS_SIS5595 is not set
-# CONFIG_SENSORS_SMSC47M1 is not set
-# CONFIG_SENSORS_SMSC47M192 is not set
-CONFIG_SENSORS_SMSC47B397=m
-# CONFIG_SENSORS_VIA686A is not set
-# CONFIG_SENSORS_VT1211 is not set
-# CONFIG_SENSORS_VT8231 is not set
-# CONFIG_SENSORS_W83781D is not set
-# CONFIG_SENSORS_W83791D is not set
-# CONFIG_SENSORS_W83792D is not set
-# CONFIG_SENSORS_W83793 is not set
-# CONFIG_SENSORS_W83L785TS is not set
-# CONFIG_SENSORS_W83627HF is not set
-# CONFIG_SENSORS_W83627EHF is not set
-# CONFIG_SENSORS_HDAPS is not set
-# CONFIG_SENSORS_APPLESMC is not set
-# CONFIG_HWMON_DEBUG_CHIP is not set
+# CONFIG_POWER_SUPPLY is not set
+# CONFIG_HWMON is not set
 
 #
 # Multifunction device drivers
@@ -1149,15 +974,11 @@ CONFIG_SOUND=y
 # Open Sound System
 #
 CONFIG_SOUND_PRIME=y
-# CONFIG_OSS_OBSOLETE is not set
 # CONFIG_SOUND_TRIDENT is not set
 # CONFIG_SOUND_MSNDCLAS is not set
 # CONFIG_SOUND_MSNDPIN is not set
 # CONFIG_SOUND_OSS is not set
-
-#
-# HID Devices
-#
+CONFIG_HID_SUPPORT=y
 CONFIG_HID=y
 # CONFIG_HID_DEBUG is not set
 
@@ -1168,10 +989,7 @@ CONFIG_USB_HID=y
 # CONFIG_USB_HIDINPUT_POWERBOOK is not set
 # CONFIG_HID_FF is not set
 # CONFIG_USB_HIDDEV is not set
-
-#
-# USB support
-#
+CONFIG_USB_SUPPORT=y
 CONFIG_USB_ARCH_HAS_HCD=y
 CONFIG_USB_ARCH_HAS_OHCI=y
 CONFIG_USB_ARCH_HAS_EHCI=y
@@ -1185,6 +1003,7 @@ CONFIG_USB_DEVICEFS=y
 # CONFIG_USB_DEVICE_CLASS is not set
 # CONFIG_USB_DYNAMIC_MINORS is not set
 # CONFIG_USB_SUSPEND is not set
+# CONFIG_USB_PERSIST is not set
 # CONFIG_USB_OTG is not set
 
 #
@@ -1194,7 +1013,6 @@ CONFIG_USB_EHCI_HCD=y
 # CONFIG_USB_EHCI_SPLIT_ISO is not set
 # CONFIG_USB_EHCI_ROOT_HUB_TT is not set
 # CONFIG_USB_EHCI_TT_NEWSCHED is not set
-# CONFIG_USB_EHCI_BIG_ENDIAN_MMIO is not set
 # CONFIG_USB_ISP116X_HCD is not set
 CONFIG_USB_OHCI_HCD=y
 # CONFIG_USB_OHCI_BIG_ENDIAN_DESC is not set
@@ -1202,6 +1020,7 @@ CONFIG_USB_OHCI_HCD=y
 CONFIG_USB_OHCI_LITTLE_ENDIAN=y
 CONFIG_USB_UHCI_HCD=y
 # CONFIG_USB_SL811_HCD is not set
+# CONFIG_USB_R8A66597_HCD is not set
 
 #
 # USB Device Class drivers
@@ -1292,15 +1111,7 @@ CONFIG_USB_MON=y
 #
 # LED Triggers
 #
-
-#
-# InfiniBand support
-#
 # CONFIG_INFINIBAND is not set
-
-#
-# EDAC - error detection and reporting (RAS) (EXPERIMENTAL)
-#
 # CONFIG_EDAC is not set
 
 #
@@ -1320,11 +1131,13 @@ CONFIG_USB_MON=y
 #
 # DMA Devices
 #
+CONFIG_VIRTUALIZATION=y
+# CONFIG_KVM is not set
 
 #
-# Virtualization
+# Userspace I/O
 #
-# CONFIG_KVM is not set
+# CONFIG_UIO is not set
 
 #
 # Firmware Drivers
@@ -1332,6 +1145,7 @@ CONFIG_USB_MON=y
 # CONFIG_EDD is not set
 # CONFIG_DELL_RBU is not set
 # CONFIG_DCDBAS is not set
+CONFIG_DMIID=y
 
 #
 # File systems
@@ -1447,7 +1261,6 @@ CONFIG_SUNRPC=y
 # CONFIG_NCP_FS is not set
 # CONFIG_CODA_FS is not set
 # CONFIG_AFS_FS is not set
-# CONFIG_9P_FS is not set
 
 #
 # Partition Types
@@ -1524,8 +1337,9 @@ CONFIG_DEBUG_FS=y
 CONFIG_DEBUG_KERNEL=y
 # CONFIG_DEBUG_SHIRQ is not set
 CONFIG_DETECT_SOFTLOCKUP=y
+# CONFIG_SCHED_DEBUG is not set
 # CONFIG_SCHEDSTATS is not set
-# CONFIG_TIMER_STATS is not set
+CONFIG_TIMER_STATS=y
 # CONFIG_DEBUG_SLAB is not set
 # CONFIG_DEBUG_RT_MUTEXES is not set
 # CONFIG_RT_MUTEX_TESTER is not set
@@ -1533,6 +1347,7 @@ CONFIG_DETECT_SOFTLOCKUP=y
 # CONFIG_DEBUG_MUTEXES is not set
 # CONFIG_DEBUG_LOCK_ALLOC is not set
 # CONFIG_PROVE_LOCKING is not set
+# CONFIG_LOCK_STAT is not set
 # CONFIG_DEBUG_SPINLOCK_SLEEP is not set
 # CONFIG_DEBUG_LOCKING_API_SELFTESTS is not set
 # CONFIG_DEBUG_KOBJECT is not set
@@ -1541,8 +1356,6 @@ CONFIG_DEBUG_BUGVERBOSE=y
 # CONFIG_DEBUG_VM is not set
 # CONFIG_DEBUG_LIST is not set
 # CONFIG_FRAME_POINTER is not set
-CONFIG_UNWIND_INFO=y
-CONFIG_STACK_UNWIND=y
 # CONFIG_FORCED_INLINING is not set
 # CONFIG_RCU_TORTURE_TEST is not set
 # CONFIG_LKDTM is not set
@@ -1557,10 +1370,6 @@ CONFIG_DEBUG_STACKOVERFLOW=y
 #
 # CONFIG_KEYS is not set
 # CONFIG_SECURITY is not set
-
-#
-# Cryptographic options
-#
 # CONFIG_CRYPTO is not set
 
 #
@@ -1571,6 +1380,7 @@ CONFIG_BITREVERSE=y
 # CONFIG_CRC16 is not set
 # CONFIG_CRC_ITU_T is not set
 CONFIG_CRC32=y
+# CONFIG_CRC7 is not set
 # CONFIG_LIBCRC32C is not set
 CONFIG_ZLIB_INFLATE=y
 CONFIG_PLIST=y
diff --git a/arch/x86_64/ia32/ia32_binfmt.c b/arch/x86_64/ia32/ia32_binfmt.c
index ed56a8806eab..b70f3e7cf06c 100644
--- a/arch/x86_64/ia32/ia32_binfmt.c
+++ b/arch/x86_64/ia32/ia32_binfmt.c
@@ -38,6 +38,7 @@
 
 int sysctl_vsyscall32 = 1;
 
+#undef ARCH_DLINFO
 #define ARCH_DLINFO do {  \
         if (sysctl_vsyscall32) { \
         NEW_AUX_ENT(AT_SYSINFO, (u32)(u64)VSYSCALL32_VSYSCALL); \
diff --git a/arch/x86_64/ia32/ia32entry.S b/arch/x86_64/ia32/ia32entry.S
index 3f66e970d86f..938278697e20 100644
--- a/arch/x86_64/ia32/ia32entry.S
+++ b/arch/x86_64/ia32/ia32entry.S
@@ -104,7 +104,7 @@ ENTRY(ia32_sysenter_target)
         pushq   %rax
         CFI_ADJUST_CFA_OFFSET 8
         cld
-        SAVE_ARGS 0,0,0
+        SAVE_ARGS 0,0,1
         /* no need to do an access_ok check here because rbp has been
            32bit zero extended */ 
 1:      movl    (%rbp),%r9d
@@ -294,7 +294,7 @@ ia32_badarg:
  */                             
 
 ENTRY(ia32_syscall)
-        CFI_STARTPROC   simple
+        CFI_STARTPROC32 simple
         CFI_SIGNAL_FRAME
         CFI_DEF_CFA     rsp,SS+8-RIP
         /*CFI_REL_OFFSET        ss,SS-RIP*/
@@ -330,6 +330,7 @@ ia32_sysret:
 
 ia32_tracesys:                   
         SAVE_REST
+        CLEAR_RREGS
         movq $-ENOSYS,RAX(%rsp) /* really needed? */
         movq %rsp,%rdi        /* &pt_regs -> arg1 */
         call syscall_trace_enter
diff --git a/arch/x86_64/kernel/aperture.c b/arch/x86_64/kernel/aperture.c
index a3d450d6c15b..8f681cae7bf7 100644
--- a/arch/x86_64/kernel/aperture.c
+++ b/arch/x86_64/kernel/aperture.c
@@ -20,7 +20,7 @@
 #include <linux/ioport.h>
 #include <asm/e820.h>
 #include <asm/io.h>
-#include <asm/proto.h>
+#include <asm/iommu.h>
 #include <asm/pci-direct.h>
 #include <asm/dma.h>
 #include <asm/k8.h>
@@ -214,7 +214,7 @@ void __init iommu_hole_init(void)
         if (iommu_aperture_disabled || !fix_aperture || !early_pci_allowed())
                 return;
 
-        printk("Checking aperture...\n"); 
+        printk(KERN_INFO  "Checking aperture...\n");
 
         fix = 0;
         for (num = 24; num < 32; num++) {               
diff --git a/arch/x86_64/kernel/apic.c b/arch/x86_64/kernel/apic.c
index 1b0e07bb8728..900ff38d68de 100644
--- a/arch/x86_64/kernel/apic.c
+++ b/arch/x86_64/kernel/apic.c
@@ -92,8 +92,9 @@ unsigned int safe_apic_wait_icr_idle(void)
 void enable_NMI_through_LVT0 (void * dummy)
 {
         unsigned int v;
-        
-        v = APIC_DM_NMI;                        /* unmask and set to NMI */
+
+        /* unmask and set to NMI */
+        v = APIC_DM_NMI;
         apic_write(APIC_LVT0, v);
 }
 
@@ -120,7 +121,7 @@ void ack_bad_irq(unsigned int irq)
          * holds up an irq slot - in excessive cases (when multiple
          * unexpected vectors occur) that might lock up the APIC
          * completely.
-         * But don't ack when the APIC is disabled. -AK
+         * But don't ack when the APIC is disabled. -AK
          */
         if (!disable_apic)
                 ack_APIC_irq();
@@ -616,7 +617,7 @@ early_param("apic", apic_set_verbosity);
  * Detect and enable local APICs on non-SMP boards.
  * Original code written by Keir Fraser.
  * On AMD64 we trust the BIOS - if it says no APIC it is likely
- * not correctly set up (usually the APIC timer won't work etc.) 
+ * not correctly set up (usually the APIC timer won't work etc.)
  */
 
 static int __init detect_init_APIC (void)
@@ -789,13 +790,13 @@ static void setup_APIC_timer(unsigned int clocks)
         local_irq_save(flags);
 
         /* wait for irq slice */
-        if (hpet_address && hpet_use_timer) {
-                int trigger = hpet_readl(HPET_T0_CMP);
-                while (hpet_readl(HPET_COUNTER) >= trigger)
-                        /* do nothing */ ;
-                while (hpet_readl(HPET_COUNTER) <  trigger)
-                        /* do nothing */ ;
-        } else {
+        if (hpet_address && hpet_use_timer) {
+                int trigger = hpet_readl(HPET_T0_CMP);
+                while (hpet_readl(HPET_COUNTER) >= trigger)
+                        /* do nothing */ ;
+                while (hpet_readl(HPET_COUNTER) <  trigger)
+                        /* do nothing */ ;
+        } else {
                 int c1, c2;
                 outb_p(0x00, 0x43);
                 c2 = inb_p(0x40);
@@ -881,10 +882,10 @@ static unsigned int calibration_result;
 
 void __init setup_boot_APIC_clock (void)
 {
-        if (disable_apic_timer) { 
-                printk(KERN_INFO "Disabling APIC timer\n"); 
-                return; 
-        } 
+        if (disable_apic_timer) {
+                printk(KERN_INFO "Disabling APIC timer\n");
+                return;
+        }
 
         printk(KERN_INFO "Using local APIC timer interrupts.\n");
         using_apic_timer = 1;
@@ -990,8 +991,8 @@ int setup_profiling_timer(unsigned int multiplier)
         return -EINVAL;
 }
 
-void setup_APIC_extened_lvt(unsigned char lvt_off, unsigned char vector,
-                            unsigned char msg_type, unsigned char mask)
+void setup_APIC_extended_lvt(unsigned char lvt_off, unsigned char vector,
+                             unsigned char msg_type, unsigned char mask)
 {
         unsigned long reg = (lvt_off << 4) + K8_APIC_EXT_LVT_BASE;
         unsigned int  v   = (mask << 16) | (msg_type << 8) | vector;
@@ -1128,20 +1129,6 @@ asmlinkage void smp_spurious_interrupt(void)
         if (v & (1 << (SPURIOUS_APIC_VECTOR & 0x1f)))
                 ack_APIC_irq();
 
-#if 0
-        static unsigned long last_warning; 
-        static unsigned long skipped; 
-
-        /* see sw-dev-man vol 3, chapter 7.4.13.5 */
-        if (time_before(last_warning+30*HZ,jiffies)) { 
-                printk(KERN_INFO "spurious APIC interrupt on CPU#%d, %ld skipped.\n",
-                       smp_processor_id(), skipped);
-                last_warning = jiffies; 
-                skipped = 0;
-        } else { 
-                skipped++; 
-        } 
-#endif 
         irq_exit();
 }
 
@@ -1173,11 +1160,11 @@ asmlinkage void smp_error_interrupt(void)
            7: Illegal register address
         */
         printk (KERN_DEBUG "APIC error on CPU%d: %02x(%02x)\n",
-                smp_processor_id(), v , v1);
+                smp_processor_id(), v , v1);
         irq_exit();
 }
 
-int disable_apic; 
+int disable_apic;
 
 /*
  * This initializes the IO-APIC and APIC hardware if this is
@@ -1185,11 +1172,11 @@ int disable_apic;
  */
 int __init APIC_init_uniprocessor (void)
 {
-        if (disable_apic) { 
+        if (disable_apic) {
                 printk(KERN_INFO "Apic disabled\n");
-                return -1; 
+                return -1;
         }
-        if (!cpu_has_apic) { 
+        if (!cpu_has_apic) {
                 disable_apic = 1;
                 printk(KERN_INFO "Apic disabled by BIOS\n");
                 return -1;
@@ -1211,8 +1198,8 @@ int __init APIC_init_uniprocessor (void)
         return 0;
 }
 
-static __init int setup_disableapic(char *str) 
-{ 
+static __init int setup_disableapic(char *str)
+{
         disable_apic = 1;
         clear_bit(X86_FEATURE_APIC, boot_cpu_data.x86_capability);
         return 0;
@@ -1220,10 +1207,10 @@ static __init int setup_disableapic(char *str)
 early_param("disableapic", setup_disableapic);
 
 /* same as disableapic, for compatibility */
-static __init int setup_nolapic(char *str) 
-{ 
+static __init int setup_nolapic(char *str)
+{
         return setup_disableapic(str);
-} 
+}
 early_param("nolapic", setup_nolapic);
 
 static int __init parse_lapic_timer_c2_ok(char *arg)
@@ -1233,13 +1220,13 @@ static int __init parse_lapic_timer_c2_ok(char *arg)
 }
 early_param("lapic_timer_c2_ok", parse_lapic_timer_c2_ok);
 
-static __init int setup_noapictimer(char *str) 
-{ 
+static __init int setup_noapictimer(char *str)
+{
         if (str[0] != ' ' && str[0] != 0)
                 return 0;
         disable_apic_timer = 1;
         return 1;
-} 
+}
 
 static __init int setup_apicmaintimer(char *str)
 {
@@ -1264,5 +1251,5 @@ static __init int setup_apicpmtimer(char *s)
 }
 __setup("apicpmtimer", setup_apicpmtimer);
 
-__setup("noapictimer", setup_noapictimer); 
+__setup("noapictimer", setup_noapictimer);
 
diff --git a/arch/x86_64/kernel/e820.c b/arch/x86_64/kernel/e820.c
index 13c6c37610e0..0f4d5e209e9b 100644
--- a/arch/x86_64/kernel/e820.c
+++ b/arch/x86_64/kernel/e820.c
@@ -194,37 +194,6 @@ unsigned long __init e820_end_of_ram(void)
 }
 
 /*
- * Find the hole size in the range.
- */
-unsigned long __init e820_hole_size(unsigned long start, unsigned long end)
-{
-        unsigned long ram = 0;
-        int i;
-
-        for (i = 0; i < e820.nr_map; i++) {
-                struct e820entry *ei = &e820.map[i];
-                unsigned long last, addr;
-
-                if (ei->type != E820_RAM ||
-                    ei->addr+ei->size <= start ||
-                    ei->addr >= end)
-                        continue;
-
-                addr = round_up(ei->addr, PAGE_SIZE);
-                if (addr < start)
-                        addr = start;
-
-                last = round_down(ei->addr + ei->size, PAGE_SIZE);
-                if (last >= end)
-                        last = end;
-
-                if (last > addr)
-                        ram += last - addr;
-        }
-        return ((end - start) - ram);
-}
-
-/*
  * Mark e820 reserved areas as busy for the resource manager.
  */
 void __init e820_reserve_resources(void)
@@ -289,47 +258,61 @@ void __init e820_mark_nosave_regions(void)
         }
 }
 
-/* Walk the e820 map and register active regions within a node */
-void __init
-e820_register_active_regions(int nid, unsigned long start_pfn,
-                                                        unsigned long end_pfn)
+/*
+ * Finds an active region in the address range from start_pfn to end_pfn and
+ * returns its range in ei_startpfn and ei_endpfn for the e820 entry.
+ */
+static int __init e820_find_active_region(const struct e820entry *ei,
+                                          unsigned long start_pfn,
+                                          unsigned long end_pfn,
+                                          unsigned long *ei_startpfn,
+                                          unsigned long *ei_endpfn)
 {
-        int i;
-        unsigned long ei_startpfn, ei_endpfn;
-        for (i = 0; i < e820.nr_map; i++) {
-                struct e820entry *ei = &e820.map[i];
-                ei_startpfn = round_up(ei->addr, PAGE_SIZE) >> PAGE_SHIFT;
-                ei_endpfn = round_down(ei->addr + ei->size, PAGE_SIZE)
-                                                                >> PAGE_SHIFT;
+        *ei_startpfn = round_up(ei->addr, PAGE_SIZE) >> PAGE_SHIFT;
+        *ei_endpfn = round_down(ei->addr + ei->size, PAGE_SIZE) >> PAGE_SHIFT;
 
-                /* Skip map entries smaller than a page */
-                if (ei_startpfn >= ei_endpfn)
-                        continue;
+        /* Skip map entries smaller than a page */
+        if (*ei_startpfn >= *ei_endpfn)
+                return 0;
 
-                /* Check if end_pfn_map should be updated */
-                if (ei->type != E820_RAM && ei_endpfn > end_pfn_map)
-                        end_pfn_map = ei_endpfn;
+        /* Check if end_pfn_map should be updated */
+        if (ei->type != E820_RAM && *ei_endpfn > end_pfn_map)
+                end_pfn_map = *ei_endpfn;
 
-                /* Skip if map is outside the node */
-                if (ei->type != E820_RAM ||
-                                ei_endpfn <= start_pfn ||
-                                ei_startpfn >= end_pfn)
-                        continue;
+        /* Skip if map is outside the node */
+        if (ei->type != E820_RAM || *ei_endpfn <= start_pfn ||
+                                    *ei_startpfn >= end_pfn)
+                return 0;
 
-                /* Check for overlaps */
-                if (ei_startpfn < start_pfn)
-                        ei_startpfn = start_pfn;
-                if (ei_endpfn > end_pfn)
-                        ei_endpfn = end_pfn;
+        /* Check for overlaps */
+        if (*ei_startpfn < start_pfn)
+                *ei_startpfn = start_pfn;
+        if (*ei_endpfn > end_pfn)
+                *ei_endpfn = end_pfn;
 
-                /* Obey end_user_pfn to save on memmap */
-                if (ei_startpfn >= end_user_pfn)
-                        continue;
-                if (ei_endpfn > end_user_pfn)
-                        ei_endpfn = end_user_pfn;
+        /* Obey end_user_pfn to save on memmap */
+        if (*ei_startpfn >= end_user_pfn)
+                return 0;
+        if (*ei_endpfn > end_user_pfn)
+                *ei_endpfn = end_user_pfn;
 
-                add_active_range(nid, ei_startpfn, ei_endpfn);
-        }
+        return 1;
+}
+
+/* Walk the e820 map and register active regions within a node */
+void __init
+e820_register_active_regions(int nid, unsigned long start_pfn,
+                                                        unsigned long end_pfn)
+{
+        unsigned long ei_startpfn;
+        unsigned long ei_endpfn;
+        int i;
+
+        for (i = 0; i < e820.nr_map; i++)
+                if (e820_find_active_region(&e820.map[i],
+                                            start_pfn, end_pfn,
+                                            &ei_startpfn, &ei_endpfn))
+                        add_active_range(nid, ei_startpfn, ei_endpfn);
 }
 
 /* 
@@ -350,12 +333,35 @@ void __init add_memory_region(unsigned long start, unsigned long size, int type)
         e820.nr_map++;
 }
 
+/*
+ * Find the hole size (in bytes) in the memory range.
+ * @start: starting address of the memory range to scan
+ * @end: ending address of the memory range to scan
+ */
+unsigned long __init e820_hole_size(unsigned long start, unsigned long end)
+{
+        unsigned long start_pfn = start >> PAGE_SHIFT;
+        unsigned long end_pfn = end >> PAGE_SHIFT;
+        unsigned long ei_startpfn;
+        unsigned long ei_endpfn;
+        unsigned long ram = 0;
+        int i;
+
+        for (i = 0; i < e820.nr_map; i++) {
+                if (e820_find_active_region(&e820.map[i],
+                                            start_pfn, end_pfn,
+                                            &ei_startpfn, &ei_endpfn))
+                        ram += ei_endpfn - ei_startpfn;
+        }
+        return end - start - (ram << PAGE_SHIFT);
+}
+
 void __init e820_print_map(char *who)
 {
         int i;
 
         for (i = 0; i < e820.nr_map; i++) {
-                printk(" %s: %016Lx - %016Lx ", who,
+                printk(KERN_INFO " %s: %016Lx - %016Lx ", who,
                         (unsigned long long) e820.map[i].addr,
                         (unsigned long long) (e820.map[i].addr + e820.map[i].size));
                 switch (e820.map[i].type) {
diff --git a/arch/x86_64/kernel/early-quirks.c b/arch/x86_64/kernel/early-quirks.c
index 990d9c218a5d..13aa4fd728f3 100644
--- a/arch/x86_64/kernel/early-quirks.c
+++ b/arch/x86_64/kernel/early-quirks.c
@@ -14,6 +14,7 @@
 #include <linux/pci_ids.h>
 #include <asm/pci-direct.h>
 #include <asm/proto.h>
+#include <asm/iommu.h>
 #include <asm/dma.h>
 
 static void __init via_bugs(void)
diff --git a/arch/x86_64/kernel/entry.S b/arch/x86_64/kernel/entry.S
index a67f87bf4015..830cfc6ee8cb 100644
--- a/arch/x86_64/kernel/entry.S
+++ b/arch/x86_64/kernel/entry.S
@@ -282,7 +282,7 @@ sysret_careful:
 sysret_signal:
         TRACE_IRQS_ON
         sti
-        testl $(_TIF_SIGPENDING|_TIF_NOTIFY_RESUME|_TIF_SINGLESTEP),%edx
+        testl $(_TIF_SIGPENDING|_TIF_NOTIFY_RESUME|_TIF_SINGLESTEP|_TIF_MCE_NOTIFY),%edx
         jz    1f
 
         /* Really a signal */
@@ -375,7 +375,7 @@ int_very_careful:
         jmp int_restore_rest
         
 int_signal:
-        testl $(_TIF_NOTIFY_RESUME|_TIF_SIGPENDING|_TIF_SINGLESTEP),%edx
+        testl $(_TIF_NOTIFY_RESUME|_TIF_SIGPENDING|_TIF_SINGLESTEP|_TIF_MCE_NOTIFY),%edx
         jz 1f
         movq %rsp,%rdi          # &ptregs -> arg1
         xorl %esi,%esi          # oldset -> arg2
@@ -599,7 +599,7 @@ retint_careful:
         jmp retint_check
         
 retint_signal:
-        testl $(_TIF_SIGPENDING|_TIF_NOTIFY_RESUME|_TIF_SINGLESTEP),%edx
+        testl $(_TIF_SIGPENDING|_TIF_NOTIFY_RESUME|_TIF_SINGLESTEP|_TIF_MCE_NOTIFY),%edx
         jz    retint_swapgs
         TRACE_IRQS_ON
         sti
diff --git a/arch/x86_64/kernel/hpet.c b/arch/x86_64/kernel/hpet.c
index b8286968662d..636f4f9fc6bb 100644
--- a/arch/x86_64/kernel/hpet.c
+++ b/arch/x86_64/kernel/hpet.c
@@ -190,7 +190,7 @@ int hpet_reenable(void)
  */
 
 #define TICK_COUNT 100000000
-#define TICK_MIN   5000
+#define SMI_THRESHOLD 50000
 #define MAX_TRIES  5
 
 /*
@@ -205,7 +205,7 @@ static void __init read_hpet_tsc(int *hpet, int *tsc)
                 tsc1 = get_cycles_sync();
                 hpet1 = hpet_readl(HPET_COUNTER);
                 tsc2 = get_cycles_sync();
-                if (tsc2 - tsc1 > TICK_MIN)
+                if ((tsc2 - tsc1) < SMI_THRESHOLD)
                         break;
         }
         *hpet = hpet1;
@@ -439,7 +439,7 @@ int hpet_rtc_dropped_irq(void)
         return 1;
 }
 
-irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id, struct pt_regs *regs)
+irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id)
 {
         struct rtc_time curr_time;
         unsigned long rtc_int_flag = 0;
diff --git a/arch/x86_64/kernel/i8259.c b/arch/x86_64/kernel/i8259.c
index 4b326655b208..948cae646099 100644
--- a/arch/x86_64/kernel/i8259.c
+++ b/arch/x86_64/kernel/i8259.c
@@ -444,24 +444,6 @@ void __init init_ISA_irqs (void)
         }
 }
 
-void apic_timer_interrupt(void);
-void spurious_interrupt(void);
-void error_interrupt(void);
-void reschedule_interrupt(void);
-void call_function_interrupt(void);
-void irq_move_cleanup_interrupt(void);
-void invalidate_interrupt0(void);
-void invalidate_interrupt1(void);
-void invalidate_interrupt2(void);
-void invalidate_interrupt3(void);
-void invalidate_interrupt4(void);
-void invalidate_interrupt5(void);
-void invalidate_interrupt6(void);
-void invalidate_interrupt7(void);
-void thermal_interrupt(void);
-void threshold_interrupt(void);
-void i8254_timer_resume(void);
-
 static void setup_timer_hardware(void)
 {
         outb_p(0x34,0x43);              /* binary, mode 2, LSB/MSB, ch 0 */
diff --git a/arch/x86_64/kernel/io_apic.c b/arch/x86_64/kernel/io_apic.c
index 1c6c6f724573..050141c0602b 100644
--- a/arch/x86_64/kernel/io_apic.c
+++ b/arch/x86_64/kernel/io_apic.c
@@ -152,6 +152,32 @@ static inline void io_apic_modify(unsigned int apic, unsigned int value)
         writel(value, &io_apic->data);
 }
 
+static int io_apic_level_ack_pending(unsigned int irq)
+{
+        struct irq_pin_list *entry;
+        unsigned long flags;
+        int pending = 0;
+
+        spin_lock_irqsave(&ioapic_lock, flags);
+        entry = irq_2_pin + irq;
+        for (;;) {
+                unsigned int reg;
+                int pin;
+
+                pin = entry->pin;
+                if (pin == -1)
+                        break;
+                reg = io_apic_read(entry->apic, 0x10 + pin*2);
+                /* Is the remote IRR bit set? */
+                pending |= (reg >> 14) & 1;
+                if (!entry->next)
+                        break;
+                entry = irq_2_pin + entry->next;
+        }
+        spin_unlock_irqrestore(&ioapic_lock, flags);
+        return pending;
+}
+
 /*
  * Synchronize the IO-APIC and the CPU by doing
  * a dummy read from the IO-APIC
@@ -1418,9 +1444,37 @@ static void ack_apic_level(unsigned int irq)
         ack_APIC_irq();
 
         /* Now we can move and renable the irq */
-        move_masked_irq(irq);
-        if (unlikely(do_unmask_irq))
+        if (unlikely(do_unmask_irq)) {
+                /* Only migrate the irq if the ack has been received.
+                 *
+                 * On rare occasions the broadcast level triggered ack gets
+                 * delayed going to ioapics, and if we reprogram the
+                 * vector while Remote IRR is still set the irq will never
+                 * fire again.
+                 *
+                 * To prevent this scenario we read the Remote IRR bit
+                 * of the ioapic.  This has two effects.
+                 * - On any sane system the read of the ioapic will
+                 *   flush writes (and acks) going to the ioapic from
+                 *   this cpu.
+                 * - We get to see if the ACK has actually been delivered.
+                 *
+                 * Based on failed experiments of reprogramming the
+                 * ioapic entry from outside of irq context starting
+                 * with masking the ioapic entry and then polling until
+                 * Remote IRR was clear before reprogramming the
+                 * ioapic I don't trust the Remote IRR bit to be
+                 * completey accurate.
+                 *
+                 * However there appears to be no other way to plug
+                 * this race, so if the Remote IRR bit is not
+                 * accurate and is causing problems then it is a hardware bug
+                 * and you can go talk to the chipset vendor about it.
+                 */
+                if (!io_apic_level_ack_pending(irq))
+                        move_masked_irq(irq);
                 unmask_IO_APIC_irq(irq);
+        }
 }
 
 static struct irq_chip ioapic_chip __read_mostly = {
diff --git a/arch/x86_64/kernel/mce.c b/arch/x86_64/kernel/mce.c
index f3fb8174559e..4d8450ee3635 100644
--- a/arch/x86_64/kernel/mce.c
+++ b/arch/x86_64/kernel/mce.c
@@ -18,6 +18,8 @@
 #include <linux/capability.h>
 #include <linux/cpu.h>
 #include <linux/percpu.h>
+#include <linux/poll.h>
+#include <linux/thread_info.h>
 #include <linux/ctype.h>
 #include <linux/kmod.h>
 #include <linux/kdebug.h>
@@ -26,6 +28,7 @@
 #include <asm/mce.h>
 #include <asm/uaccess.h>
 #include <asm/smp.h>
+#include <asm/idle.h>
 
 #define MISC_MCELOG_MINOR 227
 #define NR_BANKS 6
@@ -34,13 +37,17 @@ atomic_t mce_entry;
 
 static int mce_dont_init;
 
-/* 0: always panic, 1: panic if deadlock possible, 2: try to avoid panic,
-   3: never panic or exit (for testing only) */
+/*
+ * Tolerant levels:
+ *   0: always panic on uncorrected errors, log corrected errors
+ *   1: panic or SIGBUS on uncorrected errors, log corrected errors
+ *   2: SIGBUS or log uncorrected errors (if possible), log corrected errors
+ *   3: never panic or SIGBUS, log all errors (for testing only)
+ */
 static int tolerant = 1;
 static int banks;
 static unsigned long bank[NR_BANKS] = { [0 ... NR_BANKS-1] = ~0UL };
-static unsigned long console_logged;
-static int notify_user;
+static unsigned long notify_user;
 static int rip_msr;
 static int mce_bootlog = 1;
 static atomic_t mce_events;
@@ -48,6 +55,8 @@ static atomic_t mce_events;
 static char trigger[128];
 static char *trigger_argv[2] = { trigger, NULL };
 
+static DECLARE_WAIT_QUEUE_HEAD(mce_wait);
+
 /*
  * Lockless MCE logging infrastructure.
  * This avoids deadlocks on printk locks without having to break locks. Also
@@ -94,8 +103,7 @@ void mce_log(struct mce *mce)
         mcelog.entry[entry].finished = 1;
         wmb();
 
-        if (!test_and_set_bit(0, &console_logged))
-                notify_user = 1;
+        set_bit(0, &notify_user);
 }
 
 static void print_mce(struct mce *m)
@@ -128,6 +136,7 @@ static void print_mce(struct mce *m)
 static void mce_panic(char *msg, struct mce *backup, unsigned long start)
 { 
         int i;
+
         oops_begin();
         for (i = 0; i < MCE_LOG_LEN; i++) {
                 unsigned long tsc = mcelog.entry[i].tsc;
@@ -139,10 +148,7 @@ static void mce_panic(char *msg, struct mce *backup, unsigned long start)
         }
         if (backup)
                 print_mce(backup);
-        if (tolerant >= 3)
-                printk("Fake panic: %s\n", msg);
-        else
-                panic(msg);
+        panic(msg);
 } 
 
 static int mce_available(struct cpuinfo_x86 *c)
@@ -167,17 +173,6 @@ static inline void mce_get_rip(struct mce *m, struct pt_regs *regs)
         }
 }
 
-static void do_mce_trigger(void)
-{
-        static atomic_t mce_logged;
-        int events = atomic_read(&mce_events);
-        if (events != atomic_read(&mce_logged) && trigger[0]) {
-                /* Small race window, but should be harmless.  */
-                atomic_set(&mce_logged, events);
-                call_usermodehelper(trigger, trigger_argv, NULL, UMH_NO_WAIT);
-        }
-}
-
 /* 
  * The actual machine check handler
  */
@@ -185,11 +180,19 @@ static void do_mce_trigger(void)
 void do_machine_check(struct pt_regs * regs, long error_code)
 {
         struct mce m, panicm;
-        int nowayout = (tolerant < 1); 
-        int kill_it = 0;
         u64 mcestart = 0;
         int i;
         int panicm_found = 0;
+        /*
+         * If no_way_out gets set, there is no safe way to recover from this
+         * MCE.  If tolerant is cranked up, we'll try anyway.
+         */
+        int no_way_out = 0;
+        /*
+         * If kill_it gets set, there might be a way to recover from this
+         * error.
+         */
+        int kill_it = 0;
 
         atomic_inc(&mce_entry);
 
@@ -201,8 +204,9 @@ void do_machine_check(struct pt_regs * regs, long error_code)
         memset(&m, 0, sizeof(struct mce));
         m.cpu = smp_processor_id();
         rdmsrl(MSR_IA32_MCG_STATUS, m.mcgstatus);
+        /* if the restart IP is not valid, we're done for */
         if (!(m.mcgstatus & MCG_STATUS_RIPV))
-                kill_it = 1;
+                no_way_out = 1;
         
         rdtscll(mcestart);
         barrier();
@@ -221,10 +225,18 @@ void do_machine_check(struct pt_regs * regs, long error_code)
                         continue;
 
                 if (m.status & MCI_STATUS_EN) {
-                        /* In theory _OVER could be a nowayout too, but
-                           assume any overflowed errors were no fatal. */
-                        nowayout |= !!(m.status & MCI_STATUS_PCC);
-                        kill_it |= !!(m.status & MCI_STATUS_UC);
+                        /* if PCC was set, there's no way out */
+                        no_way_out |= !!(m.status & MCI_STATUS_PCC);
+                        /*
+                         * If this error was uncorrectable and there was
+                         * an overflow, we're in trouble.  If no overflow,
+                         * we might get away with just killing a task.
+                         */
+                        if (m.status & MCI_STATUS_UC) {
+                                if (tolerant < 1 || m.status & MCI_STATUS_OVER)
+                                        no_way_out = 1;
+                                kill_it = 1;
+                        }
                 }
 
                 if (m.status & MCI_STATUS_MISCV)
@@ -235,7 +247,6 @@ void do_machine_check(struct pt_regs * regs, long error_code)
                 mce_get_rip(&m, regs);
                 if (error_code >= 0)
                         rdtscll(m.tsc);
-                wrmsrl(MSR_IA32_MC0_STATUS + i*4, 0);
                 if (error_code != -2)
                         mce_log(&m);
 
@@ -251,45 +262,59 @@ void do_machine_check(struct pt_regs * regs, long error_code)
         }
 
         /* Never do anything final in the polling timer */
-        if (!regs) {
-                /* Normal interrupt context here. Call trigger for any new
-                   events. */
-                do_mce_trigger();
+        if (!regs)
                 goto out;
-        }
 
         /* If we didn't find an uncorrectable error, pick
            the last one (shouldn't happen, just being safe). */
         if (!panicm_found)
                 panicm = m;
-        if (nowayout)
+
+        /*
+         * If we have decided that we just CAN'T continue, and the user
+         *  has not set tolerant to an insane level, give up and die.
+         */
+        if (no_way_out && tolerant < 3)
                 mce_panic("Machine check", &panicm, mcestart);
-        if (kill_it) {
+
+        /*
+         * If the error seems to be unrecoverable, something should be
+         * done.  Try to kill as little as possible.  If we can kill just
+         * one task, do that.  If the user has set the tolerance very
+         * high, don't try to do anything at all.
+         */
+        if (kill_it && tolerant < 3) {
                 int user_space = 0;
 
-                if (m.mcgstatus & MCG_STATUS_RIPV)
+                /*
+                 * If the EIPV bit is set, it means the saved IP is the
+                 * instruction which caused the MCE.
+                 */
+                if (m.mcgstatus & MCG_STATUS_EIPV)
                         user_space = panicm.rip && (panicm.cs & 3);
-                
-                /* When the machine was in user space and the CPU didn't get
-                   confused it's normally not necessary to panic, unless you 
-                   are paranoid (tolerant == 0)
-
-                   RED-PEN could be more tolerant for MCEs in idle,
-                   but most likely they occur at boot anyways, where
-                   it is best to just halt the machine. */
-                if ((!user_space && (panic_on_oops || tolerant < 2)) ||
-                    (unsigned)current->pid <= 1)
-                        mce_panic("Uncorrected machine check", &panicm, mcestart);
-
-                /* do_exit takes an awful lot of locks and has as
-                   slight risk of deadlocking. If you don't want that
-                   don't set tolerant >= 2 */
-                if (tolerant < 3)
+
+                /*
+                 * If we know that the error was in user space, send a
+                 * SIGBUS.  Otherwise, panic if tolerance is low.
+                 *
+                 * do_exit() takes an awful lot of locks and has a slight
+                 * risk of deadlocking.
+                 */
+                if (user_space) {
                         do_exit(SIGBUS);
+                } else if (panic_on_oops || tolerant < 2) {
+                        mce_panic("Uncorrected machine check",
+                                &panicm, mcestart);
+                }
         }
 
+        /* notify userspace ASAP */
+        set_thread_flag(TIF_MCE_NOTIFY);
+
  out:
-        /* Last thing done in the machine check exception to clear state. */
+        /* the last thing we do is clear state */
+        for (i = 0; i < banks; i++)
+                wrmsrl(MSR_IA32_MC0_STATUS+4*i, 0);
         wrmsrl(MSR_IA32_MCG_STATUS, 0);
  out2:
         atomic_dec(&mce_entry);
@@ -344,37 +369,69 @@ static void mcheck_timer(struct work_struct *work)
         on_each_cpu(mcheck_check_cpu, NULL, 1, 1);
 
         /*
-         * It's ok to read stale data here for notify_user and
-         * console_logged as we'll simply get the updated versions
-         * on the next mcheck_timer execution and atomic operations
-         * on console_logged act as synchronization for notify_user
-         * writes.
+         * Alert userspace if needed.  If we logged an MCE, reduce the
+         * polling interval, otherwise increase the polling interval.
          */
-        if (notify_user && console_logged) {
+        if (mce_notify_user()) {
+                next_interval = max(next_interval/2, HZ/100);
+        } else {
+                next_interval = min(next_interval*2,
+                                (int)round_jiffies_relative(check_interval*HZ));
+        }
+
+        schedule_delayed_work(&mcheck_work, next_interval);
+}
+
+/*
+ * This is only called from process context.  This is where we do
+ * anything we need to alert userspace about new MCEs.  This is called
+ * directly from the poller and also from entry.S and idle, thanks to
+ * TIF_MCE_NOTIFY.
+ */
+int mce_notify_user(void)
+{
+        clear_thread_flag(TIF_MCE_NOTIFY);
+        if (test_and_clear_bit(0, &notify_user)) {
                 static unsigned long last_print;
                 unsigned long now = jiffies;
 
-                /* if we logged an MCE, reduce the polling interval */
-                next_interval = max(next_interval/2, HZ/100);
-                notify_user = 0;
-                clear_bit(0, &console_logged);
+                wake_up_interruptible(&mce_wait);
+                if (trigger[0])
+                        call_usermodehelper(trigger, trigger_argv, NULL,
+                                                UMH_NO_WAIT);
+
                 if (time_after_eq(now, last_print + (check_interval*HZ))) {
                         last_print = now;
                         printk(KERN_INFO "Machine check events logged\n");
                 }
-        } else {
-                next_interval = min(next_interval*2, check_interval*HZ);
+
+                return 1;
         }
+        return 0;
+}
 
-        schedule_delayed_work(&mcheck_work, next_interval);
+/* see if the idle task needs to notify userspace */
+static int
+mce_idle_callback(struct notifier_block *nfb, unsigned long action, void *junk)
+{
+        /* IDLE_END should be safe - interrupts are back on */
+        if (action == IDLE_END && test_thread_flag(TIF_MCE_NOTIFY))
+                mce_notify_user();
+
+        return NOTIFY_OK;
 }
 
+static struct notifier_block mce_idle_notifier = {
+        .notifier_call = mce_idle_callback,
+};
 
 static __init int periodic_mcheck_init(void)
 { 
         next_interval = check_interval * HZ;
         if (next_interval)
-                schedule_delayed_work(&mcheck_work, next_interval);
+                schedule_delayed_work(&mcheck_work,
+                                      round_jiffies_relative(next_interval));
+        idle_notifier_register(&mce_idle_notifier);
         return 0;
 } 
 __initcall(periodic_mcheck_init);
@@ -465,6 +522,40 @@ void __cpuinit mcheck_init(struct cpuinfo_x86 *c)
  * Character device to read and clear the MCE log.
  */
 
+static DEFINE_SPINLOCK(mce_state_lock);
+static int open_count;  /* #times opened */
+static int open_exclu;  /* already open exclusive? */
+
+static int mce_open(struct inode *inode, struct file *file)
+{
+        spin_lock(&mce_state_lock);
+
+        if (open_exclu || (open_count && (file->f_flags & O_EXCL))) {
+                spin_unlock(&mce_state_lock);
+                return -EBUSY;
+        }
+
+        if (file->f_flags & O_EXCL)
+                open_exclu = 1;
+        open_count++;
+
+        spin_unlock(&mce_state_lock);
+
+        return nonseekable_open(inode, file);
+}
+
+static int mce_release(struct inode *inode, struct file *file)
+{
+        spin_lock(&mce_state_lock);
+
+        open_count--;
+        open_exclu = 0;
+
+        spin_unlock(&mce_state_lock);
+
+        return 0;
+}
+
 static void collect_tscs(void *data) 
 { 
         unsigned long *cpu_tsc = (unsigned long *)data;
@@ -532,6 +623,14 @@ static ssize_t mce_read(struct file *filp, char __user *ubuf, size_t usize, loff
         return err ? -EFAULT : buf - ubuf; 
 }
 
+static unsigned int mce_poll(struct file *file, poll_table *wait)
+{
+        poll_wait(file, &mce_wait, wait);
+        if (rcu_dereference(mcelog.next))
+                return POLLIN | POLLRDNORM;
+        return 0;
+}
+
 static int mce_ioctl(struct inode *i, struct file *f,unsigned int cmd, unsigned long arg)
 {
         int __user *p = (int __user *)arg;
@@ -555,7 +654,10 @@ static int mce_ioctl(struct inode *i, struct file *f,unsigned int cmd, unsigned
 }
 
 static const struct file_operations mce_chrdev_ops = {
+        .open = mce_open,
+        .release = mce_release,
         .read = mce_read,
+        .poll = mce_poll,
         .ioctl = mce_ioctl,
 };
 
@@ -620,7 +722,8 @@ static void mce_restart(void)
         on_each_cpu(mce_init, NULL, 1, 1);       
         next_interval = check_interval * HZ;
         if (next_interval)
-                schedule_delayed_work(&mcheck_work, next_interval);
+                schedule_delayed_work(&mcheck_work,
+                                      round_jiffies_relative(next_interval));
 }
 
 static struct sysdev_class mce_sysclass = {
diff --git a/arch/x86_64/kernel/mce_amd.c b/arch/x86_64/kernel/mce_amd.c
index 03356e64f9c8..2f8a7f18b0fe 100644
--- a/arch/x86_64/kernel/mce_amd.c
+++ b/arch/x86_64/kernel/mce_amd.c
@@ -157,9 +157,9 @@ void __cpuinit mce_amd_feature_init(struct cpuinfo_x86 *c)
                         high |= K8_APIC_EXT_LVT_ENTRY_THRESHOLD << 20;
                         wrmsr(address, low, high);
 
-                        setup_APIC_extened_lvt(K8_APIC_EXT_LVT_ENTRY_THRESHOLD,
-                                               THRESHOLD_APIC_VECTOR,
-                                               K8_APIC_EXT_INT_MSG_FIX, 0);
+                        setup_APIC_extended_lvt(K8_APIC_EXT_LVT_ENTRY_THRESHOLD,
+                                                THRESHOLD_APIC_VECTOR,
+                                                K8_APIC_EXT_INT_MSG_FIX, 0);
 
                         threshold_defaults.address = address;
                         threshold_restart_bank(&threshold_defaults, 0, 0);
diff --git a/arch/x86_64/kernel/mpparse.c b/arch/x86_64/kernel/mpparse.c
index 61ae57eb9e4c..8bf0ca03ac8e 100644
--- a/arch/x86_64/kernel/mpparse.c
+++ b/arch/x86_64/kernel/mpparse.c
@@ -32,7 +32,6 @@
 
 /* Have we found an MP table */
 int smp_found_config;
-unsigned int __initdata maxcpus = NR_CPUS;
 
 /*
  * Various Linux-internal data structures created from the
@@ -649,6 +648,20 @@ static int mp_find_ioapic(int gsi)
         return -1;
 }
 
+static u8 uniq_ioapic_id(u8 id)
+{
+        int i;
+        DECLARE_BITMAP(used, 256);
+        bitmap_zero(used, 256);
+        for (i = 0; i < nr_ioapics; i++) {
+                struct mpc_config_ioapic *ia = &mp_ioapics[i];
+                __set_bit(ia->mpc_apicid, used);
+        }
+        if (!test_bit(id, used))
+                return id;
+        return find_first_zero_bit(used, 256);
+}
+
 void __init mp_register_ioapic(u8 id, u32 address, u32 gsi_base)
 {
         int idx = 0;
@@ -656,14 +669,14 @@ void __init mp_register_ioapic(u8 id, u32 address, u32 gsi_base)
         if (bad_ioapic(address))
                 return;
 
-        idx = nr_ioapics++;
+        idx = nr_ioapics;
 
         mp_ioapics[idx].mpc_type = MP_IOAPIC;
         mp_ioapics[idx].mpc_flags = MPC_APIC_USABLE;
         mp_ioapics[idx].mpc_apicaddr = address;
 
         set_fixmap_nocache(FIX_IO_APIC_BASE_0 + idx, address);
-        mp_ioapics[idx].mpc_apicid = id;
+        mp_ioapics[idx].mpc_apicid = uniq_ioapic_id(id);
         mp_ioapics[idx].mpc_apicver = 0;
         
         /* 
@@ -680,6 +693,8 @@ void __init mp_register_ioapic(u8 id, u32 address, u32 gsi_base)
                 mp_ioapics[idx].mpc_apicaddr,
                 mp_ioapic_routing[idx].gsi_start,
                 mp_ioapic_routing[idx].gsi_end);
+
+        nr_ioapics++;
 }
 
 void __init
diff --git a/arch/x86_64/kernel/pci-calgary.c b/arch/x86_64/kernel/pci-calgary.c
index 5bd20b542c1e..ba16c968ca3f 100644
--- a/arch/x86_64/kernel/pci-calgary.c
+++ b/arch/x86_64/kernel/pci-calgary.c
@@ -1,7 +1,7 @@
 /*
  * Derived from arch/powerpc/kernel/iommu.c
  *
- * Copyright (C) IBM Corporation, 2006
+ * Copyright IBM Corporation, 2006-2007
  * Copyright (C) 2006  Jon Mason <jdmason@kudzu.us>
  *
  * Author: Jon Mason <jdmason@kudzu.us>
@@ -35,7 +35,7 @@
 #include <linux/pci_ids.h>
 #include <linux/pci.h>
 #include <linux/delay.h>
-#include <asm/proto.h>
+#include <asm/iommu.h>
 #include <asm/calgary.h>
 #include <asm/tce.h>
 #include <asm/pci-direct.h>
@@ -50,13 +50,7 @@ int use_calgary __read_mostly = 0;
 #endif /* CONFIG_CALGARY_DEFAULT_ENABLED */
 
 #define PCI_DEVICE_ID_IBM_CALGARY 0x02a1
-#define PCI_VENDOR_DEVICE_ID_CALGARY \
-        (PCI_VENDOR_ID_IBM | PCI_DEVICE_ID_IBM_CALGARY << 16)
-
-/* we need these for register space address calculation */
-#define START_ADDRESS           0xfe000000
-#define CHASSIS_BASE            0
-#define ONE_BASED_CHASSIS_NUM   1
+#define PCI_DEVICE_ID_IBM_CALIOC2 0x0308
 
 /* register offsets inside the host bridge space */
 #define CALGARY_CONFIG_REG      0x0108
@@ -80,6 +74,12 @@ int use_calgary __read_mostly = 0;
 #define PHB_MEM_2_SIZE_LOW      0x02E0
 #define PHB_DOSHOLE_OFFSET      0x08E0
 
+/* CalIOC2 specific */
+#define PHB_SAVIOR_L2           0x0DB0
+#define PHB_PAGE_MIG_CTRL       0x0DA8
+#define PHB_PAGE_MIG_DEBUG      0x0DA0
+#define PHB_ROOT_COMPLEX_STATUS 0x0CB0
+
 /* PHB_CONFIG_RW */
 #define PHB_TCE_ENABLE          0x20000000
 #define PHB_SLOT_DISABLE        0x1C000000
@@ -92,7 +92,11 @@ int use_calgary __read_mostly = 0;
 /* CSR (Channel/DMA Status Register) */
 #define CSR_AGENT_MASK          0xffe0ffff
 /* CCR (Calgary Configuration Register) */
-#define CCR_2SEC_TIMEOUT        0x000000000000000EUL
+#define CCR_2SEC_TIMEOUT        0x000000000000000EUL
+/* PMCR/PMDR (Page Migration Control/Debug Registers */
+#define PMR_SOFTSTOP            0x80000000
+#define PMR_SOFTSTOPFAULT       0x40000000
+#define PMR_HARDSTOP            0x20000000
 
 #define MAX_NUM_OF_PHBS         8 /* how many PHBs in total? */
 #define MAX_NUM_CHASSIS         8 /* max number of chassis */
@@ -155,9 +159,26 @@ struct calgary_bus_info {
         void __iomem *bbar;
 };
 
-static struct calgary_bus_info bus_info[MAX_PHB_BUS_NUM] = { { NULL, 0, 0 }, };
+static void calgary_handle_quirks(struct iommu_table *tbl, struct pci_dev *dev);
+static void calgary_tce_cache_blast(struct iommu_table *tbl);
+static void calgary_dump_error_regs(struct iommu_table *tbl);
+static void calioc2_handle_quirks(struct iommu_table *tbl, struct pci_dev *dev);
+static void calioc2_tce_cache_blast(struct iommu_table *tbl);
+static void calioc2_dump_error_regs(struct iommu_table *tbl);
+
+static struct cal_chipset_ops calgary_chip_ops = {
+        .handle_quirks = calgary_handle_quirks,
+        .tce_cache_blast = calgary_tce_cache_blast,
+        .dump_error_regs = calgary_dump_error_regs
+};
 
-static void tce_cache_blast(struct iommu_table *tbl);
+static struct cal_chipset_ops calioc2_chip_ops = {
+        .handle_quirks = calioc2_handle_quirks,
+        .tce_cache_blast = calioc2_tce_cache_blast,
+        .dump_error_regs = calioc2_dump_error_regs
+};
+
+static struct calgary_bus_info bus_info[MAX_PHB_BUS_NUM] = { { NULL, 0, 0 }, };
 
 /* enable this to stress test the chip's TCE cache */
 #ifdef CONFIG_IOMMU_DEBUG
@@ -187,6 +208,7 @@ static inline unsigned long verify_bit_range(unsigned long* bitmap,
 {
         return ~0UL;
 }
+
 #endif /* CONFIG_IOMMU_DEBUG */
 
 static inline unsigned int num_dma_pages(unsigned long dma, unsigned int dmalen)
@@ -206,11 +228,12 @@ static inline int translate_phb(struct pci_dev* dev)
 }
 
 static void iommu_range_reserve(struct iommu_table *tbl,
-        unsigned long start_addr, unsigned int npages)
+        unsigned long start_addr, unsigned int npages)
 {
         unsigned long index;
         unsigned long end;
         unsigned long badbit;
+        unsigned long flags;
 
         index = start_addr >> PAGE_SHIFT;
 
@@ -222,6 +245,8 @@ static void iommu_range_reserve(struct iommu_table *tbl,
         if (end > tbl->it_size) /* don't go off the table */
                 end = tbl->it_size;
 
+        spin_lock_irqsave(&tbl->it_lock, flags);
+
         badbit = verify_bit_range(tbl->it_map, 0, index, end);
         if (badbit != ~0UL) {
                 if (printk_ratelimit())
@@ -231,23 +256,29 @@ static void iommu_range_reserve(struct iommu_table *tbl,
         }
 
         set_bit_string(tbl->it_map, index, npages);
+
+        spin_unlock_irqrestore(&tbl->it_lock, flags);
 }
 
 static unsigned long iommu_range_alloc(struct iommu_table *tbl,
         unsigned int npages)
 {
+        unsigned long flags;
         unsigned long offset;
 
         BUG_ON(npages == 0);
 
+        spin_lock_irqsave(&tbl->it_lock, flags);
+
         offset = find_next_zero_string(tbl->it_map, tbl->it_hint,
                                        tbl->it_size, npages);
         if (offset == ~0UL) {
-                tce_cache_blast(tbl);
+                tbl->chip_ops->tce_cache_blast(tbl);
                 offset = find_next_zero_string(tbl->it_map, 0,
                                                tbl->it_size, npages);
                 if (offset == ~0UL) {
                         printk(KERN_WARNING "Calgary: IOMMU full.\n");
+                        spin_unlock_irqrestore(&tbl->it_lock, flags);
                         if (panic_on_overflow)
                                 panic("Calgary: fix the allocator.\n");
                         else
@@ -259,17 +290,17 @@ static unsigned long iommu_range_alloc(struct iommu_table *tbl,
         tbl->it_hint = offset + npages;
         BUG_ON(tbl->it_hint > tbl->it_size);
 
+        spin_unlock_irqrestore(&tbl->it_lock, flags);
+
         return offset;
 }
 
 static dma_addr_t iommu_alloc(struct iommu_table *tbl, void *vaddr,
         unsigned int npages, int direction)
 {
-        unsigned long entry, flags;
+        unsigned long entry;
         dma_addr_t ret = bad_dma_address;
 
-        spin_lock_irqsave(&tbl->it_lock, flags);
-
         entry = iommu_range_alloc(tbl, npages);
 
         if (unlikely(entry == bad_dma_address))
@@ -282,23 +313,21 @@ static dma_addr_t iommu_alloc(struct iommu_table *tbl, void *vaddr,
         tce_build(tbl, entry, npages, (unsigned long)vaddr & PAGE_MASK,
                   direction);
 
-        spin_unlock_irqrestore(&tbl->it_lock, flags);
-
         return ret;
 
 error:
-        spin_unlock_irqrestore(&tbl->it_lock, flags);
         printk(KERN_WARNING "Calgary: failed to allocate %u pages in "
                "iommu %p\n", npages, tbl);
         return bad_dma_address;
 }
 
-static void __iommu_free(struct iommu_table *tbl, dma_addr_t dma_addr,
+static void iommu_free(struct iommu_table *tbl, dma_addr_t dma_addr,
         unsigned int npages)
 {
         unsigned long entry;
         unsigned long badbit;
         unsigned long badend;
+        unsigned long flags;
 
         /* were we called with bad_dma_address? */
         badend = bad_dma_address + (EMERGENCY_PAGES * PAGE_SIZE);
@@ -315,6 +344,8 @@ static void __iommu_free(struct iommu_table *tbl, dma_addr_t dma_addr,
 
         tce_free(tbl, entry, npages);
 
+        spin_lock_irqsave(&tbl->it_lock, flags);
+
         badbit = verify_bit_range(tbl->it_map, 1, entry, entry + npages);
         if (badbit != ~0UL) {
                 if (printk_ratelimit())
@@ -324,23 +355,40 @@ static void __iommu_free(struct iommu_table *tbl, dma_addr_t dma_addr,
         }
 
         __clear_bit_string(tbl->it_map, entry, npages);
+
+        spin_unlock_irqrestore(&tbl->it_lock, flags);
 }
 
-static void iommu_free(struct iommu_table *tbl, dma_addr_t dma_addr,
-        unsigned int npages)
+static inline struct iommu_table *find_iommu_table(struct device *dev)
 {
-        unsigned long flags;
+        struct pci_dev *pdev;
+        struct pci_bus *pbus;
+        struct iommu_table *tbl;
 
-        spin_lock_irqsave(&tbl->it_lock, flags);
+        pdev = to_pci_dev(dev);
 
-        __iommu_free(tbl, dma_addr, npages);
+        /* is the device behind a bridge? */
+        if (unlikely(pdev->bus->parent))
+                pbus = pdev->bus->parent;
+        else
+                pbus = pdev->bus;
 
-        spin_unlock_irqrestore(&tbl->it_lock, flags);
+        tbl = pci_iommu(pbus);
+
+        BUG_ON(pdev->bus->parent &&
+               (tbl->it_busno != pdev->bus->parent->number));
+
+        return tbl;
 }
 
-static void __calgary_unmap_sg(struct iommu_table *tbl,
+static void calgary_unmap_sg(struct device *dev,
         struct scatterlist *sglist, int nelems, int direction)
 {
+        struct iommu_table *tbl = find_iommu_table(dev);
+
+        if (!translate_phb(to_pci_dev(dev)))
+                return;
+
         while (nelems--) {
                 unsigned int npages;
                 dma_addr_t dma = sglist->dma_address;
@@ -350,33 +398,17 @@ static void __calgary_unmap_sg(struct iommu_table *tbl,
                         break;
 
                 npages = num_dma_pages(dma, dmalen);
-                __iommu_free(tbl, dma, npages);
+                iommu_free(tbl, dma, npages);
                 sglist++;
         }
 }
 
-void calgary_unmap_sg(struct device *dev, struct scatterlist *sglist,
-                      int nelems, int direction)
-{
-        unsigned long flags;
-        struct iommu_table *tbl = to_pci_dev(dev)->bus->self->sysdata;
-
-        if (!translate_phb(to_pci_dev(dev)))
-                return;
-
-        spin_lock_irqsave(&tbl->it_lock, flags);
-
-        __calgary_unmap_sg(tbl, sglist, nelems, direction);
-
-        spin_unlock_irqrestore(&tbl->it_lock, flags);
-}
-
 static int calgary_nontranslate_map_sg(struct device* dev,
         struct scatterlist *sg, int nelems, int direction)
 {
         int i;
 
-        for (i = 0; i < nelems; i++ ) {
+        for (i = 0; i < nelems; i++ ) {
                 struct scatterlist *s = &sg[i];
                 BUG_ON(!s->page);
                 s->dma_address = virt_to_bus(page_address(s->page) +s->offset);
@@ -385,11 +417,10 @@ static int calgary_nontranslate_map_sg(struct device* dev,
         return nelems;
 }
 
-int calgary_map_sg(struct device *dev, struct scatterlist *sg,
+static int calgary_map_sg(struct device *dev, struct scatterlist *sg,
         int nelems, int direction)
 {
-        struct iommu_table *tbl = to_pci_dev(dev)->bus->self->sysdata;
-        unsigned long flags;
+        struct iommu_table *tbl = find_iommu_table(dev);
         unsigned long vaddr;
         unsigned int npages;
         unsigned long entry;
@@ -398,8 +429,6 @@ int calgary_map_sg(struct device *dev, struct scatterlist *sg,
         if (!translate_phb(to_pci_dev(dev)))
                 return calgary_nontranslate_map_sg(dev, sg, nelems, direction);
 
-        spin_lock_irqsave(&tbl->it_lock, flags);
-
         for (i = 0; i < nelems; i++ ) {
                 struct scatterlist *s = &sg[i];
                 BUG_ON(!s->page);
@@ -423,26 +452,23 @@ int calgary_map_sg(struct device *dev, struct scatterlist *sg,
                 s->dma_length = s->length;
         }
 
-        spin_unlock_irqrestore(&tbl->it_lock, flags);
-
         return nelems;
 error:
-        __calgary_unmap_sg(tbl, sg, nelems, direction);
+        calgary_unmap_sg(dev, sg, nelems, direction);
         for (i = 0; i < nelems; i++) {
                 sg[i].dma_address = bad_dma_address;
                 sg[i].dma_length = 0;
         }
-        spin_unlock_irqrestore(&tbl->it_lock, flags);
         return 0;
 }
 
-dma_addr_t calgary_map_single(struct device *dev, void *vaddr,
+static dma_addr_t calgary_map_single(struct device *dev, void *vaddr,
         size_t size, int direction)
 {
         dma_addr_t dma_handle = bad_dma_address;
         unsigned long uaddr;
         unsigned int npages;
-        struct iommu_table *tbl = to_pci_dev(dev)->bus->self->sysdata;
+        struct iommu_table *tbl = find_iommu_table(dev);
 
         uaddr = (unsigned long)vaddr;
         npages = num_dma_pages(uaddr, size);
@@ -455,10 +481,10 @@ dma_addr_t calgary_map_single(struct device *dev, void *vaddr,
         return dma_handle;
 }
 
-void calgary_unmap_single(struct device *dev, dma_addr_t dma_handle,
+static void calgary_unmap_single(struct device *dev, dma_addr_t dma_handle,
         size_t size, int direction)
 {
-        struct iommu_table *tbl = to_pci_dev(dev)->bus->self->sysdata;
+        struct iommu_table *tbl = find_iommu_table(dev);
         unsigned int npages;
 
         if (!translate_phb(to_pci_dev(dev)))
@@ -468,15 +494,13 @@ void calgary_unmap_single(struct device *dev, dma_addr_t dma_handle,
         iommu_free(tbl, dma_handle, npages);
 }
 
-void* calgary_alloc_coherent(struct device *dev, size_t size,
+static void* calgary_alloc_coherent(struct device *dev, size_t size,
         dma_addr_t *dma_handle, gfp_t flag)
 {
         void *ret = NULL;
         dma_addr_t mapping;
         unsigned int npages, order;
-        struct iommu_table *tbl;
-
-        tbl = to_pci_dev(dev)->bus->self->sysdata;
+        struct iommu_table *tbl = find_iommu_table(dev);
 
         size = PAGE_ALIGN(size); /* size rounded up to full pages */
         npages = size >> PAGE_SHIFT;
@@ -552,7 +576,22 @@ static inline void __iomem* calgary_reg(void __iomem *bar, unsigned long offset)
         return (void __iomem*)target;
 }
 
-static void tce_cache_blast(struct iommu_table *tbl)
+static inline int is_calioc2(unsigned short device)
+{
+        return (device == PCI_DEVICE_ID_IBM_CALIOC2);
+}
+
+static inline int is_calgary(unsigned short device)
+{
+        return (device == PCI_DEVICE_ID_IBM_CALGARY);
+}
+
+static inline int is_cal_pci_dev(unsigned short device)
+{
+        return (is_calgary(device) || is_calioc2(device));
+}
+
+static void calgary_tce_cache_blast(struct iommu_table *tbl)
 {
         u64 val;
         u32 aer;
@@ -589,6 +628,85 @@ static void tce_cache_blast(struct iommu_table *tbl)
         (void)readl(target); /* flush */
 }
 
+static void calioc2_tce_cache_blast(struct iommu_table *tbl)
+{
+        void __iomem *bbar = tbl->bbar;
+        void __iomem *target;
+        u64 val64;
+        u32 val;
+        int i = 0;
+        int count = 1;
+        unsigned char bus = tbl->it_busno;
+
+begin:
+        printk(KERN_DEBUG "Calgary: CalIOC2 bus 0x%x entering tce cache blast "
+               "sequence - count %d\n", bus, count);
+
+        /* 1. using the Page Migration Control reg set SoftStop */
+        target = calgary_reg(bbar, phb_offset(bus) | PHB_PAGE_MIG_CTRL);
+        val = be32_to_cpu(readl(target));
+        printk(KERN_DEBUG "1a. read 0x%x [LE] from %p\n", val, target);
+        val |= PMR_SOFTSTOP;
+        printk(KERN_DEBUG "1b. writing 0x%x [LE] to %p\n", val, target);
+        writel(cpu_to_be32(val), target);
+
+        /* 2. poll split queues until all DMA activity is done */
+        printk(KERN_DEBUG "2a. starting to poll split queues\n");
+        target = calgary_reg(bbar, split_queue_offset(bus));
+        do {
+                val64 = readq(target);
+                i++;
+        } while ((val64 & 0xff) != 0xff && i < 100);
+        if (i == 100)
+                printk(KERN_WARNING "CalIOC2: PCI bus not quiesced, "
+                       "continuing anyway\n");
+
+        /* 3. poll Page Migration DEBUG for SoftStopFault */
+        target = calgary_reg(bbar, phb_offset(bus) | PHB_PAGE_MIG_DEBUG);
+        val = be32_to_cpu(readl(target));
+        printk(KERN_DEBUG "3. read 0x%x [LE] from %p\n", val, target);
+
+        /* 4. if SoftStopFault - goto (1) */
+        if (val & PMR_SOFTSTOPFAULT) {
+                if (++count < 100)
+                        goto begin;
+                else {
+                        printk(KERN_WARNING "CalIOC2: too many SoftStopFaults, "
+                               "aborting TCE cache flush sequence!\n");
+                        return; /* pray for the best */
+                }
+        }
+
+        /* 5. Slam into HardStop by reading PHB_PAGE_MIG_CTRL */
+        target = calgary_reg(bbar, phb_offset(bus) | PHB_PAGE_MIG_CTRL);
+        printk(KERN_DEBUG "5a. slamming into HardStop by reading %p\n", target);
+        val = be32_to_cpu(readl(target));
+        printk(KERN_DEBUG "5b. read 0x%x [LE] from %p\n", val, target);
+        target = calgary_reg(bbar, phb_offset(bus) | PHB_PAGE_MIG_DEBUG);
+        val = be32_to_cpu(readl(target));
+        printk(KERN_DEBUG "5c. read 0x%x [LE] from %p (debug)\n", val, target);
+
+        /* 6. invalidate TCE cache */
+        printk(KERN_DEBUG "6. invalidating TCE cache\n");
+        target = calgary_reg(bbar, tar_offset(bus));
+        writeq(tbl->tar_val, target);
+
+        /* 7. Re-read PMCR */
+        printk(KERN_DEBUG "7a. Re-reading PMCR\n");
+        target = calgary_reg(bbar, phb_offset(bus) | PHB_PAGE_MIG_CTRL);
+        val = be32_to_cpu(readl(target));
+        printk(KERN_DEBUG "7b. read 0x%x [LE] from %p\n", val, target);
+
+        /* 8. Remove HardStop */
+        printk(KERN_DEBUG "8a. removing HardStop from PMCR\n");
+        target = calgary_reg(bbar, phb_offset(bus) | PHB_PAGE_MIG_CTRL);
+        val = 0;
+        printk(KERN_DEBUG "8b. writing 0x%x [LE] to %p\n", val, target);
+        writel(cpu_to_be32(val), target);
+        val = be32_to_cpu(readl(target));
+        printk(KERN_DEBUG "8c. read 0x%x [LE] from %p\n", val, target);
+}
+
 static void __init calgary_reserve_mem_region(struct pci_dev *dev, u64 start,
         u64 limit)
 {
@@ -598,7 +716,7 @@ static void __init calgary_reserve_mem_region(struct pci_dev *dev, u64 start,
         limit++;
 
         numpages = ((limit - start) >> PAGE_SHIFT);
-        iommu_range_reserve(dev->sysdata, start, numpages);
+        iommu_range_reserve(pci_iommu(dev->bus), start, numpages);
 }
 
 static void __init calgary_reserve_peripheral_mem_1(struct pci_dev *dev)
@@ -606,7 +724,7 @@ static void __init calgary_reserve_peripheral_mem_1(struct pci_dev *dev)
         void __iomem *target;
         u64 low, high, sizelow;
         u64 start, limit;
-        struct iommu_table *tbl = dev->sysdata;
+        struct iommu_table *tbl = pci_iommu(dev->bus);
         unsigned char busnum = dev->bus->number;
         void __iomem *bbar = tbl->bbar;
 
@@ -630,7 +748,7 @@ static void __init calgary_reserve_peripheral_mem_2(struct pci_dev *dev)
         u32 val32;
         u64 low, high, sizelow, sizehigh;
         u64 start, limit;
-        struct iommu_table *tbl = dev->sysdata;
+        struct iommu_table *tbl = pci_iommu(dev->bus);
         unsigned char busnum = dev->bus->number;
         void __iomem *bbar = tbl->bbar;
 
@@ -666,14 +784,20 @@ static void __init calgary_reserve_regions(struct pci_dev *dev)
 {
         unsigned int npages;
         u64 start;
-        struct iommu_table *tbl = dev->sysdata;
+        struct iommu_table *tbl = pci_iommu(dev->bus);
 
         /* reserve EMERGENCY_PAGES from bad_dma_address and up */
         iommu_range_reserve(tbl, bad_dma_address, EMERGENCY_PAGES);
 
         /* avoid the BIOS/VGA first 640KB-1MB region */
-        start = (640 * 1024);
-        npages = ((1024 - 640) * 1024) >> PAGE_SHIFT;
+        /* for CalIOC2 - avoid the entire first MB */
+        if (is_calgary(dev->device)) {
+                start = (640 * 1024);
+                npages = ((1024 - 640) * 1024) >> PAGE_SHIFT;
+        } else { /* calioc2 */
+                start = 0;
+                npages = (1 * 1024 * 1024) >> PAGE_SHIFT;
+        }
         iommu_range_reserve(tbl, start, npages);
 
         /* reserve the two PCI peripheral memory regions in IO space */
@@ -694,10 +818,17 @@ static int __init calgary_setup_tar(struct pci_dev *dev, void __iomem *bbar)
         if (ret)
                 return ret;
 
-        tbl = dev->sysdata;
+        tbl = pci_iommu(dev->bus);
         tbl->it_base = (unsigned long)bus_info[dev->bus->number].tce_space;
         tce_free(tbl, 0, tbl->it_size);
 
+        if (is_calgary(dev->device))
+                tbl->chip_ops = &calgary_chip_ops;
+        else if (is_calioc2(dev->device))
+                tbl->chip_ops = &calioc2_chip_ops;
+        else
+                BUG();
+
         calgary_reserve_regions(dev);
 
         /* set TARs for each PHB */
@@ -706,15 +837,15 @@ static int __init calgary_setup_tar(struct pci_dev *dev, void __iomem *bbar)
 
         /* zero out all TAR bits under sw control */
         val64 &= ~TAR_SW_BITS;
-
-        tbl = dev->sysdata;
         table_phys = (u64)__pa(tbl->it_base);
+
         val64 |= table_phys;
 
         BUG_ON(specified_table_size > TCE_TABLE_SIZE_8M);
         val64 |= (u64) specified_table_size;
 
         tbl->tar_val = cpu_to_be64(val64);
+
         writeq(tbl->tar_val, target);
         readq(target); /* flush */
 
@@ -724,7 +855,7 @@ static int __init calgary_setup_tar(struct pci_dev *dev, void __iomem *bbar)
 static void __init calgary_free_bus(struct pci_dev *dev)
 {
         u64 val64;
-        struct iommu_table *tbl = dev->sysdata;
+        struct iommu_table *tbl = pci_iommu(dev->bus);
         void __iomem *target;
         unsigned int bitmapsz;
 
@@ -739,16 +870,81 @@ static void __init calgary_free_bus(struct pci_dev *dev)
         tbl->it_map = NULL;
 
         kfree(tbl);
-        dev->sysdata = NULL;
+        
+        set_pci_iommu(dev->bus, NULL);
 
         /* Can't free bootmem allocated memory after system is up :-( */
         bus_info[dev->bus->number].tce_space = NULL;
 }
 
+static void calgary_dump_error_regs(struct iommu_table *tbl)
+{
+        void __iomem *bbar = tbl->bbar;
+        void __iomem *target;
+        u32 csr, plssr;
+
+        target = calgary_reg(bbar, phb_offset(tbl->it_busno) | PHB_CSR_OFFSET);
+        csr = be32_to_cpu(readl(target));
+
+        target = calgary_reg(bbar, phb_offset(tbl->it_busno) | PHB_PLSSR_OFFSET);
+        plssr = be32_to_cpu(readl(target));
+
+        /* If no error, the agent ID in the CSR is not valid */
+        printk(KERN_EMERG "Calgary: DMA error on Calgary PHB 0x%x, "
+               "0x%08x@CSR 0x%08x@PLSSR\n", tbl->it_busno, csr, plssr);
+}
+
+static void calioc2_dump_error_regs(struct iommu_table *tbl)
+{
+        void __iomem *bbar = tbl->bbar;
+        u32 csr, csmr, plssr, mck, rcstat;
+        void __iomem *target;
+        unsigned long phboff = phb_offset(tbl->it_busno);
+        unsigned long erroff;
+        u32 errregs[7];
+        int i;
+
+        /* dump CSR */
+        target = calgary_reg(bbar, phboff | PHB_CSR_OFFSET);
+        csr = be32_to_cpu(readl(target));
+        /* dump PLSSR */
+        target = calgary_reg(bbar, phboff | PHB_PLSSR_OFFSET);
+        plssr = be32_to_cpu(readl(target));
+        /* dump CSMR */
+        target = calgary_reg(bbar, phboff | 0x290);
+        csmr = be32_to_cpu(readl(target));
+        /* dump mck */
+        target = calgary_reg(bbar, phboff | 0x800);
+        mck = be32_to_cpu(readl(target));
+
+        printk(KERN_EMERG "Calgary: DMA error on CalIOC2 PHB 0x%x\n",
+               tbl->it_busno);
+
+        printk(KERN_EMERG "Calgary: 0x%08x@CSR 0x%08x@PLSSR 0x%08x@CSMR 0x%08x@MCK\n",
+               csr, plssr, csmr, mck);
+
+        /* dump rest of error regs */
+        printk(KERN_EMERG "Calgary: ");
+        for (i = 0; i < ARRAY_SIZE(errregs); i++) {
+                /* err regs are at 0x810 - 0x870 */
+                erroff = (0x810 + (i * 0x10));
+                target = calgary_reg(bbar, phboff | erroff);
+                errregs[i] = be32_to_cpu(readl(target));
+                printk("0x%08x@0x%lx ", errregs[i], erroff);
+        }
+        printk("\n");
+
+        /* root complex status */
+        target = calgary_reg(bbar, phboff | PHB_ROOT_COMPLEX_STATUS);
+        rcstat = be32_to_cpu(readl(target));
+        printk(KERN_EMERG "Calgary: 0x%08x@0x%x\n", rcstat,
+               PHB_ROOT_COMPLEX_STATUS);
+}
+
 static void calgary_watchdog(unsigned long data)
 {
         struct pci_dev *dev = (struct pci_dev *)data;
-        struct iommu_table *tbl = dev->sysdata;
+        struct iommu_table *tbl = pci_iommu(dev->bus);
         void __iomem *bbar = tbl->bbar;
         u32 val32;
         void __iomem *target;
@@ -758,13 +954,14 @@ static void calgary_watchdog(unsigned long data)
 
         /* If no error, the agent ID in the CSR is not valid */
         if (val32 & CSR_AGENT_MASK) {
-                printk(KERN_EMERG "calgary_watchdog: DMA error on PHB %#x, "
-                                  "CSR = %#x\n", dev->bus->number, val32);
+                tbl->chip_ops->dump_error_regs(tbl);
+
+                /* reset error */
                 writel(0, target);
 
                 /* Disable bus that caused the error */
                 target = calgary_reg(bbar, phb_offset(tbl->it_busno) |
-                                           PHB_CONFIG_RW_OFFSET);
+                                     PHB_CONFIG_RW_OFFSET);
                 val32 = be32_to_cpu(readl(target));
                 val32 |= PHB_SLOT_DISABLE;
                 writel(cpu_to_be32(val32), target);
@@ -775,8 +972,8 @@ static void calgary_watchdog(unsigned long data)
         }
 }
 
-static void __init calgary_increase_split_completion_timeout(void __iomem *bbar,
-        unsigned char busnum)
+static void __init calgary_set_split_completion_timeout(void __iomem *bbar,
+        unsigned char busnum, unsigned long timeout)
 {
         u64 val64;
         void __iomem *target;
@@ -802,11 +999,40 @@ static void __init calgary_increase_split_completion_timeout(void __iomem *bbar,
         /* zero out this PHB's timer bits */
         mask = ~(0xFUL << phb_shift);
         val64 &= mask;
-        val64 |= (CCR_2SEC_TIMEOUT << phb_shift);
+        val64 |= (timeout << phb_shift);
         writeq(cpu_to_be64(val64), target);
         readq(target); /* flush */
 }
 
+static void calioc2_handle_quirks(struct iommu_table *tbl, struct pci_dev *dev)
+{
+        unsigned char busnum = dev->bus->number;
+        void __iomem *bbar = tbl->bbar;
+        void __iomem *target;
+        u32 val;
+
+        /*
+         * CalIOC2 designers recommend setting bit 8 in 0xnDB0 to 1
+         */
+        target = calgary_reg(bbar, phb_offset(busnum) | PHB_SAVIOR_L2);
+        val = cpu_to_be32(readl(target));
+        val |= 0x00800000;
+        writel(cpu_to_be32(val), target);
+}
+
+static void calgary_handle_quirks(struct iommu_table *tbl, struct pci_dev *dev)
+{
+        unsigned char busnum = dev->bus->number;
+
+        /*
+         * Give split completion a longer timeout on bus 1 for aic94xx
+         * http://bugzilla.kernel.org/show_bug.cgi?id=7180
+         */
+        if (is_calgary(dev->device) && (busnum == 1))
+                calgary_set_split_completion_timeout(tbl->bbar, busnum,
+                                                     CCR_2SEC_TIMEOUT);
+}
+
 static void __init calgary_enable_translation(struct pci_dev *dev)
 {
         u32 val32;
@@ -816,7 +1042,7 @@ static void __init calgary_enable_translation(struct pci_dev *dev)
         struct iommu_table *tbl;
 
         busnum = dev->bus->number;
-        tbl = dev->sysdata;
+        tbl = pci_iommu(dev->bus);
         bbar = tbl->bbar;
 
         /* enable TCE in PHB Config Register */
@@ -824,20 +1050,15 @@ static void __init calgary_enable_translation(struct pci_dev *dev)
         val32 = be32_to_cpu(readl(target));
         val32 |= PHB_TCE_ENABLE | PHB_DAC_DISABLE | PHB_MCSR_ENABLE;
 
-        printk(KERN_INFO "Calgary: enabling translation on PHB %#x\n", busnum);
+        printk(KERN_INFO "Calgary: enabling translation on %s PHB %#x\n",
+               (dev->device == PCI_DEVICE_ID_IBM_CALGARY) ?
+               "Calgary" : "CalIOC2", busnum);
         printk(KERN_INFO "Calgary: errant DMAs will now be prevented on this "
                "bus.\n");
 
         writel(cpu_to_be32(val32), target);
         readl(target); /* flush */
 
-        /*
-         * Give split completion a longer timeout on bus 1 for aic94xx
-         * http://bugzilla.kernel.org/show_bug.cgi?id=7180
-         */
-        if (busnum == 1)
-                calgary_increase_split_completion_timeout(bbar, busnum);
-
         init_timer(&tbl->watchdog_timer);
         tbl->watchdog_timer.function = &calgary_watchdog;
         tbl->watchdog_timer.data = (unsigned long)dev;
@@ -853,7 +1074,7 @@ static void __init calgary_disable_translation(struct pci_dev *dev)
         struct iommu_table *tbl;
 
         busnum = dev->bus->number;
-        tbl = dev->sysdata;
+        tbl = pci_iommu(dev->bus);
         bbar = tbl->bbar;
 
         /* disable TCE in PHB Config Register */
@@ -871,13 +1092,19 @@ static void __init calgary_disable_translation(struct pci_dev *dev)
 static void __init calgary_init_one_nontraslated(struct pci_dev *dev)
 {
         pci_dev_get(dev);
-        dev->sysdata = NULL;
-        dev->bus->self = dev;
+        set_pci_iommu(dev->bus, NULL);
+
+        /* is the device behind a bridge? */
+        if (dev->bus->parent)
+                dev->bus->parent->self = dev;
+        else
+                dev->bus->self = dev;
 }
 
 static int __init calgary_init_one(struct pci_dev *dev)
 {
         void __iomem *bbar;
+        struct iommu_table *tbl;
         int ret;
 
         BUG_ON(dev->bus->number >= MAX_PHB_BUS_NUM);
@@ -888,7 +1115,18 @@ static int __init calgary_init_one(struct pci_dev *dev)
                 goto done;
 
         pci_dev_get(dev);
-        dev->bus->self = dev;
+
+        if (dev->bus->parent) {
+                if (dev->bus->parent->self)
+                        printk(KERN_WARNING "Calgary: IEEEE, dev %p has "
+                               "bus->parent->self!\n", dev);
+                dev->bus->parent->self = dev;
+        } else
+                dev->bus->self = dev;
+
+        tbl = pci_iommu(dev->bus);
+        tbl->chip_ops->handle_quirks(tbl, dev);
+
         calgary_enable_translation(dev);
 
         return 0;
@@ -924,11 +1162,18 @@ static int __init calgary_locate_bbars(void)
                         target = calgary_reg(bbar, offset);
 
                         val = be32_to_cpu(readl(target));
+
                         start_bus = (u8)((val & 0x00FF0000) >> 16);
                         end_bus = (u8)((val & 0x0000FF00) >> 8);
-                        for (bus = start_bus; bus <= end_bus; bus++) {
-                                bus_info[bus].bbar = bbar;
-                                bus_info[bus].phbid = phb;
+
+                        if (end_bus) {
+                                for (bus = start_bus; bus <= end_bus; bus++) {
+                                        bus_info[bus].bbar = bbar;
+                                        bus_info[bus].phbid = phb;
+                                }
+                        } else {
+                                bus_info[start_bus].bbar = bbar;
+                                bus_info[start_bus].phbid = phb;
                         }
                 }
         }
@@ -948,22 +1193,24 @@ static int __init calgary_init(void)
 {
         int ret;
         struct pci_dev *dev = NULL;
+        void *tce_space;
 
         ret = calgary_locate_bbars();
         if (ret)
                 return ret;
 
         do {
-                dev = pci_get_device(PCI_VENDOR_ID_IBM,
-                                     PCI_DEVICE_ID_IBM_CALGARY,
-                                     dev);
+                dev = pci_get_device(PCI_VENDOR_ID_IBM, PCI_ANY_ID, dev);
                 if (!dev)
                         break;
+                if (!is_cal_pci_dev(dev->device))
+                        continue;
                 if (!translate_phb(dev)) {
                         calgary_init_one_nontraslated(dev);
                         continue;
                 }
-                if (!bus_info[dev->bus->number].tce_space && !translate_empty_slots)
+                tce_space = bus_info[dev->bus->number].tce_space;
+                if (!tce_space && !translate_empty_slots)
                         continue;
 
                 ret = calgary_init_one(dev);
@@ -976,10 +1223,11 @@ static int __init calgary_init(void)
 error:
         do {
                 dev = pci_get_device_reverse(PCI_VENDOR_ID_IBM,
-                                              PCI_DEVICE_ID_IBM_CALGARY,
-                                              dev);
+                                             PCI_ANY_ID, dev);
                 if (!dev)
                         break;
+                if (!is_cal_pci_dev(dev->device))
+                        continue;
                 if (!translate_phb(dev)) {
                         pci_dev_put(dev);
                         continue;
@@ -1057,9 +1305,29 @@ static int __init build_detail_arrays(void)
         return 0;
 }
 
-void __init detect_calgary(void)
+static int __init calgary_bus_has_devices(int bus, unsigned short pci_dev)
 {
+        int dev;
         u32 val;
+
+        if (pci_dev == PCI_DEVICE_ID_IBM_CALIOC2) {
+                /*
+                 * FIXME: properly scan for devices accross the
+                 * PCI-to-PCI bridge on every CalIOC2 port.
+                 */
+                return 1;
+        }
+
+        for (dev = 1; dev < 8; dev++) {
+                val = read_pci_config(bus, dev, 0, 0);
+                if (val != 0xffffffff)
+                        break;
+        }
+        return (val != 0xffffffff);
+}
+
+void __init detect_calgary(void)
+{
         int bus;
         void *tbl;
         int calgary_found = 0;
@@ -1116,29 +1384,26 @@ void __init detect_calgary(void)
         specified_table_size = determine_tce_table_size(end_pfn * PAGE_SIZE);
 
         for (bus = 0; bus < MAX_PHB_BUS_NUM; bus++) {
-                int dev;
                 struct calgary_bus_info *info = &bus_info[bus];
+                unsigned short pci_device;
+                u32 val;
+
+                val = read_pci_config(bus, 0, 0, 0);
+                pci_device = (val & 0xFFFF0000) >> 16;
 
-                if (read_pci_config(bus, 0, 0, 0) != PCI_VENDOR_DEVICE_ID_CALGARY)
+                if (!is_cal_pci_dev(pci_device))
                         continue;
 
                 if (info->translation_disabled)
                         continue;
 
-                /*
-                 * Scan the slots of the PCI bus to see if there is a device present.
-                 * The parent bus will be the zero-ith device, so start at 1.
-                 */
-                for (dev = 1; dev < 8; dev++) {
-                        val = read_pci_config(bus, dev, 0, 0);
-                        if (val != 0xffffffff || translate_empty_slots) {
-                                tbl = alloc_tce_table();
-                                if (!tbl)
-                                        goto cleanup;
-                                info->tce_space = tbl;
-                                calgary_found = 1;
-                                break;
-                        }
+                if (calgary_bus_has_devices(bus, pci_device) ||
+                    translate_empty_slots) {
+                        tbl = alloc_tce_table();
+                        if (!tbl)
+                                goto cleanup;
+                        info->tce_space = tbl;
+                        calgary_found = 1;
                 }
         }
 
@@ -1249,3 +1514,66 @@ static int __init calgary_parse_options(char *p)
         return 1;
 }
 __setup("calgary=", calgary_parse_options);
+
+static void __init calgary_fixup_one_tce_space(struct pci_dev *dev)
+{
+        struct iommu_table *tbl;
+        unsigned int npages;
+        int i;
+
+        tbl = pci_iommu(dev->bus);
+
+        for (i = 0; i < 4; i++) {
+                struct resource *r = &dev->resource[PCI_BRIDGE_RESOURCES + i];
+
+                /* Don't give out TCEs that map MEM resources */
+                if (!(r->flags & IORESOURCE_MEM))
+                        continue;
+
+                /* 0-based? we reserve the whole 1st MB anyway */
+                if (!r->start)
+                        continue;
+
+                /* cover the whole region */
+                npages = (r->end - r->start) >> PAGE_SHIFT;
+                npages++;
+
+                iommu_range_reserve(tbl, r->start, npages);
+        }
+}
+
+static int __init calgary_fixup_tce_spaces(void)
+{
+        struct pci_dev *dev = NULL;
+        void *tce_space;
+
+        if (no_iommu || swiotlb || !calgary_detected)
+                return -ENODEV;
+
+        printk(KERN_DEBUG "Calgary: fixing up tce spaces\n");
+
+        do {
+                dev = pci_get_device(PCI_VENDOR_ID_IBM, PCI_ANY_ID, dev);
+                if (!dev)
+                        break;
+                if (!is_cal_pci_dev(dev->device))
+                        continue;
+                if (!translate_phb(dev))
+                        continue;
+
+                tce_space = bus_info[dev->bus->number].tce_space;
+                if (!tce_space)
+                        continue;
+
+                calgary_fixup_one_tce_space(dev);
+
+        } while (1);
+
+        return 0;
+}
+
+/*
+ * We need to be call after pcibios_assign_resources (fs_initcall level)
+ * and before device_initcall.
+ */
+rootfs_initcall(calgary_fixup_tce_spaces);
diff --git a/arch/x86_64/kernel/pci-dma.c b/arch/x86_64/kernel/pci-dma.c
index 90f6315d02d4..05d745ede561 100644
--- a/arch/x86_64/kernel/pci-dma.c
+++ b/arch/x86_64/kernel/pci-dma.c
@@ -8,7 +8,7 @@
 #include <linux/pci.h>
 #include <linux/module.h>
 #include <asm/io.h>
-#include <asm/proto.h>
+#include <asm/iommu.h>
 #include <asm/calgary.h>
 
 int iommu_merge __read_mostly = 0;
@@ -321,6 +321,11 @@ static int __init pci_iommu_init(void)
         return 0;
 }
 
+void pci_iommu_shutdown(void)
+{
+        gart_iommu_shutdown();
+}
+
 #ifdef CONFIG_PCI
 /* Many VIA bridges seem to corrupt data for DAC. Disable it here */
 
diff --git a/arch/x86_64/kernel/pci-gart.c b/arch/x86_64/kernel/pci-gart.c
index ae091cdc1a4d..4918c575d582 100644
--- a/arch/x86_64/kernel/pci-gart.c
+++ b/arch/x86_64/kernel/pci-gart.c
@@ -28,6 +28,7 @@
 #include <asm/mtrr.h>
 #include <asm/pgtable.h>
 #include <asm/proto.h>
+#include <asm/iommu.h>
 #include <asm/cacheflush.h>
 #include <asm/swiotlb.h>
 #include <asm/dma.h>
@@ -235,7 +236,7 @@ static dma_addr_t gart_map_simple(struct device *dev, char *buf,
 }
 
 /* Map a single area into the IOMMU */
-dma_addr_t gart_map_single(struct device *dev, void *addr, size_t size, int dir)
+static dma_addr_t gart_map_single(struct device *dev, void *addr, size_t size, int dir)
 {
         unsigned long phys_mem, bus;
 
@@ -253,7 +254,7 @@ dma_addr_t gart_map_single(struct device *dev, void *addr, size_t size, int dir)
 /*
  * Free a DMA mapping.
  */
-void gart_unmap_single(struct device *dev, dma_addr_t dma_addr,
+static void gart_unmap_single(struct device *dev, dma_addr_t dma_addr,
                       size_t size, int direction)
 {
         unsigned long iommu_page;
@@ -275,7 +276,7 @@ void gart_unmap_single(struct device *dev, dma_addr_t dma_addr,
 /*
  * Wrapper for pci_unmap_single working with scatterlists.
  */
-void gart_unmap_sg(struct device *dev, struct scatterlist *sg, int nents, int dir)
+static void gart_unmap_sg(struct device *dev, struct scatterlist *sg, int nents, int dir)
 {
         int i;
 
@@ -571,6 +572,26 @@ static const struct dma_mapping_ops gart_dma_ops = {
         .unmap_sg = gart_unmap_sg,
 };
 
+void gart_iommu_shutdown(void)
+{
+        struct pci_dev *dev;
+        int i;
+
+        if (no_agp && (dma_ops != &gart_dma_ops))
+                return;
+
+        for (i = 0; i < num_k8_northbridges; i++) {
+                u32 ctl;
+
+                dev = k8_northbridges[i];
+                pci_read_config_dword(dev, 0x90, &ctl);
+
+                ctl &= ~1;
+
+                pci_write_config_dword(dev, 0x90, ctl);
+        }
+}
+
 void __init gart_iommu_init(void)
 { 
         struct agp_kern_info info;
diff --git a/arch/x86_64/kernel/pci-nommu.c b/arch/x86_64/kernel/pci-nommu.c
index 6dade0c867cc..2a34c6c025a9 100644
--- a/arch/x86_64/kernel/pci-nommu.c
+++ b/arch/x86_64/kernel/pci-nommu.c
@@ -6,7 +6,7 @@
 #include <linux/string.h>
 #include <linux/dma-mapping.h>
 
-#include <asm/proto.h>
+#include <asm/iommu.h>
 #include <asm/processor.h>
 #include <asm/dma.h>
 
@@ -34,7 +34,7 @@ nommu_map_single(struct device *hwdev, void *ptr, size_t size,
         return bus;
 }
 
-void nommu_unmap_single(struct device *dev, dma_addr_t addr,size_t size,
+static void nommu_unmap_single(struct device *dev, dma_addr_t addr,size_t size,
                         int direction)
 {
 }
@@ -54,7 +54,7 @@ void nommu_unmap_single(struct device *dev, dma_addr_t addr,size_t size,
  * Device ownership issues as mentioned above for pci_map_single are
  * the same here.
  */
-int nommu_map_sg(struct device *hwdev, struct scatterlist *sg,
+static int nommu_map_sg(struct device *hwdev, struct scatterlist *sg,
                int nents, int direction)
 {
         int i;
@@ -74,7 +74,7 @@ int nommu_map_sg(struct device *hwdev, struct scatterlist *sg,
  * Again, cpu read rules concerning calls here are the same as for
  * pci_unmap_single() above.
  */
-void nommu_unmap_sg(struct device *dev, struct scatterlist *sg,
+static void nommu_unmap_sg(struct device *dev, struct scatterlist *sg,
                   int nents, int dir)
 {
 }
diff --git a/arch/x86_64/kernel/pci-swiotlb.c b/arch/x86_64/kernel/pci-swiotlb.c
index 4b4569abc60c..b2f405ea7c85 100644
--- a/arch/x86_64/kernel/pci-swiotlb.c
+++ b/arch/x86_64/kernel/pci-swiotlb.c
@@ -5,7 +5,7 @@
 #include <linux/module.h>
 #include <linux/dma-mapping.h>
 
-#include <asm/proto.h>
+#include <asm/iommu.h>
 #include <asm/swiotlb.h>
 #include <asm/dma.h>
 
diff --git a/arch/x86_64/kernel/process.c b/arch/x86_64/kernel/process.c
index 5909039f37aa..92fade4a62cf 100644
--- a/arch/x86_64/kernel/process.c
+++ b/arch/x86_64/kernel/process.c
@@ -207,6 +207,7 @@ void cpu_idle (void)
                         if (__get_cpu_var(cpu_idle_state))
                                 __get_cpu_var(cpu_idle_state) = 0;
 
+                        check_pgt_cache();
                         rmb();
                         idle = pm_idle;
                         if (!idle)
@@ -278,7 +279,7 @@ void __cpuinit select_idle_routine(const struct cpuinfo_x86 *c)
                  */
                 if (!pm_idle) {
                         if (!printed) {
-                                printk("using mwait in idle threads.\n");
+                                printk(KERN_INFO "using mwait in idle threads.\n");
                                 printed = 1;
                         }
                         pm_idle = mwait_idle;
@@ -305,6 +306,7 @@ early_param("idle", idle_setup);
 void __show_regs(struct pt_regs * regs)
 {
         unsigned long cr0 = 0L, cr2 = 0L, cr3 = 0L, cr4 = 0L, fs, gs, shadowgs;
+        unsigned long d0, d1, d2, d3, d6, d7;
         unsigned int fsindex,gsindex;
         unsigned int ds,cs,es; 
 
@@ -349,6 +351,15 @@ void __show_regs(struct pt_regs * regs)
                fs,fsindex,gs,gsindex,shadowgs); 
         printk("CS:  %04x DS: %04x ES: %04x CR0: %016lx\n", cs, ds, es, cr0); 
         printk("CR2: %016lx CR3: %016lx CR4: %016lx\n", cr2, cr3, cr4);
+
+        get_debugreg(d0, 0);
+        get_debugreg(d1, 1);
+        get_debugreg(d2, 2);
+        printk("DR0: %016lx DR1: %016lx DR2: %016lx\n", d0, d1, d2);
+        get_debugreg(d3, 3);
+        get_debugreg(d6, 6);
+        get_debugreg(d7, 7);
+        printk("DR3: %016lx DR6: %016lx DR7: %016lx\n", d3, d6, d7);
 }
 
 void show_regs(struct pt_regs *regs)
diff --git a/arch/x86_64/kernel/reboot.c b/arch/x86_64/kernel/reboot.c
index 7503068e788d..368db2b9c5ac 100644
--- a/arch/x86_64/kernel/reboot.c
+++ b/arch/x86_64/kernel/reboot.c
@@ -16,6 +16,7 @@
 #include <asm/pgtable.h>
 #include <asm/tlbflush.h>
 #include <asm/apic.h>
+#include <asm/iommu.h>
 
 /*
  * Power off function, if any
@@ -81,6 +82,7 @@ static inline void kb_wait(void)
 void machine_shutdown(void)
 {
         unsigned long flags;
+
         /* Stop the cpus and apics */
 #ifdef CONFIG_SMP
         int reboot_cpu_id;
@@ -111,6 +113,8 @@ void machine_shutdown(void)
         disable_IO_APIC();
 
         local_irq_restore(flags);
+
+        pci_iommu_shutdown();
 }
 
 void machine_emergency_restart(void)
diff --git a/arch/x86_64/kernel/setup.c b/arch/x86_64/kernel/setup.c
index 33ef718f8cb5..6fa0a302e2aa 100644
--- a/arch/x86_64/kernel/setup.c
+++ b/arch/x86_64/kernel/setup.c
@@ -575,6 +575,8 @@ static void __cpuinit init_amd(struct cpuinfo_x86 *c)
         level = cpuid_eax(1);
         if (c->x86 == 15 && ((level >= 0x0f48 && level < 0x0f50) || level >= 0x0f58))
                 set_bit(X86_FEATURE_REP_GOOD, &c->x86_capability);
+        if (c->x86 == 0x10)
+                set_bit(X86_FEATURE_REP_GOOD, &c->x86_capability);
 
         /* Enable workaround for FXSAVE leak */
         if (c->x86 >= 6)
@@ -600,8 +602,11 @@ static void __cpuinit init_amd(struct cpuinfo_x86 *c)
         if (c->extended_cpuid_level >= 0x80000008)
                 amd_detect_cmp(c);
 
-        /* Fix cpuid4 emulation for more */
-        num_cache_leaves = 3;
+        if (c->extended_cpuid_level >= 0x80000006 &&
+                (cpuid_edx(0x80000006) & 0xf000))
+                num_cache_leaves = 4;
+        else
+                num_cache_leaves = 3;
 
         /* RDTSC can be speculated around */
         clear_bit(X86_FEATURE_SYNC_RDTSC, &c->x86_capability);
diff --git a/arch/x86_64/kernel/signal.c b/arch/x86_64/kernel/signal.c
index 290f5d8037cd..4886afcd6287 100644
--- a/arch/x86_64/kernel/signal.c
+++ b/arch/x86_64/kernel/signal.c
@@ -26,6 +26,7 @@
 #include <asm/i387.h>
 #include <asm/proto.h>
 #include <asm/ia32_unistd.h>
+#include <asm/mce.h>
 
 /* #define DEBUG_SIG 1 */
 
@@ -472,6 +473,12 @@ do_notify_resume(struct pt_regs *regs, void *unused, __u32 thread_info_flags)
                 clear_thread_flag(TIF_SINGLESTEP);
         }
 
+#ifdef CONFIG_X86_MCE
+        /* notify userspace of pending MCEs */
+        if (thread_info_flags & _TIF_MCE_NOTIFY)
+                mce_notify_user();
+#endif /* CONFIG_X86_MCE */
+
         /* deal with pending signal delivery */
         if (thread_info_flags & (_TIF_SIGPENDING|_TIF_RESTORE_SIGMASK))
                 do_signal(regs);
diff --git a/arch/x86_64/kernel/smp.c b/arch/x86_64/kernel/smp.c
index 0694940b2e73..673a300b5944 100644
--- a/arch/x86_64/kernel/smp.c
+++ b/arch/x86_64/kernel/smp.c
@@ -241,7 +241,7 @@ void flush_tlb_mm (struct mm_struct * mm)
         }
         if (!cpus_empty(cpu_mask))
                 flush_tlb_others(cpu_mask, mm, FLUSH_ALL);
-
+        check_pgt_cache();
         preempt_enable();
 }
 EXPORT_SYMBOL(flush_tlb_mm);
@@ -386,9 +386,9 @@ int smp_call_function_single (int cpu, void (*func) (void *info), void *info,
                 return 0;
         }
 
-        spin_lock_bh(&call_lock);
+        spin_lock(&call_lock);
         __smp_call_function_single(cpu, func, info, nonatomic, wait);
-        spin_unlock_bh(&call_lock);
+        spin_unlock(&call_lock);
         put_cpu();
         return 0;
 }
diff --git a/arch/x86_64/kernel/tce.c b/arch/x86_64/kernel/tce.c
index f61fb8e4f129..3aeae2fa2e24 100644
--- a/arch/x86_64/kernel/tce.c
+++ b/arch/x86_64/kernel/tce.c
@@ -136,9 +136,9 @@ int build_tce_table(struct pci_dev *dev, void __iomem *bbar)
         struct iommu_table *tbl;
         int ret;
 
-        if (dev->sysdata) {
-                printk(KERN_ERR "Calgary: dev %p has sysdata %p\n",
-                       dev, dev->sysdata);
+        if (pci_iommu(dev->bus)) {
+                printk(KERN_ERR "Calgary: dev %p has sysdata->iommu %p\n",
+                       dev, pci_iommu(dev->bus));
                 BUG();
         }
 
@@ -155,11 +155,7 @@ int build_tce_table(struct pci_dev *dev, void __iomem *bbar)
 
         tbl->bbar = bbar;
 
-        /*
-         * NUMA is already using the bus's sysdata pointer, so we use
-         * the bus's pci_dev's sysdata instead.
-         */
-        dev->sysdata = tbl;
+        set_pci_iommu(dev->bus, tbl);
 
         return 0;
 
diff --git a/arch/x86_64/kernel/time.c b/arch/x86_64/kernel/time.c
index 4a0895bacf51..6d48a4e826d9 100644
--- a/arch/x86_64/kernel/time.c
+++ b/arch/x86_64/kernel/time.c
@@ -33,6 +33,7 @@
 #include <acpi/acpi_bus.h>
 #endif
 #include <asm/8253pit.h>
+#include <asm/i8253.h>
 #include <asm/pgtable.h>
 #include <asm/vsyscall.h>
 #include <asm/timex.h>
@@ -44,12 +45,14 @@
 #include <asm/hpet.h>
 #include <asm/mpspec.h>
 #include <asm/nmi.h>
+#include <asm/vgtod.h>
 
 static char *timename = NULL;
 
 DEFINE_SPINLOCK(rtc_lock);
 EXPORT_SYMBOL(rtc_lock);
 DEFINE_SPINLOCK(i8253_lock);
+EXPORT_SYMBOL(i8253_lock);
 
 volatile unsigned long __jiffies __section_jiffies = INITIAL_JIFFIES;
 
@@ -79,8 +82,9 @@ EXPORT_SYMBOL(profile_pc);
  * sheet for details.
  */
 
-static void set_rtc_mmss(unsigned long nowtime)
+static int set_rtc_mmss(unsigned long nowtime)
 {
+        int retval = 0;
         int real_seconds, real_minutes, cmos_minutes;
         unsigned char control, freq_select;
 
@@ -120,6 +124,7 @@ static void set_rtc_mmss(unsigned long nowtime)
         if (abs(real_minutes - cmos_minutes) >= 30) {
                 printk(KERN_WARNING "time.c: can't update CMOS clock "
                        "from %d to %d\n", cmos_minutes, real_minutes);
+                retval = -1;
         } else {
                 BIN_TO_BCD(real_seconds);
                 BIN_TO_BCD(real_minutes);
@@ -139,12 +144,17 @@ static void set_rtc_mmss(unsigned long nowtime)
         CMOS_WRITE(freq_select, RTC_FREQ_SELECT);
 
         spin_unlock(&rtc_lock);
+
+        return retval;
 }
 
+int update_persistent_clock(struct timespec now)
+{
+        return set_rtc_mmss(now.tv_sec);
+}
 
 void main_timer_handler(void)
 {
-        static unsigned long rtc_update = 0;
 /*
  * Here we are in the timer irq handler. We have irqs locally disabled (so we
  * don't need spin_lock_irqsave()) but we don't know if the timer_bh is running
@@ -172,20 +182,6 @@ void main_timer_handler(void)
         if (!using_apic_timer)
                 smp_local_timer_interrupt();
 
-/*
- * If we have an externally synchronized Linux clock, then update CMOS clock
- * accordingly every ~11 minutes. set_rtc_mmss() will be called in the jiffy
- * closest to exactly 500 ms before the next second. If the update fails, we
- * don't care, as it'll be updated on the next turn, and the problem (time way
- * off) isn't likely to go away much sooner anyway.
- */
-
-        if (ntp_synced() && xtime.tv_sec > rtc_update &&
-                abs(xtime.tv_nsec - 500000000) <= tick_nsec / 2) {
-                set_rtc_mmss(xtime.tv_sec);
-                rtc_update = xtime.tv_sec + 660;
-        }
- 
         write_sequnlock(&xtime_lock);
 }
 
@@ -199,7 +195,7 @@ static irqreturn_t timer_interrupt(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
-static unsigned long get_cmos_time(void)
+unsigned long read_persistent_clock(void)
 {
         unsigned int year, mon, day, hour, min, sec;
         unsigned long flags;
@@ -226,7 +222,7 @@ static unsigned long get_cmos_time(void)
         /*
          * We know that x86-64 always uses BCD format, no need to check the
          * config register.
-         */
+         */
 
         BCD_TO_BIN(sec);
         BCD_TO_BIN(min);
@@ -239,11 +235,11 @@ static unsigned long get_cmos_time(void)
                 BCD_TO_BIN(century);
                 year += century * 100;
                 printk(KERN_INFO "Extended CMOS year: %d\n", century * 100);
-        } else { 
+        } else {
                 /*
                  * x86-64 systems only exists since 2002.
                  * This will work up to Dec 31, 2100
-                 */
+                 */
                 year += 2000;
         }
 
@@ -255,45 +251,45 @@ static unsigned long get_cmos_time(void)
 #define TICK_COUNT 100000000
 static unsigned int __init tsc_calibrate_cpu_khz(void)
 {
-       int tsc_start, tsc_now;
-       int i, no_ctr_free;
-       unsigned long evntsel3 = 0, pmc3 = 0, pmc_now = 0;
-       unsigned long flags;
-
-       for (i = 0; i < 4; i++)
-               if (avail_to_resrv_perfctr_nmi_bit(i))
-                       break;
-       no_ctr_free = (i == 4);
-       if (no_ctr_free) {
-               i = 3;
-               rdmsrl(MSR_K7_EVNTSEL3, evntsel3);
-               wrmsrl(MSR_K7_EVNTSEL3, 0);
-               rdmsrl(MSR_K7_PERFCTR3, pmc3);
-       } else {
-               reserve_perfctr_nmi(MSR_K7_PERFCTR0 + i);
-               reserve_evntsel_nmi(MSR_K7_EVNTSEL0 + i);
-       }
-       local_irq_save(flags);
-       /* start meauring cycles, incrementing from 0 */
-       wrmsrl(MSR_K7_PERFCTR0 + i, 0);
-       wrmsrl(MSR_K7_EVNTSEL0 + i, 1 << 22 | 3 << 16 | 0x76);
-       rdtscl(tsc_start);
-       do {
-               rdmsrl(MSR_K7_PERFCTR0 + i, pmc_now);
-               tsc_now = get_cycles_sync();
-       } while ((tsc_now - tsc_start) < TICK_COUNT);
-
-       local_irq_restore(flags);
-       if (no_ctr_free) {
-               wrmsrl(MSR_K7_EVNTSEL3, 0);
-               wrmsrl(MSR_K7_PERFCTR3, pmc3);
-               wrmsrl(MSR_K7_EVNTSEL3, evntsel3);
-       } else {
-               release_perfctr_nmi(MSR_K7_PERFCTR0 + i);
-               release_evntsel_nmi(MSR_K7_EVNTSEL0 + i);
-       }
-
-       return pmc_now * tsc_khz / (tsc_now - tsc_start);
+        int tsc_start, tsc_now;
+        int i, no_ctr_free;
+        unsigned long evntsel3 = 0, pmc3 = 0, pmc_now = 0;
+        unsigned long flags;
+
+        for (i = 0; i < 4; i++)
+                if (avail_to_resrv_perfctr_nmi_bit(i))
+                        break;
+        no_ctr_free = (i == 4);
+        if (no_ctr_free) {
+                i = 3;
+                rdmsrl(MSR_K7_EVNTSEL3, evntsel3);
+                wrmsrl(MSR_K7_EVNTSEL3, 0);
+                rdmsrl(MSR_K7_PERFCTR3, pmc3);
+        } else {
+                reserve_perfctr_nmi(MSR_K7_PERFCTR0 + i);
+                reserve_evntsel_nmi(MSR_K7_EVNTSEL0 + i);
+        }
+        local_irq_save(flags);
+        /* start meauring cycles, incrementing from 0 */
+        wrmsrl(MSR_K7_PERFCTR0 + i, 0);
+        wrmsrl(MSR_K7_EVNTSEL0 + i, 1 << 22 | 3 << 16 | 0x76);
+        rdtscl(tsc_start);
+        do {
+                rdmsrl(MSR_K7_PERFCTR0 + i, pmc_now);
+                tsc_now = get_cycles_sync();
+        } while ((tsc_now - tsc_start) < TICK_COUNT);
+
+        local_irq_restore(flags);
+        if (no_ctr_free) {
+                wrmsrl(MSR_K7_EVNTSEL3, 0);
+                wrmsrl(MSR_K7_PERFCTR3, pmc3);
+                wrmsrl(MSR_K7_EVNTSEL3, evntsel3);
+        } else {
+                release_perfctr_nmi(MSR_K7_PERFCTR0 + i);
+                release_evntsel_nmi(MSR_K7_EVNTSEL0 + i);
+        }
+
+        return pmc_now * tsc_khz / (tsc_now - tsc_start);
 }
 
 /*
@@ -321,7 +317,7 @@ static unsigned int __init pit_calibrate_tsc(void)
         end = get_cycles_sync();
 
         spin_unlock_irqrestore(&i8253_lock, flags);
-        
+
         return (end - start) / 50;
 }
 
@@ -366,25 +362,20 @@ static struct irqaction irq0 = {
         .handler        = timer_interrupt,
         .flags          = IRQF_DISABLED | IRQF_IRQPOLL,
         .mask           = CPU_MASK_NONE,
-        .name           = "timer"
+        .name           = "timer"
 };
 
 void __init time_init(void)
 {
         if (nohpet)
                 hpet_address = 0;
-        xtime.tv_sec = get_cmos_time();
-        xtime.tv_nsec = 0;
-
-        set_normalized_timespec(&wall_to_monotonic,
-                                -xtime.tv_sec, -xtime.tv_nsec);
 
         if (hpet_arch_init())
                 hpet_address = 0;
 
         if (hpet_use_timer) {
                 /* set tick_nsec to use the proper rate for HPET */
-                tick_nsec = TICK_NSEC_HPET;
+                tick_nsec = TICK_NSEC_HPET;
                 tsc_khz = hpet_calibrate_tsc();
                 timename = "HPET";
         } else {
@@ -415,54 +406,21 @@ void __init time_init(void)
         setup_irq(0, &irq0);
 }
 
-
-static long clock_cmos_diff;
-static unsigned long sleep_start;
-
 /*
  * sysfs support for the timer.
  */
 
 static int timer_suspend(struct sys_device *dev, pm_message_t state)
 {
-        /*
-         * Estimate time zone so that set_time can update the clock
-         */
-        long cmos_time =  get_cmos_time();
-
-        clock_cmos_diff = -cmos_time;
-        clock_cmos_diff += get_seconds();
-        sleep_start = cmos_time;
         return 0;
 }
 
 static int timer_resume(struct sys_device *dev)
 {
-        unsigned long flags;
-        unsigned long sec;
-        unsigned long ctime = get_cmos_time();
-        long sleep_length = (ctime - sleep_start) * HZ;
-
-        if (sleep_length < 0) {
-                printk(KERN_WARNING "Time skew detected in timer resume!\n");
-                /* The time after the resume must not be earlier than the time
-                 * before the suspend or some nasty things will happen
-                 */
-                sleep_length = 0;
-                ctime = sleep_start;
-        }
         if (hpet_address)
                 hpet_reenable();
         else
                 i8254_timer_resume();
-
-        sec = ctime + clock_cmos_diff;
-        write_seqlock_irqsave(&xtime_lock,flags);
-        xtime.tv_sec = sec;
-        xtime.tv_nsec = 0;
-        jiffies += sleep_length;
-        write_sequnlock_irqrestore(&xtime_lock,flags);
-        touch_softlockup_watchdog();
         return 0;
 }
 
diff --git a/arch/x86_64/kernel/tsc.c b/arch/x86_64/kernel/tsc.c
index e850aa01e1b3..9b76b03d0600 100644
--- a/arch/x86_64/kernel/tsc.c
+++ b/arch/x86_64/kernel/tsc.c
@@ -61,25 +61,9 @@ inline int check_tsc_unstable(void)
  * first tick after the change will be slightly wrong.
  */
 
-#include <linux/workqueue.h>
-
-static unsigned int cpufreq_delayed_issched = 0;
-static unsigned int cpufreq_init = 0;
-static struct work_struct cpufreq_delayed_get_work;
-
-static void handle_cpufreq_delayed_get(struct work_struct *v)
-{
-        unsigned int cpu;
-        for_each_online_cpu(cpu) {
-                cpufreq_get(cpu);
-        }
-        cpufreq_delayed_issched = 0;
-}
-
-static unsigned int  ref_freq = 0;
-static unsigned long loops_per_jiffy_ref = 0;
-
-static unsigned long tsc_khz_ref = 0;
+static unsigned int  ref_freq;
+static unsigned long loops_per_jiffy_ref;
+static unsigned long tsc_khz_ref;
 
 static int time_cpufreq_notifier(struct notifier_block *nb, unsigned long val,
                                  void *data)
@@ -125,10 +109,8 @@ static struct notifier_block time_cpufreq_notifier_block = {
 
 static int __init cpufreq_tsc(void)
 {
-        INIT_WORK(&cpufreq_delayed_get_work, handle_cpufreq_delayed_get);
-        if (!cpufreq_register_notifier(&time_cpufreq_notifier_block,
-                                       CPUFREQ_TRANSITION_NOTIFIER))
-                cpufreq_init = 1;
+        cpufreq_register_notifier(&time_cpufreq_notifier_block,
+                                  CPUFREQ_TRANSITION_NOTIFIER);
         return 0;
 }
 
@@ -153,17 +135,18 @@ __cpuinit int unsynchronized_tsc(void)
 #endif
         /* Most intel systems have synchronized TSCs except for
            multi node systems */
-        if (boot_cpu_data.x86_vendor == X86_VENDOR_INTEL) {
+        if (boot_cpu_data.x86_vendor == X86_VENDOR_INTEL) {
 #ifdef CONFIG_ACPI
                 /* But TSC doesn't tick in C3 so don't use it there */
-                if (acpi_gbl_FADT.header.length > 0 && acpi_gbl_FADT.C3latency < 1000)
+                if (acpi_gbl_FADT.header.length > 0 &&
+                    acpi_gbl_FADT.C3latency < 1000)
                         return 1;
 #endif
-                return 0;
+                return 0;
         }
 
-        /* Assume multi socket systems are not synchronized */
-        return num_present_cpus() > 1;
+        /* Assume multi socket systems are not synchronized */
+        return num_present_cpus() > 1;
 }
 
 int __init notsc_setup(char *s)
diff --git a/arch/x86_64/kernel/vmlinux.lds.S b/arch/x86_64/kernel/vmlinux.lds.S
index 5c57ea4591c1..e7a5eb6cd785 100644
--- a/arch/x86_64/kernel/vmlinux.lds.S
+++ b/arch/x86_64/kernel/vmlinux.lds.S
@@ -54,6 +54,13 @@ SECTIONS
 
   RODATA
 
+  . = ALIGN(4);
+  .tracedata : AT(ADDR(.tracedata) - LOAD_OFFSET) {
+        __tracedata_start = .;
+        *(.tracedata)
+        __tracedata_end = .;
+  }
+
   . = ALIGN(PAGE_SIZE);        /* Align data segment to page size boundary */
                                 /* Data */
   .data : AT(ADDR(.data) - LOAD_OFFSET) {
@@ -93,6 +100,9 @@ SECTIONS
   .vsyscall_gtod_data : AT(VLOAD(.vsyscall_gtod_data))
                 { *(.vsyscall_gtod_data) }
   vsyscall_gtod_data = VVIRT(.vsyscall_gtod_data);
+  .vsyscall_clock : AT(VLOAD(.vsyscall_clock))
+                { *(.vsyscall_clock) }
+  vsyscall_clock = VVIRT(.vsyscall_clock);
 
 
   .vsyscall_1 ADDR(.vsyscall_0) + 1024: AT(VLOAD(.vsyscall_1))
@@ -133,20 +143,11 @@ SECTIONS
   /* might get freed after init */
   . = ALIGN(4096);
   __smp_alt_begin = .;
-  __smp_alt_instructions = .;
-  .smp_altinstructions : AT(ADDR(.smp_altinstructions) - LOAD_OFFSET) {
-        *(.smp_altinstructions)
-  }
-  __smp_alt_instructions_end = .;
-  . = ALIGN(8);
   __smp_locks = .;
   .smp_locks : AT(ADDR(.smp_locks) - LOAD_OFFSET) {
         *(.smp_locks)
   }
   __smp_locks_end = .;
-  .smp_altinstr_replacement : AT(ADDR(.smp_altinstr_replacement) - LOAD_OFFSET) {
-        *(.smp_altinstr_replacement)
-  }
   . = ALIGN(4096);
   __smp_alt_end = .;
 
@@ -189,6 +190,12 @@ SECTIONS
   .exit.text : AT(ADDR(.exit.text) - LOAD_OFFSET) { *(.exit.text) }
   .exit.data : AT(ADDR(.exit.data) - LOAD_OFFSET) { *(.exit.data) }
 
+/* vdso blob that is mapped into user space */
+  vdso_start = . ;
+  .vdso  : AT(ADDR(.vdso) - LOAD_OFFSET) { *(.vdso) }
+  . = ALIGN(4096);
+  vdso_end = .;
+
 #ifdef CONFIG_BLK_DEV_INITRD
   . = ALIGN(4096);
   __initramfs_start = .;
diff --git a/arch/x86_64/kernel/vsyscall.c b/arch/x86_64/kernel/vsyscall.c
index 57660d58d500..06c34949bfdc 100644
--- a/arch/x86_64/kernel/vsyscall.c
+++ b/arch/x86_64/kernel/vsyscall.c
@@ -42,6 +42,7 @@
 #include <asm/segment.h>
 #include <asm/desc.h>
 #include <asm/topology.h>
+#include <asm/vgtod.h>
 
 #define __vsyscall(nr) __attribute__ ((unused,__section__(".vsyscall_" #nr)))
 #define __syscall_clobber "r11","rcx","memory"
@@ -57,26 +58,9 @@
  * - writen by timer interrupt or systcl (/proc/sys/kernel/vsyscall64)
  * Try to keep this structure as small as possible to avoid cache line ping pongs
  */
-struct vsyscall_gtod_data_t {
-        seqlock_t       lock;
-
-        /* open coded 'struct timespec' */
-        time_t          wall_time_sec;
-        u32             wall_time_nsec;
-
-        int             sysctl_enabled;
-        struct timezone sys_tz;
-        struct { /* extract of a clocksource struct */
-                cycle_t (*vread)(void);
-                cycle_t cycle_last;
-                cycle_t mask;
-                u32     mult;
-                u32     shift;
-        } clock;
-};
 int __vgetcpu_mode __section_vgetcpu_mode;
 
-struct vsyscall_gtod_data_t __vsyscall_gtod_data __section_vsyscall_gtod_data =
+struct vsyscall_gtod_data __vsyscall_gtod_data __section_vsyscall_gtod_data =
 {
         .lock = SEQLOCK_UNLOCKED,
         .sysctl_enabled = 1,
@@ -96,6 +80,8 @@ void update_vsyscall(struct timespec *wall_time, struct clocksource *clock)
         vsyscall_gtod_data.wall_time_sec = wall_time->tv_sec;
         vsyscall_gtod_data.wall_time_nsec = wall_time->tv_nsec;
         vsyscall_gtod_data.sys_tz = sys_tz;
+        vsyscall_gtod_data.wall_time_nsec = wall_time->tv_nsec;
+        vsyscall_gtod_data.wall_to_monotonic = wall_to_monotonic;
         write_sequnlock_irqrestore(&vsyscall_gtod_data.lock, flags);
 }
 
diff --git a/arch/x86_64/mm/fault.c b/arch/x86_64/mm/fault.c
index 84f11728fc76..2074bddd4f04 100644
--- a/arch/x86_64/mm/fault.c
+++ b/arch/x86_64/mm/fault.c
@@ -301,7 +301,7 @@ static int vmalloc_fault(unsigned long address)
         return 0;
 }
 
-int page_fault_trace = 0;
+static int page_fault_trace;
 int exception_trace = 1;
 
 /*
@@ -568,7 +568,7 @@ out_of_memory:
         }
         printk("VM: killing process %s\n", tsk->comm);
         if (error_code & 4)
-                do_exit(SIGKILL);
+                do_group_exit(SIGKILL);
         goto no_context;
 
 do_sigbus:
diff --git a/arch/x86_64/mm/init.c b/arch/x86_64/mm/init.c
index 9a0e98accf04..381c2ecd407e 100644
--- a/arch/x86_64/mm/init.c
+++ b/arch/x86_64/mm/init.c
@@ -700,8 +700,6 @@ int kern_addr_valid(unsigned long addr)
 #ifdef CONFIG_SYSCTL
 #include <linux/sysctl.h>
 
-extern int exception_trace, page_fault_trace;
-
 static ctl_table debug_table2[] = {
         {
                 .ctl_name       = 99,
@@ -774,3 +772,12 @@ void *alloc_bootmem_high_node(pg_data_t *pgdat, unsigned long size)
         return __alloc_bootmem_core(pgdat->bdata, size,
                         SMP_CACHE_BYTES, (4UL*1024*1024*1024), 0);
 }
+
+const char *arch_vma_name(struct vm_area_struct *vma)
+{
+        if (vma->vm_mm && vma->vm_start == (long)vma->vm_mm->context.vdso)
+                return "[vdso]";
+        if (vma == &gate_vma)
+                return "[vsyscall]";
+        return NULL;
+}
diff --git a/arch/x86_64/mm/k8topology.c b/arch/x86_64/mm/k8topology.c
index f983c75825d0..a96006f7ae0c 100644
--- a/arch/x86_64/mm/k8topology.c
+++ b/arch/x86_64/mm/k8topology.c
@@ -44,12 +44,12 @@ int __init k8_scan_nodes(unsigned long start, unsigned long end)
 { 
         unsigned long prevbase;
         struct bootnode nodes[8];
-        int nodeid, i, nb; 
+        int nodeid, i, j, nb;
         unsigned char nodeids[8];
         int found = 0;
         u32 reg;
         unsigned numnodes;
-        unsigned dualcore = 0;
+        unsigned num_cores;
 
         if (!early_pci_allowed())
                 return -1;
@@ -60,6 +60,9 @@ int __init k8_scan_nodes(unsigned long start, unsigned long end)
 
         printk(KERN_INFO "Scanning NUMA topology in Northbridge %d\n", nb); 
 
+        num_cores = (cpuid_ecx(0x80000008) & 0xff) + 1;
+        printk(KERN_INFO "CPU has %d num_cores\n", num_cores);
+
         reg = read_pci_config(0, nb, 0, 0x60); 
         numnodes = ((reg >> 4) & 0xF) + 1;
         if (numnodes <= 1)
@@ -73,8 +76,6 @@ int __init k8_scan_nodes(unsigned long start, unsigned long end)
                 unsigned long base,limit; 
                 u32 nodeid;
                 
-                /* Undefined before E stepping, but hopefully 0 */
-                dualcore |= ((read_pci_config(0, nb, 3, 0xe8) >> 12) & 3) == 1;
                 base = read_pci_config(0, nb, 1, 0x40 + i*8);
                 limit = read_pci_config(0, nb, 1, 0x44 + i*8);
 
@@ -170,8 +171,8 @@ int __init k8_scan_nodes(unsigned long start, unsigned long end)
         for (i = 0; i < 8; i++) {
                 if (nodes[i].start != nodes[i].end) { 
                         nodeid = nodeids[i];
-                        apicid_to_node[nodeid << dualcore] = i;
-                        apicid_to_node[(nodeid << dualcore) + dualcore] = i;
+                        for (j = 0; j < num_cores; j++)
+                                apicid_to_node[(nodeid * num_cores) + j] = i;
                         setup_node_bootmem(i, nodes[i].start, nodes[i].end); 
                 } 
         }
diff --git a/arch/x86_64/mm/numa.c b/arch/x86_64/mm/numa.c
index 51548947ad3b..6da235522269 100644
--- a/arch/x86_64/mm/numa.c
+++ b/arch/x86_64/mm/numa.c
@@ -273,9 +273,6 @@ void __init numa_init_array(void)
 
 #ifdef CONFIG_NUMA_EMU
 /* Numa emulation */
-#define E820_ADDR_HOLE_SIZE(start, end)                                 \
-        (e820_hole_size((start) >> PAGE_SHIFT, (end) >> PAGE_SHIFT) <<  \
-        PAGE_SHIFT)
 char *cmdline __initdata;
 
 /*
@@ -319,7 +316,7 @@ static int __init split_nodes_equally(struct bootnode *nodes, u64 *addr,
                 return -1;
         if (num_nodes > MAX_NUMNODES)
                 num_nodes = MAX_NUMNODES;
-        size = (max_addr - *addr - E820_ADDR_HOLE_SIZE(*addr, max_addr)) /
+        size = (max_addr - *addr - e820_hole_size(*addr, max_addr)) /
                num_nodes;
         /*
          * Calculate the number of big nodes that can be allocated as a result
@@ -347,7 +344,7 @@ static int __init split_nodes_equally(struct bootnode *nodes, u64 *addr,
                 if (i == num_nodes + node_start - 1)
                         end = max_addr;
                 else
-                        while (end - *addr - E820_ADDR_HOLE_SIZE(*addr, end) <
+                        while (end - *addr - e820_hole_size(*addr, end) <
                                size) {
                                 end += FAKE_NODE_MIN_SIZE;
                                 if (end > max_addr) {
@@ -476,18 +473,22 @@ out:
 
         /*
          * We need to vacate all active ranges that may have been registered by
-         * SRAT.
+         * SRAT and set acpi_numa to -1 so that srat_disabled() always returns
+         * true.  NUMA emulation has succeeded so we will not scan ACPI nodes.
          */
         remove_all_active_ranges();
+#ifdef CONFIG_ACPI_NUMA
+        acpi_numa = -1;
+#endif
         for_each_node_mask(i, node_possible_map) {
                 e820_register_active_regions(i, nodes[i].start >> PAGE_SHIFT,
                                                 nodes[i].end >> PAGE_SHIFT);
                 setup_node_bootmem(i, nodes[i].start, nodes[i].end);
         }
+        acpi_fake_nodes(nodes, num_nodes);
         numa_init_array();
         return 0;
 }
-#undef E820_ADDR_HOLE_SIZE
 #endif /* CONFIG_NUMA_EMU */
 
 void __init numa_initmem_init(unsigned long start_pfn, unsigned long end_pfn)
diff --git a/arch/x86_64/mm/pageattr.c b/arch/x86_64/mm/pageattr.c
index 9148f4a4cec6..36377b6b8efe 100644
--- a/arch/x86_64/mm/pageattr.c
+++ b/arch/x86_64/mm/pageattr.c
@@ -74,14 +74,12 @@ static void flush_kernel_map(void *arg)
         struct page *pg;
 
         /* When clflush is available always use it because it is
-           much cheaper than WBINVD. Disable clflush for now because
-           the high level code is not ready yet */
-        if (1 || !cpu_has_clflush)
+           much cheaper than WBINVD. */
+        if (!cpu_has_clflush)
                 asm volatile("wbinvd" ::: "memory");
         else list_for_each_entry(pg, l, lru) {
                 void *adr = page_address(pg);
-                if (cpu_has_clflush)
-                        cache_flush_page(adr);
+                cache_flush_page(adr);
         }
         __flush_tlb_all();
 }
@@ -95,7 +93,8 @@ static LIST_HEAD(deferred_pages); /* protected by init_mm.mmap_sem */
 
 static inline void save_page(struct page *fpage)
 {
-        list_add(&fpage->lru, &deferred_pages);
+        if (!test_and_set_bit(PG_arch_1, &fpage->flags))
+                list_add(&fpage->lru, &deferred_pages);
 }
 
 /* 
@@ -129,9 +128,12 @@ __change_page_attr(unsigned long address, unsigned long pfn, pgprot_t prot,
         pte_t *kpte; 
         struct page *kpte_page;
         pgprot_t ref_prot2;
+
         kpte = lookup_address(address);
         if (!kpte) return 0;
         kpte_page = virt_to_page(((unsigned long)kpte) & PAGE_MASK);
+        BUG_ON(PageLRU(kpte_page));
+        BUG_ON(PageCompound(kpte_page));
         if (pgprot_val(prot) != pgprot_val(ref_prot)) { 
                 if (!pte_huge(*kpte)) {
                         set_pte(kpte, pfn_pte(pfn, prot));
@@ -159,10 +161,9 @@ __change_page_attr(unsigned long address, unsigned long pfn, pgprot_t prot,
         /* on x86-64 the direct mapping set at boot is not using 4k pages */
         BUG_ON(PageReserved(kpte_page));
 
-        if (page_private(kpte_page) == 0) {
-                save_page(kpte_page);
+        save_page(kpte_page);
+        if (page_private(kpte_page) == 0)
                 revert_page(address, ref_prot);
-        }
         return 0;
 } 
 
@@ -234,6 +235,10 @@ void global_flush_tlb(void)
         flush_map(&l);
 
         list_for_each_entry_safe(pg, next, &l, lru) {
+                list_del(&pg->lru);
+                clear_bit(PG_arch_1, &pg->flags);
+                if (page_private(pg) != 0)
+                        continue;
                 ClearPagePrivate(pg);
                 __free_page(pg);
         } 
diff --git a/arch/x86_64/mm/srat.c b/arch/x86_64/mm/srat.c
index 1e76bb0a7277..acdf03e19146 100644
--- a/arch/x86_64/mm/srat.c
+++ b/arch/x86_64/mm/srat.c
@@ -106,9 +106,9 @@ static __init int slit_valid(struct acpi_table_slit *slit)
                 for (j = 0; j < d; j++)  {
                         u8 val = slit->entry[d*i + j];
                         if (i == j) {
-                                if (val != 10)
+                                if (val != LOCAL_DISTANCE)
                                         return 0;
-                        } else if (val <= 10)
+                        } else if (val <= LOCAL_DISTANCE)
                                 return 0;
                 }
         }
@@ -350,7 +350,7 @@ acpi_numa_memory_affinity_init(struct acpi_srat_mem_affinity *ma)
 
 /* Sanity check to catch more bad SRATs (they are amazingly common).
    Make sure the PXMs cover all memory. */
-static int nodes_cover_memory(void)
+static int __init nodes_cover_memory(const struct bootnode *nodes)
 {
         int i;
         unsigned long pxmram, e820ram;
@@ -394,6 +394,9 @@ int __init acpi_scan_nodes(unsigned long start, unsigned long end)
 {
         int i;
 
+        if (acpi_numa <= 0)
+                return -1;
+
         /* First clean up the node list */
         for (i = 0; i < MAX_NUMNODES; i++) {
                 cutoff_node(i, start, end);
@@ -403,10 +406,7 @@ int __init acpi_scan_nodes(unsigned long start, unsigned long end)
                 }
         }
 
-        if (acpi_numa <= 0)
-                return -1;
-
-        if (!nodes_cover_memory()) {
+        if (!nodes_cover_memory(nodes)) {
                 bad_srat();
                 return -1;
         }
@@ -440,6 +440,86 @@ int __init acpi_scan_nodes(unsigned long start, unsigned long end)
         return 0;
 }
 
+#ifdef CONFIG_NUMA_EMU
+static int __init find_node_by_addr(unsigned long addr)
+{
+        int ret = NUMA_NO_NODE;
+        int i;
+
+        for_each_node_mask(i, nodes_parsed) {
+                /*
+                 * Find the real node that this emulated node appears on.  For
+                 * the sake of simplicity, we only use a real node's starting
+                 * address to determine which emulated node it appears on.
+                 */
+                if (addr >= nodes[i].start && addr < nodes[i].end) {
+                        ret = i;
+                        break;
+                }
+        }
+        return i;
+}
+
+/*
+ * In NUMA emulation, we need to setup proximity domain (_PXM) to node ID
+ * mappings that respect the real ACPI topology but reflect our emulated
+ * environment.  For each emulated node, we find which real node it appears on
+ * and create PXM to NID mappings for those fake nodes which mirror that
+ * locality.  SLIT will now represent the correct distances between emulated
+ * nodes as a result of the real topology.
+ */
+void __init acpi_fake_nodes(const struct bootnode *fake_nodes, int num_nodes)
+{
+        int i, j;
+        int fake_node_to_pxm_map[MAX_NUMNODES] = {
+                [0 ... MAX_NUMNODES-1] = PXM_INVAL
+        };
+        unsigned char fake_apicid_to_node[MAX_LOCAL_APIC] = {
+                [0 ... MAX_LOCAL_APIC-1] = NUMA_NO_NODE
+        };
+
+        printk(KERN_INFO "Faking PXM affinity for fake nodes on real "
+                         "topology.\n");
+        for (i = 0; i < num_nodes; i++) {
+                int nid, pxm;
+
+                nid = find_node_by_addr(fake_nodes[i].start);
+                if (nid == NUMA_NO_NODE)
+                        continue;
+                pxm = node_to_pxm(nid);
+                if (pxm == PXM_INVAL)
+                        continue;
+                fake_node_to_pxm_map[i] = pxm;
+                /*
+                 * For each apicid_to_node mapping that exists for this real
+                 * node, it must now point to the fake node ID.
+                 */
+                for (j = 0; j < MAX_LOCAL_APIC; j++)
+                        if (apicid_to_node[j] == nid)
+                                fake_apicid_to_node[j] = i;
+        }
+        for (i = 0; i < num_nodes; i++)
+                __acpi_map_pxm_to_node(fake_node_to_pxm_map[i], i);
+        memcpy(apicid_to_node, fake_apicid_to_node, sizeof(apicid_to_node));
+
+        nodes_clear(nodes_parsed);
+        for (i = 0; i < num_nodes; i++)
+                if (fake_nodes[i].start != fake_nodes[i].end)
+                        node_set(i, nodes_parsed);
+        WARN_ON(!nodes_cover_memory(fake_nodes));
+}
+
+static int null_slit_node_compare(int a, int b)
+{
+        return node_to_pxm(a) == node_to_pxm(b);
+}
+#else
+static int null_slit_node_compare(int a, int b)
+{
+        return a == b;
+}
+#endif /* CONFIG_NUMA_EMU */
+
 void __init srat_reserve_add_area(int nodeid)
 {
         if (found_add_area && nodes_add[nodeid].end) {
@@ -464,7 +544,8 @@ int __node_distance(int a, int b)
         int index;
 
         if (!acpi_slit)
-                return a == b ? 10 : 20;
+                return null_slit_node_compare(a, b) ? LOCAL_DISTANCE :
+                                                      REMOTE_DISTANCE;
         index = acpi_slit->locality_count * node_to_pxm(a);
         return acpi_slit->entry[index + node_to_pxm(b)];
 }
diff --git a/arch/x86_64/pci/k8-bus.c b/arch/x86_64/pci/k8-bus.c
index 3acf60ded2a0..9cc813e29706 100644
--- a/arch/x86_64/pci/k8-bus.c
+++ b/arch/x86_64/pci/k8-bus.c
@@ -59,6 +59,8 @@ fill_mp_bus_to_cpumask(void)
                                      j <= SUBORDINATE_LDT_BUS_NUMBER(ldtbus);
                                      j++) { 
                                         struct pci_bus *bus;
+                                        struct pci_sysdata *sd;
+
                                         long node = NODE_ID(nid);
                                         /* Algorithm a bit dumb, but
                                            it shouldn't matter here */
@@ -67,7 +69,9 @@ fill_mp_bus_to_cpumask(void)
                                                 continue;
                                         if (!node_online(node))
                                                 node = 0;
-                                        bus->sysdata = (void *)node;
+
+                                        sd = bus->sysdata;
+                                        sd->node = node;
                                 }               
                         }
                 }
diff --git a/arch/x86_64/vdso/Makefile b/arch/x86_64/vdso/Makefile
new file mode 100644
index 000000000000..faaa72fb250c
--- /dev/null
+++ b/arch/x86_64/vdso/Makefile
@@ -0,0 +1,49 @@
+#
+# x86-64 vDSO.
+#
+
+# files to link into the vdso
+# vdso-start.o has to be first
+vobjs-y := vdso-start.o vdso-note.o vclock_gettime.o vgetcpu.o vvar.o
+
+# files to link into kernel
+obj-y := vma.o vdso.o vdso-syms.o
+
+vobjs := $(foreach F,$(vobjs-y),$(obj)/$F)
+
+$(obj)/vdso.o: $(obj)/vdso.so
+
+targets += vdso.so vdso.lds $(vobjs-y) vdso-syms.o
+
+# The DSO images are built using a special linker script.
+quiet_cmd_syscall = SYSCALL $@
+      cmd_syscall = $(CC) -m elf_x86_64 -nostdlib $(SYSCFLAGS_$(@F)) \
+                          -Wl,-T,$(filter-out FORCE,$^) -o $@
+
+export CPPFLAGS_vdso.lds += -P -C -U$(ARCH)
+
+vdso-flags = -fPIC -shared -Wl,-soname=linux-vdso.so.1 \
+                 $(call ld-option, -Wl$(comma)--hash-style=sysv) \
+                -Wl,-z,max-page-size=4096 -Wl,-z,common-page-size=4096
+SYSCFLAGS_vdso.so = $(vdso-flags)
+
+$(obj)/vdso.o: $(src)/vdso.S $(obj)/vdso.so
+
+$(obj)/vdso.so: $(src)/vdso.lds $(vobjs) FORCE
+        $(call if_changed,syscall)
+
+CF := $(PROFILING) -mcmodel=small -fPIC -g0 -O2 -fasynchronous-unwind-tables -m64
+
+$(obj)/vclock_gettime.o: CFLAGS = $(CF)
+$(obj)/vgetcpu.o: CFLAGS = $(CF)
+
+# We also create a special relocatable object that should mirror the symbol
+# table and layout of the linked DSO.  With ld -R we can then refer to
+# these symbols in the kernel code rather than hand-coded addresses.
+extra-y += vdso-syms.o
+$(obj)/built-in.o: $(obj)/vdso-syms.o
+$(obj)/built-in.o: ld_flags += -R $(obj)/vdso-syms.o
+
+SYSCFLAGS_vdso-syms.o = -r -d
+$(obj)/vdso-syms.o: $(src)/vdso.lds $(vobjs) FORCE
+        $(call if_changed,syscall)
diff --git a/arch/x86_64/vdso/vclock_gettime.c b/arch/x86_64/vdso/vclock_gettime.c
new file mode 100644
index 000000000000..17f6a00de712
--- /dev/null
+++ b/arch/x86_64/vdso/vclock_gettime.c
@@ -0,0 +1,120 @@
+/*
+ * Copyright 2006 Andi Kleen, SUSE Labs.
+ * Subject to the GNU Public License, v.2
+ *
+ * Fast user context implementation of clock_gettime and gettimeofday.
+ *
+ * The code should have no internal unresolved relocations.
+ * Check with readelf after changing.
+ * Also alternative() doesn't work.
+ */
+
+#include <linux/kernel.h>
+#include <linux/posix-timers.h>
+#include <linux/time.h>
+#include <linux/string.h>
+#include <asm/vsyscall.h>
+#include <asm/vgtod.h>
+#include <asm/timex.h>
+#include <asm/hpet.h>
+#include <asm/unistd.h>
+#include <asm/io.h>
+#include <asm/vgtod.h>
+#include "vextern.h"
+
+#define gtod vdso_vsyscall_gtod_data
+
+static long vdso_fallback_gettime(long clock, struct timespec *ts)
+{
+        long ret;
+        asm("syscall" : "=a" (ret) :
+            "0" (__NR_clock_gettime),"D" (clock), "S" (ts) : "memory");
+        return ret;
+}
+
+static inline long vgetns(void)
+{
+        cycles_t (*vread)(void);
+        vread = gtod->clock.vread;
+        return ((vread() - gtod->clock.cycle_last) * gtod->clock.mult) >>
+                gtod->clock.shift;
+}
+
+static noinline int do_realtime(struct timespec *ts)
+{
+        unsigned long seq, ns;
+        do {
+                seq = read_seqbegin(&gtod->lock);
+                ts->tv_sec = gtod->wall_time_sec;
+                ts->tv_nsec = gtod->wall_time_nsec;
+                ns = vgetns();
+        } while (unlikely(read_seqretry(&gtod->lock, seq)));
+        timespec_add_ns(ts, ns);
+        return 0;
+}
+
+/* Copy of the version in kernel/time.c which we cannot directly access */
+static void vset_normalized_timespec(struct timespec *ts, long sec, long nsec)
+{
+        while (nsec >= NSEC_PER_SEC) {
+                nsec -= NSEC_PER_SEC;
+                ++sec;
+        }
+        while (nsec < 0) {
+                nsec += NSEC_PER_SEC;
+                --sec;
+        }
+        ts->tv_sec = sec;
+        ts->tv_nsec = nsec;
+}
+
+static noinline int do_monotonic(struct timespec *ts)
+{
+        unsigned long seq, ns, secs;
+        do {
+                seq = read_seqbegin(&gtod->lock);
+                secs = gtod->wall_time_sec;
+                ns = gtod->wall_time_nsec + vgetns();
+                secs += gtod->wall_to_monotonic.tv_sec;
+                ns += gtod->wall_to_monotonic.tv_nsec;
+        } while (unlikely(read_seqretry(&gtod->lock, seq)));
+        vset_normalized_timespec(ts, secs, ns);
+        return 0;
+}
+
+int __vdso_clock_gettime(clockid_t clock, struct timespec *ts)
+{
+        if (likely(gtod->sysctl_enabled && gtod->clock.vread))
+                switch (clock) {
+                case CLOCK_REALTIME:
+                        return do_realtime(ts);
+                case CLOCK_MONOTONIC:
+                        return do_monotonic(ts);
+                }
+        return vdso_fallback_gettime(clock, ts);
+}
+int clock_gettime(clockid_t, struct timespec *)
+        __attribute__((weak, alias("__vdso_clock_gettime")));
+
+int __vdso_gettimeofday(struct timeval *tv, struct timezone *tz)
+{
+        long ret;
+        if (likely(gtod->sysctl_enabled && gtod->clock.vread)) {
+                BUILD_BUG_ON(offsetof(struct timeval, tv_usec) !=
+                             offsetof(struct timespec, tv_nsec) ||
+                             sizeof(*tv) != sizeof(struct timespec));
+                do_realtime((struct timespec *)tv);
+                tv->tv_usec /= 1000;
+                if (unlikely(tz != NULL)) {
+                        /* This relies on gcc inlining the memcpy. We'll notice
+                           if it ever fails to do so. */
+                        memcpy(tz, &gtod->sys_tz, sizeof(struct timezone));
+                }
+                return 0;
+        }
+        asm("syscall" : "=a" (ret) :
+            "0" (__NR_gettimeofday), "D" (tv), "S" (tz) : "memory");
+        return ret;
+}
+int gettimeofday(struct timeval *, struct timezone *)
+        __attribute__((weak, alias("__vdso_gettimeofday")));
diff --git a/arch/x86_64/vdso/vdso-note.S b/arch/x86_64/vdso/vdso-note.S
new file mode 100644
index 000000000000..79a071e4357e
--- /dev/null
+++ b/arch/x86_64/vdso/vdso-note.S
@@ -0,0 +1,12 @@
+/*
+ * This supplies .note.* sections to go into the PT_NOTE inside the vDSO text.
+ * Here we can supply some information useful to userland.
+ */
+
+#include <linux/uts.h>
+#include <linux/version.h>
+#include <linux/elfnote.h>
+
+ELFNOTE_START(Linux, 0, "a")
+        .long LINUX_VERSION_CODE
+ELFNOTE_END
diff --git a/arch/x86_64/vdso/vdso-start.S b/arch/x86_64/vdso/vdso-start.S
new file mode 100644
index 000000000000..2dc2cdb84d67
--- /dev/null
+++ b/arch/x86_64/vdso/vdso-start.S
@@ -0,0 +1,2 @@
+        .globl vdso_kernel_start
+vdso_kernel_start:
diff --git a/arch/x86_64/vdso/vdso.S b/arch/x86_64/vdso/vdso.S
new file mode 100644
index 000000000000..92e80c1972a7
--- /dev/null
+++ b/arch/x86_64/vdso/vdso.S
@@ -0,0 +1,2 @@
+        .section ".vdso","a"
+        .incbin "arch/x86_64/vdso/vdso.so"
diff --git a/arch/x86_64/vdso/vdso.lds.S b/arch/x86_64/vdso/vdso.lds.S
new file mode 100644
index 000000000000..b9a60e665d08
--- /dev/null
+++ b/arch/x86_64/vdso/vdso.lds.S
@@ -0,0 +1,77 @@
+/*
+ * Linker script for vsyscall DSO.  The vsyscall page is an ELF shared
+ * object prelinked to its virtual address, and with only one read-only
+ * segment (that fits in one page).  This script controls its layout.
+ */
+#include <asm/asm-offsets.h>
+#include "voffset.h"
+
+#define VDSO_PRELINK 0xffffffffff700000
+
+SECTIONS
+{
+  . = VDSO_PRELINK + SIZEOF_HEADERS;
+
+  .hash           : { *(.hash) }                :text
+  .gnu.hash       : { *(.gnu.hash) }
+  .dynsym         : { *(.dynsym) }
+  .dynstr         : { *(.dynstr) }
+  .gnu.version    : { *(.gnu.version) }
+  .gnu.version_d  : { *(.gnu.version_d) }
+  .gnu.version_r  : { *(.gnu.version_r) }
+
+  /* This linker script is used both with -r and with -shared.
+     For the layouts to match, we need to skip more than enough
+     space for the dynamic symbol table et al.  If this amount
+     is insufficient, ld -shared will barf.  Just increase it here.  */
+  . = VDSO_PRELINK + VDSO_TEXT_OFFSET;
+
+  .text           : { *(.text) }                :text
+  .text.ptr       : { *(.text.ptr) }            :text
+  . = VDSO_PRELINK + 0x900;
+  .data           : { *(.data) }                :text
+  .bss            : { *(.bss) }                 :text
+
+  .altinstructions : { *(.altinstructions) }                    :text
+  .altinstr_replacement  : { *(.altinstr_replacement) } :text
+
+  .note           : { *(.note.*) }              :text :note
+  .eh_frame_hdr   : { *(.eh_frame_hdr) }        :text :eh_frame_hdr
+  .eh_frame       : { KEEP (*(.eh_frame)) }     :text
+  .dynamic        : { *(.dynamic) }             :text :dynamic
+  .useless        : {
+        *(.got.plt) *(.got)
+        *(.gnu.linkonce.d.*)
+        *(.dynbss)
+        *(.gnu.linkonce.b.*)
+  }                                             :text
+}
+
+/*
+ * We must supply the ELF program headers explicitly to get just one
+ * PT_LOAD segment, and set the flags explicitly to make segments read-only.
+ */
+PHDRS
+{
+  text PT_LOAD FILEHDR PHDRS FLAGS(5); /* PF_R|PF_X */
+  dynamic PT_DYNAMIC FLAGS(4); /* PF_R */
+  note PT_NOTE FLAGS(4); /* PF_R */
+  eh_frame_hdr 0x6474e550; /* PT_GNU_EH_FRAME, but ld doesn't match the name */
+}
+
+/*
+ * This controls what symbols we export from the DSO.
+ */
+VERSION
+{
+  LINUX_2.6 {
+    global:
+        clock_gettime;
+        __vdso_clock_gettime;
+        gettimeofday;
+        __vdso_gettimeofday;
+        getcpu;
+        __vdso_getcpu;
+    local: *;
+  };
+}
diff --git a/arch/x86_64/vdso/vextern.h b/arch/x86_64/vdso/vextern.h
new file mode 100644
index 000000000000..1683ba2ae3e8
--- /dev/null
+++ b/arch/x86_64/vdso/vextern.h
@@ -0,0 +1,16 @@
+#ifndef VEXTERN
+#include <asm/vsyscall.h>
+#define VEXTERN(x) \
+        extern typeof(x) *vdso_ ## x __attribute__((visibility("hidden")));
+#endif
+
+#define VMAGIC 0xfeedbabeabcdefabUL
+
+/* Any kernel variables used in the vDSO must be exported in the main
+   kernel's vmlinux.lds.S/vsyscall.h/proper __section and
+   put into vextern.h and be referenced as a pointer with vdso prefix.
+   The main kernel later fills in the values.   */
+
+VEXTERN(jiffies)
+VEXTERN(vgetcpu_mode)
+VEXTERN(vsyscall_gtod_data)
diff --git a/arch/x86_64/vdso/vgetcpu.c b/arch/x86_64/vdso/vgetcpu.c
new file mode 100644
index 000000000000..91f6e85d0fc2
--- /dev/null
+++ b/arch/x86_64/vdso/vgetcpu.c
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2006 Andi Kleen, SUSE Labs.
+ * Subject to the GNU Public License, v.2
+ *
+ * Fast user context implementation of getcpu()
+ */
+
+#include <linux/kernel.h>
+#include <linux/getcpu.h>
+#include <linux/jiffies.h>
+#include <linux/time.h>
+#include <asm/vsyscall.h>
+#include <asm/vgtod.h>
+#include "vextern.h"
+
+long __vdso_getcpu(unsigned *cpu, unsigned *node, struct getcpu_cache *tcache)
+{
+        unsigned int dummy, p;
+        unsigned long j = 0;
+
+        /* Fast cache - only recompute value once per jiffies and avoid
+           relatively costly rdtscp/cpuid otherwise.
+           This works because the scheduler usually keeps the process
+           on the same CPU and this syscall doesn't guarantee its
+           results anyways.
+           We do this here because otherwise user space would do it on
+           its own in a likely inferior way (no access to jiffies).
+           If you don't like it pass NULL. */
+        if (tcache && tcache->blob[0] == (j = *vdso_jiffies)) {
+                p = tcache->blob[1];
+        } else if (*vdso_vgetcpu_mode == VGETCPU_RDTSCP) {
+                /* Load per CPU data from RDTSCP */
+                rdtscp(dummy, dummy, p);
+        } else {
+                /* Load per CPU data from GDT */
+                asm("lsl %1,%0" : "=r" (p) : "r" (__PER_CPU_SEG));
+        }
+        if (tcache) {
+                tcache->blob[0] = j;
+                tcache->blob[1] = p;
+        }
+        if (cpu)
+                *cpu = p & 0xfff;
+        if (node)
+                *node = p >> 12;
+        return 0;
+}
+
+long getcpu(unsigned *cpu, unsigned *node, struct getcpu_cache *tcache)
+        __attribute__((weak, alias("__vdso_getcpu")));
diff --git a/arch/x86_64/vdso/vma.c b/arch/x86_64/vdso/vma.c
new file mode 100644
index 000000000000..d4cb83a6c066
--- /dev/null
+++ b/arch/x86_64/vdso/vma.c
@@ -0,0 +1,139 @@
+/*
+ * Set up the VMAs to tell the VM about the vDSO.
+ * Copyright 2007 Andi Kleen, SUSE Labs.
+ * Subject to the GPL, v.2
+ */
+#include <linux/mm.h>
+#include <linux/sched.h>
+#include <linux/init.h>
+#include <linux/random.h>
+#include <asm/vsyscall.h>
+#include <asm/vgtod.h>
+#include <asm/proto.h>
+#include "voffset.h"
+
+int vdso_enabled = 1;
+
+#define VEXTERN(x) extern typeof(__ ## x) *vdso_ ## x;
+#include "vextern.h"
+#undef VEXTERN
+
+extern char vdso_kernel_start[], vdso_start[], vdso_end[];
+extern unsigned short vdso_sync_cpuid;
+
+struct page **vdso_pages;
+
+static inline void *var_ref(void *vbase, char *var, char *name)
+{
+        unsigned offset = var - &vdso_kernel_start[0] + VDSO_TEXT_OFFSET;
+        void *p = vbase + offset;
+        if (*(void **)p != (void *)VMAGIC) {
+                printk("VDSO: variable %s broken\n", name);
+                vdso_enabled = 0;
+        }
+        return p;
+}
+
+static int __init init_vdso_vars(void)
+{
+        int npages = (vdso_end - vdso_start + PAGE_SIZE - 1) / PAGE_SIZE;
+        int i;
+        char *vbase;
+
+        vdso_pages = kmalloc(sizeof(struct page *) * npages, GFP_KERNEL);
+        if (!vdso_pages)
+                goto oom;
+        for (i = 0; i < npages; i++) {
+                struct page *p;
+                p = alloc_page(GFP_KERNEL);
+                if (!p)
+                        goto oom;
+                vdso_pages[i] = p;
+                copy_page(page_address(p), vdso_start + i*PAGE_SIZE);
+        }
+
+        vbase = vmap(vdso_pages, npages, 0, PAGE_KERNEL);
+        if (!vbase)
+                goto oom;
+
+        if (memcmp(vbase, "\177ELF", 4)) {
+                printk("VDSO: I'm broken; not ELF\n");
+                vdso_enabled = 0;
+        }
+
+#define V(x) *(typeof(x) *) var_ref(vbase, (char *)RELOC_HIDE(&x, 0), #x)
+#define VEXTERN(x) \
+        V(vdso_ ## x) = &__ ## x;
+#include "vextern.h"
+#undef VEXTERN
+        return 0;
+
+ oom:
+        printk("Cannot allocate vdso\n");
+        vdso_enabled = 0;
+        return -ENOMEM;
+}
+__initcall(init_vdso_vars);
+
+struct linux_binprm;
+
+/* Put the vdso above the (randomized) stack with another randomized offset.
+   This way there is no hole in the middle of address space.
+   To save memory make sure it is still in the same PTE as the stack top.
+   This doesn't give that many random bits */
+static unsigned long vdso_addr(unsigned long start, unsigned len)
+{
+        unsigned long addr, end;
+        unsigned offset;
+        end = (start + PMD_SIZE - 1) & PMD_MASK;
+        if (end >= TASK_SIZE64)
+                end = TASK_SIZE64;
+        end -= len;
+        /* This loses some more bits than a modulo, but is cheaper */
+        offset = get_random_int() & (PTRS_PER_PTE - 1);
+        addr = start + (offset << PAGE_SHIFT);
+        if (addr >= end)
+                addr = end;
+        return addr;
+}
+
+/* Setup a VMA at program startup for the vsyscall page.
+   Not called for compat tasks */
+int arch_setup_additional_pages(struct linux_binprm *bprm, int exstack)
+{
+        struct mm_struct *mm = current->mm;
+        unsigned long addr;
+        int ret;
+        unsigned len = round_up(vdso_end - vdso_start, PAGE_SIZE);
+
+        if (!vdso_enabled)
+                return 0;
+
+        down_write(&mm->mmap_sem);
+        addr = vdso_addr(mm->start_stack, len);
+        addr = get_unmapped_area(NULL, addr, len, 0, 0);
+        if (IS_ERR_VALUE(addr)) {
+                ret = addr;
+                goto up_fail;
+        }
+
+        ret = install_special_mapping(mm, addr, len,
+                                      VM_READ|VM_EXEC|
+                                      VM_MAYREAD|VM_MAYWRITE|VM_MAYEXEC|
+                                      VM_ALWAYSDUMP,
+                                      vdso_pages);
+        if (ret)
+                goto up_fail;
+
+        current->mm->context.vdso = (void *)addr;
+up_fail:
+        up_write(&mm->mmap_sem);
+        return ret;
+}
+
+static __init int vdso_setup(char *s)
+{
+        vdso_enabled = simple_strtoul(s, NULL, 0);
+        return 0;
+}
+__setup("vdso=", vdso_setup);
diff --git a/arch/x86_64/vdso/voffset.h b/arch/x86_64/vdso/voffset.h
new file mode 100644
index 000000000000..5304204911f2
--- /dev/null
+++ b/arch/x86_64/vdso/voffset.h
@@ -0,0 +1 @@
+#define VDSO_TEXT_OFFSET 0x500
diff --git a/arch/x86_64/vdso/vvar.c b/arch/x86_64/vdso/vvar.c
new file mode 100644
index 000000000000..6fc22219a472
--- /dev/null
+++ b/arch/x86_64/vdso/vvar.c
@@ -0,0 +1,12 @@
+/* Define pointer to external vDSO variables.
+   These are part of the vDSO. The kernel fills in the real addresses
+   at boot time. This is done because when the vdso is linked the
+   kernel isn't yet and we don't know the final addresses. */
+#include <linux/kernel.h>
+#include <linux/time.h>
+#include <asm/vsyscall.h>
+#include <asm/timex.h>
+#include <asm/vgtod.h>
+
+#define VEXTERN(x) typeof (__ ## x) *vdso_ ## x = (void *)VMAGIC;
+#include "vextern.h"
diff --git a/drivers/acpi/numa.c b/drivers/acpi/numa.c
index 0c9f15c54e8c..ab04d848b19d 100644
--- a/drivers/acpi/numa.c
+++ b/drivers/acpi/numa.c
@@ -36,13 +36,11 @@
 ACPI_MODULE_NAME("numa");
 
 static nodemask_t nodes_found_map = NODE_MASK_NONE;
-#define PXM_INVAL       -1
-#define NID_INVAL       -1
 
 /* maps to convert between proximity domain and logical node ID */
-static int pxm_to_node_map[MAX_PXM_DOMAINS]
+static int __cpuinitdata pxm_to_node_map[MAX_PXM_DOMAINS]
                                 = { [0 ... MAX_PXM_DOMAINS - 1] = NID_INVAL };
-static int node_to_pxm_map[MAX_NUMNODES]
+static int __cpuinitdata node_to_pxm_map[MAX_NUMNODES]
                                 = { [0 ... MAX_NUMNODES - 1] = PXM_INVAL };
 
 int pxm_to_node(int pxm)
@@ -59,6 +57,12 @@ int node_to_pxm(int node)
         return node_to_pxm_map[node];
 }
 
+void __acpi_map_pxm_to_node(int pxm, int node)
+{
+        pxm_to_node_map[pxm] = node;
+        node_to_pxm_map[node] = pxm;
+}
+
 int acpi_map_pxm_to_node(int pxm)
 {
         int node = pxm_to_node_map[pxm];
@@ -67,8 +71,7 @@ int acpi_map_pxm_to_node(int pxm)
                 if (nodes_weight(nodes_found_map) >= MAX_NUMNODES)
                         return NID_INVAL;
                 node = first_unset_node(nodes_found_map);
-                pxm_to_node_map[pxm] = node;
-                node_to_pxm_map[node] = pxm;
+                __acpi_map_pxm_to_node(pxm, node);
                 node_set(node, nodes_found_map);
         }
 
@@ -83,7 +86,8 @@ void __cpuinit acpi_unmap_pxm_to_node(int node)
         node_clear(node, nodes_found_map);
 }
 
-void __init acpi_table_print_srat_entry(struct acpi_subtable_header * header)
+static void __init
+acpi_table_print_srat_entry(struct acpi_subtable_header *header)
 {
 
         ACPI_FUNCTION_NAME("acpi_table_print_srat_entry");
@@ -200,7 +204,7 @@ static int __init acpi_parse_srat(struct acpi_table_header *table)
         return 0;
 }
 
-int __init
+static int __init
 acpi_table_parse_srat(enum acpi_srat_type id,
                       acpi_table_entry_handler handler, unsigned int max_entries)
 {
@@ -211,14 +215,13 @@ acpi_table_parse_srat(enum acpi_srat_type id,
 
 int __init acpi_numa_init(void)
 {
-        int result;
-
         /* SRAT: Static Resource Affinity Table */
         if (!acpi_table_parse(ACPI_SIG_SRAT, acpi_parse_srat)) {
-                result = acpi_table_parse_srat(ACPI_SRAT_TYPE_CPU_AFFINITY,
-                                               acpi_parse_processor_affinity,
-                                               NR_CPUS);
-                result = acpi_table_parse_srat(ACPI_SRAT_TYPE_MEMORY_AFFINITY, acpi_parse_memory_affinity, NR_NODE_MEMBLKS);    // IA64 specific
+                acpi_table_parse_srat(ACPI_SRAT_TYPE_CPU_AFFINITY,
+                                      acpi_parse_processor_affinity, NR_CPUS);
+                acpi_table_parse_srat(ACPI_SRAT_TYPE_MEMORY_AFFINITY,
+                                      acpi_parse_memory_affinity,
+                                      NR_NODE_MEMBLKS);
         }
 
         /* SLIT: System Locality Information Table */
diff --git a/drivers/base/power/trace.c b/drivers/base/power/trace.c
index a9ab30fefffc..2b0c601e422e 100644
--- a/drivers/base/power/trace.c
+++ b/drivers/base/power/trace.c
@@ -142,6 +142,7 @@ void set_trace_device(struct device *dev)
 {
         dev_hash_value = hash_string(DEVSEED, dev->bus_id, DEVHASH);
 }
+EXPORT_SYMBOL(set_trace_device);
 
 /*
  * We could just take the "tracedata" index into the .tracedata
@@ -162,6 +163,7 @@ void generate_resume_trace(void *tracedata, unsigned int user)
         file_hash_value = hash_string(lineno, file, FILEHASH);
         set_magic_time(user_hash_value, file_hash_value, dev_hash_value);
 }
+EXPORT_SYMBOL(generate_resume_trace);
 
 extern char __tracedata_start, __tracedata_end;
 static int show_file_hash(unsigned int value)
@@ -170,7 +172,8 @@ static int show_file_hash(unsigned int value)
         char *tracedata;
 
         match = 0;
-        for (tracedata = &__tracedata_start ; tracedata < &__tracedata_end ; tracedata += 6) {
+        for (tracedata = &__tracedata_start ; tracedata < &__tracedata_end ;
+                        tracedata += 2 + sizeof(unsigned long)) {
                 unsigned short lineno = *(unsigned short *)tracedata;
                 const char *file = *(const char **)(tracedata + 2);
                 unsigned int hash = hash_string(lineno, file, FILEHASH);
diff --git a/drivers/block/Makefile b/drivers/block/Makefile
index 819c829125fb..a7a099027fca 100644
--- a/drivers/block/Makefile
+++ b/drivers/block/Makefile
@@ -8,6 +8,7 @@
 obj-$(CONFIG_MAC_FLOPPY)        += swim3.o
 obj-$(CONFIG_BLK_DEV_FD)        += floppy.o
 obj-$(CONFIG_AMIGA_FLOPPY)      += amiflop.o
+obj-$(CONFIG_PS3_DISK)          += ps3disk.o
 obj-$(CONFIG_ATARI_FLOPPY)      += ataflop.o
 obj-$(CONFIG_AMIGA_Z2RAM)       += z2ram.o
 obj-$(CONFIG_BLK_DEV_RAM)       += rd.o
diff --git a/drivers/block/ps3disk.c b/drivers/block/ps3disk.c
new file mode 100644
index 000000000000..170fb33dba97
--- /dev/null
+++ b/drivers/block/ps3disk.c
@@ -0,0 +1,630 @@
+/*
+ * PS3 Disk Storage Driver
+ *
+ * Copyright (C) 2007 Sony Computer Entertainment Inc.
+ * Copyright 2007 Sony Corp.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published
+ * by the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include <linux/ata.h>
+#include <linux/blkdev.h>
+
+#include <asm/lv1call.h>
+#include <asm/ps3stor.h>
+#include <asm/firmware.h>
+
+
+#define DEVICE_NAME             "ps3disk"
+
+#define BOUNCE_SIZE             (64*1024)
+
+#define PS3DISK_MAX_DISKS       16
+#define PS3DISK_MINORS          16
+
+
+#define PS3DISK_NAME            "ps3d%c"
+
+
+struct ps3disk_private {
+        spinlock_t lock;                /* Request queue spinlock */
+        struct request_queue *queue;
+        struct gendisk *gendisk;
+        unsigned int blocking_factor;
+        struct request *req;
+        u64 raw_capacity;
+        unsigned char model[ATA_ID_PROD_LEN+1];
+};
+
+
+#define LV1_STORAGE_SEND_ATA_COMMAND    (2)
+#define LV1_STORAGE_ATA_HDDOUT          (0x23)
+
+struct lv1_ata_cmnd_block {
+        u16     features;
+        u16     sector_count;
+        u16     LBA_low;
+        u16     LBA_mid;
+        u16     LBA_high;
+        u8      device;
+        u8      command;
+        u32     is_ext;
+        u32     proto;
+        u32     in_out;
+        u32     size;
+        u64     buffer;
+        u32     arglen;
+};
+
+enum lv1_ata_proto {
+        NON_DATA_PROTO     = 0,
+        PIO_DATA_IN_PROTO  = 1,
+        PIO_DATA_OUT_PROTO = 2,
+        DMA_PROTO = 3
+};
+
+enum lv1_ata_in_out {
+        DIR_WRITE = 0,                  /* memory -> device */
+        DIR_READ = 1                    /* device -> memory */
+};
+
+static int ps3disk_major;
+
+
+static struct block_device_operations ps3disk_fops = {
+        .owner          = THIS_MODULE,
+};
+
+
+static void ps3disk_scatter_gather(struct ps3_storage_device *dev,
+                                   struct request *req, int gather)
+{
+        unsigned int offset = 0;
+        struct bio *bio;
+        sector_t sector;
+        struct bio_vec *bvec;
+        unsigned int i = 0, j;
+        size_t size;
+        void *buf;
+
+        rq_for_each_bio(bio, req) {
+                sector = bio->bi_sector;
+                dev_dbg(&dev->sbd.core,
+                        "%s:%u: bio %u: %u segs %u sectors from %lu\n",
+                        __func__, __LINE__, i, bio_segments(bio),
+                        bio_sectors(bio), sector);
+                bio_for_each_segment(bvec, bio, j) {
+                        size = bvec->bv_len;
+                        buf = __bio_kmap_atomic(bio, j, KM_IRQ0);
+                        if (gather)
+                                memcpy(dev->bounce_buf+offset, buf, size);
+                        else
+                                memcpy(buf, dev->bounce_buf+offset, size);
+                        offset += size;
+                        flush_kernel_dcache_page(bio_iovec_idx(bio, j)->bv_page);
+                        __bio_kunmap_atomic(bio, KM_IRQ0);
+                }
+                i++;
+        }
+}
+
+static int ps3disk_submit_request_sg(struct ps3_storage_device *dev,
+                                     struct request *req)
+{
+        struct ps3disk_private *priv = dev->sbd.core.driver_data;
+        int write = rq_data_dir(req), res;
+        const char *op = write ? "write" : "read";
+        u64 start_sector, sectors;
+        unsigned int region_id = dev->regions[dev->region_idx].id;
+
+#ifdef DEBUG
+        unsigned int n = 0;
+        struct bio *bio;
+
+        rq_for_each_bio(bio, req)
+                n++;
+        dev_dbg(&dev->sbd.core,
+                "%s:%u: %s req has %u bios for %lu sectors %lu hard sectors\n",
+                __func__, __LINE__, op, n, req->nr_sectors,
+                req->hard_nr_sectors);
+#endif
+
+        start_sector = req->sector * priv->blocking_factor;
+        sectors = req->nr_sectors * priv->blocking_factor;
+        dev_dbg(&dev->sbd.core, "%s:%u: %s %lu sectors starting at %lu\n",
+                __func__, __LINE__, op, sectors, start_sector);
+
+        if (write) {
+                ps3disk_scatter_gather(dev, req, 1);
+
+                res = lv1_storage_write(dev->sbd.dev_id, region_id,
+                                        start_sector, sectors, 0,
+                                        dev->bounce_lpar, &dev->tag);
+        } else {
+                res = lv1_storage_read(dev->sbd.dev_id, region_id,
+                                       start_sector, sectors, 0,
+                                       dev->bounce_lpar, &dev->tag);
+        }
+        if (res) {
+                dev_err(&dev->sbd.core, "%s:%u: %s failed %d\n", __func__,
+                        __LINE__, op, res);
+                end_request(req, 0);
+                return 0;
+        }
+
+        priv->req = req;
+        return 1;
+}
+
+static int ps3disk_submit_flush_request(struct ps3_storage_device *dev,
+                                        struct request *req)
+{
+        struct ps3disk_private *priv = dev->sbd.core.driver_data;
+        u64 res;
+
+        dev_dbg(&dev->sbd.core, "%s:%u: flush request\n", __func__, __LINE__);
+
+        res = lv1_storage_send_device_command(dev->sbd.dev_id,
+                                              LV1_STORAGE_ATA_HDDOUT, 0, 0, 0,
+                                              0, &dev->tag);
+        if (res) {
+                dev_err(&dev->sbd.core, "%s:%u: sync cache failed 0x%lx\n",
+                        __func__, __LINE__, res);
+                end_request(req, 0);
+                return 0;
+        }
+
+        priv->req = req;
+        return 1;
+}
+
+static void ps3disk_do_request(struct ps3_storage_device *dev,
+                               request_queue_t *q)
+{
+        struct request *req;
+
+        dev_dbg(&dev->sbd.core, "%s:%u\n", __func__, __LINE__);
+
+        while ((req = elv_next_request(q))) {
+                if (blk_fs_request(req)) {
+                        if (ps3disk_submit_request_sg(dev, req))
+                                break;
+                } else if (req->cmd_type == REQ_TYPE_FLUSH) {
+                        if (ps3disk_submit_flush_request(dev, req))
+                                break;
+                } else {
+                        blk_dump_rq_flags(req, DEVICE_NAME " bad request");
+                        end_request(req, 0);
+                        continue;
+                }
+        }
+}
+
+static void ps3disk_request(request_queue_t *q)
+{
+        struct ps3_storage_device *dev = q->queuedata;
+        struct ps3disk_private *priv = dev->sbd.core.driver_data;
+
+        if (priv->req) {
+                dev_dbg(&dev->sbd.core, "%s:%u busy\n", __func__, __LINE__);
+                return;
+        }
+
+        ps3disk_do_request(dev, q);
+}
+
+static irqreturn_t ps3disk_interrupt(int irq, void *data)
+{
+        struct ps3_storage_device *dev = data;
+        struct ps3disk_private *priv;
+        struct request *req;
+        int res, read, uptodate;
+        u64 tag, status;
+        unsigned long num_sectors;
+        const char *op;
+
+        res = lv1_storage_get_async_status(dev->sbd.dev_id, &tag, &status);
+
+        if (tag != dev->tag)
+                dev_err(&dev->sbd.core,
+                        "%s:%u: tag mismatch, got %lx, expected %lx\n",
+                        __func__, __LINE__, tag, dev->tag);
+
+        if (res) {
+                dev_err(&dev->sbd.core, "%s:%u: res=%d status=0x%lx\n",
+                        __func__, __LINE__, res, status);
+                return IRQ_HANDLED;
+        }
+
+        priv = dev->sbd.core.driver_data;
+        req = priv->req;
+        if (!req) {
+                dev_dbg(&dev->sbd.core,
+                        "%s:%u non-block layer request completed\n", __func__,
+                        __LINE__);
+                dev->lv1_status = status;
+                complete(&dev->done);
+                return IRQ_HANDLED;
+        }
+
+        if (req->cmd_type == REQ_TYPE_FLUSH) {
+                read = 0;
+                num_sectors = req->hard_cur_sectors;
+                op = "flush";
+        } else {
+                read = !rq_data_dir(req);
+                num_sectors = req->nr_sectors;
+                op = read ? "read" : "write";
+        }
+        if (status) {
+                dev_dbg(&dev->sbd.core, "%s:%u: %s failed 0x%lx\n", __func__,
+                        __LINE__, op, status);
+                uptodate = 0;
+        } else {
+                dev_dbg(&dev->sbd.core, "%s:%u: %s completed\n", __func__,
+                        __LINE__, op);
+                uptodate = 1;
+                if (read)
+                        ps3disk_scatter_gather(dev, req, 0);
+        }
+
+        spin_lock(&priv->lock);
+        if (!end_that_request_first(req, uptodate, num_sectors)) {
+                add_disk_randomness(req->rq_disk);
+                blkdev_dequeue_request(req);
+                end_that_request_last(req, uptodate);
+        }
+        priv->req = NULL;
+        ps3disk_do_request(dev, priv->queue);
+        spin_unlock(&priv->lock);
+
+        return IRQ_HANDLED;
+}
+
+static int ps3disk_sync_cache(struct ps3_storage_device *dev)
+{
+        u64 res;
+
+        dev_dbg(&dev->sbd.core, "%s:%u: sync cache\n", __func__, __LINE__);
+
+        res = ps3stor_send_command(dev, LV1_STORAGE_ATA_HDDOUT, 0, 0, 0, 0);
+        if (res) {
+                dev_err(&dev->sbd.core, "%s:%u: sync cache failed 0x%lx\n",
+                        __func__, __LINE__, res);
+                return -EIO;
+        }
+        return 0;
+}
+
+
+/* ATA helpers copied from drivers/ata/libata-core.c */
+
+static void swap_buf_le16(u16 *buf, unsigned int buf_words)
+{
+#ifdef __BIG_ENDIAN
+        unsigned int i;
+
+        for (i = 0; i < buf_words; i++)
+                buf[i] = le16_to_cpu(buf[i]);
+#endif /* __BIG_ENDIAN */
+}
+
+static u64 ata_id_n_sectors(const u16 *id)
+{
+        if (ata_id_has_lba(id)) {
+                if (ata_id_has_lba48(id))
+                        return ata_id_u64(id, 100);
+                else
+                        return ata_id_u32(id, 60);
+        } else {
+                if (ata_id_current_chs_valid(id))
+                        return ata_id_u32(id, 57);
+                else
+                        return id[1] * id[3] * id[6];
+        }
+}
+
+static void ata_id_string(const u16 *id, unsigned char *s, unsigned int ofs,
+                          unsigned int len)
+{
+        unsigned int c;
+
+        while (len > 0) {
+                c = id[ofs] >> 8;
+                *s = c;
+                s++;
+
+                c = id[ofs] & 0xff;
+                *s = c;
+                s++;
+
+                ofs++;
+                len -= 2;
+        }
+}
+
+static void ata_id_c_string(const u16 *id, unsigned char *s, unsigned int ofs,
+                            unsigned int len)
+{
+        unsigned char *p;
+
+        WARN_ON(!(len & 1));
+
+        ata_id_string(id, s, ofs, len - 1);
+
+        p = s + strnlen(s, len - 1);
+        while (p > s && p[-1] == ' ')
+                p--;
+        *p = '\0';
+}
+
+static int ps3disk_identify(struct ps3_storage_device *dev)
+{
+        struct ps3disk_private *priv = dev->sbd.core.driver_data;
+        struct lv1_ata_cmnd_block ata_cmnd;
+        u16 *id = dev->bounce_buf;
+        u64 res;
+
+        dev_dbg(&dev->sbd.core, "%s:%u: identify disk\n", __func__, __LINE__);
+
+        memset(&ata_cmnd, 0, sizeof(struct lv1_ata_cmnd_block));
+        ata_cmnd.command = ATA_CMD_ID_ATA;
+        ata_cmnd.sector_count = 1;
+        ata_cmnd.size = ata_cmnd.arglen = ATA_ID_WORDS * 2;
+        ata_cmnd.buffer = dev->bounce_lpar;
+        ata_cmnd.proto = PIO_DATA_IN_PROTO;
+        ata_cmnd.in_out = DIR_READ;
+
+        res = ps3stor_send_command(dev, LV1_STORAGE_SEND_ATA_COMMAND,
+                                   ps3_mm_phys_to_lpar(__pa(&ata_cmnd)),
+                                   sizeof(ata_cmnd), ata_cmnd.buffer,
+                                   ata_cmnd.arglen);
+        if (res) {
+                dev_err(&dev->sbd.core, "%s:%u: identify disk failed 0x%lx\n",
+                        __func__, __LINE__, res);
+                return -EIO;
+        }
+
+        swap_buf_le16(id, ATA_ID_WORDS);
+
+        /* All we're interested in are raw capacity and model name */
+        priv->raw_capacity = ata_id_n_sectors(id);
+        ata_id_c_string(id, priv->model, ATA_ID_PROD, sizeof(priv->model));
+        return 0;
+}
+
+static void ps3disk_prepare_flush(request_queue_t *q, struct request *req)
+{
+        struct ps3_storage_device *dev = q->queuedata;
+
+        dev_dbg(&dev->sbd.core, "%s:%u\n", __func__, __LINE__);
+
+        memset(req->cmd, 0, sizeof(req->cmd));
+        req->cmd_type = REQ_TYPE_FLUSH;
+}
+
+static int ps3disk_issue_flush(request_queue_t *q, struct gendisk *gendisk,
+                               sector_t *sector)
+{
+        struct ps3_storage_device *dev = q->queuedata;
+        struct request *req;
+        int res;
+
+        dev_dbg(&dev->sbd.core, "%s:%u\n", __func__, __LINE__);
+
+        req = blk_get_request(q, WRITE, __GFP_WAIT);
+        ps3disk_prepare_flush(q, req);
+        res = blk_execute_rq(q, gendisk, req, 0);
+        if (res)
+                dev_err(&dev->sbd.core, "%s:%u: flush request failed %d\n",
+                        __func__, __LINE__, res);
+        blk_put_request(req);
+        return res;
+}
+
+
+static unsigned long ps3disk_mask;
+
+static DEFINE_MUTEX(ps3disk_mask_mutex);
+
+static int __devinit ps3disk_probe(struct ps3_system_bus_device *_dev)
+{
+        struct ps3_storage_device *dev = to_ps3_storage_device(&_dev->core);
+        struct ps3disk_private *priv;
+        int error;
+        unsigned int devidx;
+        struct request_queue *queue;
+        struct gendisk *gendisk;
+
+        if (dev->blk_size < 512) {
+                dev_err(&dev->sbd.core,
+                        "%s:%u: cannot handle block size %lu\n", __func__,
+                        __LINE__, dev->blk_size);
+                return -EINVAL;
+        }
+
+        BUILD_BUG_ON(PS3DISK_MAX_DISKS > BITS_PER_LONG);
+        mutex_lock(&ps3disk_mask_mutex);
+        devidx = find_first_zero_bit(&ps3disk_mask, PS3DISK_MAX_DISKS);
+        if (devidx >= PS3DISK_MAX_DISKS) {
+                dev_err(&dev->sbd.core, "%s:%u: Too many disks\n", __func__,
+                        __LINE__);
+                mutex_unlock(&ps3disk_mask_mutex);
+                return -ENOSPC;
+        }
+        __set_bit(devidx, &ps3disk_mask);
+        mutex_unlock(&ps3disk_mask_mutex);
+
+        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+        if (!priv) {
+                error = -ENOMEM;
+                goto fail;
+        }
+
+        dev->sbd.core.driver_data = priv;
+        spin_lock_init(&priv->lock);
+
+        dev->bounce_size = BOUNCE_SIZE;
+        dev->bounce_buf = kmalloc(BOUNCE_SIZE, GFP_DMA);
+        if (!dev->bounce_buf) {
+                error = -ENOMEM;
+                goto fail_free_priv;
+        }
+
+        error = ps3stor_setup(dev, ps3disk_interrupt);
+        if (error)
+                goto fail_free_bounce;
+
+        ps3disk_identify(dev);
+
+        queue = blk_init_queue(ps3disk_request, &priv->lock);
+        if (!queue) {
+                dev_err(&dev->sbd.core, "%s:%u: blk_init_queue failed\n",
+                        __func__, __LINE__);
+                error = -ENOMEM;
+                goto fail_teardown;
+        }
+
+        priv->queue = queue;
+        queue->queuedata = dev;
+
+        blk_queue_bounce_limit(queue, BLK_BOUNCE_HIGH);
+
+        blk_queue_max_sectors(queue, dev->bounce_size >> 9);
+        blk_queue_segment_boundary(queue, -1UL);
+        blk_queue_dma_alignment(queue, dev->blk_size-1);
+        blk_queue_hardsect_size(queue, dev->blk_size);
+
+        blk_queue_issue_flush_fn(queue, ps3disk_issue_flush);
+        blk_queue_ordered(queue, QUEUE_ORDERED_DRAIN_FLUSH,
+                          ps3disk_prepare_flush);
+
+        blk_queue_max_phys_segments(queue, -1);
+        blk_queue_max_hw_segments(queue, -1);
+        blk_queue_max_segment_size(queue, dev->bounce_size);
+
+        gendisk = alloc_disk(PS3DISK_MINORS);
+        if (!gendisk) {
+                dev_err(&dev->sbd.core, "%s:%u: alloc_disk failed\n", __func__,
+                        __LINE__);
+                error = -ENOMEM;
+                goto fail_cleanup_queue;
+        }
+
+        priv->gendisk = gendisk;
+        gendisk->major = ps3disk_major;
+        gendisk->first_minor = devidx * PS3DISK_MINORS;
+        gendisk->fops = &ps3disk_fops;
+        gendisk->queue = queue;
+        gendisk->private_data = dev;
+        gendisk->driverfs_dev = &dev->sbd.core;
+        snprintf(gendisk->disk_name, sizeof(gendisk->disk_name), PS3DISK_NAME,
+                 devidx+'a');
+        priv->blocking_factor = dev->blk_size >> 9;
+        set_capacity(gendisk,
+                     dev->regions[dev->region_idx].size*priv->blocking_factor);
+
+        dev_info(&dev->sbd.core,
+                 "%s is a %s (%lu MiB total, %lu MiB for OtherOS)\n",
+                 gendisk->disk_name, priv->model, priv->raw_capacity >> 11,
+                 get_capacity(gendisk) >> 11);
+
+        add_disk(gendisk);
+        return 0;
+
+fail_cleanup_queue:
+        blk_cleanup_queue(queue);
+fail_teardown:
+        ps3stor_teardown(dev);
+fail_free_bounce:
+        kfree(dev->bounce_buf);
+fail_free_priv:
+        kfree(priv);
+        dev->sbd.core.driver_data = NULL;
+fail:
+        mutex_lock(&ps3disk_mask_mutex);
+        __clear_bit(devidx, &ps3disk_mask);
+        mutex_unlock(&ps3disk_mask_mutex);
+        return error;
+}
+
+static int ps3disk_remove(struct ps3_system_bus_device *_dev)
+{
+        struct ps3_storage_device *dev = to_ps3_storage_device(&_dev->core);
+        struct ps3disk_private *priv = dev->sbd.core.driver_data;
+
+        mutex_lock(&ps3disk_mask_mutex);
+        __clear_bit(priv->gendisk->first_minor / PS3DISK_MINORS,
+                    &ps3disk_mask);
+        mutex_unlock(&ps3disk_mask_mutex);
+        del_gendisk(priv->gendisk);
+        blk_cleanup_queue(priv->queue);
+        put_disk(priv->gendisk);
+        dev_notice(&dev->sbd.core, "Synchronizing disk cache\n");
+        ps3disk_sync_cache(dev);
+        ps3stor_teardown(dev);
+        kfree(dev->bounce_buf);
+        kfree(priv);
+        dev->sbd.core.driver_data = NULL;
+        return 0;
+}
+
+static struct ps3_system_bus_driver ps3disk = {
+        .match_id       = PS3_MATCH_ID_STOR_DISK,
+        .core.name      = DEVICE_NAME,
+        .core.owner     = THIS_MODULE,
+        .probe          = ps3disk_probe,
+        .remove         = ps3disk_remove,
+        .shutdown       = ps3disk_remove,
+};
+
+
+static int __init ps3disk_init(void)
+{
+        int error;
+
+        if (!firmware_has_feature(FW_FEATURE_PS3_LV1))
+                return -ENODEV;
+
+        error = register_blkdev(0, DEVICE_NAME);
+        if (error <= 0) {
+                printk(KERN_ERR "%s:%u: register_blkdev failed %d\n", __func__,
+                       __LINE__, error);
+                return error;
+        }
+        ps3disk_major = error;
+
+        pr_info("%s:%u: registered block device major %d\n", __func__,
+                __LINE__, ps3disk_major);
+
+        error = ps3_system_bus_driver_register(&ps3disk);
+        if (error)
+                unregister_blkdev(ps3disk_major, DEVICE_NAME);
+
+        return error;
+}
+
+static void __exit ps3disk_exit(void)
+{
+        ps3_system_bus_driver_unregister(&ps3disk);
+        unregister_blkdev(ps3disk_major, DEVICE_NAME);
+}
+
+module_init(ps3disk_init);
+module_exit(ps3disk_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("PS3 Disk Storage Driver");
+MODULE_AUTHOR("Sony Corporation");
+MODULE_ALIAS(PS3_MODULE_ALIAS_STOR_DISK);
diff --git a/drivers/char/Makefile b/drivers/char/Makefile
index 4e6f387fd189..8fecaf4010b1 100644
--- a/drivers/char/Makefile
+++ b/drivers/char/Makefile
@@ -107,6 +107,8 @@ obj-$(CONFIG_IPMI_HANDLER)	+= ipmi/
 obj-$(CONFIG_HANGCHECK_TIMER)   += hangcheck-timer.o
 obj-$(CONFIG_TCG_TPM)           += tpm/
 
+obj-$(CONFIG_PS3_FLASH)         += ps3flash.o
+
 # Files generated that shall be removed upon make clean
 clean-files := consolemap_deftbl.c defkeymap.c
 
diff --git a/drivers/char/hw_random/Kconfig b/drivers/char/hw_random/Kconfig
index 7cda04b33534..2d7cd486e025 100644
--- a/drivers/char/hw_random/Kconfig
+++ b/drivers/char/hw_random/Kconfig
@@ -41,7 +41,7 @@ config HW_RANDOM_AMD
 
 config HW_RANDOM_GEODE
         tristate "AMD Geode HW Random Number Generator support"
-        depends on HW_RANDOM && X86 && PCI
+        depends on HW_RANDOM && X86_32 && PCI
         default HW_RANDOM
         ---help---
           This driver provides kernel-side support for the Random Number
diff --git a/drivers/char/ps3flash.c b/drivers/char/ps3flash.c
new file mode 100644
index 000000000000..79b6f461be75
--- /dev/null
+++ b/drivers/char/ps3flash.c
@@ -0,0 +1,440 @@
+/*
+ * PS3 FLASH ROM Storage Driver
+ *
+ * Copyright (C) 2007 Sony Computer Entertainment Inc.
+ * Copyright 2007 Sony Corp.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published
+ * by the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include <linux/fs.h>
+#include <linux/miscdevice.h>
+#include <linux/uaccess.h>
+
+#include <asm/lv1call.h>
+#include <asm/ps3stor.h>
+
+
+#define DEVICE_NAME             "ps3flash"
+
+#define FLASH_BLOCK_SIZE        (256*1024)
+
+
+struct ps3flash_private {
+        struct mutex mutex;     /* Bounce buffer mutex */
+};
+
+static struct ps3_storage_device *ps3flash_dev;
+
+static ssize_t ps3flash_read_write_sectors(struct ps3_storage_device *dev,
+                                           u64 lpar, u64 start_sector,
+                                           u64 sectors, int write)
+{
+        u64 res = ps3stor_read_write_sectors(dev, lpar, start_sector, sectors,
+                                             write);
+        if (res) {
+                dev_err(&dev->sbd.core, "%s:%u: %s failed 0x%lx\n", __func__,
+                        __LINE__, write ? "write" : "read", res);
+                return -EIO;
+        }
+        return sectors;
+}
+
+static ssize_t ps3flash_read_sectors(struct ps3_storage_device *dev,
+                                     u64 start_sector, u64 sectors,
+                                     unsigned int sector_offset)
+{
+        u64 max_sectors, lpar;
+
+        max_sectors = dev->bounce_size / dev->blk_size;
+        if (sectors > max_sectors) {
+                dev_dbg(&dev->sbd.core, "%s:%u Limiting sectors to %lu\n",
+                        __func__, __LINE__, max_sectors);
+                sectors = max_sectors;
+        }
+
+        lpar = dev->bounce_lpar + sector_offset * dev->blk_size;
+        return ps3flash_read_write_sectors(dev, lpar, start_sector, sectors,
+                                           0);
+}
+
+static ssize_t ps3flash_write_chunk(struct ps3_storage_device *dev,
+                                    u64 start_sector)
+{
+       u64 sectors = dev->bounce_size / dev->blk_size;
+       return ps3flash_read_write_sectors(dev, dev->bounce_lpar, start_sector,
+                                          sectors, 1);
+}
+
+static loff_t ps3flash_llseek(struct file *file, loff_t offset, int origin)
+{
+        struct ps3_storage_device *dev = ps3flash_dev;
+        loff_t res;
+
+        mutex_lock(&file->f_mapping->host->i_mutex);
+        switch (origin) {
+        case 1:
+                offset += file->f_pos;
+                break;
+        case 2:
+                offset += dev->regions[dev->region_idx].size*dev->blk_size;
+                break;
+        }
+        if (offset < 0) {
+                res = -EINVAL;
+                goto out;
+        }
+
+        file->f_pos = offset;
+        res = file->f_pos;
+
+out:
+        mutex_unlock(&file->f_mapping->host->i_mutex);
+        return res;
+}
+
+static ssize_t ps3flash_read(struct file *file, char __user *buf, size_t count,
+                             loff_t *pos)
+{
+        struct ps3_storage_device *dev = ps3flash_dev;
+        struct ps3flash_private *priv = dev->sbd.core.driver_data;
+        u64 size, start_sector, end_sector, offset;
+        ssize_t sectors_read;
+        size_t remaining, n;
+
+        dev_dbg(&dev->sbd.core,
+                "%s:%u: Reading %zu bytes at position %lld to user 0x%p\n",
+                __func__, __LINE__, count, *pos, buf);
+
+        size = dev->regions[dev->region_idx].size*dev->blk_size;
+        if (*pos >= size || !count)
+                return 0;
+
+        if (*pos + count > size) {
+                dev_dbg(&dev->sbd.core,
+                        "%s:%u Truncating count from %zu to %llu\n", __func__,
+                        __LINE__, count, size - *pos);
+                count = size - *pos;
+        }
+
+        start_sector = *pos / dev->blk_size;
+        offset = *pos % dev->blk_size;
+        end_sector = DIV_ROUND_UP(*pos + count, dev->blk_size);
+
+        remaining = count;
+        do {
+                mutex_lock(&priv->mutex);
+
+                sectors_read = ps3flash_read_sectors(dev, start_sector,
+                                                     end_sector-start_sector,
+                                                     0);
+                if (sectors_read < 0) {
+                        mutex_unlock(&priv->mutex);
+                        goto fail;
+                }
+
+                n = min(remaining, sectors_read*dev->blk_size-offset);
+                dev_dbg(&dev->sbd.core,
+                        "%s:%u: copy %lu bytes from 0x%p to user 0x%p\n",
+                        __func__, __LINE__, n, dev->bounce_buf+offset, buf);
+                if (copy_to_user(buf, dev->bounce_buf+offset, n)) {
+                        mutex_unlock(&priv->mutex);
+                        sectors_read = -EFAULT;
+                        goto fail;
+                }
+
+                mutex_unlock(&priv->mutex);
+
+                *pos += n;
+                buf += n;
+                remaining -= n;
+                start_sector += sectors_read;
+                offset = 0;
+        } while (remaining > 0);
+
+        return count;
+
+fail:
+        return sectors_read;
+}
+
+static ssize_t ps3flash_write(struct file *file, const char __user *buf,
+                              size_t count, loff_t *pos)
+{
+        struct ps3_storage_device *dev = ps3flash_dev;
+        struct ps3flash_private *priv = dev->sbd.core.driver_data;
+        u64 size, chunk_sectors, start_write_sector, end_write_sector,
+            end_read_sector, start_read_sector, head, tail, offset;
+        ssize_t res;
+        size_t remaining, n;
+        unsigned int sec_off;
+
+        dev_dbg(&dev->sbd.core,
+                "%s:%u: Writing %zu bytes at position %lld from user 0x%p\n",
+                __func__, __LINE__, count, *pos, buf);
+
+        size = dev->regions[dev->region_idx].size*dev->blk_size;
+        if (*pos >= size || !count)
+                return 0;
+
+        if (*pos + count > size) {
+                dev_dbg(&dev->sbd.core,
+                        "%s:%u Truncating count from %zu to %llu\n", __func__,
+                        __LINE__, count, size - *pos);
+                count = size - *pos;
+        }
+
+        chunk_sectors = dev->bounce_size / dev->blk_size;
+
+        start_write_sector = *pos / dev->bounce_size * chunk_sectors;
+        offset = *pos % dev->bounce_size;
+        end_write_sector = DIV_ROUND_UP(*pos + count, dev->bounce_size) *
+                           chunk_sectors;
+
+        end_read_sector = DIV_ROUND_UP(*pos, dev->blk_size);
+        start_read_sector = (*pos + count) / dev->blk_size;
+
+        /*
+         * As we have to write in 256 KiB chunks, while we can read in blk_size
+         * (usually 512 bytes) chunks, we perform the following steps:
+         *   1. Read from start_write_sector to end_read_sector ("head")
+         *   2. Read from start_read_sector to end_write_sector ("tail")
+         *   3. Copy data to buffer
+         *   4. Write from start_write_sector to end_write_sector
+         * All of this is complicated by using only one 256 KiB bounce buffer.
+         */
+
+        head = end_read_sector - start_write_sector;
+        tail = end_write_sector - start_read_sector;
+
+        remaining = count;
+        do {
+                mutex_lock(&priv->mutex);
+
+                if (end_read_sector >= start_read_sector) {
+                        /* Merge head and tail */
+                        dev_dbg(&dev->sbd.core,
+                                "Merged head and tail: %lu sectors at %lu\n",
+                                chunk_sectors, start_write_sector);
+                        res = ps3flash_read_sectors(dev, start_write_sector,
+                                                    chunk_sectors, 0);
+                        if (res < 0)
+                                goto fail;
+                } else {
+                        if (head) {
+                                /* Read head */
+                                dev_dbg(&dev->sbd.core,
+                                        "head: %lu sectors at %lu\n", head,
+                                        start_write_sector);
+                                res = ps3flash_read_sectors(dev,
+                                                            start_write_sector,
+                                                            head, 0);
+                                if (res < 0)
+                                        goto fail;
+                        }
+                        if (start_read_sector <
+                            start_write_sector+chunk_sectors) {
+                                /* Read tail */
+                                dev_dbg(&dev->sbd.core,
+                                        "tail: %lu sectors at %lu\n", tail,
+                                        start_read_sector);
+                                sec_off = start_read_sector-start_write_sector;
+                                res = ps3flash_read_sectors(dev,
+                                                            start_read_sector,
+                                                            tail, sec_off);
+                                if (res < 0)
+                                        goto fail;
+                        }
+                }
+
+                n = min(remaining, dev->bounce_size-offset);
+                dev_dbg(&dev->sbd.core,
+                        "%s:%u: copy %lu bytes from user 0x%p to 0x%p\n",
+                        __func__, __LINE__, n, buf, dev->bounce_buf+offset);
+                if (copy_from_user(dev->bounce_buf+offset, buf, n)) {
+                        res = -EFAULT;
+                        goto fail;
+                }
+
+                res = ps3flash_write_chunk(dev, start_write_sector);
+                if (res < 0)
+                        goto fail;
+
+                mutex_unlock(&priv->mutex);
+
+                *pos += n;
+                buf += n;
+                remaining -= n;
+                start_write_sector += chunk_sectors;
+                head = 0;
+                offset = 0;
+        } while (remaining > 0);
+
+        return count;
+
+fail:
+        mutex_unlock(&priv->mutex);
+        return res;
+}
+
+
+static irqreturn_t ps3flash_interrupt(int irq, void *data)
+{
+        struct ps3_storage_device *dev = data;
+        int res;
+        u64 tag, status;
+
+        res = lv1_storage_get_async_status(dev->sbd.dev_id, &tag, &status);
+
+        if (tag != dev->tag)
+                dev_err(&dev->sbd.core,
+                        "%s:%u: tag mismatch, got %lx, expected %lx\n",
+                        __func__, __LINE__, tag, dev->tag);
+
+        if (res) {
+                dev_err(&dev->sbd.core, "%s:%u: res=%d status=0x%lx\n",
+                        __func__, __LINE__, res, status);
+        } else {
+                dev->lv1_status = status;
+                complete(&dev->done);
+        }
+        return IRQ_HANDLED;
+}
+
+
+static const struct file_operations ps3flash_fops = {
+        .owner  = THIS_MODULE,
+        .llseek = ps3flash_llseek,
+        .read   = ps3flash_read,
+        .write  = ps3flash_write,
+};
+
+static struct miscdevice ps3flash_misc = {
+        .minor  = MISC_DYNAMIC_MINOR,
+        .name   = DEVICE_NAME,
+        .fops   = &ps3flash_fops,
+};
+
+static int __devinit ps3flash_probe(struct ps3_system_bus_device *_dev)
+{
+        struct ps3_storage_device *dev = to_ps3_storage_device(&_dev->core);
+        struct ps3flash_private *priv;
+        int error;
+        unsigned long tmp;
+
+        tmp = dev->regions[dev->region_idx].start*dev->blk_size;
+        if (tmp % FLASH_BLOCK_SIZE) {
+                dev_err(&dev->sbd.core,
+                        "%s:%u region start %lu is not aligned\n", __func__,
+                        __LINE__, tmp);
+                return -EINVAL;
+        }
+        tmp = dev->regions[dev->region_idx].size*dev->blk_size;
+        if (tmp % FLASH_BLOCK_SIZE) {
+                dev_err(&dev->sbd.core,
+                        "%s:%u region size %lu is not aligned\n", __func__,
+                        __LINE__, tmp);
+                return -EINVAL;
+        }
+
+        /* use static buffer, kmalloc cannot allocate 256 KiB */
+        if (!ps3flash_bounce_buffer.address)
+                return -ENODEV;
+
+        if (ps3flash_dev) {
+                dev_err(&dev->sbd.core,
+                        "Only one FLASH device is supported\n");
+                return -EBUSY;
+        }
+
+        ps3flash_dev = dev;
+
+        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+        if (!priv) {
+                error = -ENOMEM;
+                goto fail;
+        }
+
+        dev->sbd.core.driver_data = priv;
+        mutex_init(&priv->mutex);
+
+        dev->bounce_size = ps3flash_bounce_buffer.size;
+        dev->bounce_buf = ps3flash_bounce_buffer.address;
+
+        error = ps3stor_setup(dev, ps3flash_interrupt);
+        if (error)
+                goto fail_free_priv;
+
+        ps3flash_misc.parent = &dev->sbd.core;
+        error = misc_register(&ps3flash_misc);
+        if (error) {
+                dev_err(&dev->sbd.core, "%s:%u: misc_register failed %d\n",
+                        __func__, __LINE__, error);
+                goto fail_teardown;
+        }
+
+        dev_info(&dev->sbd.core, "%s:%u: registered misc device %d\n",
+                 __func__, __LINE__, ps3flash_misc.minor);
+        return 0;
+
+fail_teardown:
+        ps3stor_teardown(dev);
+fail_free_priv:
+        kfree(priv);
+        dev->sbd.core.driver_data = NULL;
+fail:
+        ps3flash_dev = NULL;
+        return error;
+}
+
+static int ps3flash_remove(struct ps3_system_bus_device *_dev)
+{
+        struct ps3_storage_device *dev = to_ps3_storage_device(&_dev->core);
+
+        misc_deregister(&ps3flash_misc);
+        ps3stor_teardown(dev);
+        kfree(dev->sbd.core.driver_data);
+        dev->sbd.core.driver_data = NULL;
+        ps3flash_dev = NULL;
+        return 0;
+}
+
+
+static struct ps3_system_bus_driver ps3flash = {
+        .match_id       = PS3_MATCH_ID_STOR_FLASH,
+        .core.name      = DEVICE_NAME,
+        .core.owner     = THIS_MODULE,
+        .probe          = ps3flash_probe,
+        .remove         = ps3flash_remove,
+        .shutdown       = ps3flash_remove,
+};
+
+
+static int __init ps3flash_init(void)
+{
+        return ps3_system_bus_driver_register(&ps3flash);
+}
+
+static void __exit ps3flash_exit(void)
+{
+        ps3_system_bus_driver_unregister(&ps3flash);
+}
+
+module_init(ps3flash_init);
+module_exit(ps3flash_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("PS3 FLASH ROM Storage Driver");
+MODULE_AUTHOR("Sony Corporation");
+MODULE_ALIAS(PS3_MODULE_ALIAS_STOR_FLASH);
diff --git a/drivers/char/rtc.c b/drivers/char/rtc.c
index 30c3f54c7666..ec6b65ec69ea 100644
--- a/drivers/char/rtc.c
+++ b/drivers/char/rtc.c
@@ -82,7 +82,7 @@
 #include <asm/uaccess.h>
 #include <asm/system.h>
 
-#if defined(__i386__)
+#ifdef CONFIG_X86
 #include <asm/hpet.h>
 #endif
 
diff --git a/drivers/clocksource/acpi_pm.c b/drivers/clocksource/acpi_pm.c
index e783dbf0f162..7b46faf22318 100644
--- a/drivers/clocksource/acpi_pm.c
+++ b/drivers/clocksource/acpi_pm.c
@@ -71,7 +71,7 @@ static struct clocksource clocksource_acpi_pm = {
         .rating         = 200,
         .read           = acpi_pm_read,
         .mask           = (cycle_t)ACPI_PM_MASK,
-        .mult           = 0, /*to be caluclated*/
+        .mult           = 0, /*to be calculated*/
         .shift          = 22,
         .flags          = CLOCK_SOURCE_IS_CONTINUOUS,
 
diff --git a/drivers/input/misc/pcspkr.c b/drivers/input/misc/pcspkr.c
index 31989dcd922c..906bf5e8de89 100644
--- a/drivers/input/misc/pcspkr.c
+++ b/drivers/input/misc/pcspkr.c
@@ -24,7 +24,12 @@ MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
 MODULE_DESCRIPTION("PC Speaker beeper driver");
 MODULE_LICENSE("GPL");
 
-static DEFINE_SPINLOCK(i8253_beep_lock);
+#ifdef CONFIG_X86
+/* Use the global PIT lock ! */
+#include <asm/i8253.h>
+#else
+static DEFINE_SPINLOCK(i8253_lock);
+#endif
 
 static int pcspkr_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
 {
@@ -43,7 +48,7 @@ static int pcspkr_event(struct input_dev *dev, unsigned int type, unsigned int c
         if (value > 20 && value < 32767)
                 count = PIT_TICK_RATE / value;
 
-        spin_lock_irqsave(&i8253_beep_lock, flags);
+        spin_lock_irqsave(&i8253_lock, flags);
 
         if (count) {
                 /* enable counter 2 */
@@ -58,7 +63,7 @@ static int pcspkr_event(struct input_dev *dev, unsigned int type, unsigned int c
                 outb(inb_p(0x61) & 0xFC, 0x61);
         }
 
-        spin_unlock_irqrestore(&i8253_beep_lock, flags);
+        spin_unlock_irqrestore(&i8253_lock, flags);
 
         return 0;
 }
diff --git a/drivers/isdn/Kconfig b/drivers/isdn/Kconfig
index cf906c8cee4d..66f946aa30b3 100644
--- a/drivers/isdn/Kconfig
+++ b/drivers/isdn/Kconfig
@@ -21,9 +21,7 @@ menuconfig ISDN
 
 if ISDN
 
-menu "Old ISDN4Linux"
-
-config ISDN_I4L
+menuconfig ISDN_I4L
         tristate "Old ISDN4Linux (deprecated)"
         ---help---
           This driver allows you to use an ISDN adapter for networking
@@ -45,12 +43,8 @@ if ISDN_I4L
 source "drivers/isdn/i4l/Kconfig"
 endif
 
-endmenu
-
-comment "CAPI subsystem"
-
-config ISDN_CAPI
-        tristate "CAPI2.0 support"
+menuconfig ISDN_CAPI
+        tristate "CAPI 2.0 subsystem"
         help
           This provides the CAPI (Common ISDN Application Programming
           Interface, a standard making it easy for programs to access ISDN
diff --git a/drivers/isdn/act2000/Kconfig b/drivers/isdn/act2000/Kconfig
index 78e6ad8d57c5..3fc1a5434ef7 100644
--- a/drivers/isdn/act2000/Kconfig
+++ b/drivers/isdn/act2000/Kconfig
@@ -3,7 +3,7 @@
 #
 config ISDN_DRV_ACT2000
         tristate "IBM Active 2000 support"
-        depends on ISDN_I4L && ISA
+        depends on ISA
         help
           Say Y here if you have an IBM Active 2000 ISDN card. In order to use
           this card, additional firmware is necessary, which has to be loaded
diff --git a/drivers/isdn/gigaset/Kconfig b/drivers/isdn/gigaset/Kconfig
index bcbb6502a773..0017e50c6948 100644
--- a/drivers/isdn/gigaset/Kconfig
+++ b/drivers/isdn/gigaset/Kconfig
@@ -1,9 +1,5 @@
-menu "Siemens Gigaset"
-        depends on ISDN_I4L
-
-config ISDN_DRV_GIGASET
+menuconfig ISDN_DRV_GIGASET
         tristate "Siemens Gigaset support (isdn)"
-        depends on ISDN_I4L
         select CRC_CCITT
         select BITREVERSE
         help
@@ -55,6 +51,4 @@ config GIGASET_UNDOCREQ
           features like configuration mode of M105, say yes. If you
           care about your device, say no.
 
-endif
-
-endmenu
+endif # ISDN_DRV_GIGASET != n
diff --git a/drivers/isdn/hisax/Kconfig b/drivers/isdn/hisax/Kconfig
index 12d91fb9f8cb..a3b945ac3256 100644
--- a/drivers/isdn/hisax/Kconfig
+++ b/drivers/isdn/hisax/Kconfig
@@ -1,6 +1,5 @@
 
 menu "Passive cards"
-        depends on ISDN_I4L
 
 config ISDN_DRV_HISAX
         tristate "HiSax SiemensChipSet driver support"
diff --git a/drivers/isdn/i4l/Kconfig b/drivers/isdn/i4l/Kconfig
index e91c187992dd..36778b270c30 100644
--- a/drivers/isdn/i4l/Kconfig
+++ b/drivers/isdn/i4l/Kconfig
@@ -99,7 +99,6 @@ config ISDN_DRV_LOOP
 
 config ISDN_DIVERSION
         tristate "Support isdn diversion services"
-        depends on ISDN_I4L
         help
           This option allows you to use some supplementary diversion
           services in conjunction with the HiSax driver on an EURO/DSS1
@@ -119,13 +118,11 @@ config ISDN_DIVERSION
 endmenu
 
 comment "ISDN4Linux hardware drivers"
-        depends on ISDN_I4L
 
 source "drivers/isdn/hisax/Kconfig"
 
 
 menu "Active cards"
-        depends on ISDN_I4L!=n
 
 source "drivers/isdn/icn/Kconfig"
 
diff --git a/drivers/isdn/icn/Kconfig b/drivers/isdn/icn/Kconfig
index fcb99f5f0b26..89d15eed765e 100644
--- a/drivers/isdn/icn/Kconfig
+++ b/drivers/isdn/icn/Kconfig
@@ -3,7 +3,7 @@
 #
 config ISDN_DRV_ICN
         tristate "ICN 2B and 4B support"
-        depends on ISDN_I4L && ISA
+        depends on ISA
         help
           This enables support for two kinds of ISDN-cards made by a German
           company called ICN.  2B is the standard version for a single ISDN
diff --git a/drivers/isdn/pcbit/Kconfig b/drivers/isdn/pcbit/Kconfig
index 0933881ab0c2..ffba6eca1244 100644
--- a/drivers/isdn/pcbit/Kconfig
+++ b/drivers/isdn/pcbit/Kconfig
@@ -3,7 +3,7 @@
 #
 config ISDN_DRV_PCBIT
         tristate "PCBIT-D support"
-        depends on ISDN_I4L && ISA && (BROKEN || X86)
+        depends on ISA && (BROKEN || X86)
         help
           This enables support for the PCBIT ISDN-card.  This card is
           manufactured in Portugal by Octal.  For running this card,
diff --git a/drivers/isdn/sc/Kconfig b/drivers/isdn/sc/Kconfig
index 5346e33d816c..e6510ca7bf43 100644
--- a/drivers/isdn/sc/Kconfig
+++ b/drivers/isdn/sc/Kconfig
@@ -3,7 +3,7 @@
 #
 config ISDN_DRV_SC
         tristate "Spellcaster support"
-        depends on ISDN_I4L && ISA
+        depends on ISA
         help
           This enables support for the Spellcaster BRI ISDN boards.  This
           driver currently builds only in a modularized version.
diff --git a/drivers/kvm/mmu.c b/drivers/kvm/mmu.c
index d99d2fe53dca..1a87ba9d5156 100644
--- a/drivers/kvm/mmu.c
+++ b/drivers/kvm/mmu.c
@@ -244,7 +244,7 @@ static int mmu_topup_memory_cache_page(struct kvm_mmu_memory_cache *cache,
 static void mmu_free_memory_cache_page(struct kvm_mmu_memory_cache *mc)
 {
         while (mc->nobjs)
-                __free_page(mc->objects[--mc->nobjs]);
+                free_page((unsigned long)mc->objects[--mc->nobjs]);
 }
 
 static int __mmu_topup_memory_caches(struct kvm_vcpu *vcpu, gfp_t gfp_flags)
diff --git a/drivers/lguest/lguest.c b/drivers/lguest/lguest.c
index 434fea1e82f7..18dade06d4a9 100644
--- a/drivers/lguest/lguest.c
+++ b/drivers/lguest/lguest.c
@@ -398,6 +398,8 @@ static void lguest_clockevent_set_mode(enum clock_event_mode mode,
                 break;
         case CLOCK_EVT_MODE_PERIODIC:
                 BUG();
+        case CLOCK_EVT_MODE_RESUME:
+                break;
         }
 }
 
diff --git a/drivers/md/dm-crypt.c b/drivers/md/dm-crypt.c
index ba952a032598..bdc52d6922b7 100644
--- a/drivers/md/dm-crypt.c
+++ b/drivers/md/dm-crypt.c
@@ -920,6 +920,8 @@ static void crypt_dtr(struct dm_target *ti)
 {
         struct crypt_config *cc = (struct crypt_config *) ti->private;
 
+        flush_workqueue(_kcryptd_workqueue);
+
         bioset_free(cc->bs);
         mempool_destroy(cc->page_pool);
         mempool_destroy(cc->io_pool);
diff --git a/drivers/mmc/host/at91_mci.c b/drivers/mmc/host/at91_mci.c
index 28c881895ab7..15aab374127e 100644
--- a/drivers/mmc/host/at91_mci.c
+++ b/drivers/mmc/host/at91_mci.c
@@ -903,8 +903,10 @@ static int __init at91_mci_probe(struct platform_device *pdev)
         /*
          * Add host to MMC layer
          */
-        if (host->board->det_pin)
+        if (host->board->det_pin) {
                 host->present = !at91_get_gpio_value(host->board->det_pin);
+                device_init_wakeup(&pdev->dev, 1);
+        }
         else
                 host->present = -1;
 
@@ -940,6 +942,7 @@ static int __exit at91_mci_remove(struct platform_device *pdev)
         host = mmc_priv(mmc);
 
         if (host->present != -1) {
+                device_init_wakeup(&pdev->dev, 0);
                 free_irq(host->board->det_pin, host);
                 cancel_delayed_work(&host->mmc->detect);
         }
@@ -966,8 +969,12 @@ static int __exit at91_mci_remove(struct platform_device *pdev)
 static int at91_mci_suspend(struct platform_device *pdev, pm_message_t state)
 {
         struct mmc_host *mmc = platform_get_drvdata(pdev);
+        struct at91mci_host *host = mmc_priv(mmc);
         int ret = 0;
 
+        if (device_may_wakeup(&pdev->dev))
+                enable_irq_wake(host->board->det_pin);
+
         if (mmc)
                 ret = mmc_suspend_host(mmc, state);
 
@@ -977,8 +984,12 @@ static int at91_mci_suspend(struct platform_device *pdev, pm_message_t state)
 static int at91_mci_resume(struct platform_device *pdev)
 {
         struct mmc_host *mmc = platform_get_drvdata(pdev);
+        struct at91mci_host *host = mmc_priv(mmc);
         int ret = 0;
 
+        if (device_may_wakeup(&pdev->dev))
+                disable_irq_wake(host->board->det_pin);
+
         if (mmc)
                 ret = mmc_resume_host(mmc);
 
diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
index 10d15c39d003..4a24db028d87 100644
--- a/drivers/mmc/host/sdhci.c
+++ b/drivers/mmc/host/sdhci.c
@@ -1024,6 +1024,8 @@ static irqreturn_t sdhci_irq(int irq, void *dev_id)
 
         intmask &= ~(SDHCI_INT_CMD_MASK | SDHCI_INT_DATA_MASK);
 
+        intmask &= ~SDHCI_INT_ERROR;
+
         if (intmask & SDHCI_INT_BUS_POWER) {
                 printk(KERN_ERR "%s: Card is consuming too much power!\n",
                         mmc_hostname(host->mmc));
diff --git a/drivers/mmc/host/sdhci.h b/drivers/mmc/host/sdhci.h
index 7400f4bc114f..a6c870480b8a 100644
--- a/drivers/mmc/host/sdhci.h
+++ b/drivers/mmc/host/sdhci.h
@@ -107,6 +107,7 @@
 #define  SDHCI_INT_CARD_INSERT  0x00000040
 #define  SDHCI_INT_CARD_REMOVE  0x00000080
 #define  SDHCI_INT_CARD_INT     0x00000100
+#define  SDHCI_INT_ERROR        0x00008000
 #define  SDHCI_INT_TIMEOUT      0x00010000
 #define  SDHCI_INT_CRC          0x00020000
 #define  SDHCI_INT_END_BIT      0x00040000
diff --git a/drivers/rtc/Kconfig b/drivers/rtc/Kconfig
index 35f34665e3c4..9d8d40d5c8f7 100644
--- a/drivers/rtc/Kconfig
+++ b/drivers/rtc/Kconfig
@@ -38,6 +38,9 @@ config RTC_HCTOSYS_DEVICE
           clock, usually rtc0.  Initialization is done when the system
           starts up, and when it resumes from a low power state.
 
+          The driver for this RTC device must be loaded before late_initcall
+          functions run, so it must usually be statically linked.
+
           This clock should be battery-backed, so that it reads the correct
           time when the system boots from a power-off state.  Otherwise, your
           system will need an external clock source (like an NTP server).
@@ -305,6 +308,16 @@ config RTC_DRV_DS1553
           This driver can also be built as a module. If so, the module
           will be called rtc-ds1553.
 
+config RTC_DRV_STK17TA8
+        tristate "Simtek STK17TA8"
+        depends on RTC_CLASS
+        help
+          If you say yes here you get support for the
+          Simtek STK17TA8 timekeeping chip.
+
+          This driver can also be built as a module. If so, the module
+          will be called rtc-stk17ta8.
+
 config RTC_DRV_DS1742
         tristate "Dallas DS1742/1743"
         depends on RTC_CLASS
diff --git a/drivers/rtc/Makefile b/drivers/rtc/Makefile
index 3109af9a1651..7ede9e725360 100644
--- a/drivers/rtc/Makefile
+++ b/drivers/rtc/Makefile
@@ -32,6 +32,7 @@ obj-$(CONFIG_RTC_DRV_RS5C348)	+= rtc-rs5c348.o
 obj-$(CONFIG_RTC_DRV_M41T80)    += rtc-m41t80.o
 obj-$(CONFIG_RTC_DRV_M48T86)    += rtc-m48t86.o
 obj-$(CONFIG_RTC_DRV_DS1553)    += rtc-ds1553.o
+obj-$(CONFIG_RTC_DRV_STK17TA8)  += rtc-stk17ta8.o
 obj-$(CONFIG_RTC_DRV_RS5C313)   += rtc-rs5c313.o
 obj-$(CONFIG_RTC_DRV_EP93XX)    += rtc-ep93xx.o
 obj-$(CONFIG_RTC_DRV_SA1100)    += rtc-sa1100.o
diff --git a/drivers/rtc/rtc-ds1553.c b/drivers/rtc/rtc-ds1553.c
index f98a83a11aae..46da5714932c 100644
--- a/drivers/rtc/rtc-ds1553.c
+++ b/drivers/rtc/rtc-ds1553.c
@@ -407,7 +407,7 @@ static __init int ds1553_init(void)
 
 static __exit void ds1553_exit(void)
 {
-        return platform_driver_unregister(&ds1553_rtc_driver);
+        platform_driver_unregister(&ds1553_rtc_driver);
 }
 
 module_init(ds1553_init);
diff --git a/drivers/rtc/rtc-ds1742.c b/drivers/rtc/rtc-ds1742.c
index d1778ae8bca5..b2e5481ba3b6 100644
--- a/drivers/rtc/rtc-ds1742.c
+++ b/drivers/rtc/rtc-ds1742.c
@@ -263,7 +263,7 @@ static __init int ds1742_init(void)
 
 static __exit void ds1742_exit(void)
 {
-        return platform_driver_unregister(&ds1742_rtc_driver);
+        platform_driver_unregister(&ds1742_rtc_driver);
 }
 
 module_init(ds1742_init);
diff --git a/drivers/rtc/rtc-max6900.c b/drivers/rtc/rtc-max6900.c
index eee4ee5bb75a..a1cd448639c9 100644
--- a/drivers/rtc/rtc-max6900.c
+++ b/drivers/rtc/rtc-max6900.c
@@ -31,17 +31,24 @@
 #define MAX6900_REG_DW                  5       /* day of week   1-7  */
 #define MAX6900_REG_YR                  6       /* year         00-99 */
 #define MAX6900_REG_CT                  7       /* control */
-#define MAX6900_REG_LEN                 8
+                                                /* register 8 is undocumented */
+#define MAX6900_REG_CENTURY             9       /* century */
+#define MAX6900_REG_LEN                 10
+
+#define MAX6900_BURST_LEN               8       /* can burst r/w first 8 regs */
 
 #define MAX6900_REG_CT_WP               (1 << 7)        /* Write Protect */
 
+
 /*
  * register read/write commands
  */
 #define MAX6900_REG_CONTROL_WRITE       0x8e
-#define MAX6900_REG_BURST_READ          0xbf
-#define MAX6900_REG_BURST_WRITE         0xbe
+#define MAX6900_REG_CENTURY_WRITE       0x92
+#define MAX6900_REG_CENTURY_READ        0x93
 #define MAX6900_REG_RESERVED_READ       0x96
+#define MAX6900_REG_BURST_WRITE         0xbe
+#define MAX6900_REG_BURST_READ          0xbf
 
 #define MAX6900_IDLE_TIME_AFTER_WRITE   3       /* specification says 2.5 mS */
 
@@ -58,19 +65,32 @@ static int max6900_probe(struct i2c_adapter *adapter, int addr, int kind);
 
 static int max6900_i2c_read_regs(struct i2c_client *client, u8 *buf)
 {
-        u8 reg_addr[1] = { MAX6900_REG_BURST_READ };
-        struct i2c_msg msgs[2] = {
+        u8 reg_burst_read[1] = { MAX6900_REG_BURST_READ };
+        u8 reg_century_read[1] = { MAX6900_REG_CENTURY_READ };
+        struct i2c_msg msgs[4] = {
                 {
                         .addr   = client->addr,
                         .flags  = 0, /* write */
-                        .len    = sizeof(reg_addr),
-                        .buf    = reg_addr
+                        .len    = sizeof(reg_burst_read),
+                        .buf    = reg_burst_read
                 },
                 {
                         .addr   = client->addr,
                         .flags  = I2C_M_RD,
-                        .len    = MAX6900_REG_LEN,
+                        .len    = MAX6900_BURST_LEN,
                         .buf    = buf
+                },
+                {
+                        .addr   = client->addr,
+                        .flags  = 0, /* write */
+                        .len    = sizeof(reg_century_read),
+                        .buf    = reg_century_read
+                },
+                {
+                        .addr   = client->addr,
+                        .flags  = I2C_M_RD,
+                        .len    = sizeof(buf[MAX6900_REG_CENTURY]),
+                        .buf    = &buf[MAX6900_REG_CENTURY]
                 }
         };
         int rc;
@@ -86,33 +106,58 @@ static int max6900_i2c_read_regs(struct i2c_client *client, u8 *buf)
 
 static int max6900_i2c_write_regs(struct i2c_client *client, u8 const *buf)
 {
-        u8 i2c_buf[MAX6900_REG_LEN + 1] = { MAX6900_REG_BURST_WRITE };
-        struct i2c_msg msgs[1] = {
+        u8 i2c_century_buf[1 + 1] = { MAX6900_REG_CENTURY_WRITE };
+        struct i2c_msg century_msgs[1] = {
                 {
                         .addr   = client->addr,
                         .flags  = 0, /* write */
-                        .len    = MAX6900_REG_LEN + 1,
-                        .buf    = i2c_buf
+                        .len    = sizeof(i2c_century_buf),
+                        .buf    = i2c_century_buf
+                }
+        };
+        u8 i2c_burst_buf[MAX6900_BURST_LEN + 1] = { MAX6900_REG_BURST_WRITE };
+        struct i2c_msg burst_msgs[1] = {
+                {
+                        .addr   = client->addr,
+                        .flags  = 0, /* write */
+                        .len    = sizeof(i2c_burst_buf),
+                        .buf    = i2c_burst_buf
                 }
         };
         int rc;
 
-        memcpy(&i2c_buf[1], buf, MAX6900_REG_LEN);
+        /*
+         * We have to make separate calls to i2c_transfer because of
+         * the need to delay after each write to the chip.  Also,
+         * we write the century byte first, since we set the write-protect
+         * bit as part of the burst write.
+         */
+        i2c_century_buf[1] = buf[MAX6900_REG_CENTURY];
+        rc = i2c_transfer(client->adapter, century_msgs,
+                          ARRAY_SIZE(century_msgs));
+        if (rc != ARRAY_SIZE(century_msgs))
+                goto write_failed;
+        msleep(MAX6900_IDLE_TIME_AFTER_WRITE);
 
-        rc = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
-        if (rc != ARRAY_SIZE(msgs)) {
-                dev_err(&client->dev, "%s: register write failed\n",
-                        __FUNCTION__);
-                return -EIO;
-        }
+        memcpy(&i2c_burst_buf[1], buf, MAX6900_BURST_LEN);
+
+        rc = i2c_transfer(client->adapter, burst_msgs, ARRAY_SIZE(burst_msgs));
+        if (rc != ARRAY_SIZE(burst_msgs))
+                goto write_failed;
         msleep(MAX6900_IDLE_TIME_AFTER_WRITE);
+
         return 0;
+
+write_failed:
+        dev_err(&client->dev, "%s: register write failed\n",
+                __FUNCTION__);
+        return -EIO;
 }
 
 static int max6900_i2c_validate_client(struct i2c_client *client)
 {
         u8 regs[MAX6900_REG_LEN];
-        u8 zero_mask[MAX6900_REG_LEN] = {
+        u8 zero_mask[] = {
                 0x80,   /* seconds */
                 0x80,   /* minutes */
                 0x40,   /* hours */
@@ -134,7 +179,7 @@ static int max6900_i2c_validate_client(struct i2c_client *client)
         if (rc < 0)
                 return rc;
 
-        for (i = 0; i < MAX6900_REG_LEN; ++i) {
+        for (i = 0; i < ARRAY_SIZE(zero_mask); ++i) {
                 if (regs[i] & zero_mask[i])
                         return -ENODEV;
         }
@@ -156,7 +201,8 @@ static int max6900_i2c_read_time(struct i2c_client *client, struct rtc_time *tm)
         tm->tm_hour = BCD2BIN(regs[MAX6900_REG_HR] & 0x3f);
         tm->tm_mday = BCD2BIN(regs[MAX6900_REG_DT]);
         tm->tm_mon = BCD2BIN(regs[MAX6900_REG_MO]) - 1;
-        tm->tm_year = BCD2BIN(regs[MAX6900_REG_YR]) + 100;
+        tm->tm_year = BCD2BIN(regs[MAX6900_REG_YR]) +
+                      BCD2BIN(regs[MAX6900_REG_CENTURY]) * 100 - 1900;
         tm->tm_wday = BCD2BIN(regs[MAX6900_REG_DW]);
 
         return 0;
@@ -189,9 +235,11 @@ static int max6900_i2c_set_time(struct i2c_client *client,
         regs[MAX6900_REG_HR] = BIN2BCD(tm->tm_hour);
         regs[MAX6900_REG_DT] = BIN2BCD(tm->tm_mday);
         regs[MAX6900_REG_MO] = BIN2BCD(tm->tm_mon + 1);
-        regs[MAX6900_REG_YR] = BIN2BCD(tm->tm_year - 100);
         regs[MAX6900_REG_DW] = BIN2BCD(tm->tm_wday);
-        regs[MAX6900_REG_CT] = MAX6900_REG_CT_WP;       /* set write protect */
+        regs[MAX6900_REG_YR] = BIN2BCD(tm->tm_year % 100);
+        regs[MAX6900_REG_CENTURY] = BIN2BCD((tm->tm_year + 1900) / 100);
+        /* set write protect */
+        regs[MAX6900_REG_CT] = MAX6900_REG_CT_WP;
 
         rc = max6900_i2c_write_regs(client, regs);
         if (rc < 0)
diff --git a/drivers/rtc/rtc-stk17ta8.c b/drivers/rtc/rtc-stk17ta8.c
new file mode 100644
index 000000000000..f10d3facecbe
--- /dev/null
+++ b/drivers/rtc/rtc-stk17ta8.c
@@ -0,0 +1,420 @@
+/*
+ * A RTC driver for the Simtek STK17TA8
+ *
+ * By Thomas Hommel <thomas.hommel@gefanuc.com>
+ *
+ * Based on the DS1553 driver from
+ * Atsushi Nemoto <anemo@mba.ocn.ne.jp>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/bcd.h>
+#include <linux/init.h>
+#include <linux/kernel.h>
+#include <linux/delay.h>
+#include <linux/jiffies.h>
+#include <linux/interrupt.h>
+#include <linux/rtc.h>
+#include <linux/platform_device.h>
+#include <linux/io.h>
+
+#define DRV_VERSION "0.1"
+
+#define RTC_REG_SIZE            0x20000
+#define RTC_OFFSET              0x1fff0
+
+#define RTC_FLAGS               (RTC_OFFSET + 0)
+#define RTC_CENTURY             (RTC_OFFSET + 1)
+#define RTC_SECONDS_ALARM       (RTC_OFFSET + 2)
+#define RTC_MINUTES_ALARM       (RTC_OFFSET + 3)
+#define RTC_HOURS_ALARM         (RTC_OFFSET + 4)
+#define RTC_DATE_ALARM          (RTC_OFFSET + 5)
+#define RTC_INTERRUPTS          (RTC_OFFSET + 6)
+#define RTC_WATCHDOG            (RTC_OFFSET + 7)
+#define RTC_CALIBRATION         (RTC_OFFSET + 8)
+#define RTC_SECONDS             (RTC_OFFSET + 9)
+#define RTC_MINUTES             (RTC_OFFSET + 10)
+#define RTC_HOURS               (RTC_OFFSET + 11)
+#define RTC_DAY                 (RTC_OFFSET + 12)
+#define RTC_DATE                (RTC_OFFSET + 13)
+#define RTC_MONTH               (RTC_OFFSET + 14)
+#define RTC_YEAR                (RTC_OFFSET + 15)
+
+#define RTC_SECONDS_MASK        0x7f
+#define RTC_DAY_MASK            0x07
+#define RTC_CAL_MASK            0x3f
+
+/* Bits in the Calibration register */
+#define RTC_STOP                0x80
+
+/* Bits in the Flags register */
+#define RTC_FLAGS_AF            0x40
+#define RTC_FLAGS_PF            0x20
+#define RTC_WRITE               0x02
+#define RTC_READ                0x01
+
+/* Bits in the Interrupts register */
+#define RTC_INTS_AIE            0x40
+
+struct rtc_plat_data {
+        struct rtc_device *rtc;
+        void __iomem *ioaddr;
+        unsigned long baseaddr;
+        unsigned long last_jiffies;
+        int irq;
+        unsigned int irqen;
+        int alrm_sec;
+        int alrm_min;
+        int alrm_hour;
+        int alrm_mday;
+};
+
+static int stk17ta8_rtc_set_time(struct device *dev, struct rtc_time *tm)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+        void __iomem *ioaddr = pdata->ioaddr;
+        u8 flags;
+
+        flags = readb(pdata->ioaddr + RTC_FLAGS);
+        writeb(flags | RTC_WRITE, pdata->ioaddr + RTC_FLAGS);
+
+        writeb(BIN2BCD(tm->tm_year % 100), ioaddr + RTC_YEAR);
+        writeb(BIN2BCD(tm->tm_mon + 1), ioaddr + RTC_MONTH);
+        writeb(BIN2BCD(tm->tm_wday) & RTC_DAY_MASK, ioaddr + RTC_DAY);
+        writeb(BIN2BCD(tm->tm_mday), ioaddr + RTC_DATE);
+        writeb(BIN2BCD(tm->tm_hour), ioaddr + RTC_HOURS);
+        writeb(BIN2BCD(tm->tm_min), ioaddr + RTC_MINUTES);
+        writeb(BIN2BCD(tm->tm_sec) & RTC_SECONDS_MASK, ioaddr + RTC_SECONDS);
+        writeb(BIN2BCD((tm->tm_year + 1900) / 100), ioaddr + RTC_CENTURY);
+
+        writeb(flags & ~RTC_WRITE, pdata->ioaddr + RTC_FLAGS);
+        return 0;
+}
+
+static int stk17ta8_rtc_read_time(struct device *dev, struct rtc_time *tm)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+        void __iomem *ioaddr = pdata->ioaddr;
+        unsigned int year, month, day, hour, minute, second, week;
+        unsigned int century;
+        u8 flags;
+
+        /* give enough time to update RTC in case of continuous read */
+        if (pdata->last_jiffies == jiffies)
+                msleep(1);
+        pdata->last_jiffies = jiffies;
+
+        flags = readb(pdata->ioaddr + RTC_FLAGS);
+        writeb(flags | RTC_READ, ioaddr + RTC_FLAGS);
+        second = readb(ioaddr + RTC_SECONDS) & RTC_SECONDS_MASK;
+        minute = readb(ioaddr + RTC_MINUTES);
+        hour = readb(ioaddr + RTC_HOURS);
+        day = readb(ioaddr + RTC_DATE);
+        week = readb(ioaddr + RTC_DAY) & RTC_DAY_MASK;
+        month = readb(ioaddr + RTC_MONTH);
+        year = readb(ioaddr + RTC_YEAR);
+        century = readb(ioaddr + RTC_CENTURY);
+        writeb(flags & ~RTC_READ, ioaddr + RTC_FLAGS);
+        tm->tm_sec = BCD2BIN(second);
+        tm->tm_min = BCD2BIN(minute);
+        tm->tm_hour = BCD2BIN(hour);
+        tm->tm_mday = BCD2BIN(day);
+        tm->tm_wday = BCD2BIN(week);
+        tm->tm_mon = BCD2BIN(month) - 1;
+        /* year is 1900 + tm->tm_year */
+        tm->tm_year = BCD2BIN(year) + BCD2BIN(century) * 100 - 1900;
+
+        if (rtc_valid_tm(tm) < 0) {
+                dev_err(dev, "retrieved date/time is not valid.\n");
+                rtc_time_to_tm(0, tm);
+        }
+        return 0;
+}
+
+static void stk17ta8_rtc_update_alarm(struct rtc_plat_data *pdata)
+{
+        void __iomem *ioaddr = pdata->ioaddr;
+        unsigned long irqflags;
+        u8 flags;
+
+        spin_lock_irqsave(&pdata->rtc->irq_lock, irqflags);
+
+        flags = readb(ioaddr + RTC_FLAGS);
+        writeb(flags | RTC_WRITE, ioaddr + RTC_FLAGS);
+
+        writeb(pdata->alrm_mday < 0 || (pdata->irqen & RTC_UF) ?
+               0x80 : BIN2BCD(pdata->alrm_mday),
+               ioaddr + RTC_DATE_ALARM);
+        writeb(pdata->alrm_hour < 0 || (pdata->irqen & RTC_UF) ?
+               0x80 : BIN2BCD(pdata->alrm_hour),
+               ioaddr + RTC_HOURS_ALARM);
+        writeb(pdata->alrm_min < 0 || (pdata->irqen & RTC_UF) ?
+               0x80 : BIN2BCD(pdata->alrm_min),
+               ioaddr + RTC_MINUTES_ALARM);
+        writeb(pdata->alrm_sec < 0 || (pdata->irqen & RTC_UF) ?
+               0x80 : BIN2BCD(pdata->alrm_sec),
+               ioaddr + RTC_SECONDS_ALARM);
+        writeb(pdata->irqen ? RTC_INTS_AIE : 0, ioaddr + RTC_INTERRUPTS);
+        readb(ioaddr + RTC_FLAGS);      /* clear interrupts */
+        writeb(flags & ~RTC_WRITE, ioaddr + RTC_FLAGS);
+        spin_unlock_irqrestore(&pdata->rtc->irq_lock, irqflags);
+}
+
+static int stk17ta8_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+
+        if (pdata->irq < 0)
+                return -EINVAL;
+        pdata->alrm_mday = alrm->time.tm_mday;
+        pdata->alrm_hour = alrm->time.tm_hour;
+        pdata->alrm_min = alrm->time.tm_min;
+        pdata->alrm_sec = alrm->time.tm_sec;
+        if (alrm->enabled)
+                pdata->irqen |= RTC_AF;
+        stk17ta8_rtc_update_alarm(pdata);
+        return 0;
+}
+
+static int stk17ta8_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alrm)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+
+        if (pdata->irq < 0)
+                return -EINVAL;
+        alrm->time.tm_mday = pdata->alrm_mday < 0 ? 0 : pdata->alrm_mday;
+        alrm->time.tm_hour = pdata->alrm_hour < 0 ? 0 : pdata->alrm_hour;
+        alrm->time.tm_min = pdata->alrm_min < 0 ? 0 : pdata->alrm_min;
+        alrm->time.tm_sec = pdata->alrm_sec < 0 ? 0 : pdata->alrm_sec;
+        alrm->enabled = (pdata->irqen & RTC_AF) ? 1 : 0;
+        return 0;
+}
+
+static irqreturn_t stk17ta8_rtc_interrupt(int irq, void *dev_id)
+{
+        struct platform_device *pdev = dev_id;
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+        void __iomem *ioaddr = pdata->ioaddr;
+        unsigned long events = RTC_IRQF;
+
+        /* read and clear interrupt */
+        if (!(readb(ioaddr + RTC_FLAGS) & RTC_FLAGS_AF))
+                return IRQ_NONE;
+        if (readb(ioaddr + RTC_SECONDS_ALARM) & 0x80)
+                events |= RTC_UF;
+        else
+                events |= RTC_AF;
+        rtc_update_irq(pdata->rtc, 1, events);
+        return IRQ_HANDLED;
+}
+
+static void stk17ta8_rtc_release(struct device *dev)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+
+        if (pdata->irq >= 0) {
+                pdata->irqen = 0;
+                stk17ta8_rtc_update_alarm(pdata);
+        }
+}
+
+static int stk17ta8_rtc_ioctl(struct device *dev, unsigned int cmd,
+                            unsigned long arg)
+{
+        struct platform_device *pdev = to_platform_device(dev);
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+
+        if (pdata->irq < 0)
+                return -ENOIOCTLCMD; /* fall back into rtc-dev's emulation */
+        switch (cmd) {
+        case RTC_AIE_OFF:
+                pdata->irqen &= ~RTC_AF;
+                stk17ta8_rtc_update_alarm(pdata);
+                break;
+        case RTC_AIE_ON:
+                pdata->irqen |= RTC_AF;
+                stk17ta8_rtc_update_alarm(pdata);
+                break;
+        default:
+                return -ENOIOCTLCMD;
+        }
+        return 0;
+}
+
+static const struct rtc_class_ops stk17ta8_rtc_ops = {
+        .read_time      = stk17ta8_rtc_read_time,
+        .set_time       = stk17ta8_rtc_set_time,
+        .read_alarm     = stk17ta8_rtc_read_alarm,
+        .set_alarm      = stk17ta8_rtc_set_alarm,
+        .release        = stk17ta8_rtc_release,
+        .ioctl          = stk17ta8_rtc_ioctl,
+};
+
+static ssize_t stk17ta8_nvram_read(struct kobject *kobj, char *buf,
+                                 loff_t pos, size_t size)
+{
+        struct platform_device *pdev =
+                to_platform_device(container_of(kobj, struct device, kobj));
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+        void __iomem *ioaddr = pdata->ioaddr;
+        ssize_t count;
+
+        for (count = 0; size > 0 && pos < RTC_OFFSET; count++, size--)
+                *buf++ = readb(ioaddr + pos++);
+        return count;
+}
+
+static ssize_t stk17ta8_nvram_write(struct kobject *kobj, char *buf,
+                                  loff_t pos, size_t size)
+{
+        struct platform_device *pdev =
+                to_platform_device(container_of(kobj, struct device, kobj));
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+        void __iomem *ioaddr = pdata->ioaddr;
+        ssize_t count;
+
+        for (count = 0; size > 0 && pos < RTC_OFFSET; count++, size--)
+                writeb(*buf++, ioaddr + pos++);
+        return count;
+}
+
+static struct bin_attribute stk17ta8_nvram_attr = {
+        .attr = {
+                .name = "nvram",
+                .mode = S_IRUGO | S_IWUGO,
+                .owner = THIS_MODULE,
+        },
+        .size = RTC_OFFSET,
+        .read = stk17ta8_nvram_read,
+        .write = stk17ta8_nvram_write,
+};
+
+static int __init stk17ta8_rtc_probe(struct platform_device *pdev)
+{
+        struct rtc_device *rtc;
+        struct resource *res;
+        unsigned int cal;
+        unsigned int flags;
+        struct rtc_plat_data *pdata;
+        void __iomem *ioaddr = NULL;
+        int ret = 0;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res)
+                return -ENODEV;
+
+        pdata = kzalloc(sizeof(*pdata), GFP_KERNEL);
+        if (!pdata)
+                return -ENOMEM;
+        pdata->irq = -1;
+        if (!request_mem_region(res->start, RTC_REG_SIZE, pdev->name)) {
+                ret = -EBUSY;
+                goto out;
+        }
+        pdata->baseaddr = res->start;
+        ioaddr = ioremap(pdata->baseaddr, RTC_REG_SIZE);
+        if (!ioaddr) {
+                ret = -ENOMEM;
+                goto out;
+        }
+        pdata->ioaddr = ioaddr;
+        pdata->irq = platform_get_irq(pdev, 0);
+
+        /* turn RTC on if it was not on */
+        cal = readb(ioaddr + RTC_CALIBRATION);
+        if (cal & RTC_STOP) {
+                cal &= RTC_CAL_MASK;
+                flags = readb(ioaddr + RTC_FLAGS);
+                writeb(flags | RTC_WRITE, ioaddr + RTC_FLAGS);
+                writeb(cal, ioaddr + RTC_CALIBRATION);
+                writeb(flags & ~RTC_WRITE, ioaddr + RTC_FLAGS);
+        }
+        if (readb(ioaddr + RTC_FLAGS) & RTC_FLAGS_PF)
+                dev_warn(&pdev->dev, "voltage-low detected.\n");
+
+        if (pdata->irq >= 0) {
+                writeb(0, ioaddr + RTC_INTERRUPTS);
+                if (request_irq(pdata->irq, stk17ta8_rtc_interrupt,
+                                IRQF_DISABLED | IRQF_SHARED,
+                                pdev->name, pdev) < 0) {
+                        dev_warn(&pdev->dev, "interrupt not available.\n");
+                        pdata->irq = -1;
+                }
+        }
+
+        rtc = rtc_device_register(pdev->name, &pdev->dev,
+                                  &stk17ta8_rtc_ops, THIS_MODULE);
+        if (IS_ERR(rtc)) {
+                ret = PTR_ERR(rtc);
+                goto out;
+        }
+        pdata->rtc = rtc;
+        pdata->last_jiffies = jiffies;
+        platform_set_drvdata(pdev, pdata);
+        ret = sysfs_create_bin_file(&pdev->dev.kobj, &stk17ta8_nvram_attr);
+        if (ret)
+                goto out;
+        return 0;
+ out:
+        if (pdata->rtc)
+                rtc_device_unregister(pdata->rtc);
+        if (pdata->irq >= 0)
+                free_irq(pdata->irq, pdev);
+        if (ioaddr)
+                iounmap(ioaddr);
+        if (pdata->baseaddr)
+                release_mem_region(pdata->baseaddr, RTC_REG_SIZE);
+        kfree(pdata);
+        return ret;
+}
+
+static int __devexit stk17ta8_rtc_remove(struct platform_device *pdev)
+{
+        struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
+
+        sysfs_remove_bin_file(&pdev->dev.kobj, &stk17ta8_nvram_attr);
+        rtc_device_unregister(pdata->rtc);
+        if (pdata->irq >= 0) {
+                writeb(0, pdata->ioaddr + RTC_INTERRUPTS);
+                free_irq(pdata->irq, pdev);
+        }
+        iounmap(pdata->ioaddr);
+        release_mem_region(pdata->baseaddr, RTC_REG_SIZE);
+        kfree(pdata);
+        return 0;
+}
+
+static struct platform_driver stk17ta8_rtc_driver = {
+        .probe          = stk17ta8_rtc_probe,
+        .remove         = __devexit_p(stk17ta8_rtc_remove),
+        .driver         = {
+                .name   = "stk17ta8",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static __init int stk17ta8_init(void)
+{
+        return platform_driver_register(&stk17ta8_rtc_driver);
+}
+
+static __exit void stk17ta8_exit(void)
+{
+        return platform_driver_unregister(&stk17ta8_rtc_driver);
+}
+
+module_init(stk17ta8_init);
+module_exit(stk17ta8_exit);
+
+MODULE_AUTHOR("Thomas Hommel <thomas.hommel@gefanuc.com>");
+MODULE_DESCRIPTION("Simtek STK17TA8 RTC driver");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(DRV_VERSION);
diff --git a/drivers/scsi/Makefile b/drivers/scsi/Makefile
index 0f8689557158..86a7ba7bad63 100644
--- a/drivers/scsi/Makefile
+++ b/drivers/scsi/Makefile
@@ -132,6 +132,7 @@ obj-$(CONFIG_SCSI_IBMVSCSI)	+= ibmvscsi/
 obj-$(CONFIG_SCSI_IBMVSCSIS)    += ibmvscsi/
 obj-$(CONFIG_SCSI_HPTIOP)       += hptiop.o
 obj-$(CONFIG_SCSI_STEX)         += stex.o
+obj-$(CONFIG_PS3_ROM)           += ps3rom.o
 
 obj-$(CONFIG_ARM)               += arm/
 
diff --git a/drivers/scsi/ps3rom.c b/drivers/scsi/ps3rom.c
new file mode 100644
index 000000000000..b50f1e14f2a5
--- /dev/null
+++ b/drivers/scsi/ps3rom.c
@@ -0,0 +1,533 @@
+/*
+ * PS3 BD/DVD/CD-ROM Storage Driver
+ *
+ * Copyright (C) 2007 Sony Computer Entertainment Inc.
+ * Copyright 2007 Sony Corp.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published
+ * by the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include <linux/cdrom.h>
+#include <linux/highmem.h>
+
+#include <scsi/scsi.h>
+#include <scsi/scsi_cmnd.h>
+#include <scsi/scsi_dbg.h>
+#include <scsi/scsi_device.h>
+#include <scsi/scsi_host.h>
+
+#include <asm/lv1call.h>
+#include <asm/ps3stor.h>
+
+
+#define DEVICE_NAME                     "ps3rom"
+
+#define BOUNCE_SIZE                     (64*1024)
+
+#define PS3ROM_MAX_SECTORS              (BOUNCE_SIZE / CD_FRAMESIZE)
+
+
+struct ps3rom_private {
+        struct ps3_storage_device *dev;
+        struct scsi_cmnd *curr_cmd;
+};
+
+
+#define LV1_STORAGE_SEND_ATAPI_COMMAND  (1)
+
+struct lv1_atapi_cmnd_block {
+        u8      pkt[32];        /* packet command block           */
+        u32     pktlen;         /* should be 12 for ATAPI 8020    */
+        u32     blocks;
+        u32     block_size;
+        u32     proto;          /* transfer mode                  */
+        u32     in_out;         /* transfer direction             */
+        u64     buffer;         /* parameter except command block */
+        u32     arglen;         /* length above                   */
+};
+
+enum lv1_atapi_proto {
+        NON_DATA_PROTO     = 0,
+        PIO_DATA_IN_PROTO  = 1,
+        PIO_DATA_OUT_PROTO = 2,
+        DMA_PROTO = 3
+};
+
+enum lv1_atapi_in_out {
+        DIR_WRITE = 0,          /* memory -> device */
+        DIR_READ = 1            /* device -> memory */
+};
+
+
+static int ps3rom_slave_configure(struct scsi_device *scsi_dev)
+{
+        struct ps3rom_private *priv = shost_priv(scsi_dev->host);
+        struct ps3_storage_device *dev = priv->dev;
+
+        dev_dbg(&dev->sbd.core, "%s:%u: id %u, lun %u, channel %u\n", __func__,
+                __LINE__, scsi_dev->id, scsi_dev->lun, scsi_dev->channel);
+
+        /*
+         * ATAPI SFF8020 devices use MODE_SENSE_10,
+         * so we can prohibit MODE_SENSE_6
+         */
+        scsi_dev->use_10_for_ms = 1;
+
+        /* we don't support {READ,WRITE}_6 */
+        scsi_dev->use_10_for_rw = 1;
+
+        return 0;
+}
+
+/*
+ * copy data from device into scatter/gather buffer
+ */
+static int fill_from_dev_buffer(struct scsi_cmnd *cmd, const void *buf)
+{
+        int k, req_len, act_len, len, active;
+        void *kaddr;
+        struct scatterlist *sgpnt;
+        unsigned int buflen;
+
+        buflen = cmd->request_bufflen;
+        if (!buflen)
+                return 0;
+
+        if (!cmd->request_buffer)
+                return -1;
+
+        sgpnt = cmd->request_buffer;
+        active = 1;
+        for (k = 0, req_len = 0, act_len = 0; k < cmd->use_sg; ++k, ++sgpnt) {
+                if (active) {
+                        kaddr = kmap_atomic(sgpnt->page, KM_IRQ0);
+                        len = sgpnt->length;
+                        if ((req_len + len) > buflen) {
+                                active = 0;
+                                len = buflen - req_len;
+                        }
+                        memcpy(kaddr + sgpnt->offset, buf + req_len, len);
+                        flush_kernel_dcache_page(sgpnt->page);
+                        kunmap_atomic(kaddr, KM_IRQ0);
+                        act_len += len;
+                }
+                req_len += sgpnt->length;
+        }
+        cmd->resid = req_len - act_len;
+        return 0;
+}
+
+/*
+ * copy data from scatter/gather into device's buffer
+ */
+static int fetch_to_dev_buffer(struct scsi_cmnd *cmd, void *buf)
+{
+        int k, req_len, len, fin;
+        void *kaddr;
+        struct scatterlist *sgpnt;
+        unsigned int buflen;
+
+        buflen = cmd->request_bufflen;
+        if (!buflen)
+                return 0;
+
+        if (!cmd->request_buffer)
+                return -1;
+
+        sgpnt = cmd->request_buffer;
+        for (k = 0, req_len = 0, fin = 0; k < cmd->use_sg; ++k, ++sgpnt) {
+                kaddr = kmap_atomic(sgpnt->page, KM_IRQ0);
+                len = sgpnt->length;
+                if ((req_len + len) > buflen) {
+                        len = buflen - req_len;
+                        fin = 1;
+                }
+                memcpy(buf + req_len, kaddr + sgpnt->offset, len);
+                kunmap_atomic(kaddr, KM_IRQ0);
+                if (fin)
+                        return req_len + len;
+                req_len += sgpnt->length;
+        }
+        return req_len;
+}
+
+static int ps3rom_atapi_request(struct ps3_storage_device *dev,
+                                struct scsi_cmnd *cmd)
+{
+        struct lv1_atapi_cmnd_block atapi_cmnd;
+        unsigned char opcode = cmd->cmnd[0];
+        int res;
+        u64 lpar;
+
+        dev_dbg(&dev->sbd.core, "%s:%u: send ATAPI command 0x%02x\n", __func__,
+                __LINE__, opcode);
+
+        memset(&atapi_cmnd, 0, sizeof(struct lv1_atapi_cmnd_block));
+        memcpy(&atapi_cmnd.pkt, cmd->cmnd, 12);
+        atapi_cmnd.pktlen = 12;
+        atapi_cmnd.block_size = 1; /* transfer size is block_size * blocks */
+        atapi_cmnd.blocks = atapi_cmnd.arglen = cmd->request_bufflen;
+        atapi_cmnd.buffer = dev->bounce_lpar;
+
+        switch (cmd->sc_data_direction) {
+        case DMA_FROM_DEVICE:
+                if (cmd->request_bufflen >= CD_FRAMESIZE)
+                        atapi_cmnd.proto = DMA_PROTO;
+                else
+                        atapi_cmnd.proto = PIO_DATA_IN_PROTO;
+                atapi_cmnd.in_out = DIR_READ;
+                break;
+
+        case DMA_TO_DEVICE:
+                if (cmd->request_bufflen >= CD_FRAMESIZE)
+                        atapi_cmnd.proto = DMA_PROTO;
+                else
+                        atapi_cmnd.proto = PIO_DATA_OUT_PROTO;
+                atapi_cmnd.in_out = DIR_WRITE;
+                res = fetch_to_dev_buffer(cmd, dev->bounce_buf);
+                if (res < 0)
+                        return DID_ERROR << 16;
+                break;
+
+        default:
+                atapi_cmnd.proto = NON_DATA_PROTO;
+                break;
+        }
+
+        lpar = ps3_mm_phys_to_lpar(__pa(&atapi_cmnd));
+        res = lv1_storage_send_device_command(dev->sbd.dev_id,
+                                              LV1_STORAGE_SEND_ATAPI_COMMAND,
+                                              lpar, sizeof(atapi_cmnd),
+                                              atapi_cmnd.buffer,
+                                              atapi_cmnd.arglen, &dev->tag);
+        if (res == LV1_DENIED_BY_POLICY) {
+                dev_dbg(&dev->sbd.core,
+                        "%s:%u: ATAPI command 0x%02x denied by policy\n",
+                        __func__, __LINE__, opcode);
+                return DID_ERROR << 16;
+        }
+
+        if (res) {
+                dev_err(&dev->sbd.core,
+                        "%s:%u: ATAPI command 0x%02x failed %d\n", __func__,
+                        __LINE__, opcode, res);
+                return DID_ERROR << 16;
+        }
+
+        return 0;
+}
+
+static inline unsigned int srb10_lba(const struct scsi_cmnd *cmd)
+{
+        return cmd->cmnd[2] << 24 | cmd->cmnd[3] << 16 | cmd->cmnd[4] << 8 |
+               cmd->cmnd[5];
+}
+
+static inline unsigned int srb10_len(const struct scsi_cmnd *cmd)
+{
+        return cmd->cmnd[7] << 8 | cmd->cmnd[8];
+}
+
+static int ps3rom_read_request(struct ps3_storage_device *dev,
+                               struct scsi_cmnd *cmd, u32 start_sector,
+                               u32 sectors)
+{
+        int res;
+
+        dev_dbg(&dev->sbd.core, "%s:%u: read %u sectors starting at %u\n",
+                __func__, __LINE__, sectors, start_sector);
+
+        res = lv1_storage_read(dev->sbd.dev_id,
+                               dev->regions[dev->region_idx].id, start_sector,
+                               sectors, 0, dev->bounce_lpar, &dev->tag);
+        if (res) {
+                dev_err(&dev->sbd.core, "%s:%u: read failed %d\n", __func__,
+                        __LINE__, res);
+                return DID_ERROR << 16;
+        }
+
+        return 0;
+}
+
+static int ps3rom_write_request(struct ps3_storage_device *dev,
+                                struct scsi_cmnd *cmd, u32 start_sector,
+                                u32 sectors)
+{
+        int res;
+
+        dev_dbg(&dev->sbd.core, "%s:%u: write %u sectors starting at %u\n",
+                __func__, __LINE__, sectors, start_sector);
+
+        res = fetch_to_dev_buffer(cmd, dev->bounce_buf);
+        if (res < 0)
+                return DID_ERROR << 16;
+
+        res = lv1_storage_write(dev->sbd.dev_id,
+                                dev->regions[dev->region_idx].id, start_sector,
+                                sectors, 0, dev->bounce_lpar, &dev->tag);
+        if (res) {
+                dev_err(&dev->sbd.core, "%s:%u: write failed %d\n", __func__,
+                        __LINE__, res);
+                return DID_ERROR << 16;
+        }
+
+        return 0;
+}
+
+static int ps3rom_queuecommand(struct scsi_cmnd *cmd,
+                               void (*done)(struct scsi_cmnd *))
+{
+        struct ps3rom_private *priv = shost_priv(cmd->device->host);
+        struct ps3_storage_device *dev = priv->dev;
+        unsigned char opcode;
+        int res;
+
+#ifdef DEBUG
+        scsi_print_command(cmd);
+#endif
+
+        priv->curr_cmd = cmd;
+        cmd->scsi_done = done;
+
+        opcode = cmd->cmnd[0];
+        /*
+         * While we can submit READ/WRITE SCSI commands as ATAPI commands,
+         * it's recommended for various reasons (performance, error handling,
+         * ...) to use lv1_storage_{read,write}() instead
+         */
+        switch (opcode) {
+        case READ_10:
+                res = ps3rom_read_request(dev, cmd, srb10_lba(cmd),
+                                          srb10_len(cmd));
+                break;
+
+        case WRITE_10:
+                res = ps3rom_write_request(dev, cmd, srb10_lba(cmd),
+                                           srb10_len(cmd));
+                break;
+
+        default:
+                res = ps3rom_atapi_request(dev, cmd);
+                break;
+        }
+
+        if (res) {
+                memset(cmd->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
+                cmd->result = res;
+                cmd->sense_buffer[0] = 0x70;
+                cmd->sense_buffer[2] = ILLEGAL_REQUEST;
+                priv->curr_cmd = NULL;
+                cmd->scsi_done(cmd);
+        }
+
+        return 0;
+}
+
+static int decode_lv1_status(u64 status, unsigned char *sense_key,
+                             unsigned char *asc, unsigned char *ascq)
+{
+        if (((status >> 24) & 0xff) != SAM_STAT_CHECK_CONDITION)
+                return -1;
+
+        *sense_key = (status >> 16) & 0xff;
+        *asc       = (status >>  8) & 0xff;
+        *ascq      =  status        & 0xff;
+        return 0;
+}
+
+static irqreturn_t ps3rom_interrupt(int irq, void *data)
+{
+        struct ps3_storage_device *dev = data;
+        struct Scsi_Host *host;
+        struct ps3rom_private *priv;
+        struct scsi_cmnd *cmd;
+        int res;
+        u64 tag, status;
+        unsigned char sense_key, asc, ascq;
+
+        res = lv1_storage_get_async_status(dev->sbd.dev_id, &tag, &status);
+        /*
+         * status = -1 may mean that ATAPI transport completed OK, but
+         * ATAPI command itself resulted CHECK CONDITION
+         * so, upper layer should issue REQUEST_SENSE to check the sense data
+         */
+
+        if (tag != dev->tag)
+                dev_err(&dev->sbd.core,
+                        "%s:%u: tag mismatch, got %lx, expected %lx\n",
+                        __func__, __LINE__, tag, dev->tag);
+
+        if (res) {
+                dev_err(&dev->sbd.core, "%s:%u: res=%d status=0x%lx\n",
+                        __func__, __LINE__, res, status);
+                return IRQ_HANDLED;
+        }
+
+        host = dev->sbd.core.driver_data;
+        priv = shost_priv(host);
+        cmd = priv->curr_cmd;
+
+        if (!status) {
+                /* OK, completed */
+                if (cmd->sc_data_direction == DMA_FROM_DEVICE) {
+                        res = fill_from_dev_buffer(cmd, dev->bounce_buf);
+                        if (res) {
+                                cmd->result = DID_ERROR << 16;
+                                goto done;
+                        }
+                }
+                cmd->result = DID_OK << 16;
+                goto done;
+        }
+
+        if (cmd->cmnd[0] == REQUEST_SENSE) {
+                /* SCSI spec says request sense should never get error */
+                dev_err(&dev->sbd.core, "%s:%u: end error without autosense\n",
+                        __func__, __LINE__);
+                cmd->result = DID_ERROR << 16 | SAM_STAT_CHECK_CONDITION;
+                goto done;
+        }
+
+        if (decode_lv1_status(status, &sense_key, &asc, &ascq)) {
+                cmd->result = DID_ERROR << 16;
+                goto done;
+        }
+
+        cmd->sense_buffer[0]  = 0x70;
+        cmd->sense_buffer[2]  = sense_key;
+        cmd->sense_buffer[7]  = 16 - 6;
+        cmd->sense_buffer[12] = asc;
+        cmd->sense_buffer[13] = ascq;
+        cmd->result = SAM_STAT_CHECK_CONDITION;
+
+done:
+        priv->curr_cmd = NULL;
+        cmd->scsi_done(cmd);
+        return IRQ_HANDLED;
+}
+
+static struct scsi_host_template ps3rom_host_template = {
+        .name =                 DEVICE_NAME,
+        .slave_configure =      ps3rom_slave_configure,
+        .queuecommand =         ps3rom_queuecommand,
+        .can_queue =            1,
+        .this_id =              7,
+        .sg_tablesize =         SG_ALL,
+        .cmd_per_lun =          1,
+        .emulated =             1,              /* only sg driver uses this */
+        .max_sectors =          PS3ROM_MAX_SECTORS,
+        .use_clustering =       ENABLE_CLUSTERING,
+        .module =               THIS_MODULE,
+};
+
+
+static int __devinit ps3rom_probe(struct ps3_system_bus_device *_dev)
+{
+        struct ps3_storage_device *dev = to_ps3_storage_device(&_dev->core);
+        int error;
+        struct Scsi_Host *host;
+        struct ps3rom_private *priv;
+
+        if (dev->blk_size != CD_FRAMESIZE) {
+                dev_err(&dev->sbd.core,
+                        "%s:%u: cannot handle block size %lu\n", __func__,
+                        __LINE__, dev->blk_size);
+                return -EINVAL;
+        }
+
+        dev->bounce_size = BOUNCE_SIZE;
+        dev->bounce_buf = kmalloc(BOUNCE_SIZE, GFP_DMA);
+        if (!dev->bounce_buf)
+                return -ENOMEM;
+
+        error = ps3stor_setup(dev, ps3rom_interrupt);
+        if (error)
+                goto fail_free_bounce;
+
+        host = scsi_host_alloc(&ps3rom_host_template,
+                               sizeof(struct ps3rom_private));
+        if (!host) {
+                dev_err(&dev->sbd.core, "%s:%u: scsi_host_alloc failed\n",
+                        __func__, __LINE__);
+                goto fail_teardown;
+        }
+
+        priv = shost_priv(host);
+        dev->sbd.core.driver_data = host;
+        priv->dev = dev;
+
+        /* One device/LUN per SCSI bus */
+        host->max_id = 1;
+        host->max_lun = 1;
+
+        error = scsi_add_host(host, &dev->sbd.core);
+        if (error) {
+                dev_err(&dev->sbd.core, "%s:%u: scsi_host_alloc failed %d\n",
+                        __func__, __LINE__, error);
+                error = -ENODEV;
+                goto fail_host_put;
+        }
+
+        scsi_scan_host(host);
+        return 0;
+
+fail_host_put:
+        scsi_host_put(host);
+        dev->sbd.core.driver_data = NULL;
+fail_teardown:
+        ps3stor_teardown(dev);
+fail_free_bounce:
+        kfree(dev->bounce_buf);
+        return error;
+}
+
+static int ps3rom_remove(struct ps3_system_bus_device *_dev)
+{
+        struct ps3_storage_device *dev = to_ps3_storage_device(&_dev->core);
+        struct Scsi_Host *host = dev->sbd.core.driver_data;
+
+        scsi_remove_host(host);
+        ps3stor_teardown(dev);
+        scsi_host_put(host);
+        dev->sbd.core.driver_data = NULL;
+        kfree(dev->bounce_buf);
+        return 0;
+}
+
+static struct ps3_system_bus_driver ps3rom = {
+        .match_id       = PS3_MATCH_ID_STOR_ROM,
+        .core.name      = DEVICE_NAME,
+        .core.owner     = THIS_MODULE,
+        .probe          = ps3rom_probe,
+        .remove         = ps3rom_remove
+};
+
+
+static int __init ps3rom_init(void)
+{
+        return ps3_system_bus_driver_register(&ps3rom);
+}
+
+static void __exit ps3rom_exit(void)
+{
+        ps3_system_bus_driver_unregister(&ps3rom);
+}
+
+module_init(ps3rom_init);
+module_exit(ps3rom_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("PS3 BD/DVD/CD-ROM Storage Driver");
+MODULE_AUTHOR("Sony Corporation");
+MODULE_ALIAS(PS3_MODULE_ALIAS_STOR_ROM);
diff --git a/drivers/spi/spi.c b/drivers/spi/spi.c
index 018884d7a5fa..b05de30b5d9b 100644
--- a/drivers/spi/spi.c
+++ b/drivers/spi/spi.c
@@ -303,8 +303,7 @@ spi_register_board_info(struct spi_board_info const *info, unsigned n)
  * creates board info from kernel command lines
  */
 
-static void __init_or_module
-scan_boardinfo(struct spi_master *master)
+static void scan_boardinfo(struct spi_master *master)
 {
         struct boardinfo        *bi;
         struct device           *dev = master->cdev.dev;
diff --git a/drivers/video/Kconfig b/drivers/video/Kconfig
index 0c5644bb59af..2a237f09ee5d 100644
--- a/drivers/video/Kconfig
+++ b/drivers/video/Kconfig
@@ -849,6 +849,16 @@ config FB_INTSRAM
           Say Y if you want to map Frame Buffer in internal SRAM. Say N if you want
           to let frame buffer in external SDRAM.
 
+config FB_ATMEL_STN
+        bool "Use a STN display with AT91/AT32 LCD Controller"
+        depends on FB_ATMEL && MACH_AT91SAM9261EK
+        default n
+        help
+          Say Y if you want to connect a STN LCD display to the AT91/AT32 LCD
+          Controller. Say N if you want to connect a TFT.
+
+          If unsure, say N.
+
 config FB_NVIDIA
         tristate "nVidia Framebuffer Support"
         depends on FB && PCI
@@ -1796,13 +1806,14 @@ config FB_PS3
         select FB_SYS_COPYAREA
         select FB_SYS_IMAGEBLIT
         select FB_SYS_FOPS
+        select VT_HW_CONSOLE_BINDING if FRAMEBUFFER_CONSOLE
         ---help---
           Include support for the virtual frame buffer in the PS3 platform.
 
 config FB_PS3_DEFAULT_SIZE_M
         int "PS3 default frame buffer size (in MiB)"
         depends on FB_PS3
-        default 18
+        default 9
         ---help---
           This is the default size (in MiB) of the virtual frame buffer in
           the PS3.
diff --git a/drivers/video/atmel_lcdfb.c b/drivers/video/atmel_lcdfb.c
index e1d5bd0c98c4..235b618b4117 100644
--- a/drivers/video/atmel_lcdfb.c
+++ b/drivers/video/atmel_lcdfb.c
@@ -79,6 +79,29 @@ static struct fb_fix_screeninfo atmel_lcdfb_fix __initdata = {
         .accel          = FB_ACCEL_NONE,
 };
 
+static unsigned long compute_hozval(unsigned long xres, unsigned long lcdcon2)
+{
+        unsigned long value;
+
+        if (!(cpu_is_at91sam9261() || cpu_is_at32ap7000()))
+                return xres;
+
+        value = xres;
+        if ((lcdcon2 & ATMEL_LCDC_DISTYPE) != ATMEL_LCDC_DISTYPE_TFT) {
+                /* STN display */
+                if ((lcdcon2 & ATMEL_LCDC_DISTYPE) == ATMEL_LCDC_DISTYPE_STNCOLOR) {
+                        value *= 3;
+                }
+                if ( (lcdcon2 & ATMEL_LCDC_IFWIDTH) == ATMEL_LCDC_IFWIDTH_4
+                   || ( (lcdcon2 & ATMEL_LCDC_IFWIDTH) == ATMEL_LCDC_IFWIDTH_8
+                      && (lcdcon2 & ATMEL_LCDC_SCANMOD) == ATMEL_LCDC_SCANMOD_DUAL ))
+                        value = DIV_ROUND_UP(value, 4);
+                else
+                        value = DIV_ROUND_UP(value, 8);
+        }
+
+        return value;
+}
 
 static void atmel_lcdfb_update_dma(struct fb_info *info,
                                struct fb_var_screeninfo *var)
@@ -181,6 +204,7 @@ static int atmel_lcdfb_check_var(struct fb_var_screeninfo *var,
         var->xoffset = var->yoffset = 0;
 
         switch (var->bits_per_pixel) {
+        case 1:
         case 2:
         case 4:
         case 8:
@@ -195,8 +219,11 @@ static int atmel_lcdfb_check_var(struct fb_var_screeninfo *var,
                 var->blue.offset = 10;
                 var->red.length = var->green.length = var->blue.length = 5;
                 break;
-        case 24:
         case 32:
+                var->transp.offset = 24;
+                var->transp.length = 8;
+                /* fall through */
+        case 24:
                 var->red.offset = 0;
                 var->green.offset = 8;
                 var->blue.offset = 16;
@@ -228,8 +255,10 @@ static int atmel_lcdfb_check_var(struct fb_var_screeninfo *var,
 static int atmel_lcdfb_set_par(struct fb_info *info)
 {
         struct atmel_lcdfb_info *sinfo = info->par;
+        unsigned long hozval_linesz;
         unsigned long value;
         unsigned long clk_value_khz;
+        unsigned long bits_per_line;
 
         dev_dbg(info->device, "%s:\n", __func__);
         dev_dbg(info->device, "  * resolution: %ux%u (%ux%u virtual)\n",
@@ -241,12 +270,15 @@ static int atmel_lcdfb_set_par(struct fb_info *info)
 
         lcdc_writel(sinfo, ATMEL_LCDC_DMACON, 0);
 
-        if (info->var.bits_per_pixel <= 8)
+        if (info->var.bits_per_pixel == 1)
+                info->fix.visual = FB_VISUAL_MONO01;
+        else if (info->var.bits_per_pixel <= 8)
                 info->fix.visual = FB_VISUAL_PSEUDOCOLOR;
         else
                 info->fix.visual = FB_VISUAL_TRUECOLOR;
 
-        info->fix.line_length = info->var.xres_virtual * (info->var.bits_per_pixel / 8);
+        bits_per_line = info->var.xres_virtual * info->var.bits_per_pixel;
+        info->fix.line_length = DIV_ROUND_UP(bits_per_line, 8);
 
         /* Re-initialize the DMA engine... */
         dev_dbg(info->device, "  * update DMA engine\n");
@@ -262,18 +294,21 @@ static int atmel_lcdfb_set_par(struct fb_info *info)
         /* Set pixel clock */
         clk_value_khz = clk_get_rate(sinfo->lcdc_clk) / 1000;
 
-        value = clk_value_khz / PICOS2KHZ(info->var.pixclock);
-
-        if (clk_value_khz % PICOS2KHZ(info->var.pixclock))
-                value++;
+        value = DIV_ROUND_UP(clk_value_khz, PICOS2KHZ(info->var.pixclock));
 
         value = (value / 2) - 1;
+        dev_dbg(info->device, "  * programming CLKVAL = 0x%08lx\n", value);
 
         if (value <= 0) {
                 dev_notice(info->device, "Bypassing pixel clock divider\n");
                 lcdc_writel(sinfo, ATMEL_LCDC_LCDCON1, ATMEL_LCDC_BYPASS);
-        } else
+        } else {
                 lcdc_writel(sinfo, ATMEL_LCDC_LCDCON1, value << ATMEL_LCDC_CLKVAL_OFFSET);
+                info->var.pixclock = KHZ2PICOS(clk_value_khz / (2 * (value + 1)));
+                dev_dbg(info->device, "  updated pixclk:     %lu KHz\n",
+                                        PICOS2KHZ(info->var.pixclock));
+        }
+
 
         /* Initialize control register 2 */
         value = sinfo->default_lcdcon2;
@@ -311,9 +346,14 @@ static int atmel_lcdfb_set_par(struct fb_info *info)
         dev_dbg(info->device, "  * LCDTIM2 = %08lx\n", value);
         lcdc_writel(sinfo, ATMEL_LCDC_TIM2, value);
 
+        /* Horizontal value (aka line size) */
+        hozval_linesz = compute_hozval(info->var.xres,
+                                        lcdc_readl(sinfo, ATMEL_LCDC_LCDCON2));
+
         /* Display size */
-        value = (info->var.xres - 1) << ATMEL_LCDC_HOZVAL_OFFSET;
+        value = (hozval_linesz - 1) << ATMEL_LCDC_HOZVAL_OFFSET;
         value |= info->var.yres - 1;
+        dev_dbg(info->device, "  * LCDFRMCFG = %08lx\n", value);
         lcdc_writel(sinfo, ATMEL_LCDC_LCDFRMCFG, value);
 
         /* FIFO Threshold: Use formula from data sheet */
@@ -421,6 +461,15 @@ static int atmel_lcdfb_setcolreg(unsigned int regno, unsigned int red,
                         ret = 0;
                 }
                 break;
+
+        case FB_VISUAL_MONO01:
+                if (regno < 2) {
+                        val = (regno == 0) ? 0x00 : 0x1F;
+                        lcdc_writel(sinfo, ATMEL_LCDC_LUT(regno), val);
+                        ret = 0;
+                }
+                break;
+
         }
 
         return ret;
diff --git a/drivers/video/console/vgacon.c b/drivers/video/console/vgacon.c
index f46fe95f69fb..d18b73aafa0d 100644
--- a/drivers/video/console/vgacon.c
+++ b/drivers/video/console/vgacon.c
@@ -187,7 +187,11 @@ static void vgacon_scrollback_init(int pitch)
         }
 }
 
-static void vgacon_scrollback_startup(void)
+/*
+ * Called only duing init so call of alloc_bootmen is ok.
+ * Marked __init_refok to silence modpost.
+ */
+static void __init_refok vgacon_scrollback_startup(void)
 {
         vgacon_scrollback = alloc_bootmem(CONFIG_VGACON_SOFT_SCROLLBACK_SIZE
                                           * 1024);
diff --git a/drivers/video/ps3fb.c b/drivers/video/ps3fb.c
index 3972aa8cf859..646ec823c168 100644
--- a/drivers/video/ps3fb.c
+++ b/drivers/video/ps3fb.c
@@ -1067,7 +1067,7 @@ static int __devinit ps3fb_probe(struct ps3_system_bus_device *dev)
         info->fix.smem_len = ps3fb_videomemory.size - offset;
         info->pseudo_palette = info->par;
         info->par = NULL;
-        info->flags = FBINFO_FLAG_DEFAULT;
+        info->flags = FBINFO_DEFAULT | FBINFO_READS_FAST;
 
         retval = fb_alloc_cmap(&info->cmap, 256, 0);
         if (retval < 0)
diff --git a/drivers/video/riva/fbdev.c b/drivers/video/riva/fbdev.c
index 0fe547842c64..41381e61832c 100644
--- a/drivers/video/riva/fbdev.c
+++ b/drivers/video/riva/fbdev.c
@@ -2146,7 +2146,7 @@ static void __devexit rivafb_remove(struct pci_dev *pd)
  * ------------------------------------------------------------------------- */
 
 #ifndef MODULE
-static int __init rivafb_setup(char *options)
+static int __devinit rivafb_setup(char *options)
 {
         char *this_opt;
 
diff --git a/fs/binfmt_elf.c b/fs/binfmt_elf.c
index ba24cb2ff6ce..4482a0673b15 100644
--- a/fs/binfmt_elf.c
+++ b/fs/binfmt_elf.c
@@ -45,7 +45,7 @@
 
 static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs);
 static int load_elf_library(struct file *);
-static unsigned long elf_map (struct file *, unsigned long, struct elf_phdr *, int, int, unsigned long);
+static unsigned long elf_map (struct file *, unsigned long, struct elf_phdr *, int, int);
 
 /*
  * If we don't support core dumping, then supply a NULL so we
@@ -80,7 +80,7 @@ static struct linux_binfmt elf_format = {
                 .hasvdso        = 1
 };
 
-#define BAD_ADDR(x) IS_ERR_VALUE(x)
+#define BAD_ADDR(x) ((unsigned long)(x) >= TASK_SIZE)
 
 static int set_brk(unsigned long start, unsigned long end)
 {
@@ -295,70 +295,33 @@ create_elf_tables(struct linux_binprm *bprm, struct elfhdr *exec,
 #ifndef elf_map
 
 static unsigned long elf_map(struct file *filep, unsigned long addr,
-                struct elf_phdr *eppnt, int prot, int type,
-                unsigned long total_size)
+                struct elf_phdr *eppnt, int prot, int type)
 {
         unsigned long map_addr;
-        unsigned long size = eppnt->p_filesz + ELF_PAGEOFFSET(eppnt->p_vaddr);
-        unsigned long off = eppnt->p_offset - ELF_PAGEOFFSET(eppnt->p_vaddr);
-        addr = ELF_PAGESTART(addr);
-        size = ELF_PAGEALIGN(size);
+        unsigned long pageoffset = ELF_PAGEOFFSET(eppnt->p_vaddr);
 
+        down_write(&current->mm->mmap_sem);
         /* mmap() will return -EINVAL if given a zero size, but a
          * segment with zero filesize is perfectly valid */
-        if (!size)
-                return addr;
-
-        down_write(&current->mm->mmap_sem);
-        /*
-        * total_size is the size of the ELF (interpreter) image.
-        * The _first_ mmap needs to know the full size, otherwise
-        * randomization might put this image into an overlapping
-        * position with the ELF binary image. (since size < total_size)
-        * So we first map the 'big' image - and unmap the remainder at
-        * the end. (which unmap is needed for ELF images with holes.)
-        */
-        if (total_size) {
-                total_size = ELF_PAGEALIGN(total_size);
-                map_addr = do_mmap(filep, addr, total_size, prot, type, off);
-                if (!BAD_ADDR(map_addr))
-                        do_munmap(current->mm, map_addr+size, total_size-size);
-        } else
-                map_addr = do_mmap(filep, addr, size, prot, type, off);
-
+        if (eppnt->p_filesz + pageoffset)
+                map_addr = do_mmap(filep, ELF_PAGESTART(addr),
+                                   eppnt->p_filesz + pageoffset, prot, type,
+                                   eppnt->p_offset - pageoffset);
+        else
+                map_addr = ELF_PAGESTART(addr);
         up_write(&current->mm->mmap_sem);
         return(map_addr);
 }
 
 #endif /* !elf_map */
 
-static unsigned long total_mapping_size(struct elf_phdr *cmds, int nr)
-{
-        int i, first_idx = -1, last_idx = -1;
-
-        for (i = 0; i < nr; i++) {
-                if (cmds[i].p_type == PT_LOAD) {
-                        last_idx = i;
-                        if (first_idx == -1)
-                                first_idx = i;
-                }
-        }
-        if (first_idx == -1)
-                return 0;
-
-        return cmds[last_idx].p_vaddr + cmds[last_idx].p_memsz -
-                                ELF_PAGESTART(cmds[first_idx].p_vaddr);
-}
-
-
 /* This is much more generalized than the library routine read function,
    so we keep this separate.  Technically the library read function
    is only provided so that we can read a.out libraries that have
    an ELF header */
 
 static unsigned long load_elf_interp(struct elfhdr *interp_elf_ex,
-                struct file *interpreter, unsigned long *interp_map_addr,
-                unsigned long no_base)
+                struct file *interpreter, unsigned long *interp_load_addr)
 {
         struct elf_phdr *elf_phdata;
         struct elf_phdr *eppnt;
@@ -366,7 +329,6 @@ static unsigned long load_elf_interp(struct elfhdr *interp_elf_ex,
         int load_addr_set = 0;
         unsigned long last_bss = 0, elf_bss = 0;
         unsigned long error = ~0UL;
-        unsigned long total_size;
         int retval, i, size;
 
         /* First of all, some simple consistency checks */
@@ -405,12 +367,6 @@ static unsigned long load_elf_interp(struct elfhdr *interp_elf_ex,
                 goto out_close;
         }
 
-        total_size = total_mapping_size(elf_phdata, interp_elf_ex->e_phnum);
-        if (!total_size) {
-                error = -EINVAL;
-                goto out_close;
-        }
-
         eppnt = elf_phdata;
         for (i = 0; i < interp_elf_ex->e_phnum; i++, eppnt++) {
                 if (eppnt->p_type == PT_LOAD) {
@@ -428,14 +384,9 @@ static unsigned long load_elf_interp(struct elfhdr *interp_elf_ex,
                         vaddr = eppnt->p_vaddr;
                         if (interp_elf_ex->e_type == ET_EXEC || load_addr_set)
                                 elf_type |= MAP_FIXED;
-                        else if (no_base && interp_elf_ex->e_type == ET_DYN)
-                                load_addr = -vaddr;
 
                         map_addr = elf_map(interpreter, load_addr + vaddr,
-                                           eppnt, elf_prot, elf_type, total_size);
-                        total_size = 0;
-                        if (!*interp_map_addr)
-                                *interp_map_addr = map_addr;
+                                           eppnt, elf_prot, elf_type);
                         error = map_addr;
                         if (BAD_ADDR(map_addr))
                                 goto out_close;
@@ -501,7 +452,8 @@ static unsigned long load_elf_interp(struct elfhdr *interp_elf_ex,
                         goto out_close;
         }
 
-        error = load_addr;
+        *interp_load_addr = load_addr;
+        error = ((unsigned long)interp_elf_ex->e_entry) + load_addr;
 
 out_close:
         kfree(elf_phdata);
@@ -598,8 +550,7 @@ static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs)
         int elf_exec_fileno;
         int retval, i;
         unsigned int size;
-        unsigned long elf_entry;
-        unsigned long interp_load_addr = 0;
+        unsigned long elf_entry, interp_load_addr = 0;
         unsigned long start_code, end_code, start_data, end_data;
         unsigned long reloc_func_desc = 0;
         char passed_fileno[6];
@@ -863,7 +814,9 @@ static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs)
         current->mm->start_stack = bprm->p;
 
         /* Now we do a little grungy work by mmaping the ELF image into
-           the correct location in memory. */
+           the correct location in memory.  At this point, we assume that
+           the image should be loaded at fixed address, not at a variable
+           address. */
         for(i = 0, elf_ppnt = elf_phdata;
             i < loc->elf_ex.e_phnum; i++, elf_ppnt++) {
                 int elf_prot = 0, elf_flags;
@@ -917,15 +870,11 @@ static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs)
                          * default mmap base, as well as whatever program they
                          * might try to exec.  This is because the brk will
                          * follow the loader, and is not movable.  */
-#ifdef CONFIG_X86
-                        load_bias = 0;
-#else
                         load_bias = ELF_PAGESTART(ELF_ET_DYN_BASE - vaddr);
-#endif
                 }
 
                 error = elf_map(bprm->file, load_bias + vaddr, elf_ppnt,
-                                elf_prot, elf_flags,0);
+                                elf_prot, elf_flags);
                 if (BAD_ADDR(error)) {
                         send_sig(SIGKILL, current, 0);
                         retval = IS_ERR((void *)error) ?
@@ -1001,25 +950,13 @@ static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs)
         }
 
         if (elf_interpreter) {
-                if (interpreter_type == INTERPRETER_AOUT) {
+                if (interpreter_type == INTERPRETER_AOUT)
                         elf_entry = load_aout_interp(&loc->interp_ex,
                                                      interpreter);
-                } else {
-                        unsigned long uninitialized_var(interp_map_addr);
-
+                else
                         elf_entry = load_elf_interp(&loc->interp_elf_ex,
                                                     interpreter,
-                                                    &interp_map_addr,
-                                                    load_bias);
-                        if (!BAD_ADDR(elf_entry)) {
-                                /*
-                                 * load_elf_interp() returns relocation
-                                 * adjustment
-                                 */
-                                interp_load_addr = elf_entry;
-                                elf_entry += loc->interp_elf_ex.e_entry;
-                        }
-                }
+                                                    &interp_load_addr);
                 if (BAD_ADDR(elf_entry)) {
                         force_sig(SIGSEGV, current);
                         retval = IS_ERR((void *)elf_entry) ?
diff --git a/fs/coda/dir.c b/fs/coda/dir.c
index 8e61236abf4a..f89ff083079b 100644
--- a/fs/coda/dir.c
+++ b/fs/coda/dir.c
@@ -86,7 +86,6 @@ const struct file_operations coda_dir_operations = {
         .read           = generic_read_dir,
         .readdir        = coda_readdir,
         .open           = coda_open,
-        .flush          = coda_flush,
         .release        = coda_release,
         .fsync          = coda_fsync,
 };
diff --git a/fs/coda/file.c b/fs/coda/file.c
index 7594962604c2..29137ff3ca67 100644
--- a/fs/coda/file.c
+++ b/fs/coda/file.c
@@ -25,10 +25,6 @@
 
 #include "coda_int.h"
 
-/* if CODA_STORE fails with EOPNOTSUPP, venus clearly doesn't support
- * CODA_STORE/CODA_RELEASE and we fall back on using the CODA_CLOSE upcall */
-static int use_coda_close;
-
 static ssize_t
 coda_file_read(struct file *coda_file, char __user *buf, size_t count, loff_t *ppos)
 {
@@ -163,47 +159,6 @@ int coda_open(struct inode *coda_inode, struct file *coda_file)
         return 0;
 }
 
-int coda_flush(struct file *coda_file, fl_owner_t id)
-{
-        unsigned short flags = coda_file->f_flags & ~O_EXCL;
-        unsigned short coda_flags = coda_flags_to_cflags(flags);
-        struct coda_file_info *cfi;
-        struct inode *coda_inode;
-        int err = 0, fcnt;
-
-        lock_kernel();
-
-        /* last close semantics */
-        fcnt = file_count(coda_file);
-        if (fcnt > 1)
-                goto out;
-
-        /* No need to make an upcall when we have not made any modifications
-         * to the file */
-        if ((coda_file->f_flags & O_ACCMODE) == O_RDONLY)
-                goto out;
-
-        if (use_coda_close)
-                goto out;
-
-        cfi = CODA_FTOC(coda_file);
-        BUG_ON(!cfi || cfi->cfi_magic != CODA_MAGIC);
-
-        coda_inode = coda_file->f_path.dentry->d_inode;
-
-        err = venus_store(coda_inode->i_sb, coda_i2f(coda_inode), coda_flags,
-                          coda_file->f_uid);
-
-        if (err == -EOPNOTSUPP) {
-                use_coda_close = 1;
-                err = 0;
-        }
-
-out:
-        unlock_kernel();
-        return err;
-}
-
 int coda_release(struct inode *coda_inode, struct file *coda_file)
 {
         unsigned short flags = (coda_file->f_flags) & (~O_EXCL);
@@ -215,21 +170,11 @@ int coda_release(struct inode *coda_inode, struct file *coda_file)
 
         lock_kernel();
 
-        if (!use_coda_close) {
-                err = venus_release(coda_inode->i_sb, coda_i2f(coda_inode),
-                                    coda_flags);
-                if (err == -EOPNOTSUPP) {
-                        use_coda_close = 1;
-                        err = 0;
-                }
-        }
-
         cfi = CODA_FTOC(coda_file);
         BUG_ON(!cfi || cfi->cfi_magic != CODA_MAGIC);
 
-        if (use_coda_close)
-                err = venus_close(coda_inode->i_sb, coda_i2f(coda_inode),
-                                  coda_flags, coda_file->f_uid);
+        err = venus_close(coda_inode->i_sb, coda_i2f(coda_inode),
+                          coda_flags, coda_file->f_uid);
 
         host_inode = cfi->cfi_container->f_path.dentry->d_inode;
         cii = ITOC(coda_inode);
@@ -246,7 +191,10 @@ int coda_release(struct inode *coda_inode, struct file *coda_file)
         coda_file->private_data = NULL;
 
         unlock_kernel();
-        return err;
+
+        /* VFS fput ignores the return value from file_operations->release, so
+         * there is no use returning an error here */
+        return 0;
 }
 
 int coda_fsync(struct file *coda_file, struct dentry *coda_dentry, int datasync)
@@ -288,7 +236,6 @@ const struct file_operations coda_file_operations = {
         .write          = coda_file_write,
         .mmap           = coda_file_mmap,
         .open           = coda_open,
-        .flush          = coda_flush,
         .release        = coda_release,
         .fsync          = coda_fsync,
         .splice_read    = coda_file_splice_read,
diff --git a/fs/coda/upcall.c b/fs/coda/upcall.c
index cd561d2e90b0..cdb4c07a7870 100644
--- a/fs/coda/upcall.c
+++ b/fs/coda/upcall.c
@@ -160,55 +160,8 @@ int venus_lookup(struct super_block *sb, struct CodaFid *fid,
         return error;
 }
 
-int venus_store(struct super_block *sb, struct CodaFid *fid, int flags,
-                vuid_t uid)
-{
-        union inputArgs *inp;
-        union outputArgs *outp;
-        int insize, outsize, error;
-#ifdef CONFIG_CODA_FS_OLD_API
-        struct coda_cred cred = { 0, };
-        cred.cr_fsuid = uid;
-#endif
-        
-        insize = SIZE(store);
-        UPARG(CODA_STORE);
-        
-#ifdef CONFIG_CODA_FS_OLD_API
-        memcpy(&(inp->ih.cred), &cred, sizeof(cred));
-#else
-        inp->ih.uid = uid;
-#endif
-        
-        inp->coda_store.VFid = *fid;
-        inp->coda_store.flags = flags;
-
-        error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
-
-        CODA_FREE(inp, insize);
-        return error;
-}
-
-int venus_release(struct super_block *sb, struct CodaFid *fid, int flags)
-{
-        union inputArgs *inp;
-        union outputArgs *outp;
-        int insize, outsize, error;
-        
-        insize = SIZE(release);
-        UPARG(CODA_RELEASE);
-        
-        inp->coda_release.VFid = *fid;
-        inp->coda_release.flags = flags;
-
-        error = coda_upcall(coda_vcp(sb), insize, &outsize, inp);
-
-        CODA_FREE(inp, insize);
-        return error;
-}
-
 int venus_close(struct super_block *sb, struct CodaFid *fid, int flags,
-                vuid_t uid)
+                vuid_t uid)
 {
         union inputArgs *inp;
         union outputArgs *outp;
diff --git a/fs/nfsd/export.c b/fs/nfsd/export.c
index 6ab8de40904c..2d295dda4c1d 100644
--- a/fs/nfsd/export.c
+++ b/fs/nfsd/export.c
@@ -1503,9 +1503,9 @@ static void exp_flags(struct seq_file *m, int flag, int fsid,
         if (flag & NFSEXP_FSID)
                 seq_printf(m, ",fsid=%d", fsid);
         if (anonu != (uid_t)-2 && anonu != (0x10000-2))
-                seq_printf(m, ",sanonuid=%d", anonu);
+                seq_printf(m, ",anonuid=%u", anonu);
         if (anong != (gid_t)-2 && anong != (0x10000-2))
-                seq_printf(m, ",sanongid=%d", anong);
+                seq_printf(m, ",anongid=%u", anong);
         if (fsloc && fsloc->locations_count > 0) {
                 char *loctype = (fsloc->migrated) ? "refer" : "replicas";
                 int i;
diff --git a/fs/proc/proc_misc.c b/fs/proc/proc_misc.c
index f133afebed7a..bee251cb87c8 100644
--- a/fs/proc/proc_misc.c
+++ b/fs/proc/proc_misc.c
@@ -507,7 +507,8 @@ static int show_stat(struct seq_file *p, void *v)
         }
         seq_printf(p, "intr %llu", (unsigned long long)sum);
 
-#if !defined(CONFIG_PPC64) && !defined(CONFIG_ALPHA) && !defined(CONFIG_IA64)
+#ifndef CONFIG_SMP
+        /* Touches too many cache lines on SMP setups */
         for (i = 0; i < NR_IRQS; i++)
                 seq_printf(p, " %u", per_irq_sum[i]);
 #endif
diff --git a/fs/udf/balloc.c b/fs/udf/balloc.c
index ef48d094dd2b..276f7207a564 100644
--- a/fs/udf/balloc.c
+++ b/fs/udf/balloc.c
@@ -70,9 +70,9 @@ static inline int find_next_one_bit(void *addr, int size, int offset)
         if (!size)
                 return result;
         tmp = leBPL_to_cpup(p);
-      found_first:
+found_first:
         tmp &= ~0UL >> (BITS_PER_LONG - size);
-      found_middle:
+found_middle:
         return result + ffz(~tmp);
 }
 
@@ -110,11 +110,11 @@ static int __load_block_bitmap(struct super_block *sb,
                           nr_groups);
         }
 
-        if (bitmap->s_block_bitmap[block_group])
+        if (bitmap->s_block_bitmap[block_group]) {
                 return block_group;
-        else {
-                retval =
-                    read_block_bitmap(sb, bitmap, block_group, block_group);
+        } else {
+                retval = read_block_bitmap(sb, bitmap, block_group,
+                                           block_group);
                 if (retval < 0)
                         return retval;
                 return block_group;
@@ -155,22 +155,16 @@ static void udf_bitmap_free_blocks(struct super_block *sb,
 
         mutex_lock(&sbi->s_alloc_mutex);
         if (bloc.logicalBlockNum < 0 ||
-            (bloc.logicalBlockNum + count) > UDF_SB_PARTLEN(sb,
-                                                            bloc.
-                                                            partitionReferenceNum))
-        {
-                udf_debug("%d < %d || %d + %d > %d\n", bloc.logicalBlockNum, 0,
-                          bloc.logicalBlockNum, count, UDF_SB_PARTLEN(sb,
-                                                                      bloc.
-                                                                      partitionReferenceNum));
+            (bloc.logicalBlockNum + count) > UDF_SB_PARTLEN(sb, bloc.partitionReferenceNum)) {
+                udf_debug("%d < %d || %d + %d > %d\n",
+                          bloc.logicalBlockNum, 0, bloc.logicalBlockNum, count,
+                          UDF_SB_PARTLEN(sb, bloc.partitionReferenceNum));
                 goto error_return;
         }
 
-        block =
-            bloc.logicalBlockNum + offset +
-            (sizeof(struct spaceBitmapDesc) << 3);
+        block = bloc.logicalBlockNum + offset + (sizeof(struct spaceBitmapDesc) << 3);
 
-      do_more:
+do_more:
         overflow = 0;
         block_group = block >> (sb->s_blocksize_bits + 3);
         bit = block % (sb->s_blocksize << 3);
@@ -190,18 +184,13 @@ static void udf_bitmap_free_blocks(struct super_block *sb,
         for (i = 0; i < count; i++) {
                 if (udf_set_bit(bit + i, bh->b_data)) {
                         udf_debug("bit %ld already set\n", bit + i);
-                        udf_debug("byte=%2x\n",
-                                  ((char *)bh->b_data)[(bit + i) >> 3]);
+                        udf_debug("byte=%2x\n", ((char *)bh->b_data)[(bit + i) >> 3]);
                 } else {
                         if (inode)
                                 DQUOT_FREE_BLOCK(inode, 1);
                         if (UDF_SB_LVIDBH(sb)) {
-                                UDF_SB_LVID(sb)->
-                                    freeSpaceTable[UDF_SB_PARTITION(sb)] =
-                                    cpu_to_le32(le32_to_cpu
-                                                (UDF_SB_LVID(sb)->
-                                                 freeSpaceTable[UDF_SB_PARTITION
-                                                                (sb)]) + 1);
+                                UDF_SB_LVID(sb)->freeSpaceTable[UDF_SB_PARTITION(sb)] =
+                                        cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[UDF_SB_PARTITION(sb)]) + 1);
                         }
                 }
         }
@@ -211,7 +200,7 @@ static void udf_bitmap_free_blocks(struct super_block *sb,
                 count = overflow;
                 goto do_more;
         }
-      error_return:
+error_return:
         sb->s_dirt = 1;
         if (UDF_SB_LVIDBH(sb))
                 mark_buffer_dirty(UDF_SB_LVIDBH(sb));
@@ -238,7 +227,7 @@ static int udf_bitmap_prealloc_blocks(struct super_block *sb,
         if (first_block + block_count > UDF_SB_PARTLEN(sb, partition))
                 block_count = UDF_SB_PARTLEN(sb, partition) - first_block;
 
-      repeat:
+repeat:
         nr_groups = (UDF_SB_PARTLEN(sb, partition) +
                      (sizeof(struct spaceBitmapDesc) << 3) +
                      (sb->s_blocksize * 8) - 1) / (sb->s_blocksize * 8);
@@ -254,11 +243,11 @@ static int udf_bitmap_prealloc_blocks(struct super_block *sb,
         bit = block % (sb->s_blocksize << 3);
 
         while (bit < (sb->s_blocksize << 3) && block_count > 0) {
-                if (!udf_test_bit(bit, bh->b_data))
+                if (!udf_test_bit(bit, bh->b_data)) {
                         goto out;
-                else if (DQUOT_PREALLOC_BLOCK(inode, 1))
+                } else if (DQUOT_PREALLOC_BLOCK(inode, 1)) {
                         goto out;
-                else if (!udf_clear_bit(bit, bh->b_data)) {
+                } else if (!udf_clear_bit(bit, bh->b_data)) {
                         udf_debug("bit already cleared for block %d\n", bit);
                         DQUOT_FREE_BLOCK(inode, 1);
                         goto out;
@@ -271,12 +260,10 @@ static int udf_bitmap_prealloc_blocks(struct super_block *sb,
         mark_buffer_dirty(bh);
         if (block_count > 0)
                 goto repeat;
-      out:
+out:
         if (UDF_SB_LVIDBH(sb)) {
                 UDF_SB_LVID(sb)->freeSpaceTable[partition] =
-                    cpu_to_le32(le32_to_cpu
-                                (UDF_SB_LVID(sb)->freeSpaceTable[partition]) -
-                                alloc_count);
+                        cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[partition]) - alloc_count);
                 mark_buffer_dirty(UDF_SB_LVIDBH(sb));
         }
         sb->s_dirt = 1;
@@ -299,7 +286,7 @@ static int udf_bitmap_new_block(struct super_block *sb,
         *err = -ENOSPC;
         mutex_lock(&sbi->s_alloc_mutex);
 
-      repeat:
+repeat:
         if (goal < 0 || goal >= UDF_SB_PARTLEN(sb, partition))
                 goal = 0;
 
@@ -312,31 +299,27 @@ static int udf_bitmap_new_block(struct super_block *sb,
         if (bitmap_nr < 0)
                 goto error_return;
         bh = bitmap->s_block_bitmap[bitmap_nr];
-        ptr =
-            memscan((char *)bh->b_data + group_start, 0xFF,
-                    sb->s_blocksize - group_start);
+        ptr = memscan((char *)bh->b_data + group_start, 0xFF,
+                      sb->s_blocksize - group_start);
 
         if ((ptr - ((char *)bh->b_data)) < sb->s_blocksize) {
                 bit = block % (sb->s_blocksize << 3);
-
-                if (udf_test_bit(bit, bh->b_data)) {
+                if (udf_test_bit(bit, bh->b_data))
                         goto got_block;
-                }
+
                 end_goal = (bit + 63) & ~63;
                 bit = udf_find_next_one_bit(bh->b_data, end_goal, bit);
                 if (bit < end_goal)
                         goto got_block;
-                ptr =
-                    memscan((char *)bh->b_data + (bit >> 3), 0xFF,
-                            sb->s_blocksize - ((bit + 7) >> 3));
+
+                ptr = memscan((char *)bh->b_data + (bit >> 3), 0xFF, sb->s_blocksize - ((bit + 7) >> 3));
                 newbit = (ptr - ((char *)bh->b_data)) << 3;
                 if (newbit < sb->s_blocksize << 3) {
                         bit = newbit;
                         goto search_back;
                 }
-                newbit =
-                    udf_find_next_one_bit(bh->b_data, sb->s_blocksize << 3,
-                                          bit);
+
+                newbit = udf_find_next_one_bit(bh->b_data, sb->s_blocksize << 3, bit);
                 if (newbit < sb->s_blocksize << 3) {
                         bit = newbit;
                         goto got_block;
@@ -354,18 +337,16 @@ static int udf_bitmap_new_block(struct super_block *sb,
                         goto error_return;
                 bh = bitmap->s_block_bitmap[bitmap_nr];
                 if (i < nr_groups) {
-                        ptr =
-                            memscan((char *)bh->b_data + group_start, 0xFF,
-                                    sb->s_blocksize - group_start);
+                        ptr = memscan((char *)bh->b_data + group_start, 0xFF,
+                                      sb->s_blocksize - group_start);
                         if ((ptr - ((char *)bh->b_data)) < sb->s_blocksize) {
                                 bit = (ptr - ((char *)bh->b_data)) << 3;
                                 break;
                         }
                 } else {
-                        bit =
-                            udf_find_next_one_bit((char *)bh->b_data,
-                                                  sb->s_blocksize << 3,
-                                                  group_start << 3);
+                        bit = udf_find_next_one_bit((char *)bh->b_data,
+                                                    sb->s_blocksize << 3,
+                                                    group_start << 3);
                         if (bit < sb->s_blocksize << 3)
                                 break;
                 }
@@ -377,20 +358,17 @@ static int udf_bitmap_new_block(struct super_block *sb,
         if (bit < sb->s_blocksize << 3)
                 goto search_back;
         else
-                bit =
-                    udf_find_next_one_bit(bh->b_data, sb->s_blocksize << 3,
-                                          group_start << 3);
+                bit = udf_find_next_one_bit(bh->b_data, sb->s_blocksize << 3, group_start << 3);
         if (bit >= sb->s_blocksize << 3) {
                 mutex_unlock(&sbi->s_alloc_mutex);
                 return 0;
         }
 
-      search_back:
-        for (i = 0;
-             i < 7 && bit > (group_start << 3)
-             && udf_test_bit(bit - 1, bh->b_data); i++, bit--) ;
+search_back:
+        for (i = 0; i < 7 && bit > (group_start << 3) && udf_test_bit(bit - 1, bh->b_data); i++, bit--)
+                ; /* empty loop */
 
-      got_block:
+got_block:
 
         /*
          * Check quota for allocation of this block.
@@ -402,7 +380,7 @@ static int udf_bitmap_new_block(struct super_block *sb,
         }
 
         newblock = bit + (block_group << (sb->s_blocksize_bits + 3)) -
-            (sizeof(struct spaceBitmapDesc) << 3);
+                (sizeof(struct spaceBitmapDesc) << 3);
 
         if (!udf_clear_bit(bit, bh->b_data)) {
                 udf_debug("bit already cleared for block %d\n", bit);
@@ -413,9 +391,7 @@ static int udf_bitmap_new_block(struct super_block *sb,
 
         if (UDF_SB_LVIDBH(sb)) {
                 UDF_SB_LVID(sb)->freeSpaceTable[partition] =
-                    cpu_to_le32(le32_to_cpu
-                                (UDF_SB_LVID(sb)->freeSpaceTable[partition]) -
-                                1);
+                        cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[partition]) - 1);
                 mark_buffer_dirty(UDF_SB_LVIDBH(sb));
         }
         sb->s_dirt = 1;
@@ -423,7 +399,7 @@ static int udf_bitmap_new_block(struct super_block *sb,
         *err = 0;
         return newblock;
 
-      error_return:
+error_return:
         *err = -EIO;
         mutex_unlock(&sbi->s_alloc_mutex);
         return 0;
@@ -445,14 +421,10 @@ static void udf_table_free_blocks(struct super_block *sb,
 
         mutex_lock(&sbi->s_alloc_mutex);
         if (bloc.logicalBlockNum < 0 ||
-            (bloc.logicalBlockNum + count) > UDF_SB_PARTLEN(sb,
-                                                            bloc.
-                                                            partitionReferenceNum))
-        {
-                udf_debug("%d < %d || %d + %d > %d\n", bloc.logicalBlockNum, 0,
-                          bloc.logicalBlockNum, count, UDF_SB_PARTLEN(sb,
-                                                                      bloc.
-                                                                      partitionReferenceNum));
+            (bloc.logicalBlockNum + count) > UDF_SB_PARTLEN(sb, bloc.partitionReferenceNum)) {
+                udf_debug("%d < %d || %d + %d > %d\n",
+                          bloc.logicalBlockNum, 0, bloc.logicalBlockNum, count,
+                          UDF_SB_PARTLEN(sb, bloc.partitionReferenceNum));
                 goto error_return;
         }
 
@@ -462,9 +434,7 @@ static void udf_table_free_blocks(struct super_block *sb,
                 DQUOT_FREE_BLOCK(inode, count);
         if (UDF_SB_LVIDBH(sb)) {
                 UDF_SB_LVID(sb)->freeSpaceTable[UDF_SB_PARTITION(sb)] =
-                    cpu_to_le32(le32_to_cpu
-                                (UDF_SB_LVID(sb)->
-                                 freeSpaceTable[UDF_SB_PARTITION(sb)]) + count);
+                        cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[UDF_SB_PARTITION(sb)]) + count);
                 mark_buffer_dirty(UDF_SB_LVIDBH(sb));
         }
 
@@ -476,47 +446,28 @@ static void udf_table_free_blocks(struct super_block *sb,
         epos.block = oepos.block = UDF_I_LOCATION(table);
         epos.bh = oepos.bh = NULL;
 
-        while (count && (etype =
-                         udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) {
-                if (((eloc.logicalBlockNum + (elen >> sb->s_blocksize_bits)) ==
-                     start)) {
-                        if ((0x3FFFFFFF - elen) <
-                            (count << sb->s_blocksize_bits)) {
-                                count -=
-                                    ((0x3FFFFFFF -
-                                      elen) >> sb->s_blocksize_bits);
-                                start +=
-                                    ((0x3FFFFFFF -
-                                      elen) >> sb->s_blocksize_bits);
-                                elen =
-                                    (etype << 30) | (0x40000000 -
-                                                     sb->s_blocksize);
+        while (count &&
+               (etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) {
+                if (((eloc.logicalBlockNum + (elen >> sb->s_blocksize_bits)) == start)) {
+                        if ((0x3FFFFFFF - elen) < (count << sb->s_blocksize_bits)) {
+                                count -= ((0x3FFFFFFF - elen) >> sb->s_blocksize_bits);
+                                start += ((0x3FFFFFFF - elen) >> sb->s_blocksize_bits);
+                                elen = (etype << 30) | (0x40000000 - sb->s_blocksize);
                         } else {
-                                elen = (etype << 30) |
-                                    (elen + (count << sb->s_blocksize_bits));
+                                elen = (etype << 30) | (elen + (count << sb->s_blocksize_bits));
                                 start += count;
                                 count = 0;
                         }
                         udf_write_aext(table, &oepos, eloc, elen, 1);
                 } else if (eloc.logicalBlockNum == (end + 1)) {
-                        if ((0x3FFFFFFF - elen) <
-                            (count << sb->s_blocksize_bits)) {
-                                count -=
-                                    ((0x3FFFFFFF -
-                                      elen) >> sb->s_blocksize_bits);
-                                end -=
-                                    ((0x3FFFFFFF -
-                                      elen) >> sb->s_blocksize_bits);
-                                eloc.logicalBlockNum -=
-                                    ((0x3FFFFFFF -
-                                      elen) >> sb->s_blocksize_bits);
-                                elen =
-                                    (etype << 30) | (0x40000000 -
-                                                     sb->s_blocksize);
+                        if ((0x3FFFFFFF - elen) < (count << sb->s_blocksize_bits)) {
+                                count -= ((0x3FFFFFFF - elen) >> sb->s_blocksize_bits);
+                                end -= ((0x3FFFFFFF - elen) >> sb->s_blocksize_bits);
+                                eloc.logicalBlockNum -= ((0x3FFFFFFF - elen) >> sb->s_blocksize_bits);
+                                elen = (etype << 30) | (0x40000000 - sb->s_blocksize);
                         } else {
                                 eloc.logicalBlockNum = start;
-                                elen = (etype << 30) |
-                                    (elen + (count << sb->s_blocksize_bits));
+                                elen = (etype << 30) | (elen + (count << sb->s_blocksize_bits));
                                 end -= count;
                                 count = 0;
                         }
@@ -530,21 +481,23 @@ static void udf_table_free_blocks(struct super_block *sb,
                         get_bh(epos.bh);
                         oepos.bh = epos.bh;
                         oepos.offset = 0;
-                } else
+                } else {
                         oepos.offset = epos.offset;
+                }
         }
 
         if (count) {
-                /* NOTE: we CANNOT use udf_add_aext here, as it can try to allocate
-                   a new block, and since we hold the super block lock already
-                   very bad things would happen :)
-
-                   We copy the behavior of udf_add_aext, but instead of
-                   trying to allocate a new block close to the existing one,
-                   we just steal a block from the extent we are trying to add.
-
-                   It would be nice if the blocks were close together, but it
-                   isn't required.
+                /*
+                 * NOTE: we CANNOT use udf_add_aext here, as it can try to allocate
+                 * a new block, and since we hold the super block lock already
+                 * very bad things would happen :)
+                 *
+                 * We copy the behavior of udf_add_aext, but instead of
+                 * trying to allocate a new block close to the existing one,
+                 * we just steal a block from the extent we are trying to add.
+                 *
+                 * It would be nice if the blocks were close together, but it
+                 * isn't required.
                  */
 
                 int adsize;
@@ -553,13 +506,14 @@ static void udf_table_free_blocks(struct super_block *sb,
                 struct allocExtDesc *aed;
 
                 eloc.logicalBlockNum = start;
-                elen = EXT_RECORDED_ALLOCATED | (count << sb->s_blocksize_bits);
+                elen = EXT_RECORDED_ALLOCATED |
+                        (count << sb->s_blocksize_bits);
 
-                if (UDF_I_ALLOCTYPE(table) == ICBTAG_FLAG_AD_SHORT)
+                if (UDF_I_ALLOCTYPE(table) == ICBTAG_FLAG_AD_SHORT) {
                         adsize = sizeof(short_ad);
-                else if (UDF_I_ALLOCTYPE(table) == ICBTAG_FLAG_AD_LONG)
+                } else if (UDF_I_ALLOCTYPE(table) == ICBTAG_FLAG_AD_LONG) {
                         adsize = sizeof(long_ad);
-                else {
+                } else {
                         brelse(oepos.bh);
                         brelse(epos.bh);
                         goto error_return;
@@ -577,28 +531,21 @@ static void udf_table_free_blocks(struct super_block *sb,
                         eloc.logicalBlockNum++;
                         elen -= sb->s_blocksize;
 
-                        if (!(epos.bh = udf_tread(sb,
-                                                  udf_get_lb_pblock(sb,
-                                                                    epos.block,
-                                                                    0)))) {
+                        if (!(epos.bh = udf_tread(sb, udf_get_lb_pblock(sb, epos.block, 0)))) {
                                 brelse(oepos.bh);
                                 goto error_return;
                         }
                         aed = (struct allocExtDesc *)(epos.bh->b_data);
-                        aed->previousAllocExtLocation =
-                            cpu_to_le32(oepos.block.logicalBlockNum);
+                        aed->previousAllocExtLocation = cpu_to_le32(oepos.block.logicalBlockNum);
                         if (epos.offset + adsize > sb->s_blocksize) {
                                 loffset = epos.offset;
                                 aed->lengthAllocDescs = cpu_to_le32(adsize);
                                 sptr = UDF_I_DATA(inode) + epos.offset -
-                                    udf_file_entry_alloc_offset(inode) +
-                                    UDF_I_LENEATTR(inode) - adsize;
-                                dptr =
-                                    epos.bh->b_data +
-                                    sizeof(struct allocExtDesc);
+                                        udf_file_entry_alloc_offset(inode) +
+                                        UDF_I_LENEATTR(inode) - adsize;
+                                dptr = epos.bh->b_data + sizeof(struct allocExtDesc);
                                 memcpy(dptr, sptr, adsize);
-                                epos.offset =
-                                    sizeof(struct allocExtDesc) + adsize;
+                                epos.offset = sizeof(struct allocExtDesc) + adsize;
                         } else {
                                 loffset = epos.offset + adsize;
                                 aed->lengthAllocDescs = cpu_to_le32(0);
@@ -606,60 +553,46 @@ static void udf_table_free_blocks(struct super_block *sb,
                                 epos.offset = sizeof(struct allocExtDesc);
 
                                 if (oepos.bh) {
-                                        aed =
-                                            (struct allocExtDesc *)oepos.bh->
-                                            b_data;
+                                        aed = (struct allocExtDesc *)oepos.bh->b_data;
                                         aed->lengthAllocDescs =
-                                            cpu_to_le32(le32_to_cpu
-                                                        (aed->
-                                                         lengthAllocDescs) +
-                                                        adsize);
+                                                cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize);
                                 } else {
                                         UDF_I_LENALLOC(table) += adsize;
                                         mark_inode_dirty(table);
                                 }
                         }
                         if (UDF_SB_UDFREV(sb) >= 0x0200)
-                                udf_new_tag(epos.bh->b_data, TAG_IDENT_AED, 3,
-                                            1, epos.block.logicalBlockNum,
-                                            sizeof(tag));
+                                udf_new_tag(epos.bh->b_data, TAG_IDENT_AED, 3, 1,
+                                            epos.block.logicalBlockNum, sizeof(tag));
                         else
-                                udf_new_tag(epos.bh->b_data, TAG_IDENT_AED, 2,
-                                            1, epos.block.logicalBlockNum,
-                                            sizeof(tag));
+                                udf_new_tag(epos.bh->b_data, TAG_IDENT_AED, 2, 1,
+                                            epos.block.logicalBlockNum, sizeof(tag));
+
                         switch (UDF_I_ALLOCTYPE(table)) {
-                        case ICBTAG_FLAG_AD_SHORT:
-                                {
-                                        sad = (short_ad *) sptr;
-                                        sad->extLength =
-                                            cpu_to_le32
-                                            (EXT_NEXT_EXTENT_ALLOCDECS | sb->
-                                             s_blocksize);
-                                        sad->extPosition =
-                                            cpu_to_le32(epos.block.
-                                                        logicalBlockNum);
+                                case ICBTAG_FLAG_AD_SHORT:
+                                        sad = (short_ad *)sptr;
+                                        sad->extLength = cpu_to_le32(
+                                                EXT_NEXT_EXTENT_ALLOCDECS |
+                                                sb->s_blocksize);
+                                        sad->extPosition = cpu_to_le32(epos.block.logicalBlockNum);
                                         break;
-                                }
-                        case ICBTAG_FLAG_AD_LONG:
-                                {
-                                        lad = (long_ad *) sptr;
-                                        lad->extLength =
-                                            cpu_to_le32
-                                            (EXT_NEXT_EXTENT_ALLOCDECS | sb->
-                                             s_blocksize);
-                                        lad->extLocation =
-                                            cpu_to_lelb(epos.block);
+                                case ICBTAG_FLAG_AD_LONG:
+                                        lad = (long_ad *)sptr;
+                                        lad->extLength = cpu_to_le32(
+                                                EXT_NEXT_EXTENT_ALLOCDECS |
+                                                sb->s_blocksize);
+                                        lad->extLocation = cpu_to_lelb(epos.block);
                                         break;
-                                }
                         }
                         if (oepos.bh) {
                                 udf_update_tag(oepos.bh->b_data, loffset);
                                 mark_buffer_dirty(oepos.bh);
-                        } else
+                        } else {
                                 mark_inode_dirty(table);
+                        }
                 }
 
-                if (elen) {     /* It's possible that stealing the block emptied the extent */
+                if (elen) { /* It's possible that stealing the block emptied the extent */
                         udf_write_aext(table, &epos, eloc, elen, 1);
 
                         if (!epos.bh) {
@@ -668,9 +601,7 @@ static void udf_table_free_blocks(struct super_block *sb,
                         } else {
                                 aed = (struct allocExtDesc *)epos.bh->b_data;
                                 aed->lengthAllocDescs =
-                                    cpu_to_le32(le32_to_cpu
-                                                (aed->lengthAllocDescs) +
-                                                adsize);
+                                        cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize);
                                 udf_update_tag(epos.bh->b_data, epos.offset);
                                 mark_buffer_dirty(epos.bh);
                         }
@@ -680,7 +611,7 @@ static void udf_table_free_blocks(struct super_block *sb,
         brelse(epos.bh);
         brelse(oepos.bh);
 
-      error_return:
+error_return:
         sb->s_dirt = 1;
         mutex_unlock(&sbi->s_alloc_mutex);
         return;
@@ -714,47 +645,36 @@ static int udf_table_prealloc_blocks(struct super_block *sb,
         epos.bh = NULL;
         eloc.logicalBlockNum = 0xFFFFFFFF;
 
-        while (first_block != eloc.logicalBlockNum && (etype =
-                                                       udf_next_aext(table,
-                                                                     &epos,
-                                                                     &eloc,
-                                                                     &elen,
-                                                                     1)) !=
-               -1) {
+        while (first_block != eloc.logicalBlockNum &&
+               (etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) {
                 udf_debug("eloc=%d, elen=%d, first_block=%d\n",
                           eloc.logicalBlockNum, elen, first_block);
-                ;               /* empty loop body */
+                ; /* empty loop body */
         }
 
         if (first_block == eloc.logicalBlockNum) {
                 epos.offset -= adsize;
 
                 alloc_count = (elen >> sb->s_blocksize_bits);
-                if (inode
-                    && DQUOT_PREALLOC_BLOCK(inode,
-                                            alloc_count >
-                                            block_count ? block_count :
-                                            alloc_count))
+                if (inode && DQUOT_PREALLOC_BLOCK(inode, alloc_count > block_count ? block_count : alloc_count)) {
                         alloc_count = 0;
-                else if (alloc_count > block_count) {
+                } else if (alloc_count > block_count) {
                         alloc_count = block_count;
                         eloc.logicalBlockNum += alloc_count;
                         elen -= (alloc_count << sb->s_blocksize_bits);
-                        udf_write_aext(table, &epos, eloc, (etype << 30) | elen,
-                                       1);
-                } else
-                        udf_delete_aext(table, epos, eloc,
-                                        (etype << 30) | elen);
-        } else
+                        udf_write_aext(table, &epos, eloc, (etype << 30) | elen, 1);
+                } else {
+                        udf_delete_aext(table, epos, eloc, (etype << 30) | elen);
+                }
+        } else {
                 alloc_count = 0;
+        }
 
         brelse(epos.bh);
 
         if (alloc_count && UDF_SB_LVIDBH(sb)) {
                 UDF_SB_LVID(sb)->freeSpaceTable[partition] =
-                    cpu_to_le32(le32_to_cpu
-                                (UDF_SB_LVID(sb)->freeSpaceTable[partition]) -
-                                alloc_count);
+                        cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[partition]) - alloc_count);
                 mark_buffer_dirty(UDF_SB_LVIDBH(sb));
                 sb->s_dirt = 1;
         }
@@ -797,18 +717,17 @@ static int udf_table_new_block(struct super_block *sb,
         epos.block = UDF_I_LOCATION(table);
         epos.bh = goal_epos.bh = NULL;
 
-        while (spread && (etype =
-                          udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) {
+        while (spread &&
+               (etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) {
                 if (goal >= eloc.logicalBlockNum) {
-                        if (goal <
-                            eloc.logicalBlockNum +
-                            (elen >> sb->s_blocksize_bits))
+                        if (goal < eloc.logicalBlockNum + (elen >> sb->s_blocksize_bits))
                                 nspread = 0;
                         else
                                 nspread = goal - eloc.logicalBlockNum -
-                                    (elen >> sb->s_blocksize_bits);
-                } else
+                                        (elen >> sb->s_blocksize_bits);
+                } else {
                         nspread = eloc.logicalBlockNum - goal;
+                }
 
                 if (nspread < spread) {
                         spread = nspread;
@@ -856,9 +775,7 @@ static int udf_table_new_block(struct super_block *sb,
 
         if (UDF_SB_LVIDBH(sb)) {
                 UDF_SB_LVID(sb)->freeSpaceTable[partition] =
-                    cpu_to_le32(le32_to_cpu
-                                (UDF_SB_LVID(sb)->freeSpaceTable[partition]) -
-                                1);
+                        cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[partition]) - 1);
                 mark_buffer_dirty(UDF_SB_LVIDBH(sb));
         }
 
@@ -877,27 +794,23 @@ inline void udf_free_blocks(struct super_block *sb,
 
         if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_BITMAP) {
                 return udf_bitmap_free_blocks(sb, inode,
-                                              UDF_SB_PARTMAPS(sb)[partition].
-                                              s_uspace.s_bitmap, bloc, offset,
-                                              count);
-        } else if (UDF_SB_PARTFLAGS(sb, partition) &
-                   UDF_PART_FLAG_UNALLOC_TABLE) {
+                                              UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_bitmap,
+                                              bloc, offset, count);
+        } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_TABLE) {
                 return udf_table_free_blocks(sb, inode,
-                                             UDF_SB_PARTMAPS(sb)[partition].
-                                             s_uspace.s_table, bloc, offset,
-                                             count);
+                                             UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_table,
+                                             bloc, offset, count);
         } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_BITMAP) {
                 return udf_bitmap_free_blocks(sb, inode,
-                                              UDF_SB_PARTMAPS(sb)[partition].
-                                              s_fspace.s_bitmap, bloc, offset,
-                                              count);
+                                              UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_bitmap,
+                                              bloc, offset, count);
         } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_TABLE) {
                 return udf_table_free_blocks(sb, inode,
-                                             UDF_SB_PARTMAPS(sb)[partition].
-                                             s_fspace.s_table, bloc, offset,
-                                             count);
-        } else
+                                             UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_table,
+                                             bloc, offset, count);
+        } else {
                 return;
+        }
 }
 
 inline int udf_prealloc_blocks(struct super_block *sb,
@@ -907,29 +820,23 @@ inline int udf_prealloc_blocks(struct super_block *sb,
 {
         if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_BITMAP) {
                 return udf_bitmap_prealloc_blocks(sb, inode,
-                                                  UDF_SB_PARTMAPS(sb)
-                                                  [partition].s_uspace.s_bitmap,
-                                                  partition, first_block,
-                                                  block_count);
-        } else if (UDF_SB_PARTFLAGS(sb, partition) &
-                   UDF_PART_FLAG_UNALLOC_TABLE) {
+                                                  UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_bitmap,
+                                                  partition, first_block, block_count);
+        } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_TABLE) {
                 return udf_table_prealloc_blocks(sb, inode,
-                                                 UDF_SB_PARTMAPS(sb)[partition].
-                                                 s_uspace.s_table, partition,
-                                                 first_block, block_count);
+                                                 UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_table,
+                                                 partition, first_block, block_count);
         } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_BITMAP) {
                 return udf_bitmap_prealloc_blocks(sb, inode,
-                                                  UDF_SB_PARTMAPS(sb)
-                                                  [partition].s_fspace.s_bitmap,
-                                                  partition, first_block,
-                                                  block_count);
+                                                  UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_bitmap,
+                                                  partition, first_block, block_count);
         } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_TABLE) {
                 return udf_table_prealloc_blocks(sb, inode,
-                                                 UDF_SB_PARTMAPS(sb)[partition].
-                                                 s_fspace.s_table, partition,
-                                                 first_block, block_count);
-        } else
+                                                 UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_table,
+                                                 partition, first_block, block_count);
+        } else {
                 return 0;
+        }
 }
 
 inline int udf_new_block(struct super_block *sb,
@@ -940,26 +847,21 @@ inline int udf_new_block(struct super_block *sb,
 
         if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_BITMAP) {
                 ret = udf_bitmap_new_block(sb, inode,
-                                           UDF_SB_PARTMAPS(sb)[partition].
-                                           s_uspace.s_bitmap, partition, goal,
-                                           err);
+                                           UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_bitmap,
+                                           partition, goal, err);
                 return ret;
-        } else if (UDF_SB_PARTFLAGS(sb, partition) &
-                   UDF_PART_FLAG_UNALLOC_TABLE) {
+        } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_TABLE) {
                 return udf_table_new_block(sb, inode,
-                                           UDF_SB_PARTMAPS(sb)[partition].
-                                           s_uspace.s_table, partition, goal,
-                                           err);
+                                           UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_table,
+                                           partition, goal, err);
         } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_BITMAP) {
                 return udf_bitmap_new_block(sb, inode,
-                                            UDF_SB_PARTMAPS(sb)[partition].
-                                            s_fspace.s_bitmap, partition, goal,
-                                            err);
+                                            UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_bitmap,
+                                            partition, goal, err);
         } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_TABLE) {
                 return udf_table_new_block(sb, inode,
-                                           UDF_SB_PARTMAPS(sb)[partition].
-                                           s_fspace.s_table, partition, goal,
-                                           err);
+                                           UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_table,
+                                           partition, goal, err);
         } else {
                 *err = -EIO;
                 return 0;
diff --git a/fs/udf/crc.c b/fs/udf/crc.c
index ae3d49790941..85aaee5fab26 100644
--- a/fs/udf/crc.c
+++ b/fs/udf/crc.c
@@ -111,7 +111,7 @@ int main(void)
         return 0;
 }
 
-#endif                          /* defined(TEST) */
+#endif /* defined(TEST) */
 
 /****************************************************************************/
 #if defined(GENERATE)
@@ -169,4 +169,4 @@ int main(int argc, char **argv)
         return 0;
 }
 
-#endif                          /* defined(GENERATE) */
+#endif /* defined(GENERATE) */
diff --git a/fs/udf/dir.c b/fs/udf/dir.c
index 79bab9fe120c..9e3b9f97ddbc 100644
--- a/fs/udf/dir.c
+++ b/fs/udf/dir.c
@@ -43,10 +43,10 @@ static int do_udf_readdir(struct inode *, struct file *, filldir_t, void *);
 /* readdir and lookup functions */
 
 const struct file_operations udf_dir_operations = {
-        .read = generic_read_dir,
-        .readdir = udf_readdir,
-        .ioctl = udf_ioctl,
-        .fsync = udf_fsync_file,
+        .read                   = generic_read_dir,
+        .readdir                = udf_readdir,
+        .ioctl                  = udf_ioctl,
+        .fsync                  = udf_fsync_file,
 };
 
 /*
@@ -83,8 +83,7 @@ int udf_readdir(struct file *filp, void *dirent, filldir_t filldir)
         lock_kernel();
 
         if (filp->f_pos == 0) {
-                if (filldir(dirent, ".", 1, filp->f_pos, dir->i_ino, DT_DIR) <
-                    0) {
+                if (filldir(dirent, ".", 1, filp->f_pos, dir->i_ino, DT_DIR) < 0) {
                         unlock_kernel();
                         return 0;
                 }
@@ -93,7 +92,7 @@ int udf_readdir(struct file *filp, void *dirent, filldir_t filldir)
 
         result = do_udf_readdir(dir, filp, filldir, dirent);
         unlock_kernel();
-        return result;
+        return result;
 }
 
 static int
@@ -125,21 +124,20 @@ do_udf_readdir(struct inode *dir, struct file *filp, filldir_t filldir,
         if (nf_pos == 0)
                 nf_pos = (udf_ext0_offset(dir) >> 2);
 
-        fibh.soffset = fibh.eoffset =
-            (nf_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2;
-        if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)
+        fibh.soffset = fibh.eoffset = (nf_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2;
+        if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {
                 fibh.sbh = fibh.ebh = NULL;
-        else if (inode_bmap(dir, nf_pos >> (dir->i_sb->s_blocksize_bits - 2),
-                            &epos, &eloc, &elen,
-                            &offset) == (EXT_RECORDED_ALLOCATED >> 30)) {
+        } else if (inode_bmap(dir, nf_pos >> (dir->i_sb->s_blocksize_bits - 2),
+                              &epos, &eloc, &elen, &offset) == (EXT_RECORDED_ALLOCATED >> 30)) {
                 block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
                 if ((++offset << dir->i_sb->s_blocksize_bits) < elen) {
                         if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)
                                 epos.offset -= sizeof(short_ad);
                         else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)
                                 epos.offset -= sizeof(long_ad);
-                } else
+                } else {
                         offset = 0;
+                }
 
                 if (!(fibh.sbh = fibh.ebh = udf_tread(dir->i_sb, block))) {
                         brelse(epos.bh);
@@ -149,15 +147,11 @@ do_udf_readdir(struct inode *dir, struct file *filp, filldir_t filldir,
                 if (!(offset & ((16 >> (dir->i_sb->s_blocksize_bits - 9)) - 1))) {
                         i = 16 >> (dir->i_sb->s_blocksize_bits - 9);
                         if (i + offset > (elen >> dir->i_sb->s_blocksize_bits))
-                                i = (elen >> dir->i_sb->s_blocksize_bits) -
-                                    offset;
+                                i = (elen >> dir->i_sb->s_blocksize_bits) - offset;
                         for (num = 0; i > 0; i--) {
-                                block =
-                                    udf_get_lb_pblock(dir->i_sb, eloc,
-                                                      offset + i);
+                                block = udf_get_lb_pblock(dir->i_sb, eloc, offset + i);
                                 tmp = udf_tgetblk(dir->i_sb, block);
-                                if (tmp && !buffer_uptodate(tmp)
-                                    && !buffer_locked(tmp))
+                                if (tmp && !buffer_uptodate(tmp) && !buffer_locked(tmp))
                                         bha[num++] = tmp;
                                 else
                                         brelse(tmp);
@@ -178,7 +172,6 @@ do_udf_readdir(struct inode *dir, struct file *filp, filldir_t filldir,
 
                 fi = udf_fileident_read(dir, &nf_pos, &fibh, &cfi, &epos, &eloc,
                                         &elen, &offset);
-
                 if (!fi) {
                         if (fibh.sbh != fibh.ebh)
                                 brelse(fibh.ebh);
@@ -190,19 +183,16 @@ do_udf_readdir(struct inode *dir, struct file *filp, filldir_t filldir,
                 liu = le16_to_cpu(cfi.lengthOfImpUse);
                 lfi = cfi.lengthFileIdent;
 
-                if (fibh.sbh == fibh.ebh)
+                if (fibh.sbh == fibh.ebh) {
                         nameptr = fi->fileIdent + liu;
-                else {
+                } else {
                         int poffset;    /* Unpaded ending offset */
 
-                        poffset =
-                            fibh.soffset + sizeof(struct fileIdentDesc) + liu +
-                            lfi;
+                        poffset = fibh.soffset + sizeof(struct fileIdentDesc) + liu + lfi;
 
-                        if (poffset >= lfi)
-                                nameptr =
-                                    (char *)(fibh.ebh->b_data + poffset - lfi);
-                        else {
+                        if (poffset >= lfi) {
+                                nameptr = (char *)(fibh.ebh->b_data + poffset - lfi);
+                        } else {
                                 nameptr = fname;
                                 memcpy(nameptr, fi->fileIdent + liu,
                                        lfi - poffset);
@@ -235,17 +225,15 @@ do_udf_readdir(struct inode *dir, struct file *filp, filldir_t filldir,
                 }
 
                 if (flen) {
-                        if (filldir
-                            (dirent, fname, flen, filp->f_pos, iblock,
-                             dt_type) < 0) {
+                        if (filldir(dirent, fname, flen, filp->f_pos, iblock, dt_type) < 0) {
                                 if (fibh.sbh != fibh.ebh)
                                         brelse(fibh.ebh);
                                 brelse(fibh.sbh);
                                 brelse(epos.bh);
-                                return 0;
+                                return 0;
                         }
                 }
-        }                       /* end while */
+        } /* end while */
 
         filp->f_pos = nf_pos + 1;
 
diff --git a/fs/udf/directory.c b/fs/udf/directory.c
index 8adc77c1d579..ff8c08fd7bf5 100644
--- a/fs/udf/directory.c
+++ b/fs/udf/directory.c
@@ -31,7 +31,7 @@ static uint8_t *udf_filead_read(struct inode *dir, uint8_t * tmpad,
 
         *error = 0;
 
-        ad = (uint8_t *) (*bh)->b_data + *offset;
+        ad = (uint8_t *)(*bh)->b_data + *offset;
         *offset += ad_size;
 
         if (!ad) {
@@ -51,7 +51,7 @@ static uint8_t *udf_filead_read(struct inode *dir, uint8_t * tmpad,
                 ad = tmpad;
 
                 remainder = dir->i_sb->s_blocksize - loffset;
-                memcpy((uint8_t *) ad, (*bh)->b_data + loffset, remainder);
+                memcpy((uint8_t *)ad, (*bh)->b_data + loffset, remainder);
 
                 brelse(*bh);
                 block = udf_get_lb_pblock(dir->i_sb, fe_loc, ++*pos);
@@ -60,10 +60,10 @@ static uint8_t *udf_filead_read(struct inode *dir, uint8_t * tmpad,
                 if (!((*bh) = udf_tread(dir->i_sb, block)))
                         return NULL;
 
-                memcpy((uint8_t *) ad + remainder, (*bh)->b_data,
-                       ad_size - remainder);
+                memcpy((uint8_t *)ad + remainder, (*bh)->b_data, ad_size - remainder);
                 *offset = ad_size - remainder;
         }
+
         return ad;
 }
 #endif
@@ -86,15 +86,13 @@ struct fileIdentDesc *udf_fileident_read(struct inode *dir, loff_t * nf_pos,
                                        (UDF_I_EFE(dir) ?
                                         sizeof(struct extendedFileEntry) :
                                         sizeof(struct fileEntry)),
-                                       dir->i_sb->s_blocksize,
-                                       &(fibh->eoffset));
-
+                                       dir->i_sb->s_blocksize, &(fibh->eoffset));
                 if (!fi)
                         return NULL;
 
                 *nf_pos += ((fibh->eoffset - fibh->soffset) >> 2);
 
-                memcpy((uint8_t *) cfi, (uint8_t *) fi,
+                memcpy((uint8_t *)cfi, (uint8_t *)fi,
                        sizeof(struct fileIdentDesc));
 
                 return fi;
@@ -121,21 +119,14 @@ struct fileIdentDesc *udf_fileident_read(struct inode *dir, loff_t * nf_pos,
                         return NULL;
                 fibh->soffset = fibh->eoffset = 0;
 
-                if (!
-                    (*offset & ((16 >> (dir->i_sb->s_blocksize_bits - 9)) - 1)))
-                {
+                if (!(*offset & ((16 >> (dir->i_sb->s_blocksize_bits - 9)) - 1))) {
                         i = 16 >> (dir->i_sb->s_blocksize_bits - 9);
-                        if (i + *offset >
-                            (*elen >> dir->i_sb->s_blocksize_bits))
-                                i = (*elen >> dir->i_sb->s_blocksize_bits) -
-                                    *offset;
+                        if (i + *offset > (*elen >> dir->i_sb->s_blocksize_bits))
+                                i = (*elen >> dir->i_sb->s_blocksize_bits)-*offset;
                         for (num = 0; i > 0; i--) {
-                                block =
-                                    udf_get_lb_pblock(dir->i_sb, *eloc,
-                                                      *offset + i);
+                                block = udf_get_lb_pblock(dir->i_sb, *eloc, *offset + i);
                                 tmp = udf_tgetblk(dir->i_sb, block);
-                                if (tmp && !buffer_uptodate(tmp)
-                                    && !buffer_locked(tmp))
+                                if (tmp && !buffer_uptodate(tmp) && !buffer_locked(tmp))
                                         bha[num++] = tmp;
                                 else
                                         brelse(tmp);
@@ -160,7 +151,7 @@ struct fileIdentDesc *udf_fileident_read(struct inode *dir, loff_t * nf_pos,
         *nf_pos += ((fibh->eoffset - fibh->soffset) >> 2);
 
         if (fibh->eoffset <= dir->i_sb->s_blocksize) {
-                memcpy((uint8_t *) cfi, (uint8_t *) fi,
+                memcpy((uint8_t *)cfi, (uint8_t *)fi,
                        sizeof(struct fileIdentDesc));
         } else if (fibh->eoffset > dir->i_sb->s_blocksize) {
                 int lextoffset = epos->offset;
@@ -187,21 +178,17 @@ struct fileIdentDesc *udf_fileident_read(struct inode *dir, loff_t * nf_pos,
                 if (sizeof(struct fileIdentDesc) > -fibh->soffset) {
                         int fi_len;
 
-                        memcpy((uint8_t *) cfi, (uint8_t *) fi, -fibh->soffset);
-                        memcpy((uint8_t *) cfi - fibh->soffset,
-                               fibh->ebh->b_data,
+                        memcpy((uint8_t *)cfi, (uint8_t *)fi, -fibh->soffset);
+                        memcpy((uint8_t *)cfi - fibh->soffset, fibh->ebh->b_data,
                                sizeof(struct fileIdentDesc) + fibh->soffset);
 
-                        fi_len =
-                            (sizeof(struct fileIdentDesc) +
-                             cfi->lengthFileIdent +
-                             le16_to_cpu(cfi->lengthOfImpUse) + 3) & ~3;
+                        fi_len = (sizeof(struct fileIdentDesc) + cfi->lengthFileIdent +
+                                  le16_to_cpu(cfi->lengthOfImpUse) + 3) & ~3;
 
-                        *nf_pos +=
-                            ((fi_len - (fibh->eoffset - fibh->soffset)) >> 2);
+                        *nf_pos += ((fi_len - (fibh->eoffset - fibh->soffset)) >> 2);
                         fibh->eoffset = fibh->soffset + fi_len;
                 } else {
-                        memcpy((uint8_t *) cfi, (uint8_t *) fi,
+                        memcpy((uint8_t *)cfi, (uint8_t *)fi,
                                sizeof(struct fileIdentDesc));
                 }
         }
@@ -237,9 +224,10 @@ struct fileIdentDesc *udf_get_fileident(void *buffer, int bufsize, int *offset)
         }
         if ((*offset + sizeof(struct fileIdentDesc)) > bufsize) {
                 lengthThisIdent = sizeof(struct fileIdentDesc);
-        } else
+        } else {
                 lengthThisIdent = sizeof(struct fileIdentDesc) +
-                    fi->lengthFileIdent + le16_to_cpu(fi->lengthOfImpUse);
+                        fi->lengthFileIdent + le16_to_cpu(fi->lengthOfImpUse);
+        }
 
         /* we need to figure padding, too! */
         padlen = lengthThisIdent % UDF_NAME_PAD;
@@ -270,22 +258,20 @@ static extent_ad *udf_get_fileextent(void *buffer, int bufsize, int *offset)
                 return NULL;
         }
 
-        ptr =
-            (uint8_t *) (fe->extendedAttr) +
-            le32_to_cpu(fe->lengthExtendedAttr);
+        ptr = (uint8_t *)(fe->extendedAttr) + le32_to_cpu(fe->lengthExtendedAttr);
 
         if ((*offset > 0) && (*offset < le32_to_cpu(fe->lengthAllocDescs))) {
                 ptr += *offset;
         }
 
-        ext = (extent_ad *) ptr;
+        ext = (extent_ad *)ptr;
 
         *offset = *offset + sizeof(extent_ad);
         return ext;
 }
 #endif
 
-short_ad *udf_get_fileshortad(uint8_t * ptr, int maxoffset, int *offset,
+short_ad *udf_get_fileshortad(uint8_t *ptr, int maxoffset, int *offset,
                               int inc)
 {
         short_ad *sa;
@@ -297,7 +283,7 @@ short_ad *udf_get_fileshortad(uint8_t * ptr, int maxoffset, int *offset,
 
         if ((*offset < 0) || ((*offset + sizeof(short_ad)) > maxoffset))
                 return NULL;
-        else if ((sa = (short_ad *) ptr)->extLength == 0)
+        else if ((sa = (short_ad *)ptr)->extLength == 0)
                 return NULL;
 
         if (inc)
@@ -305,7 +291,7 @@ short_ad *udf_get_fileshortad(uint8_t * ptr, int maxoffset, int *offset,
         return sa;
 }
 
-long_ad *udf_get_filelongad(uint8_t * ptr, int maxoffset, int *offset, int inc)
+long_ad *udf_get_filelongad(uint8_t *ptr, int maxoffset, int *offset, int inc)
 {
         long_ad *la;
 
@@ -316,7 +302,7 @@ long_ad *udf_get_filelongad(uint8_t * ptr, int maxoffset, int *offset, int inc)
 
         if ((*offset < 0) || ((*offset + sizeof(long_ad)) > maxoffset))
                 return NULL;
-        else if ((la = (long_ad *) ptr)->extLength == 0)
+        else if ((la = (long_ad *)ptr)->extLength == 0)
                 return NULL;
 
         if (inc)
diff --git a/fs/udf/ecma_167.h b/fs/udf/ecma_167.h
index 294ce2daa03a..56387711589b 100644
--- a/fs/udf/ecma_167.h
+++ b/fs/udf/ecma_167.h
@@ -39,8 +39,8 @@
 
 /* Character set specification (ECMA 167r3 1/7.2.1) */
 typedef struct {
-        uint8_t charSetType;
-        uint8_t charSetInfo[63];
+        uint8_t         charSetType;
+        uint8_t         charSetInfo[63];
 } __attribute__ ((packed)) charspec;
 
 /* Character Set Type (ECMA 167r3 1/7.2.1.1) */
@@ -54,33 +54,33 @@ typedef struct {
 #define CHARSPEC_TYPE_CS7               0x07    /* (1/7.2.9) */
 #define CHARSPEC_TYPE_CS8               0x08    /* (1/7.2.10) */
 
-typedef uint8_t dstring;
+typedef uint8_t         dstring;
 
 /* Timestamp (ECMA 167r3 1/7.3) */
 typedef struct {
-        __le16 typeAndTimezone;
-        __le16 year;
-        uint8_t month;
-        uint8_t day;
-        uint8_t hour;
-        uint8_t minute;
-        uint8_t second;
-        uint8_t centiseconds;
-        uint8_t hundredsOfMicroseconds;
-        uint8_t microseconds;
+        __le16          typeAndTimezone;
+        __le16          year;
+        uint8_t         month;
+        uint8_t         day;
+        uint8_t         hour;
+        uint8_t         minute;
+        uint8_t         second;
+        uint8_t         centiseconds;
+        uint8_t         hundredsOfMicroseconds;
+        uint8_t         microseconds;
 } __attribute__ ((packed)) timestamp;
 
 typedef struct {
-        uint16_t typeAndTimezone;
-        int16_t year;
-        uint8_t month;
-        uint8_t day;
-        uint8_t hour;
-        uint8_t minute;
-        uint8_t second;
-        uint8_t centiseconds;
-        uint8_t hundredsOfMicroseconds;
-        uint8_t microseconds;
+        uint16_t        typeAndTimezone;
+        int16_t         year;
+        uint8_t         month;
+        uint8_t         day;
+        uint8_t         hour;
+        uint8_t         minute;
+        uint8_t         second;
+        uint8_t         centiseconds;
+        uint8_t         hundredsOfMicroseconds;
+        uint8_t         microseconds;
 } __attribute__ ((packed)) kernel_timestamp;
 
 /* Type and Time Zone (ECMA 167r3 1/7.3.1) */
@@ -92,9 +92,9 @@ typedef struct {
 
 /* Entity identifier (ECMA 167r3 1/7.4) */
 typedef struct {
-        uint8_t flags;
-        uint8_t ident[23];
-        uint8_t identSuffix[8];
+        uint8_t         flags;
+        uint8_t         ident[23];
+        uint8_t         identSuffix[8];
 } __attribute__ ((packed)) regid;
 
 /* Flags (ECMA 167r3 1/7.4.1) */
@@ -104,10 +104,10 @@ typedef struct {
 /* Volume Structure Descriptor (ECMA 167r3 2/9.1) */
 #define VSD_STD_ID_LEN                  5
 struct volStructDesc {
-        uint8_t structType;
-        uint8_t stdIdent[VSD_STD_ID_LEN];
-        uint8_t structVersion;
-        uint8_t structData[2041];
+        uint8_t         structType;
+        uint8_t         stdIdent[VSD_STD_ID_LEN];
+        uint8_t         structVersion;
+        uint8_t         structData[2041];
 } __attribute__ ((packed));
 
 /* Standard Identifier (EMCA 167r2 2/9.1.2) */
@@ -123,36 +123,36 @@ struct volStructDesc {
 
 /* Beginning Extended Area Descriptor (ECMA 167r3 2/9.2) */
 struct beginningExtendedAreaDesc {
-        uint8_t structType;
-        uint8_t stdIdent[VSD_STD_ID_LEN];
-        uint8_t structVersion;
-        uint8_t structData[2041];
+        uint8_t         structType;
+        uint8_t         stdIdent[VSD_STD_ID_LEN];
+        uint8_t         structVersion;
+        uint8_t         structData[2041];
 } __attribute__ ((packed));
 
 /* Terminating Extended Area Descriptor (ECMA 167r3 2/9.3) */
 struct terminatingExtendedAreaDesc {
-        uint8_t structType;
-        uint8_t stdIdent[VSD_STD_ID_LEN];
-        uint8_t structVersion;
-        uint8_t structData[2041];
+        uint8_t         structType;
+        uint8_t         stdIdent[VSD_STD_ID_LEN];
+        uint8_t         structVersion;
+        uint8_t         structData[2041];
 } __attribute__ ((packed));
 
 /* Boot Descriptor (ECMA 167r3 2/9.4) */
 struct bootDesc {
-        uint8_t structType;
-        uint8_t stdIdent[VSD_STD_ID_LEN];
-        uint8_t structVersion;
-        uint8_t reserved1;
-        regid archType;
-        regid bootIdent;
-        __le32 bootExtLocation;
-        __le32 bootExtLength;
-        __le64 loadAddress;
-        __le64 startAddress;
-        timestamp descCreationDateAndTime;
-        __le16 flags;
-        uint8_t reserved2[32];
-        uint8_t bootUse[1906];
+        uint8_t         structType;
+        uint8_t         stdIdent[VSD_STD_ID_LEN];
+        uint8_t         structVersion;
+        uint8_t         reserved1;
+        regid           archType;
+        regid           bootIdent;
+        __le32          bootExtLocation;
+        __le32          bootExtLength;
+        __le64          loadAddress;
+        __le64          startAddress;
+        timestamp       descCreationDateAndTime;
+        __le16          flags;
+        uint8_t         reserved2[32];
+        uint8_t         bootUse[1906];
 } __attribute__ ((packed));
 
 /* Flags (ECMA 167r3 2/9.4.12) */
@@ -160,25 +160,25 @@ struct bootDesc {
 
 /* Extent Descriptor (ECMA 167r3 3/7.1) */
 typedef struct {
-        __le32 extLength;
-        __le32 extLocation;
+        __le32          extLength;
+        __le32          extLocation;
 } __attribute__ ((packed)) extent_ad;
 
 typedef struct {
-        uint32_t extLength;
-        uint32_t extLocation;
+        uint32_t        extLength;
+        uint32_t        extLocation;
 } kernel_extent_ad;
 
 /* Descriptor Tag (ECMA 167r3 3/7.2) */
 typedef struct {
-        __le16 tagIdent;
-        __le16 descVersion;
-        uint8_t tagChecksum;
-        uint8_t reserved;
-        __le16 tagSerialNum;
-        __le16 descCRC;
-        __le16 descCRCLength;
-        __le32 tagLocation;
+        __le16          tagIdent;
+        __le16          descVersion;
+        uint8_t         tagChecksum;
+        uint8_t         reserved;
+        __le16          tagSerialNum;
+        __le16          descCRC;
+        __le16          descCRCLength;
+        __le32          tagLocation;
 } __attribute__ ((packed)) tag;
 
 /* Tag Identifier (ECMA 167r3 3/7.2.1) */
@@ -194,37 +194,37 @@ typedef struct {
 
 /* NSR Descriptor (ECMA 167r3 3/9.1) */
 struct NSRDesc {
-        uint8_t structType;
-        uint8_t stdIdent[VSD_STD_ID_LEN];
-        uint8_t structVersion;
-        uint8_t reserved;
-        uint8_t structData[2040];
+        uint8_t         structType;
+        uint8_t         stdIdent[VSD_STD_ID_LEN];
+        uint8_t         structVersion;
+        uint8_t         reserved;
+        uint8_t         structData[2040];
 } __attribute__ ((packed));
 
 /* Primary Volume Descriptor (ECMA 167r3 3/10.1) */
 struct primaryVolDesc {
-        tag descTag;
-        __le32 volDescSeqNum;
-        __le32 primaryVolDescNum;
-        dstring volIdent[32];
-        __le16 volSeqNum;
-        __le16 maxVolSeqNum;
-        __le16 interchangeLvl;
-        __le16 maxInterchangeLvl;
-        __le32 charSetList;
-        __le32 maxCharSetList;
-        dstring volSetIdent[128];
-        charspec descCharSet;
-        charspec explanatoryCharSet;
-        extent_ad volAbstract;
-        extent_ad volCopyright;
-        regid appIdent;
-        timestamp recordingDateAndTime;
-        regid impIdent;
-        uint8_t impUse[64];
-        __le32 predecessorVolDescSeqLocation;
-        __le16 flags;
-        uint8_t reserved[22];
+        tag             descTag;
+        __le32          volDescSeqNum;
+        __le32          primaryVolDescNum;
+        dstring         volIdent[32];
+        __le16          volSeqNum;
+        __le16          maxVolSeqNum;
+        __le16          interchangeLvl;
+        __le16          maxInterchangeLvl;
+        __le32          charSetList;
+        __le32          maxCharSetList;
+        dstring         volSetIdent[128];
+        charspec        descCharSet;
+        charspec        explanatoryCharSet;
+        extent_ad       volAbstract;
+        extent_ad       volCopyright;
+        regid           appIdent;
+        timestamp       recordingDateAndTime;
+        regid           impIdent;
+        uint8_t         impUse[64];
+        __le32          predecessorVolDescSeqLocation;
+        __le16          flags;
+        uint8_t         reserved[22];
 } __attribute__ ((packed));
 
 /* Flags (ECMA 167r3 3/10.1.21) */
@@ -232,26 +232,26 @@ struct primaryVolDesc {
 
 /* Anchor Volume Descriptor Pointer (ECMA 167r3 3/10.2) */
 struct anchorVolDescPtr {
-        tag descTag;
-        extent_ad mainVolDescSeqExt;
-        extent_ad reserveVolDescSeqExt;
-        uint8_t reserved[480];
+        tag             descTag;
+        extent_ad       mainVolDescSeqExt;
+        extent_ad       reserveVolDescSeqExt;
+        uint8_t         reserved[480];
 } __attribute__ ((packed));
 
 /* Volume Descriptor Pointer (ECMA 167r3 3/10.3) */
 struct volDescPtr {
-        tag descTag;
-        __le32 volDescSeqNum;
-        extent_ad nextVolDescSeqExt;
-        uint8_t reserved[484];
+        tag             descTag;
+        __le32          volDescSeqNum;
+        extent_ad       nextVolDescSeqExt;
+        uint8_t         reserved[484];
 } __attribute__ ((packed));
 
 /* Implementation Use Volume Descriptor (ECMA 167r3 3/10.4) */
 struct impUseVolDesc {
-        tag descTag;
-        __le32 volDescSeqNum;
-        regid impIdent;
-        uint8_t impUse[460];
+        tag             descTag;
+        __le32          volDescSeqNum;
+        regid           impIdent;
+        uint8_t         impUse[460];
 } __attribute__ ((packed));
 
 /* Partition Descriptor (ECMA 167r3 3/10.5) */
@@ -291,26 +291,26 @@ struct partitionDesc {
 
 /* Logical Volume Descriptor (ECMA 167r3 3/10.6) */
 struct logicalVolDesc {
-        tag descTag;
-        __le32 volDescSeqNum;
-        charspec descCharSet;
-        dstring logicalVolIdent[128];
-        __le32 logicalBlockSize;
-        regid domainIdent;
-        uint8_t logicalVolContentsUse[16];
-        __le32 mapTableLength;
-        __le32 numPartitionMaps;
-        regid impIdent;
-        uint8_t impUse[128];
-        extent_ad integritySeqExt;
-        uint8_t partitionMaps[0];
+        tag             descTag;
+        __le32          volDescSeqNum;
+        charspec        descCharSet;
+        dstring         logicalVolIdent[128];
+        __le32          logicalBlockSize;
+        regid           domainIdent;
+        uint8_t         logicalVolContentsUse[16];
+        __le32          mapTableLength;
+        __le32          numPartitionMaps;
+        regid           impIdent;
+        uint8_t         impUse[128];
+        extent_ad       integritySeqExt;
+        uint8_t         partitionMaps[0];
 } __attribute__ ((packed));
 
 /* Generic Partition Map (ECMA 167r3 3/10.7.1) */
 struct genericPartitionMap {
-        uint8_t partitionMapType;
-        uint8_t partitionMapLength;
-        uint8_t partitionMapping[0];
+        uint8_t         partitionMapType;
+        uint8_t         partitionMapLength;
+        uint8_t         partitionMapping[0];
 } __attribute__ ((packed));
 
 /* Partition Map Type (ECMA 167r3 3/10.7.1.1) */
@@ -320,45 +320,45 @@ struct genericPartitionMap {
 
 /* Type 1 Partition Map (ECMA 167r3 3/10.7.2) */
 struct genericPartitionMap1 {
-        uint8_t partitionMapType;
-        uint8_t partitionMapLength;
-        __le16 volSeqNum;
-        __le16 partitionNum;
+        uint8_t         partitionMapType;
+        uint8_t         partitionMapLength;
+        __le16          volSeqNum;
+        __le16          partitionNum;
 } __attribute__ ((packed));
 
 /* Type 2 Partition Map (ECMA 167r3 3/10.7.3) */
 struct genericPartitionMap2 {
-        uint8_t partitionMapType;
-        uint8_t partitionMapLength;
-        uint8_t partitionIdent[62];
+        uint8_t         partitionMapType;
+        uint8_t         partitionMapLength;
+        uint8_t         partitionIdent[62];
 } __attribute__ ((packed));
 
 /* Unallocated Space Descriptor (ECMA 167r3 3/10.8) */
 struct unallocSpaceDesc {
-        tag descTag;
-        __le32 volDescSeqNum;
-        __le32 numAllocDescs;
-        extent_ad allocDescs[0];
+        tag             descTag;
+        __le32          volDescSeqNum;
+        __le32          numAllocDescs;
+        extent_ad       allocDescs[0];
 } __attribute__ ((packed));
 
 /* Terminating Descriptor (ECMA 167r3 3/10.9) */
 struct terminatingDesc {
-        tag descTag;
-        uint8_t reserved[496];
+        tag             descTag;
+        uint8_t         reserved[496];
 } __attribute__ ((packed));
 
 /* Logical Volume Integrity Descriptor (ECMA 167r3 3/10.10) */
 struct logicalVolIntegrityDesc {
-        tag descTag;
-        timestamp recordingDateAndTime;
-        __le32 integrityType;
-        extent_ad nextIntegrityExt;
-        uint8_t logicalVolContentsUse[32];
-        __le32 numOfPartitions;
-        __le32 lengthOfImpUse;
-        __le32 freeSpaceTable[0];
-        __le32 sizeTable[0];
-        uint8_t impUse[0];
+        tag             descTag;
+        timestamp       recordingDateAndTime;
+        __le32          integrityType;
+        extent_ad       nextIntegrityExt;
+        uint8_t         logicalVolContentsUse[32];
+        __le32          numOfPartitions;
+        __le32          lengthOfImpUse;
+        __le32          freeSpaceTable[0];
+        __le32          sizeTable[0];
+        uint8_t         impUse[0];
 } __attribute__ ((packed));
 
 /* Integrity Type (ECMA 167r3 3/10.10.3) */
@@ -367,48 +367,48 @@ struct logicalVolIntegrityDesc {
 
 /* Recorded Address (ECMA 167r3 4/7.1) */
 typedef struct {
-        __le32 logicalBlockNum;
-        __le16 partitionReferenceNum;
+        __le32          logicalBlockNum;
+        __le16          partitionReferenceNum;
 } __attribute__ ((packed)) lb_addr;
 
 /* ... and its in-core analog */
 typedef struct {
-        uint32_t logicalBlockNum;
-        uint16_t partitionReferenceNum;
+        uint32_t                logicalBlockNum;
+        uint16_t                partitionReferenceNum;
 } kernel_lb_addr;
 
 /* Short Allocation Descriptor (ECMA 167r3 4/14.14.1) */
 typedef struct {
-        __le32 extLength;
-        __le32 extPosition;
+        __le32          extLength;
+        __le32          extPosition;
 } __attribute__ ((packed)) short_ad;
 
 /* Long Allocation Descriptor (ECMA 167r3 4/14.14.2) */
 typedef struct {
-        __le32 extLength;
-        lb_addr extLocation;
-        uint8_t impUse[6];
+        __le32          extLength;
+        lb_addr         extLocation;
+        uint8_t         impUse[6];
 } __attribute__ ((packed)) long_ad;
 
 typedef struct {
-        uint32_t extLength;
-        kernel_lb_addr extLocation;
-        uint8_t impUse[6];
+        uint32_t        extLength;
+        kernel_lb_addr  extLocation;
+        uint8_t         impUse[6];
 } kernel_long_ad;
 
 /* Extended Allocation Descriptor (ECMA 167r3 4/14.14.3) */
 typedef struct {
-        __le32 extLength;
-        __le32 recordedLength;
-        __le32 informationLength;
-        lb_addr extLocation;
+        __le32          extLength;
+        __le32          recordedLength;
+        __le32          informationLength;
+        lb_addr         extLocation;
 } __attribute__ ((packed)) ext_ad;
 
 typedef struct {
-        uint32_t extLength;
-        uint32_t recordedLength;
-        uint32_t informationLength;
-        kernel_lb_addr extLocation;
+        uint32_t        extLength;
+        uint32_t        recordedLength;
+        uint32_t        informationLength;
+        kernel_lb_addr  extLocation;
 } kernel_ext_ad;
 
 /* Descriptor Tag (ECMA 167r3 4/7.2 - See 3/7.2) */
@@ -428,48 +428,48 @@ typedef struct {
 
 /* File Set Descriptor (ECMA 167r3 4/14.1) */
 struct fileSetDesc {
-        tag descTag;
-        timestamp recordingDateAndTime;
-        __le16 interchangeLvl;
-        __le16 maxInterchangeLvl;
-        __le32 charSetList;
-        __le32 maxCharSetList;
-        __le32 fileSetNum;
-        __le32 fileSetDescNum;
-        charspec logicalVolIdentCharSet;
-        dstring logicalVolIdent[128];
-        charspec fileSetCharSet;
-        dstring fileSetIdent[32];
-        dstring copyrightFileIdent[32];
-        dstring abstractFileIdent[32];
-        long_ad rootDirectoryICB;
-        regid domainIdent;
-        long_ad nextExt;
-        long_ad streamDirectoryICB;
-        uint8_t reserved[32];
+        tag             descTag;
+        timestamp       recordingDateAndTime;
+        __le16          interchangeLvl;
+        __le16          maxInterchangeLvl;
+        __le32          charSetList;
+        __le32          maxCharSetList;
+        __le32          fileSetNum;
+        __le32          fileSetDescNum;
+        charspec        logicalVolIdentCharSet;
+        dstring         logicalVolIdent[128];
+        charspec        fileSetCharSet;
+        dstring         fileSetIdent[32];
+        dstring         copyrightFileIdent[32];
+        dstring         abstractFileIdent[32];
+        long_ad         rootDirectoryICB;
+        regid           domainIdent;
+        long_ad         nextExt;
+        long_ad         streamDirectoryICB;
+        uint8_t         reserved[32];
 } __attribute__ ((packed));
 
 /* Partition Header Descriptor (ECMA 167r3 4/14.3) */
 struct partitionHeaderDesc {
-        short_ad unallocSpaceTable;
-        short_ad unallocSpaceBitmap;
-        short_ad partitionIntegrityTable;
-        short_ad freedSpaceTable;
-        short_ad freedSpaceBitmap;
-        uint8_t reserved[88];
+        short_ad        unallocSpaceTable;
+        short_ad        unallocSpaceBitmap;
+        short_ad        partitionIntegrityTable;
+        short_ad        freedSpaceTable;
+        short_ad        freedSpaceBitmap;
+        uint8_t         reserved[88];
 } __attribute__ ((packed));
 
 /* File Identifier Descriptor (ECMA 167r3 4/14.4) */
 struct fileIdentDesc {
-        tag descTag;
-        __le16 fileVersionNum;
-        uint8_t fileCharacteristics;
-        uint8_t lengthFileIdent;
-        long_ad icb;
-        __le16 lengthOfImpUse;
-        uint8_t impUse[0];
-        uint8_t fileIdent[0];
-        uint8_t padding[0];
+        tag             descTag;
+        __le16          fileVersionNum;
+        uint8_t         fileCharacteristics;
+        uint8_t         lengthFileIdent;
+        long_ad         icb;
+        __le16          lengthOfImpUse;
+        uint8_t         impUse[0];
+        uint8_t         fileIdent[0];
+        uint8_t         padding[0];
 } __attribute__ ((packed));
 
 /* File Characteristics (ECMA 167r3 4/14.4.3) */
@@ -481,21 +481,21 @@ struct fileIdentDesc {
 
 /* Allocation Ext Descriptor (ECMA 167r3 4/14.5) */
 struct allocExtDesc {
-        tag descTag;
-        __le32 previousAllocExtLocation;
-        __le32 lengthAllocDescs;
+        tag             descTag;
+        __le32          previousAllocExtLocation;
+        __le32          lengthAllocDescs;
 } __attribute__ ((packed));
 
 /* ICB Tag (ECMA 167r3 4/14.6) */
 typedef struct {
-        __le32 priorRecordedNumDirectEntries;
-        __le16 strategyType;
-        __le16 strategyParameter;
-        __le16 numEntries;
-        uint8_t reserved;
-        uint8_t fileType;
-        lb_addr parentICBLocation;
-        __le16 flags;
+        __le32          priorRecordedNumDirectEntries;
+        __le16          strategyType;
+        __le16          strategyParameter;
+        __le16          numEntries;
+        uint8_t         reserved;
+        uint8_t         fileType;
+        lb_addr         parentICBLocation;
+        __le16          flags;
 } __attribute__ ((packed)) icbtag;
 
 /* Strategy Type (ECMA 167r3 4/14.6.2) */
@@ -541,41 +541,41 @@ typedef struct {
 
 /* Indirect Entry (ECMA 167r3 4/14.7) */
 struct indirectEntry {
-        tag descTag;
-        icbtag icbTag;
-        long_ad indirectICB;
+        tag             descTag;
+        icbtag          icbTag;
+        long_ad         indirectICB;
 } __attribute__ ((packed));
 
 /* Terminal Entry (ECMA 167r3 4/14.8) */
 struct terminalEntry {
-        tag descTag;
-        icbtag icbTag;
+        tag             descTag;
+        icbtag          icbTag;
 } __attribute__ ((packed));
 
 /* File Entry (ECMA 167r3 4/14.9) */
 struct fileEntry {
-        tag descTag;
-        icbtag icbTag;
-        __le32 uid;
-        __le32 gid;
-        __le32 permissions;
-        __le16 fileLinkCount;
-        uint8_t recordFormat;
-        uint8_t recordDisplayAttr;
-        __le32 recordLength;
-        __le64 informationLength;
-        __le64 logicalBlocksRecorded;
-        timestamp accessTime;
-        timestamp modificationTime;
-        timestamp attrTime;
-        __le32 checkpoint;
-        long_ad extendedAttrICB;
-        regid impIdent;
-        __le64 uniqueID;
-        __le32 lengthExtendedAttr;
-        __le32 lengthAllocDescs;
-        uint8_t extendedAttr[0];
-        uint8_t allocDescs[0];
+        tag             descTag;
+        icbtag          icbTag;
+        __le32          uid;
+        __le32          gid;
+        __le32          permissions;
+        __le16          fileLinkCount;
+        uint8_t         recordFormat;
+        uint8_t         recordDisplayAttr;
+        __le32          recordLength;
+        __le64          informationLength;
+        __le64          logicalBlocksRecorded;
+        timestamp       accessTime;
+        timestamp       modificationTime;
+        timestamp       attrTime;
+        __le32          checkpoint;
+        long_ad         extendedAttrICB;
+        regid           impIdent;
+        __le64          uniqueID;
+        __le32          lengthExtendedAttr;
+        __le32          lengthAllocDescs;
+        uint8_t         extendedAttr[0];
+        uint8_t         allocDescs[0];
 } __attribute__ ((packed));
 
 /* Permissions (ECMA 167r3 4/14.9.5) */
@@ -617,51 +617,51 @@ struct fileEntry {
 
 /* Extended Attribute Header Descriptor (ECMA 167r3 4/14.10.1) */
 struct extendedAttrHeaderDesc {
-        tag descTag;
-        __le32 impAttrLocation;
-        __le32 appAttrLocation;
+        tag             descTag;
+        __le32          impAttrLocation;
+        __le32          appAttrLocation;
 } __attribute__ ((packed));
 
 /* Generic Format (ECMA 167r3 4/14.10.2) */
 struct genericFormat {
-        __le32 attrType;
-        uint8_t attrSubtype;
-        uint8_t reserved[3];
-        __le32 attrLength;
-        uint8_t attrData[0];
+        __le32          attrType;
+        uint8_t         attrSubtype;
+        uint8_t         reserved[3];
+        __le32          attrLength;
+        uint8_t         attrData[0];
 } __attribute__ ((packed));
 
 /* Character Set Information (ECMA 167r3 4/14.10.3) */
 struct charSetInfo {
-        __le32 attrType;
-        uint8_t attrSubtype;
-        uint8_t reserved[3];
-        __le32 attrLength;
-        __le32 escapeSeqLength;
-        uint8_t charSetType;
-        uint8_t escapeSeq[0];
+        __le32          attrType;
+        uint8_t         attrSubtype;
+        uint8_t         reserved[3];
+        __le32          attrLength;
+        __le32          escapeSeqLength;
+        uint8_t         charSetType;
+        uint8_t         escapeSeq[0];
 } __attribute__ ((packed));
 
 /* Alternate Permissions (ECMA 167r3 4/14.10.4) */
 struct altPerms {
-        __le32 attrType;
-        uint8_t attrSubtype;
-        uint8_t reserved[3];
-        __le32 attrLength;
-        __le16 ownerIdent;
-        __le16 groupIdent;
-        __le16 permission;
+        __le32          attrType;
+        uint8_t         attrSubtype;
+        uint8_t         reserved[3];
+        __le32          attrLength;
+        __le16          ownerIdent;
+        __le16          groupIdent;
+        __le16          permission;
 } __attribute__ ((packed));
 
 /* File Times Extended Attribute (ECMA 167r3 4/14.10.5) */
 struct fileTimesExtAttr {
-        __le32 attrType;
-        uint8_t attrSubtype;
-        uint8_t reserved[3];
-        __le32 attrLength;
-        __le32 dataLength;
-        __le32 fileTimeExistence;
-        uint8_t fileTimes;
+        __le32          attrType;
+        uint8_t         attrSubtype;
+        uint8_t         reserved[3];
+        __le32          attrLength;
+        __le32          dataLength;
+        __le32          fileTimeExistence;
+        uint8_t         fileTimes;
 } __attribute__ ((packed));
 
 /* FileTimeExistence (ECMA 167r3 4/14.10.5.6) */
@@ -672,47 +672,47 @@ struct fileTimesExtAttr {
 
 /* Information Times Extended Attribute (ECMA 167r3 4/14.10.6) */
 struct infoTimesExtAttr {
-        __le32 attrType;
-        uint8_t attrSubtype;
-        uint8_t reserved[3];
-        __le32 attrLength;
-        __le32 dataLength;
-        __le32 infoTimeExistence;
-        uint8_t infoTimes[0];
+        __le32          attrType;
+        uint8_t         attrSubtype;
+        uint8_t         reserved[3];
+        __le32          attrLength;
+        __le32          dataLength;
+        __le32          infoTimeExistence;
+        uint8_t         infoTimes[0];
 } __attribute__ ((packed));
 
 /* Device Specification (ECMA 167r3 4/14.10.7) */
 struct deviceSpec {
-        __le32 attrType;
-        uint8_t attrSubtype;
-        uint8_t reserved[3];
-        __le32 attrLength;
-        __le32 impUseLength;
-        __le32 majorDeviceIdent;
-        __le32 minorDeviceIdent;
-        uint8_t impUse[0];
+        __le32          attrType;
+        uint8_t         attrSubtype;
+        uint8_t         reserved[3];
+        __le32          attrLength;
+        __le32          impUseLength;
+        __le32          majorDeviceIdent;
+        __le32          minorDeviceIdent;
+        uint8_t         impUse[0];
 } __attribute__ ((packed));
 
 /* Implementation Use Extended Attr (ECMA 167r3 4/14.10.8) */
 struct impUseExtAttr {
-        __le32 attrType;
-        uint8_t attrSubtype;
-        uint8_t reserved[3];
-        __le32 attrLength;
-        __le32 impUseLength;
-        regid impIdent;
-        uint8_t impUse[0];
+        __le32          attrType;
+        uint8_t         attrSubtype;
+        uint8_t         reserved[3];
+        __le32          attrLength;
+        __le32          impUseLength;
+        regid           impIdent;
+        uint8_t         impUse[0];
 } __attribute__ ((packed));
 
 /* Application Use Extended Attribute (ECMA 167r3 4/14.10.9) */
 struct appUseExtAttr {
-        __le32 attrType;
-        uint8_t attrSubtype;
-        uint8_t reserved[3];
-        __le32 attrLength;
-        __le32 appUseLength;
-        regid appIdent;
-        uint8_t appUse[0];
+        __le32          attrType;
+        uint8_t         attrSubtype;
+        uint8_t         reserved[3];
+        __le32          attrLength;
+        __le32          appUseLength;
+        regid           appIdent;
+        uint8_t         appUse[0];
 } __attribute__ ((packed));
 
 #define EXTATTR_CHAR_SET                1
@@ -725,29 +725,29 @@ struct appUseExtAttr {
 
 /* Unallocated Space Entry (ECMA 167r3 4/14.11) */
 struct unallocSpaceEntry {
-        tag descTag;
-        icbtag icbTag;
-        __le32 lengthAllocDescs;
-        uint8_t allocDescs[0];
+        tag             descTag;
+        icbtag          icbTag;
+        __le32          lengthAllocDescs;
+        uint8_t         allocDescs[0];
 } __attribute__ ((packed));
 
 /* Space Bitmap Descriptor (ECMA 167r3 4/14.12) */
 struct spaceBitmapDesc {
-        tag descTag;
-        __le32 numOfBits;
-        __le32 numOfBytes;
-        uint8_t bitmap[0];
+        tag             descTag;
+        __le32          numOfBits;
+        __le32          numOfBytes;
+        uint8_t         bitmap[0];
 } __attribute__ ((packed));
 
 /* Partition Integrity Entry (ECMA 167r3 4/14.13) */
 struct partitionIntegrityEntry {
-        tag descTag;
-        icbtag icbTag;
-        timestamp recordingDateAndTime;
-        uint8_t integrityType;
-        uint8_t reserved[175];
-        regid impIdent;
-        uint8_t impUse[256];
+        tag             descTag;
+        icbtag          icbTag;
+        timestamp       recordingDateAndTime;
+        uint8_t         integrityType;
+        uint8_t         reserved[175];
+        regid           impIdent;
+        uint8_t         impUse[256];
 } __attribute__ ((packed));
 
 /* Short Allocation Descriptor (ECMA 167r3 4/14.14.1) */
@@ -764,46 +764,46 @@ struct partitionIntegrityEntry {
 
 /* Logical Volume Header Descriptor (ECMA 167r3 4/14.15) */
 struct logicalVolHeaderDesc {
-        __le64 uniqueID;
-        uint8_t reserved[24];
+        __le64          uniqueID;
+        uint8_t         reserved[24];
 } __attribute__ ((packed));
 
 /* Path Component (ECMA 167r3 4/14.16.1) */
 struct pathComponent {
-        uint8_t componentType;
-        uint8_t lengthComponentIdent;
-        __le16 componentFileVersionNum;
-        dstring componentIdent[0];
+        uint8_t         componentType;
+        uint8_t         lengthComponentIdent;
+        __le16          componentFileVersionNum;
+        dstring         componentIdent[0];
 } __attribute__ ((packed));
 
 /* File Entry (ECMA 167r3 4/14.17) */
 struct extendedFileEntry {
-        tag descTag;
-        icbtag icbTag;
-        __le32 uid;
-        __le32 gid;
-        __le32 permissions;
-        __le16 fileLinkCount;
-        uint8_t recordFormat;
-        uint8_t recordDisplayAttr;
-        __le32 recordLength;
-        __le64 informationLength;
-        __le64 objectSize;
-        __le64 logicalBlocksRecorded;
-        timestamp accessTime;
-        timestamp modificationTime;
-        timestamp createTime;
-        timestamp attrTime;
-        __le32 checkpoint;
-        __le32 reserved;
-        long_ad extendedAttrICB;
-        long_ad streamDirectoryICB;
-        regid impIdent;
-        __le64 uniqueID;
-        __le32 lengthExtendedAttr;
-        __le32 lengthAllocDescs;
-        uint8_t extendedAttr[0];
-        uint8_t allocDescs[0];
-} __attribute__ ((packed));
-
-#endif                          /* _ECMA_167_H */
+        tag             descTag;
+        icbtag          icbTag;
+        __le32          uid;
+        __le32          gid;
+        __le32          permissions;
+        __le16          fileLinkCount;
+        uint8_t         recordFormat;
+        uint8_t         recordDisplayAttr;
+        __le32          recordLength;
+        __le64          informationLength;
+        __le64          objectSize;
+        __le64          logicalBlocksRecorded;
+        timestamp       accessTime;
+        timestamp       modificationTime;
+        timestamp       createTime;
+        timestamp       attrTime;
+        __le32          checkpoint;
+        __le32          reserved;
+        long_ad         extendedAttrICB;
+        long_ad         streamDirectoryICB;
+        regid           impIdent;
+        __le64          uniqueID;
+        __le32          lengthExtendedAttr;
+        __le32          lengthAllocDescs;
+        uint8_t         extendedAttr[0];
+        uint8_t         allocDescs[0];
+} __attribute__ ((packed));
+
+#endif /* _ECMA_167_H */
diff --git a/fs/udf/file.c b/fs/udf/file.c
index 67bf36bd3e6e..5d7a4ea27753 100644
--- a/fs/udf/file.c
+++ b/fs/udf/file.c
@@ -30,7 +30,7 @@
 #include <linux/udf_fs.h>
 #include <asm/uaccess.h>
 #include <linux/kernel.h>
-#include <linux/string.h>       /* memset */
+#include <linux/string.h> /* memset */
 #include <linux/capability.h>
 #include <linux/errno.h>
 #include <linux/smp_lock.h>
@@ -55,11 +55,11 @@ static int udf_adinicb_readpage(struct file *file, struct page *page)
         SetPageUptodate(page);
         kunmap(page);
         unlock_page(page);
+
         return 0;
 }
 
-static int udf_adinicb_writepage(struct page *page,
-                                 struct writeback_control *wbc)
+static int udf_adinicb_writepage(struct page *page, struct writeback_control *wbc)
 {
         struct inode *inode = page->mapping->host;
         char *kaddr;
@@ -72,6 +72,7 @@ static int udf_adinicb_writepage(struct page *page,
         SetPageUptodate(page);
         kunmap(page);
         unlock_page(page);
+
         return 0;
 }
 
@@ -100,11 +101,11 @@ static int udf_adinicb_commit_write(struct file *file, struct page *page,
 }
 
 const struct address_space_operations udf_adinicb_aops = {
-        .readpage = udf_adinicb_readpage,
-        .writepage = udf_adinicb_writepage,
-        .sync_page = block_sync_page,
-        .prepare_write = udf_adinicb_prepare_write,
-        .commit_write = udf_adinicb_commit_write,
+        .readpage       = udf_adinicb_readpage,
+        .writepage      = udf_adinicb_writepage,
+        .sync_page      = block_sync_page,
+        .prepare_write  = udf_adinicb_prepare_write,
+        .commit_write   = udf_adinicb_commit_write,
 };
 
 static ssize_t udf_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
@@ -122,8 +123,8 @@ static ssize_t udf_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
                 else
                         pos = ppos;
 
-                if (inode->i_sb->s_blocksize <
-                    (udf_file_entry_alloc_offset(inode) + pos + count)) {
+                if (inode->i_sb->s_blocksize < (udf_file_entry_alloc_offset(inode) +
+                                                pos + count)) {
                         udf_expand_file_adinicb(inode, pos + count, &err);
                         if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB) {
                                 udf_debug("udf_expand_adinicb: err=%d\n", err);
@@ -138,9 +139,9 @@ static ssize_t udf_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
         }
 
         retval = generic_file_aio_write(iocb, iov, nr_segs, ppos);
-
         if (retval > 0)
                 mark_inode_dirty(inode);
+
         return retval;
 }
 
@@ -181,10 +182,12 @@ static ssize_t udf_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
 int udf_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
               unsigned long arg)
 {
+        long old_block, new_block;
         int result = -EINVAL;
 
         if (file_permission(filp, MAY_READ) != 0) {
-                udf_debug("no permission to access inode %lu\n", inode->i_ino);
+                udf_debug("no permission to access inode %lu\n",
+                          inode->i_ino);
                 return -EPERM;
         }
 
@@ -196,26 +199,19 @@ int udf_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
         switch (cmd) {
         case UDF_GETVOLIDENT:
                 return copy_to_user((char __user *)arg,
-                                    UDF_SB_VOLIDENT(inode->i_sb),
-                                    32) ? -EFAULT : 0;
+                                    UDF_SB_VOLIDENT(inode->i_sb), 32) ? -EFAULT : 0;
         case UDF_RELOCATE_BLOCKS:
-                {
-                        long old, new;
-
-                        if (!capable(CAP_SYS_ADMIN))
-                                return -EACCES;
-                        if (get_user(old, (long __user *)arg))
-                                return -EFAULT;
-                        if ((result = udf_relocate_blocks(inode->i_sb,
-                                                          old, &new)) == 0)
-                                result = put_user(new, (long __user *)arg);
-
-                        return result;
-                }
+                if (!capable(CAP_SYS_ADMIN))
+                        return -EACCES;
+                if (get_user(old_block, (long __user *)arg))
+                        return -EFAULT;
+                if ((result = udf_relocate_blocks(inode->i_sb,
+                                                  old_block, &new_block)) == 0)
+                        result = put_user(new_block, (long __user *)arg);
+                return result;
         case UDF_GETEASIZE:
                 result = put_user(UDF_I_LENEATTR(inode), (int __user *)arg);
                 break;
-
         case UDF_GETEABLOCK:
                 result = copy_to_user((char __user *)arg, UDF_I_DATA(inode),
                                       UDF_I_LENEATTR(inode)) ? -EFAULT : 0;
@@ -248,16 +244,16 @@ static int udf_release_file(struct inode *inode, struct file *filp)
 }
 
 const struct file_operations udf_file_operations = {
-        .read = do_sync_read,
-        .aio_read = generic_file_aio_read,
-        .ioctl = udf_ioctl,
-        .open = generic_file_open,
-        .mmap = generic_file_mmap,
-        .write = do_sync_write,
-        .aio_write = udf_file_aio_write,
-        .release = udf_release_file,
-        .fsync = udf_fsync_file,
-        .splice_read = generic_file_splice_read,
+        .read                   = do_sync_read,
+        .aio_read               = generic_file_aio_read,
+        .ioctl                  = udf_ioctl,
+        .open                   = generic_file_open,
+        .mmap                   = generic_file_mmap,
+        .write                  = do_sync_write,
+        .aio_write              = udf_file_aio_write,
+        .release                = udf_release_file,
+        .fsync                  = udf_fsync_file,
+        .splice_read            = generic_file_splice_read,
 };
 
 const struct inode_operations udf_file_inode_operations = {
diff --git a/fs/udf/fsync.c b/fs/udf/fsync.c
index 7f0901c4f1f1..b2c472b733b8 100644
--- a/fs/udf/fsync.c
+++ b/fs/udf/fsync.c
@@ -32,6 +32,7 @@ static int udf_fsync_inode(struct inode *, int);
 int udf_fsync_file(struct file *file, struct dentry *dentry, int datasync)
 {
         struct inode *inode = dentry->d_inode;
+
         return udf_fsync_inode(inode, datasync);
 }
 
@@ -46,5 +47,6 @@ static int udf_fsync_inode(struct inode *inode, int datasync)
                 return err;
 
         err |= udf_sync_inode(inode);
+
         return err ? -EIO : 0;
 }
diff --git a/fs/udf/ialloc.c b/fs/udf/ialloc.c
index 2eb503806bce..636d8f613929 100644
--- a/fs/udf/ialloc.c
+++ b/fs/udf/ialloc.c
@@ -46,12 +46,10 @@ void udf_free_inode(struct inode *inode)
         if (sbi->s_lvidbh) {
                 if (S_ISDIR(inode->i_mode))
                         UDF_SB_LVIDIU(sb)->numDirs =
-                            cpu_to_le32(le32_to_cpu(UDF_SB_LVIDIU(sb)->numDirs)
-                                        - 1);
+                                cpu_to_le32(le32_to_cpu(UDF_SB_LVIDIU(sb)->numDirs) - 1);
                 else
                         UDF_SB_LVIDIU(sb)->numFiles =
-                            cpu_to_le32(le32_to_cpu(UDF_SB_LVIDIU(sb)->numFiles)
-                                        - 1);
+                                cpu_to_le32(le32_to_cpu(UDF_SB_LVIDIU(sb)->numFiles) - 1);
 
                 mark_buffer_dirty(sbi->s_lvidbh);
         }
@@ -82,10 +80,8 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
         UDF_I_NEXT_ALLOC_GOAL(inode) = 0;
         UDF_I_STRAT4096(inode) = 0;
 
-        block =
-            udf_new_block(dir->i_sb, NULL,
-                          UDF_I_LOCATION(dir).partitionReferenceNum, start,
-                          err);
+        block = udf_new_block(dir->i_sb, NULL, UDF_I_LOCATION(dir).partitionReferenceNum,
+                              start, err);
         if (*err) {
                 iput(inode);
                 return NULL;
@@ -95,17 +91,13 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
         if (UDF_SB_LVIDBH(sb)) {
                 struct logicalVolHeaderDesc *lvhd;
                 uint64_t uniqueID;
-                lvhd =
-                    (struct logicalVolHeaderDesc *)(UDF_SB_LVID(sb)->
-                                                    logicalVolContentsUse);
+                lvhd = (struct logicalVolHeaderDesc *)(UDF_SB_LVID(sb)->logicalVolContentsUse);
                 if (S_ISDIR(mode))
                         UDF_SB_LVIDIU(sb)->numDirs =
-                            cpu_to_le32(le32_to_cpu(UDF_SB_LVIDIU(sb)->numDirs)
-                                        + 1);
+                                cpu_to_le32(le32_to_cpu(UDF_SB_LVIDIU(sb)->numDirs) + 1);
                 else
                         UDF_SB_LVIDIU(sb)->numFiles =
-                            cpu_to_le32(le32_to_cpu(UDF_SB_LVIDIU(sb)->numFiles)
-                                        + 1);
+                                cpu_to_le32(le32_to_cpu(UDF_SB_LVIDIU(sb)->numFiles) + 1);
                 UDF_I_UNIQUE(inode) = uniqueID = le64_to_cpu(lvhd->uniqueID);
                 if (!(++uniqueID & 0x00000000FFFFFFFFUL))
                         uniqueID += 16;
@@ -118,12 +110,12 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
                 inode->i_gid = dir->i_gid;
                 if (S_ISDIR(mode))
                         mode |= S_ISGID;
-        } else
+        } else {
                 inode->i_gid = current->fsgid;
+        }
 
         UDF_I_LOCATION(inode).logicalBlockNum = block;
-        UDF_I_LOCATION(inode).partitionReferenceNum =
-            UDF_I_LOCATION(dir).partitionReferenceNum;
+        UDF_I_LOCATION(inode).partitionReferenceNum = UDF_I_LOCATION(dir).partitionReferenceNum;
         inode->i_ino = udf_get_lb_pblock(sb, UDF_I_LOCATION(inode), 0);
         inode->i_blocks = 0;
         UDF_I_LENEATTR(inode) = 0;
@@ -132,14 +124,10 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
         if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_EXTENDED_FE)) {
                 UDF_I_EFE(inode) = 1;
                 UDF_UPDATE_UDFREV(inode->i_sb, UDF_VERS_USE_EXTENDED_FE);
-                UDF_I_DATA(inode) =
-                    kzalloc(inode->i_sb->s_blocksize -
-                            sizeof(struct extendedFileEntry), GFP_KERNEL);
+                UDF_I_DATA(inode) = kzalloc(inode->i_sb->s_blocksize - sizeof(struct extendedFileEntry), GFP_KERNEL);
         } else {
                 UDF_I_EFE(inode) = 0;
-                UDF_I_DATA(inode) =
-                    kzalloc(inode->i_sb->s_blocksize - sizeof(struct fileEntry),
-                            GFP_KERNEL);
+                UDF_I_DATA(inode) = kzalloc(inode->i_sb->s_blocksize - sizeof(struct fileEntry), GFP_KERNEL);
         }
         if (!UDF_I_DATA(inode)) {
                 iput(inode);
@@ -154,7 +142,7 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
         else
                 UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_LONG;
         inode->i_mtime = inode->i_atime = inode->i_ctime =
-            UDF_I_CRTIME(inode) = current_fs_time(inode->i_sb);
+                UDF_I_CRTIME(inode) = current_fs_time(inode->i_sb);
         insert_inode_hash(inode);
         mark_inode_dirty(inode);
         mutex_unlock(&sbi->s_alloc_mutex);
diff --git a/fs/udf/inode.c b/fs/udf/inode.c
index be6326f449a1..0d2c41666cd2 100644
--- a/fs/udf/inode.c
+++ b/fs/udf/inode.c
@@ -97,7 +97,8 @@ void udf_delete_inode(struct inode *inode)
 
         unlock_kernel();
         return;
-      no_delete:
+
+no_delete:
         clear_inode(inode);
 }
 
@@ -144,12 +145,12 @@ static sector_t udf_bmap(struct address_space *mapping, sector_t block)
 }
 
 const struct address_space_operations udf_aops = {
-        .readpage = udf_readpage,
-        .writepage = udf_writepage,
-        .sync_page = block_sync_page,
-        .prepare_write = udf_prepare_write,
-        .commit_write = generic_commit_write,
-        .bmap = udf_bmap,
+        .readpage       = udf_readpage,
+        .writepage      = udf_writepage,
+        .sync_page      = block_sync_page,
+        .prepare_write  = udf_prepare_write,
+        .commit_write   = generic_commit_write,
+        .bmap           = udf_bmap,
 };
 
 void udf_expand_file_adinicb(struct inode *inode, int newsize, int *err)
@@ -230,12 +231,10 @@ struct buffer_head *udf_expand_dir_adinicb(struct inode *inode, int *block,
         *block = udf_new_block(inode->i_sb, inode,
                                UDF_I_LOCATION(inode).partitionReferenceNum,
                                UDF_I_LOCATION(inode).logicalBlockNum, err);
-
         if (!(*block))
                 return NULL;
         newblock = udf_get_pblock(inode->i_sb, *block,
-                                  UDF_I_LOCATION(inode).partitionReferenceNum,
-                                  0);
+                                  UDF_I_LOCATION(inode).partitionReferenceNum, 0);
         if (!newblock)
                 return NULL;
         dbh = udf_tgetblk(inode->i_sb, newblock);
@@ -247,16 +246,13 @@ struct buffer_head *udf_expand_dir_adinicb(struct inode *inode, int *block,
         unlock_buffer(dbh);
         mark_buffer_dirty_inode(dbh, inode);
 
-        sfibh.soffset = sfibh.eoffset =
-            (f_pos & ((inode->i_sb->s_blocksize - 1) >> 2)) << 2;
+        sfibh.soffset = sfibh.eoffset = (f_pos & ((inode->i_sb->s_blocksize - 1) >> 2)) << 2;
         sfibh.sbh = sfibh.ebh = NULL;
         dfibh.soffset = dfibh.eoffset = 0;
         dfibh.sbh = dfibh.ebh = dbh;
         while ((f_pos < size)) {
                 UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_IN_ICB;
-                sfi =
-                    udf_fileident_read(inode, &f_pos, &sfibh, &cfi, NULL, NULL,
-                                       NULL, NULL);
+                sfi = udf_fileident_read(inode, &f_pos, &sfibh, &cfi, NULL, NULL, NULL, NULL);
                 if (!sfi) {
                         brelse(dbh);
                         return NULL;
@@ -267,8 +263,7 @@ struct buffer_head *udf_expand_dir_adinicb(struct inode *inode, int *block,
                 dfibh.eoffset += (sfibh.eoffset - sfibh.soffset);
                 dfi = (struct fileIdentDesc *)(dbh->b_data + dfibh.soffset);
                 if (udf_write_fi(inode, sfi, dfi, &dfibh, sfi->impUse,
-                                 sfi->fileIdent +
-                                 le16_to_cpu(sfi->lengthOfImpUse))) {
+                                 sfi->fileIdent + le16_to_cpu(sfi->lengthOfImpUse))) {
                         UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_IN_ICB;
                         brelse(dbh);
                         return NULL;
@@ -276,12 +271,10 @@ struct buffer_head *udf_expand_dir_adinicb(struct inode *inode, int *block,
         }
         mark_buffer_dirty_inode(dbh, inode);
 
-        memset(UDF_I_DATA(inode) + UDF_I_LENEATTR(inode), 0,
-               UDF_I_LENALLOC(inode));
+        memset(UDF_I_DATA(inode) + UDF_I_LENEATTR(inode), 0, UDF_I_LENALLOC(inode));
         UDF_I_LENALLOC(inode) = 0;
         eloc.logicalBlockNum = *block;
-        eloc.partitionReferenceNum =
-            UDF_I_LOCATION(inode).partitionReferenceNum;
+        eloc.partitionReferenceNum = UDF_I_LOCATION(inode).partitionReferenceNum;
         elen = inode->i_size;
         UDF_I_LENEXTENTS(inode) = elen;
         epos.bh = NULL;
@@ -334,11 +327,12 @@ static int udf_get_block(struct inode *inode, sector_t block,
         if (new)
                 set_buffer_new(bh_result);
         map_bh(bh_result, inode->i_sb, phys);
-      abort:
+
+abort:
         unlock_kernel();
         return err;
 
-      abort_negative:
+abort_negative:
         udf_warning(inode->i_sb, "udf_get_block", "block < 0");
         goto abort;
 }
@@ -346,13 +340,13 @@ static int udf_get_block(struct inode *inode, sector_t block,
 static struct buffer_head *udf_getblk(struct inode *inode, long block,
                                       int create, int *err)
 {
+        struct buffer_head *bh;
         struct buffer_head dummy;
 
         dummy.b_state = 0;
         dummy.b_blocknr = -1000;
         *err = udf_get_block(inode, block, &dummy, create);
         if (!*err && buffer_mapped(&dummy)) {
-                struct buffer_head *bh;
                 bh = sb_getblk(inode->i_sb, dummy.b_blocknr);
                 if (buffer_new(&dummy)) {
                         lock_buffer(bh);
@@ -363,6 +357,7 @@ static struct buffer_head *udf_getblk(struct inode *inode, long block,
                 }
                 return bh;
         }
+
         return NULL;
 }
 
@@ -373,42 +368,41 @@ int udf_extend_file(struct inode *inode, struct extent_position *last_pos,
         sector_t add;
         int count = 0, fake = !(last_ext->extLength & UDF_EXTENT_LENGTH_MASK);
         struct super_block *sb = inode->i_sb;
-        kernel_lb_addr prealloc_loc = { 0, 0 };
+        kernel_lb_addr prealloc_loc = {};
         int prealloc_len = 0;
 
         /* The previous extent is fake and we should not extend by anything
          * - there's nothing to do... */
         if (!blocks && fake)
                 return 0;
+
         /* Round the last extent up to a multiple of block size */
         if (last_ext->extLength & (sb->s_blocksize - 1)) {
                 last_ext->extLength =
-                    (last_ext->extLength & UDF_EXTENT_FLAG_MASK) |
-                    (((last_ext->extLength & UDF_EXTENT_LENGTH_MASK) +
-                      sb->s_blocksize - 1) & ~(sb->s_blocksize - 1));
+                        (last_ext->extLength & UDF_EXTENT_FLAG_MASK) |
+                        (((last_ext->extLength & UDF_EXTENT_LENGTH_MASK) +
+                          sb->s_blocksize - 1) & ~(sb->s_blocksize - 1));
                 UDF_I_LENEXTENTS(inode) =
-                    (UDF_I_LENEXTENTS(inode) + sb->s_blocksize - 1) &
-                    ~(sb->s_blocksize - 1);
+                        (UDF_I_LENEXTENTS(inode) + sb->s_blocksize - 1) &
+                        ~(sb->s_blocksize - 1);
         }
+
         /* Last extent are just preallocated blocks? */
-        if ((last_ext->extLength & UDF_EXTENT_FLAG_MASK) ==
-            EXT_NOT_RECORDED_ALLOCATED) {
+        if ((last_ext->extLength & UDF_EXTENT_FLAG_MASK) == EXT_NOT_RECORDED_ALLOCATED) {
                 /* Save the extent so that we can reattach it to the end */
                 prealloc_loc = last_ext->extLocation;
                 prealloc_len = last_ext->extLength;
                 /* Mark the extent as a hole */
                 last_ext->extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
-                    (last_ext->extLength & UDF_EXTENT_LENGTH_MASK);
+                        (last_ext->extLength & UDF_EXTENT_LENGTH_MASK);
                 last_ext->extLocation.logicalBlockNum = 0;
-                last_ext->extLocation.partitionReferenceNum = 0;
+                last_ext->extLocation.partitionReferenceNum = 0;
         }
+
         /* Can we merge with the previous extent? */
-        if ((last_ext->extLength & UDF_EXTENT_FLAG_MASK) ==
-            EXT_NOT_RECORDED_NOT_ALLOCATED) {
-                add =
-                    ((1 << 30) - sb->s_blocksize -
-                     (last_ext->extLength & UDF_EXTENT_LENGTH_MASK)) >> sb->
-                    s_blocksize_bits;
+        if ((last_ext->extLength & UDF_EXTENT_FLAG_MASK) == EXT_NOT_RECORDED_NOT_ALLOCATED) {
+                add = ((1 << 30) - sb->s_blocksize - (last_ext->extLength &
+                                                      UDF_EXTENT_LENGTH_MASK)) >> sb->s_blocksize_bits;
                 if (add > blocks)
                         add = blocks;
                 blocks -= add;
@@ -419,19 +413,20 @@ int udf_extend_file(struct inode *inode, struct extent_position *last_pos,
                 udf_add_aext(inode, last_pos, last_ext->extLocation,
                              last_ext->extLength, 1);
                 count++;
-        } else
-                udf_write_aext(inode, last_pos, last_ext->extLocation,
-                               last_ext->extLength, 1);
+        } else {
+                udf_write_aext(inode, last_pos, last_ext->extLocation, last_ext->extLength, 1);
+        }
+
         /* Managed to do everything necessary? */
         if (!blocks)
                 goto out;
 
         /* All further extents will be NOT_RECORDED_NOT_ALLOCATED */
         last_ext->extLocation.logicalBlockNum = 0;
-        last_ext->extLocation.partitionReferenceNum = 0;
-        add = (1 << (30 - sb->s_blocksize_bits)) - 1;
-        last_ext->extLength =
-            EXT_NOT_RECORDED_NOT_ALLOCATED | (add << sb->s_blocksize_bits);
+        last_ext->extLocation.partitionReferenceNum = 0;
+        add = (1 << (30-sb->s_blocksize_bits)) - 1;
+        last_ext->extLength = EXT_NOT_RECORDED_NOT_ALLOCATED | (add << sb->s_blocksize_bits);
+
         /* Create enough extents to cover the whole hole */
         while (blocks > add) {
                 blocks -= add;
@@ -442,22 +437,23 @@ int udf_extend_file(struct inode *inode, struct extent_position *last_pos,
         }
         if (blocks) {
                 last_ext->extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
-                    (blocks << sb->s_blocksize_bits);
+                        (blocks << sb->s_blocksize_bits);
                 if (udf_add_aext(inode, last_pos, last_ext->extLocation,
                                  last_ext->extLength, 1) == -1)
                         return -1;
                 count++;
         }
-      out:
+
+out:
         /* Do we have some preallocated blocks saved? */
         if (prealloc_len) {
-                if (udf_add_aext(inode, last_pos, prealloc_loc, prealloc_len, 1)
-                    == -1)
+                if (udf_add_aext(inode, last_pos, prealloc_loc, prealloc_len, 1) == -1)
                         return -1;
                 last_ext->extLocation = prealloc_loc;
                 last_ext->extLength = prealloc_len;
                 count++;
         }
+
         /* last_pos should point to the last written extent... */
         if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT)
                 last_pos->offset -= sizeof(short_ad);
@@ -465,6 +461,7 @@ int udf_extend_file(struct inode *inode, struct extent_position *last_pos,
                 last_pos->offset -= sizeof(long_ad);
         else
                 return -1;
+
         return count;
 }
 
@@ -490,7 +487,7 @@ static struct buffer_head *inode_getblk(struct inode *inode, sector_t block,
         prev_epos.block = UDF_I_LOCATION(inode);
         prev_epos.bh = NULL;
         cur_epos = next_epos = prev_epos;
-        b_off = (loff_t) block << inode->i_sb->s_blocksize_bits;
+        b_off = (loff_t)block << inode->i_sb->s_blocksize_bits;
 
         /* find the extent which contains the block we are looking for.
            alternate between laarr[0] and laarr[1] for locations of the
@@ -515,8 +512,7 @@ static struct buffer_head *inode_getblk(struct inode *inode, sector_t block,
                 prev_epos.offset = cur_epos.offset;
                 cur_epos.offset = next_epos.offset;
 
-                if ((etype =
-                     udf_next_aext(inode, &next_epos, &eloc, &elen, 1)) == -1)
+                if ((etype = udf_next_aext(inode, &next_epos, &eloc, &elen, 1)) == -1)
                         break;
 
                 c = !c;
@@ -526,8 +522,8 @@ static struct buffer_head *inode_getblk(struct inode *inode, sector_t block,
 
                 if (etype != (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))
                         pgoal = eloc.logicalBlockNum +
-                            ((elen + inode->i_sb->s_blocksize - 1) >>
-                             inode->i_sb->s_blocksize_bits);
+                                ((elen + inode->i_sb->s_blocksize - 1) >>
+                                 inode->i_sb->s_blocksize_bits);
 
                 count++;
         } while (lbcount + elen <= b_off);
@@ -547,8 +543,8 @@ static struct buffer_head *inode_getblk(struct inode *inode, sector_t block,
         if (etype == (EXT_RECORDED_ALLOCATED >> 30)) {
                 if (elen & (inode->i_sb->s_blocksize - 1)) {
                         elen = EXT_RECORDED_ALLOCATED |
-                            ((elen + inode->i_sb->s_blocksize - 1) &
-                             ~(inode->i_sb->s_blocksize - 1));
+                                ((elen + inode->i_sb->s_blocksize - 1) &
+                                 ~(inode->i_sb->s_blocksize - 1));
                         etype = udf_write_aext(inode, &cur_epos, eloc, elen, 1);
                 }
                 brelse(prev_epos.bh);
@@ -570,8 +566,7 @@ static struct buffer_head *inode_getblk(struct inode *inode, sector_t block,
                         startnum = 1;
                 } else {
                         /* Create a fake extent when there's not one */
-                        memset(&laarr[0].extLocation, 0x00,
-                               sizeof(kernel_lb_addr));
+                        memset(&laarr[0].extLocation, 0x00, sizeof(kernel_lb_addr));
                         laarr[0].extLength = EXT_NOT_RECORDED_NOT_ALLOCATED;
                         /* Will udf_extend_file() create real extent from a fake one? */
                         startnum = (offset > 0);
@@ -591,16 +586,14 @@ static struct buffer_head *inode_getblk(struct inode *inode, sector_t block,
                 offset = 0;
                 count += ret;
                 /* We are not covered by a preallocated extent? */
-                if ((laarr[0].extLength & UDF_EXTENT_FLAG_MASK) !=
-                    EXT_NOT_RECORDED_ALLOCATED) {
+                if ((laarr[0].extLength & UDF_EXTENT_FLAG_MASK) != EXT_NOT_RECORDED_ALLOCATED) {
                         /* Is there any real extent? - otherwise we overwrite
                          * the fake one... */
                         if (count)
                                 c = !c;
                         laarr[c].extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
-                            inode->i_sb->s_blocksize;
-                        memset(&laarr[c].extLocation, 0x00,
-                               sizeof(kernel_lb_addr));
+                                inode->i_sb->s_blocksize;
+                        memset(&laarr[c].extLocation, 0x00, sizeof(kernel_lb_addr));
                         count++;
                         endnum++;
                 }
@@ -618,8 +611,7 @@ static struct buffer_head *inode_getblk(struct inode *inode, sector_t block,
                 }
 
                 /* if the current block is located in an extent, read the next extent */
-                if ((etype =
-                     udf_next_aext(inode, &next_epos, &eloc, &elen, 0)) != -1) {
+                if ((etype = udf_next_aext(inode, &next_epos, &eloc, &elen, 0)) != -1) {
                         laarr[c + 1].extLength = (etype << 30) | elen;
                         laarr[c + 1].extLocation = eloc;
                         count++;
@@ -631,24 +623,21 @@ static struct buffer_head *inode_getblk(struct inode *inode, sector_t block,
         }
 
         /* if the current extent is not recorded but allocated, get the
-           block in the extent corresponding to the requested block */
-        if ((laarr[c].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30))
+         * block in the extent corresponding to the requested block */
+        if ((laarr[c].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30)) {
                 newblocknum = laarr[c].extLocation.logicalBlockNum + offset;
-        else {                  /* otherwise, allocate a new block */
-
+        } else { /* otherwise, allocate a new block */
                 if (UDF_I_NEXT_ALLOC_BLOCK(inode) == block)
                         goal = UDF_I_NEXT_ALLOC_GOAL(inode);
 
                 if (!goal) {
                         if (!(goal = pgoal))
-                                goal =
-                                    UDF_I_LOCATION(inode).logicalBlockNum + 1;
+                                goal = UDF_I_LOCATION(inode).logicalBlockNum + 1;
                 }
 
                 if (!(newblocknum = udf_new_block(inode->i_sb, inode,
-                                                  UDF_I_LOCATION(inode).
-                                                  partitionReferenceNum, goal,
-                                                  err))) {
+                                                  UDF_I_LOCATION(inode).partitionReferenceNum,
+                                                  goal, err))) {
                         brelse(prev_epos.bh);
                         *err = -ENOSPC;
                         return NULL;
@@ -657,8 +646,8 @@ static struct buffer_head *inode_getblk(struct inode *inode, sector_t block,
         }
 
         /* if the extent the requsted block is located in contains multiple blocks,
-           split the extent into at most three extents. blocks prior to requested
-           block, requested block, and blocks after requested block */
+         * split the extent into at most three extents. blocks prior to requested
+         * block, requested block, and blocks after requested block */
         udf_split_extents(inode, &c, offset, newblocknum, laarr, &endnum);
 
 #ifdef UDF_PREALLOCATE
@@ -670,15 +659,14 @@ static struct buffer_head *inode_getblk(struct inode *inode, sector_t block,
         udf_merge_extents(inode, laarr, &endnum);
 
         /* write back the new extents, inserting new extents if the new number
-           of extents is greater than the old number, and deleting extents if
-           the new number of extents is less than the old number */
+         * of extents is greater than the old number, and deleting extents if
+         * the new number of extents is less than the old number */
         udf_update_extents(inode, laarr, startnum, endnum, &prev_epos);
 
         brelse(prev_epos.bh);
 
         if (!(newblock = udf_get_pblock(inode->i_sb, newblocknum,
-                                        UDF_I_LOCATION(inode).
-                                        partitionReferenceNum, 0))) {
+                                        UDF_I_LOCATION(inode).partitionReferenceNum, 0))) {
                 return NULL;
         }
         *phys = newblock;
@@ -692,6 +680,7 @@ static struct buffer_head *inode_getblk(struct inode *inode, sector_t block,
                 udf_sync_inode(inode);
         else
                 mark_inode_dirty(inode);
+
         return result;
 }
 
@@ -701,16 +690,15 @@ static void udf_split_extents(struct inode *inode, int *c, int offset,
                               int *endnum)
 {
         if ((laarr[*c].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30) ||
-            (laarr[*c].extLength >> 30) ==
-            (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30)) {
+            (laarr[*c].extLength >> 30) == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30)) {
                 int curr = *c;
                 int blen = ((laarr[curr].extLength & UDF_EXTENT_LENGTH_MASK) +
-                            inode->i_sb->s_blocksize -
-                            1) >> inode->i_sb->s_blocksize_bits;
+                            inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits;
                 int8_t etype = (laarr[curr].extLength >> 30);
 
-                if (blen == 1) ;
-                else if (!offset || blen == offset + 1) {
+                if (blen == 1) {
+                        ;
+                } else if (!offset || blen == offset + 1) {
                         laarr[curr + 2] = laarr[curr + 1];
                         laarr[curr + 1] = laarr[curr];
                 } else {
@@ -720,20 +708,15 @@ static void udf_split_extents(struct inode *inode, int *c, int offset,
 
                 if (offset) {
                         if (etype == (EXT_NOT_RECORDED_ALLOCATED >> 30)) {
-                                udf_free_blocks(inode->i_sb, inode,
-                                                laarr[curr].extLocation, 0,
-                                                offset);
-                                laarr[curr].extLength =
-                                    EXT_NOT_RECORDED_NOT_ALLOCATED | (offset <<
-                                                                      inode->
-                                                                      i_sb->
-                                                                      s_blocksize_bits);
+                                udf_free_blocks(inode->i_sb, inode, laarr[curr].extLocation, 0, offset);
+                                laarr[curr].extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
+                                        (offset << inode->i_sb->s_blocksize_bits);
                                 laarr[curr].extLocation.logicalBlockNum = 0;
-                                laarr[curr].extLocation.partitionReferenceNum =
-                                    0;
-                        } else
+                                laarr[curr].extLocation.partitionReferenceNum = 0;
+                        } else {
                                 laarr[curr].extLength = (etype << 30) |
-                                    (offset << inode->i_sb->s_blocksize_bits);
+                                        (offset << inode->i_sb->s_blocksize_bits);
+                        }
                         curr++;
                         (*c)++;
                         (*endnum)++;
@@ -742,18 +725,16 @@ static void udf_split_extents(struct inode *inode, int *c, int offset,
                 laarr[curr].extLocation.logicalBlockNum = newblocknum;
                 if (etype == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))
                         laarr[curr].extLocation.partitionReferenceNum =
-                            UDF_I_LOCATION(inode).partitionReferenceNum;
+                                UDF_I_LOCATION(inode).partitionReferenceNum;
                 laarr[curr].extLength = EXT_RECORDED_ALLOCATED |
-                    inode->i_sb->s_blocksize;
+                        inode->i_sb->s_blocksize;
                 curr++;
 
                 if (blen != offset + 1) {
                         if (etype == (EXT_NOT_RECORDED_ALLOCATED >> 30))
-                                laarr[curr].extLocation.logicalBlockNum +=
-                                    (offset + 1);
-                        laarr[curr].extLength =
-                            (etype << 30) | ((blen - (offset + 1)) << inode->
-                                             i_sb->s_blocksize_bits);
+                                laarr[curr].extLocation.logicalBlockNum += (offset + 1);
+                        laarr[curr].extLength = (etype << 30) |
+                                ((blen - (offset + 1)) << inode->i_sb->s_blocksize_bits);
                         curr++;
                         (*endnum)++;
                 }
@@ -772,90 +753,69 @@ static void udf_prealloc_extents(struct inode *inode, int c, int lastblock,
                 else
                         start = c;
         } else {
-                if ((laarr[c + 1].extLength >> 30) ==
-                    (EXT_NOT_RECORDED_ALLOCATED >> 30)) {
+                if ((laarr[c + 1].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30)) {
                         start = c + 1;
-                        length = currlength =
-                            (((laarr[c + 1].
-                               extLength & UDF_EXTENT_LENGTH_MASK) +
-                              inode->i_sb->s_blocksize -
-                              1) >> inode->i_sb->s_blocksize_bits);
-                } else
+                        length = currlength = (((laarr[c + 1].extLength & UDF_EXTENT_LENGTH_MASK) +
+                                                inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits);
+                } else {
                         start = c;
+                }
         }
 
         for (i = start + 1; i <= *endnum; i++) {
                 if (i == *endnum) {
                         if (lastblock)
                                 length += UDF_DEFAULT_PREALLOC_BLOCKS;
-                } else if ((laarr[i].extLength >> 30) ==
-                           (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))
-                        length +=
-                            (((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
-                              inode->i_sb->s_blocksize -
-                              1) >> inode->i_sb->s_blocksize_bits);
-                else
+                } else if ((laarr[i].extLength >> 30) == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30)) {
+                        length += (((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
+                                    inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits);
+                } else {
                         break;
+                }
         }
 
         if (length) {
                 int next = laarr[start].extLocation.logicalBlockNum +
-                    (((laarr[start].extLength & UDF_EXTENT_LENGTH_MASK) +
-                      inode->i_sb->s_blocksize -
-                      1) >> inode->i_sb->s_blocksize_bits);
+                        (((laarr[start].extLength & UDF_EXTENT_LENGTH_MASK) +
+                          inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits);
                 int numalloc = udf_prealloc_blocks(inode->i_sb, inode,
-                                                   laarr[start].extLocation.
-                                                   partitionReferenceNum,
-                                                   next,
-                                                   (UDF_DEFAULT_PREALLOC_BLOCKS
-                                                    >
-                                                    length ? length :
-                                                    UDF_DEFAULT_PREALLOC_BLOCKS)
-                                                   - currlength);
-
-                if (numalloc) {
-                        if (start == (c + 1))
+                                                   laarr[start].extLocation.partitionReferenceNum,
+                                                   next, (UDF_DEFAULT_PREALLOC_BLOCKS > length ? length :
+                                                          UDF_DEFAULT_PREALLOC_BLOCKS) - currlength);
+                if (numalloc)   {
+                        if (start == (c + 1)) {
                                 laarr[start].extLength +=
-                                    (numalloc << inode->i_sb->s_blocksize_bits);
-                        else {
+                                        (numalloc << inode->i_sb->s_blocksize_bits);
+                        } else {
                                 memmove(&laarr[c + 2], &laarr[c + 1],
                                         sizeof(long_ad) * (*endnum - (c + 1)));
                                 (*endnum)++;
                                 laarr[c + 1].extLocation.logicalBlockNum = next;
                                 laarr[c + 1].extLocation.partitionReferenceNum =
-                                    laarr[c].extLocation.partitionReferenceNum;
-                                laarr[c + 1].extLength =
-                                    EXT_NOT_RECORDED_ALLOCATED | (numalloc <<
-                                                                  inode->i_sb->
-                                                                  s_blocksize_bits);
+                                        laarr[c].extLocation.partitionReferenceNum;
+                                laarr[c + 1].extLength = EXT_NOT_RECORDED_ALLOCATED |
+                                        (numalloc << inode->i_sb->s_blocksize_bits);
                                 start = c + 1;
                         }
 
                         for (i = start + 1; numalloc && i < *endnum; i++) {
-                                int elen =
-                                    ((laarr[i].
-                                      extLength & UDF_EXTENT_LENGTH_MASK) +
-                                     inode->i_sb->s_blocksize -
-                                     1) >> inode->i_sb->s_blocksize_bits;
+                                int elen = ((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
+                                            inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits;
 
                                 if (elen > numalloc) {
                                         laarr[i].extLength -=
-                                            (numalloc << inode->i_sb->
-                                             s_blocksize_bits);
+                                                (numalloc << inode->i_sb->s_blocksize_bits);
                                         numalloc = 0;
                                 } else {
                                         numalloc -= elen;
                                         if (*endnum > (i + 1))
-                                                memmove(&laarr[i],
-                                                        &laarr[i + 1],
-                                                        sizeof(long_ad) *
-                                                        (*endnum - (i + 1)));
+                                                memmove(&laarr[i], &laarr[i + 1],
+                                                        sizeof(long_ad) * (*endnum - (i + 1)));
                                         i--;
                                         (*endnum)--;
                                 }
                         }
-                        UDF_I_LENEXTENTS(inode) +=
-                            numalloc << inode->i_sb->s_blocksize_bits;
+                        UDF_I_LENEXTENTS(inode) += numalloc << inode->i_sb->s_blocksize_bits;
                 }
         }
 }
@@ -867,119 +827,68 @@ static void udf_merge_extents(struct inode *inode,
         int i;
 
         for (i = 0; i < (*endnum - 1); i++) {
-                if ((laarr[i].extLength >> 30) ==
-                    (laarr[i + 1].extLength >> 30)) {
-                        if (((laarr[i].extLength >> 30) ==
-                             (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))
-                            ||
-                            ((laarr[i + 1].extLocation.logicalBlockNum -
-                              laarr[i].extLocation.logicalBlockNum) ==
+                if ((laarr[i].extLength >> 30) == (laarr[i + 1].extLength >> 30)) {
+                        if (((laarr[i].extLength >> 30) == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30)) ||
+                            ((laarr[i + 1].extLocation.logicalBlockNum - laarr[i].extLocation.logicalBlockNum) ==
                              (((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
-                               inode->i_sb->s_blocksize -
-                               1) >> inode->i_sb->s_blocksize_bits))) {
-                                if (((laarr[i].
-                                      extLength & UDF_EXTENT_LENGTH_MASK) +
-                                     (laarr[i + 1].
-                                      extLength & UDF_EXTENT_LENGTH_MASK) +
-                                     inode->i_sb->s_blocksize -
-                                     1) & ~UDF_EXTENT_LENGTH_MASK) {
-                                        laarr[i + 1].extLength =
-                                            (laarr[i + 1].extLength -
-                                             (laarr[i].
-                                              extLength &
-                                              UDF_EXTENT_LENGTH_MASK) +
-                                             UDF_EXTENT_LENGTH_MASK) & ~(inode->
-                                                                         i_sb->
-                                                                         s_blocksize
-                                                                         - 1);
-                                        laarr[i].extLength =
-                                            (laarr[i].
-                                             extLength & UDF_EXTENT_FLAG_MASK) +
-                                            (UDF_EXTENT_LENGTH_MASK + 1) -
-                                            inode->i_sb->s_blocksize;
-                                        laarr[i +
-                                              1].extLocation.logicalBlockNum =
-                                            laarr[i].extLocation.
-                                            logicalBlockNum +
-                                            ((laarr[i].
-                                              extLength &
-                                              UDF_EXTENT_LENGTH_MASK) >> inode->
-                                             i_sb->s_blocksize_bits);
+                               inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits))) {
+                                if (((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
+                                     (laarr[i + 1].extLength & UDF_EXTENT_LENGTH_MASK) +
+                                     inode->i_sb->s_blocksize - 1) & ~UDF_EXTENT_LENGTH_MASK) {
+                                        laarr[i + 1].extLength = (laarr[i + 1].extLength -
+                                                                  (laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
+                                                                  UDF_EXTENT_LENGTH_MASK) & ~(inode->i_sb->s_blocksize - 1);
+                                        laarr[i].extLength = (laarr[i].extLength & UDF_EXTENT_FLAG_MASK) +
+                                                (UDF_EXTENT_LENGTH_MASK + 1) - inode->i_sb->s_blocksize;
+                                        laarr[i + 1].extLocation.logicalBlockNum =
+                                                laarr[i].extLocation.logicalBlockNum +
+                                                ((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) >>
+                                                 inode->i_sb->s_blocksize_bits);
                                 } else {
-                                        laarr[i].extLength =
-                                            laarr[i + 1].extLength +
-                                            (((laarr[i].
-                                               extLength &
-                                               UDF_EXTENT_LENGTH_MASK) +
-                                              inode->i_sb->s_blocksize -
-                                              1) & ~(inode->i_sb->s_blocksize -
-                                                     1));
+                                        laarr[i].extLength = laarr[i + 1].extLength +
+                                                (((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
+                                                  inode->i_sb->s_blocksize - 1) & ~(inode->i_sb->s_blocksize - 1));
                                         if (*endnum > (i + 2))
-                                                memmove(&laarr[i + 1],
-                                                        &laarr[i + 2],
-                                                        sizeof(long_ad) *
-                                                        (*endnum - (i + 2)));
+                                                memmove(&laarr[i + 1], &laarr[i + 2],
+                                                        sizeof(long_ad) * (*endnum - (i + 2)));
                                         i--;
                                         (*endnum)--;
                                 }
                         }
-                } else
-                    if (((laarr[i].extLength >> 30) ==
-                         (EXT_NOT_RECORDED_ALLOCATED >> 30))
-                        && ((laarr[i + 1].extLength >> 30) ==
-                            (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))) {
-                        udf_free_blocks(inode->i_sb, inode,
-                                        laarr[i].extLocation, 0,
-                                        ((laarr[i].
-                                          extLength & UDF_EXTENT_LENGTH_MASK) +
-                                         inode->i_sb->s_blocksize -
-                                         1) >> inode->i_sb->s_blocksize_bits);
+                } else if (((laarr[i].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30)) &&
+                           ((laarr[i + 1].extLength >> 30) == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))) {
+                        udf_free_blocks(inode->i_sb, inode, laarr[i].extLocation, 0,
+                                        ((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
+                                         inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits);
                         laarr[i].extLocation.logicalBlockNum = 0;
                         laarr[i].extLocation.partitionReferenceNum = 0;
 
                         if (((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
                              (laarr[i + 1].extLength & UDF_EXTENT_LENGTH_MASK) +
-                             inode->i_sb->s_blocksize -
-                             1) & ~UDF_EXTENT_LENGTH_MASK) {
-                                laarr[i + 1].extLength =
-                                    (laarr[i + 1].extLength -
-                                     (laarr[i].
-                                      extLength & UDF_EXTENT_LENGTH_MASK) +
-                                     UDF_EXTENT_LENGTH_MASK) & ~(inode->i_sb->
-                                                                 s_blocksize -
-                                                                 1);
-                                laarr[i].extLength =
-                                    (laarr[i].
-                                     extLength & UDF_EXTENT_FLAG_MASK) +
-                                    (UDF_EXTENT_LENGTH_MASK + 1) -
-                                    inode->i_sb->s_blocksize;
+                             inode->i_sb->s_blocksize - 1) & ~UDF_EXTENT_LENGTH_MASK) {
+                                laarr[i + 1].extLength = (laarr[i + 1].extLength -
+                                                          (laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
+                                                          UDF_EXTENT_LENGTH_MASK) & ~(inode->i_sb->s_blocksize - 1);
+                                laarr[i].extLength = (laarr[i].extLength & UDF_EXTENT_FLAG_MASK) +
+                                        (UDF_EXTENT_LENGTH_MASK + 1) - inode->i_sb->s_blocksize;
                         } else {
                                 laarr[i].extLength = laarr[i + 1].extLength +
-                                    (((laarr[i].
-                                       extLength & UDF_EXTENT_LENGTH_MASK) +
-                                      inode->i_sb->s_blocksize -
-                                      1) & ~(inode->i_sb->s_blocksize - 1));
+                                        (((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
+                                          inode->i_sb->s_blocksize - 1) & ~(inode->i_sb->s_blocksize - 1));
                                 if (*endnum > (i + 2))
                                         memmove(&laarr[i + 1], &laarr[i + 2],
-                                                sizeof(long_ad) * (*endnum -
-                                                                   (i + 2)));
+                                                sizeof(long_ad) * (*endnum - (i + 2)));
                                 i--;
                                 (*endnum)--;
                         }
-                } else if ((laarr[i].extLength >> 30) ==
-                           (EXT_NOT_RECORDED_ALLOCATED >> 30)) {
-                        udf_free_blocks(inode->i_sb, inode,
-                                        laarr[i].extLocation, 0,
-                                        ((laarr[i].
-                                          extLength & UDF_EXTENT_LENGTH_MASK) +
-                                         inode->i_sb->s_blocksize -
-                                         1) >> inode->i_sb->s_blocksize_bits);
+                } else if ((laarr[i].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30)) {
+                        udf_free_blocks(inode->i_sb, inode, laarr[i].extLocation, 0,
+                                        ((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
+                                         inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits);
                         laarr[i].extLocation.logicalBlockNum = 0;
                         laarr[i].extLocation.partitionReferenceNum = 0;
-                        laarr[i].extLength =
-                            (laarr[i].
-                             extLength & UDF_EXTENT_LENGTH_MASK) |
-                            EXT_NOT_RECORDED_NOT_ALLOCATED;
+                        laarr[i].extLength = (laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) |
+                                EXT_NOT_RECORDED_NOT_ALLOCATED;
                 }
         }
 }
@@ -1025,10 +934,13 @@ struct buffer_head *udf_bread(struct inode *inode, int block,
 
         if (buffer_uptodate(bh))
                 return bh;
+
         ll_rw_block(READ, 1, &bh);
+
         wait_on_buffer(bh);
         if (buffer_uptodate(bh))
                 return bh;
+
         brelse(bh);
         *err = -EIO;
         return NULL;
@@ -1047,26 +959,24 @@ void udf_truncate(struct inode *inode)
 
         lock_kernel();
         if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB) {
-                if (inode->i_sb->s_blocksize <
-                    (udf_file_entry_alloc_offset(inode) + inode->i_size)) {
+                if (inode->i_sb->s_blocksize < (udf_file_entry_alloc_offset(inode) +
+                                                inode->i_size)) {
                         udf_expand_file_adinicb(inode, inode->i_size, &err);
                         if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB) {
                                 inode->i_size = UDF_I_LENALLOC(inode);
                                 unlock_kernel();
                                 return;
-                        } else
+                        } else {
                                 udf_truncate_extents(inode);
+                        }
                 } else {
                         offset = inode->i_size & (inode->i_sb->s_blocksize - 1);
-                        memset(UDF_I_DATA(inode) + UDF_I_LENEATTR(inode) +
-                               offset, 0x00,
-                               inode->i_sb->s_blocksize - offset -
-                               udf_file_entry_alloc_offset(inode));
+                        memset(UDF_I_DATA(inode) + UDF_I_LENEATTR(inode) + offset, 0x00,
+                               inode->i_sb->s_blocksize - offset - udf_file_entry_alloc_offset(inode));
                         UDF_I_LENALLOC(inode) = inode->i_size;
                 }
         } else {
-                block_truncate_page(inode->i_mapping, inode->i_size,
-                                    udf_get_block);
+                block_truncate_page(inode->i_mapping, inode->i_size, udf_get_block);
                 udf_truncate_extents(inode);
         }
 
@@ -1097,7 +1007,6 @@ static void __udf_read_inode(struct inode *inode)
          *      i_op = NULL;
          */
         bh = udf_read_ptagged(inode->i_sb, UDF_I_LOCATION(inode), 0, &ident);
-
         if (!bh) {
                 printk(KERN_ERR "udf: udf_read_inode(ino %ld) failed !bh\n",
                        inode->i_ino);
@@ -1107,8 +1016,7 @@ static void __udf_read_inode(struct inode *inode)
 
         if (ident != TAG_IDENT_FE && ident != TAG_IDENT_EFE &&
             ident != TAG_IDENT_USE) {
-                printk(KERN_ERR
-                       "udf: udf_read_inode(ino %ld) failed ident=%d\n",
+                printk(KERN_ERR "udf: udf_read_inode(ino %ld) failed ident=%d\n",
                        inode->i_ino, ident);
                 brelse(bh);
                 make_bad_inode(inode);
@@ -1121,9 +1029,7 @@ static void __udf_read_inode(struct inode *inode)
                 struct buffer_head *ibh = NULL, *nbh = NULL;
                 struct indirectEntry *ie;
 
-                ibh =
-                    udf_read_ptagged(inode->i_sb, UDF_I_LOCATION(inode), 1,
-                                     &ident);
+                ibh = udf_read_ptagged(inode->i_sb, UDF_I_LOCATION(inode), 1, &ident);
                 if (ident == TAG_IDENT_IE) {
                         if (ibh) {
                                 kernel_lb_addr loc;
@@ -1132,13 +1038,10 @@ static void __udf_read_inode(struct inode *inode)
                                 loc = lelb_to_cpu(ie->indirectICB.extLocation);
 
                                 if (ie->indirectICB.extLength &&
-                                    (nbh =
-                                     udf_read_ptagged(inode->i_sb, loc, 0,
-                                                      &ident))) {
-                                        if (ident == TAG_IDENT_FE
-                                            || ident == TAG_IDENT_EFE) {
-                                                memcpy(&UDF_I_LOCATION(inode),
-                                                       &loc,
+                                    (nbh = udf_read_ptagged(inode->i_sb, loc, 0, &ident))) {
+                                        if (ident == TAG_IDENT_FE ||
+                                            ident == TAG_IDENT_EFE) {
+                                                memcpy(&UDF_I_LOCATION(inode), &loc,
                                                        sizeof(kernel_lb_addr));
                                                 brelse(bh);
                                                 brelse(ibh);
@@ -1149,11 +1052,13 @@ static void __udf_read_inode(struct inode *inode)
                                                 brelse(nbh);
                                                 brelse(ibh);
                                         }
-                                } else
+                                } else {
                                         brelse(ibh);
+                                }
                         }
-                } else
+                } else {
                         brelse(ibh);
+                }
         } else if (le16_to_cpu(fe->icbTag.strategyType) != 4) {
                 printk(KERN_ERR "udf: unsupported strategy type: %d\n",
                        le16_to_cpu(fe->icbTag.strategyType));
@@ -1179,11 +1084,10 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
 
         if (le16_to_cpu(fe->icbTag.strategyType) == 4)
                 UDF_I_STRAT4096(inode) = 0;
-        else                    /* if (le16_to_cpu(fe->icbTag.strategyType) == 4096) */
+        else /* if (le16_to_cpu(fe->icbTag.strategyType) == 4096) */
                 UDF_I_STRAT4096(inode) = 1;
 
-        UDF_I_ALLOCTYPE(inode) =
-            le16_to_cpu(fe->icbTag.flags) & ICBTAG_FLAG_AD_MASK;
+        UDF_I_ALLOCTYPE(inode) = le16_to_cpu(fe->icbTag.flags) & ICBTAG_FLAG_AD_MASK;
         UDF_I_UNIQUE(inode) = 0;
         UDF_I_LENEATTR(inode) = 0;
         UDF_I_LENEXTENTS(inode) = 0;
@@ -1193,23 +1097,16 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
         if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_EFE) {
                 UDF_I_EFE(inode) = 1;
                 UDF_I_USE(inode) = 0;
-                if (udf_alloc_i_data
-                    (inode,
-                     inode->i_sb->s_blocksize -
-                     sizeof(struct extendedFileEntry))) {
+                if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize - sizeof(struct extendedFileEntry))) {
                         make_bad_inode(inode);
                         return;
                 }
-                memcpy(UDF_I_DATA(inode),
-                       bh->b_data + sizeof(struct extendedFileEntry),
-                       inode->i_sb->s_blocksize -
-                       sizeof(struct extendedFileEntry));
+                memcpy(UDF_I_DATA(inode), bh->b_data + sizeof(struct extendedFileEntry),
+                       inode->i_sb->s_blocksize - sizeof(struct extendedFileEntry));
         } else if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_FE) {
                 UDF_I_EFE(inode) = 0;
                 UDF_I_USE(inode) = 0;
-                if (udf_alloc_i_data
-                    (inode,
-                     inode->i_sb->s_blocksize - sizeof(struct fileEntry))) {
+                if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize - sizeof(struct fileEntry))) {
                         make_bad_inode(inode);
                         return;
                 }
@@ -1219,19 +1116,13 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
                 UDF_I_EFE(inode) = 0;
                 UDF_I_USE(inode) = 1;
                 UDF_I_LENALLOC(inode) =
-                    le32_to_cpu(((struct unallocSpaceEntry *)bh->b_data)->
-                                lengthAllocDescs);
-                if (udf_alloc_i_data
-                    (inode,
-                     inode->i_sb->s_blocksize -
-                     sizeof(struct unallocSpaceEntry))) {
+                    le32_to_cpu(((struct unallocSpaceEntry *)bh->b_data)->lengthAllocDescs);
+                if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize - sizeof(struct unallocSpaceEntry))) {
                         make_bad_inode(inode);
                         return;
                 }
-                memcpy(UDF_I_DATA(inode),
-                       bh->b_data + sizeof(struct unallocSpaceEntry),
-                       inode->i_sb->s_blocksize -
-                       sizeof(struct unallocSpaceEntry));
+                memcpy(UDF_I_DATA(inode), bh->b_data + sizeof(struct unallocSpaceEntry),
+                       inode->i_sb->s_blocksize - sizeof(struct unallocSpaceEntry));
                 return;
         }
 
@@ -1257,7 +1148,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
 
         if (UDF_I_EFE(inode) == 0) {
                 inode->i_blocks = le64_to_cpu(fe->logicalBlocksRecorded) <<
-                    (inode->i_sb->s_blocksize_bits - 9);
+                        (inode->i_sb->s_blocksize_bits - 9);
 
                 if (udf_stamp_to_time(&convtime, &convtime_usec,
                                       lets_to_cpu(fe->accessTime))) {
@@ -1326,78 +1217,56 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
                 UDF_I_UNIQUE(inode) = le64_to_cpu(efe->uniqueID);
                 UDF_I_LENEATTR(inode) = le32_to_cpu(efe->lengthExtendedAttr);
                 UDF_I_LENALLOC(inode) = le32_to_cpu(efe->lengthAllocDescs);
-                offset =
-                    sizeof(struct extendedFileEntry) + UDF_I_LENEATTR(inode);
+                offset = sizeof(struct extendedFileEntry) + UDF_I_LENEATTR(inode);
         }
 
         switch (fe->icbTag.fileType) {
         case ICBTAG_FILE_TYPE_DIRECTORY:
-                {
-                        inode->i_op = &udf_dir_inode_operations;
-                        inode->i_fop = &udf_dir_operations;
-                        inode->i_mode |= S_IFDIR;
-                        inc_nlink(inode);
-                        break;
-                }
+                inode->i_op = &udf_dir_inode_operations;
+                inode->i_fop = &udf_dir_operations;
+                inode->i_mode |= S_IFDIR;
+                inc_nlink(inode);
+                break;
         case ICBTAG_FILE_TYPE_REALTIME:
         case ICBTAG_FILE_TYPE_REGULAR:
         case ICBTAG_FILE_TYPE_UNDEF:
-                {
-                        if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB)
-                                inode->i_data.a_ops = &udf_adinicb_aops;
-                        else
-                                inode->i_data.a_ops = &udf_aops;
-                        inode->i_op = &udf_file_inode_operations;
-                        inode->i_fop = &udf_file_operations;
-                        inode->i_mode |= S_IFREG;
-                        break;
-                }
+                if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB)
+                        inode->i_data.a_ops = &udf_adinicb_aops;
+                else
+                        inode->i_data.a_ops = &udf_aops;
+                inode->i_op = &udf_file_inode_operations;
+                inode->i_fop = &udf_file_operations;
+                inode->i_mode |= S_IFREG;
+                break;
         case ICBTAG_FILE_TYPE_BLOCK:
-                {
-                        inode->i_mode |= S_IFBLK;
-                        break;
-                }
+                inode->i_mode |= S_IFBLK;
+                break;
         case ICBTAG_FILE_TYPE_CHAR:
-                {
-                        inode->i_mode |= S_IFCHR;
-                        break;
-                }
+                inode->i_mode |= S_IFCHR;
+                break;
         case ICBTAG_FILE_TYPE_FIFO:
-                {
-                        init_special_inode(inode, inode->i_mode | S_IFIFO, 0);
-                        break;
-                }
+                init_special_inode(inode, inode->i_mode | S_IFIFO, 0);
+                break;
         case ICBTAG_FILE_TYPE_SOCKET:
-                {
-                        init_special_inode(inode, inode->i_mode | S_IFSOCK, 0);
-                        break;
-                }
+                init_special_inode(inode, inode->i_mode | S_IFSOCK, 0);
+                break;
         case ICBTAG_FILE_TYPE_SYMLINK:
-                {
-                        inode->i_data.a_ops = &udf_symlink_aops;
-                        inode->i_op = &page_symlink_inode_operations;
-                        inode->i_mode = S_IFLNK | S_IRWXUGO;
-                        break;
-                }
+                inode->i_data.a_ops = &udf_symlink_aops;
+                inode->i_op = &page_symlink_inode_operations;
+                inode->i_mode = S_IFLNK | S_IRWXUGO;
+                break;
         default:
-                {
-                        printk(KERN_ERR
-                               "udf: udf_fill_inode(ino %ld) failed unknown file type=%d\n",
-                               inode->i_ino, fe->icbTag.fileType);
-                        make_bad_inode(inode);
-                        return;
-                }
+                printk(KERN_ERR "udf: udf_fill_inode(ino %ld) failed unknown file type=%d\n",
+                       inode->i_ino, fe->icbTag.fileType);
+                make_bad_inode(inode);
+                return;
         }
         if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
-                struct deviceSpec *dsea = (struct deviceSpec *)
-                    udf_get_extendedattr(inode, 12, 1);
-
+                struct deviceSpec *dsea = (struct deviceSpec *)udf_get_extendedattr(inode, 12, 1);
                 if (dsea) {
                         init_special_inode(inode, inode->i_mode,
-                                           MKDEV(le32_to_cpu
-                                                 (dsea->majorDeviceIdent),
-                                                 le32_to_cpu(dsea->
-                                                             minorDeviceIdent)));
+                                           MKDEV(le32_to_cpu(dsea->majorDeviceIdent),
+                                                 le32_to_cpu(dsea->minorDeviceIdent)));
                         /* Developer ID ??? */
                 } else {
                         make_bad_inode(inode);
@@ -1410,8 +1279,7 @@ static int udf_alloc_i_data(struct inode *inode, size_t size)
         UDF_I_DATA(inode) = kmalloc(size, GFP_KERNEL);
 
         if (!UDF_I_DATA(inode)) {
-                printk(KERN_ERR
-                       "udf:udf_alloc_i_data (ino %ld) no free memory\n",
+                printk(KERN_ERR "udf:udf_alloc_i_data (ino %ld) no free memory\n",
                        inode->i_ino);
                 return -ENOMEM;
         }
@@ -1428,12 +1296,12 @@ static mode_t udf_convert_permissions(struct fileEntry *fe)
         permissions = le32_to_cpu(fe->permissions);
         flags = le16_to_cpu(fe->icbTag.flags);
 
-        mode = ((permissions) & S_IRWXO) |
-            ((permissions >> 2) & S_IRWXG) |
-            ((permissions >> 4) & S_IRWXU) |
-            ((flags & ICBTAG_FLAG_SETUID) ? S_ISUID : 0) |
-            ((flags & ICBTAG_FLAG_SETGID) ? S_ISGID : 0) |
-            ((flags & ICBTAG_FLAG_STICKY) ? S_ISVTX : 0);
+        mode =  (( permissions      ) & S_IRWXO) |
+                (( permissions >> 2 ) & S_IRWXG) |
+                (( permissions >> 4 ) & S_IRWXU) |
+                (( flags & ICBTAG_FLAG_SETUID) ? S_ISUID : 0) |
+                (( flags & ICBTAG_FLAG_SETGID) ? S_ISGID : 0) |
+                (( flags & ICBTAG_FLAG_STICKY) ? S_ISVTX : 0);
 
         return mode;
 }
@@ -1456,9 +1324,11 @@ static mode_t udf_convert_permissions(struct fileEntry *fe)
 int udf_write_inode(struct inode *inode, int sync)
 {
         int ret;
+
         lock_kernel();
         ret = udf_update_inode(inode, sync);
         unlock_kernel();
+
         return ret;
 }
 
@@ -1479,10 +1349,7 @@ static int udf_update_inode(struct inode *inode, int do_sync)
         kernel_timestamp cpu_time;
         int err = 0;
 
-        bh = udf_tread(inode->i_sb,
-                       udf_get_lb_pblock(inode->i_sb, UDF_I_LOCATION(inode),
-                                         0));
-
+        bh = udf_tread(inode->i_sb, udf_get_lb_pblock(inode->i_sb, UDF_I_LOCATION(inode), 0));
         if (!bh) {
                 udf_debug("bread failure\n");
                 return -EIO;
@@ -1495,27 +1362,21 @@ static int udf_update_inode(struct inode *inode, int do_sync)
 
         if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_USE) {
                 struct unallocSpaceEntry *use =
-                    (struct unallocSpaceEntry *)bh->b_data;
+                        (struct unallocSpaceEntry *)bh->b_data;
 
                 use->lengthAllocDescs = cpu_to_le32(UDF_I_LENALLOC(inode));
-                memcpy(bh->b_data + sizeof(struct unallocSpaceEntry),
-                       UDF_I_DATA(inode),
-                       inode->i_sb->s_blocksize -
-                       sizeof(struct unallocSpaceEntry));
-                crclen =
-                    sizeof(struct unallocSpaceEntry) + UDF_I_LENALLOC(inode) -
-                    sizeof(tag);
-                use->descTag.tagLocation =
-                    cpu_to_le32(UDF_I_LOCATION(inode).logicalBlockNum);
+                memcpy(bh->b_data + sizeof(struct unallocSpaceEntry), UDF_I_DATA(inode),
+                       inode->i_sb->s_blocksize - sizeof(struct unallocSpaceEntry));
+                crclen = sizeof(struct unallocSpaceEntry) + UDF_I_LENALLOC(inode) - sizeof(tag);
+                use->descTag.tagLocation = cpu_to_le32(UDF_I_LOCATION(inode).logicalBlockNum);
                 use->descTag.descCRCLength = cpu_to_le16(crclen);
-                use->descTag.descCRC =
-                    cpu_to_le16(udf_crc((char *)use + sizeof(tag), crclen, 0));
+                use->descTag.descCRC = cpu_to_le16(udf_crc((char *)use + sizeof(tag), crclen, 0));
 
                 use->descTag.tagChecksum = 0;
-                for (i = 0; i < 16; i++)
+                for (i = 0; i < 16; i++) {
                         if (i != 4)
-                                use->descTag.tagChecksum +=
-                                    ((uint8_t *) & (use->descTag))[i];
+                                use->descTag.tagChecksum += ((uint8_t *)&(use->descTag))[i];
+                }
 
                 mark_buffer_dirty(bh);
                 brelse(bh);
@@ -1532,13 +1393,14 @@ static int udf_update_inode(struct inode *inode, int do_sync)
         else
                 fe->gid = cpu_to_le32(inode->i_gid);
 
-        udfperms = ((inode->i_mode & S_IRWXO)) |
-            ((inode->i_mode & S_IRWXG) << 2) | ((inode->i_mode & S_IRWXU) << 4);
+        udfperms =      ((inode->i_mode & S_IRWXO)     ) |
+                        ((inode->i_mode & S_IRWXG) << 2) |
+                        ((inode->i_mode & S_IRWXU) << 4);
 
-        udfperms |= (le32_to_cpu(fe->permissions) &
-                     (FE_PERM_O_DELETE | FE_PERM_O_CHATTR |
-                      FE_PERM_G_DELETE | FE_PERM_G_CHATTR |
-                      FE_PERM_U_DELETE | FE_PERM_U_CHATTR));
+        udfperms |=     (le32_to_cpu(fe->permissions) &
+                        (FE_PERM_O_DELETE | FE_PERM_O_CHATTR |
+                         FE_PERM_G_DELETE | FE_PERM_G_CHATTR |
+                         FE_PERM_U_DELETE | FE_PERM_U_CHATTR));
         fe->permissions = cpu_to_le32(udfperms);
 
         if (S_ISDIR(inode->i_mode))
@@ -1550,22 +1412,20 @@ static int udf_update_inode(struct inode *inode, int do_sync)
 
         if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
                 regid *eid;
-                struct deviceSpec *dsea = (struct deviceSpec *)
-                    udf_get_extendedattr(inode, 12, 1);
-
+                struct deviceSpec *dsea =
+                        (struct deviceSpec *)udf_get_extendedattr(inode, 12, 1);
                 if (!dsea) {
                         dsea = (struct deviceSpec *)
-                            udf_add_extendedattr(inode,
-                                                 sizeof(struct deviceSpec) +
-                                                 sizeof(regid), 12, 0x3);
+                                udf_add_extendedattr(inode,
+                                                     sizeof(struct deviceSpec) +
+                                                     sizeof(regid), 12, 0x3);
                         dsea->attrType = cpu_to_le32(12);
                         dsea->attrSubtype = 1;
-                        dsea->attrLength =
-                            cpu_to_le32(sizeof(struct deviceSpec) +
-                                        sizeof(regid));
+                        dsea->attrLength = cpu_to_le32(sizeof(struct deviceSpec) +
+                                                       sizeof(regid));
                         dsea->impUseLength = cpu_to_le32(sizeof(regid));
                 }
-                eid = (regid *) dsea->impUse;
+                eid = (regid *)dsea->impUse;
                 memset(eid, 0, sizeof(regid));
                 strcpy(eid->ident, UDF_ID_DEVELOPER);
                 eid->identSuffix[0] = UDF_OS_CLASS_UNIX;
@@ -1577,10 +1437,9 @@ static int udf_update_inode(struct inode *inode, int do_sync)
         if (UDF_I_EFE(inode) == 0) {
                 memcpy(bh->b_data + sizeof(struct fileEntry), UDF_I_DATA(inode),
                        inode->i_sb->s_blocksize - sizeof(struct fileEntry));
-                fe->logicalBlocksRecorded =
-                    cpu_to_le64((inode->i_blocks +
-                                 (1 << (inode->i_sb->s_blocksize_bits - 9)) -
-                                 1) >> (inode->i_sb->s_blocksize_bits - 9));
+                fe->logicalBlocksRecorded = cpu_to_le64(
+                        (inode->i_blocks + (1 << (inode->i_sb->s_blocksize_bits - 9)) - 1) >>
+                        (inode->i_sb->s_blocksize_bits - 9));
 
                 if (udf_time_to_stamp(&cpu_time, inode->i_atime))
                         fe->accessTime = cpu_to_lets(cpu_time);
@@ -1598,19 +1457,12 @@ static int udf_update_inode(struct inode *inode, int do_sync)
                 fe->descTag.tagIdent = cpu_to_le16(TAG_IDENT_FE);
                 crclen = sizeof(struct fileEntry);
         } else {
-                memcpy(bh->b_data + sizeof(struct extendedFileEntry),
-                       UDF_I_DATA(inode),
-                       inode->i_sb->s_blocksize -
-                       sizeof(struct extendedFileEntry));
+                memcpy(bh->b_data + sizeof(struct extendedFileEntry), UDF_I_DATA(inode),
+                       inode->i_sb->s_blocksize - sizeof(struct extendedFileEntry));
                 efe->objectSize = cpu_to_le64(inode->i_size);
-                efe->logicalBlocksRecorded = cpu_to_le64((inode->i_blocks +
-                                                          (1 <<
-                                                           (inode->i_sb->
-                                                            s_blocksize_bits -
-                                                            9)) -
-                                                          1) >> (inode->i_sb->
-                                                                 s_blocksize_bits
-                                                                 - 9));
+                efe->logicalBlocksRecorded = cpu_to_le64(
+                        (inode->i_blocks + (1 << (inode->i_sb->s_blocksize_bits - 9)) - 1) >>
+                        (inode->i_sb->s_blocksize_bits - 9));
 
                 if (UDF_I_CRTIME(inode).tv_sec > inode->i_atime.tv_sec ||
                     (UDF_I_CRTIME(inode).tv_sec == inode->i_atime.tv_sec &&
@@ -1671,13 +1523,13 @@ static int udf_update_inode(struct inode *inode, int do_sync)
         else if (S_ISSOCK(inode->i_mode))
                 fe->icbTag.fileType = ICBTAG_FILE_TYPE_SOCKET;
 
-        icbflags = UDF_I_ALLOCTYPE(inode) |
-            ((inode->i_mode & S_ISUID) ? ICBTAG_FLAG_SETUID : 0) |
-            ((inode->i_mode & S_ISGID) ? ICBTAG_FLAG_SETGID : 0) |
-            ((inode->i_mode & S_ISVTX) ? ICBTAG_FLAG_STICKY : 0) |
-            (le16_to_cpu(fe->icbTag.flags) &
-             ~(ICBTAG_FLAG_AD_MASK | ICBTAG_FLAG_SETUID |
-               ICBTAG_FLAG_SETGID | ICBTAG_FLAG_STICKY));
+        icbflags =      UDF_I_ALLOCTYPE(inode) |
+                        ((inode->i_mode & S_ISUID) ? ICBTAG_FLAG_SETUID : 0) |
+                        ((inode->i_mode & S_ISGID) ? ICBTAG_FLAG_SETGID : 0) |
+                        ((inode->i_mode & S_ISVTX) ? ICBTAG_FLAG_STICKY : 0) |
+                        (le16_to_cpu(fe->icbTag.flags) &
+                                ~(ICBTAG_FLAG_AD_MASK | ICBTAG_FLAG_SETUID |
+                                ICBTAG_FLAG_SETGID | ICBTAG_FLAG_STICKY));
 
         fe->icbTag.flags = cpu_to_le16(icbflags);
         if (UDF_SB_UDFREV(inode->i_sb) >= 0x0200)
@@ -1685,18 +1537,16 @@ static int udf_update_inode(struct inode *inode, int do_sync)
         else
                 fe->descTag.descVersion = cpu_to_le16(2);
         fe->descTag.tagSerialNum = cpu_to_le16(UDF_SB_SERIALNUM(inode->i_sb));
-        fe->descTag.tagLocation =
-            cpu_to_le32(UDF_I_LOCATION(inode).logicalBlockNum);
+        fe->descTag.tagLocation = cpu_to_le32(UDF_I_LOCATION(inode).logicalBlockNum);
         crclen += UDF_I_LENEATTR(inode) + UDF_I_LENALLOC(inode) - sizeof(tag);
         fe->descTag.descCRCLength = cpu_to_le16(crclen);
-        fe->descTag.descCRC =
-            cpu_to_le16(udf_crc((char *)fe + sizeof(tag), crclen, 0));
+        fe->descTag.descCRC = cpu_to_le16(udf_crc((char *)fe + sizeof(tag), crclen, 0));
 
         fe->descTag.tagChecksum = 0;
-        for (i = 0; i < 16; i++)
+        for (i = 0; i < 16; i++) {
                 if (i != 4)
-                        fe->descTag.tagChecksum +=
-                            ((uint8_t *) & (fe->descTag))[i];
+                        fe->descTag.tagChecksum += ((uint8_t *)&(fe->descTag))[i];
+        }
 
         /* write the data blocks */
         mark_buffer_dirty(bh);
@@ -1709,6 +1559,7 @@ static int udf_update_inode(struct inode *inode, int do_sync)
                 }
         }
         brelse(bh);
+
         return err;
 }
 
@@ -1729,8 +1580,7 @@ struct inode *udf_iget(struct super_block *sb, kernel_lb_addr ino)
         if (is_bad_inode(inode))
                 goto out_iput;
 
-        if (ino.logicalBlockNum >=
-            UDF_SB_PARTLEN(sb, ino.partitionReferenceNum)) {
+        if (ino.logicalBlockNum >= UDF_SB_PARTLEN(sb, ino.partitionReferenceNum)) {
                 udf_debug("block=%d, partition=%d out of range\n",
                           ino.logicalBlockNum, ino.partitionReferenceNum);
                 make_bad_inode(inode);
@@ -1739,7 +1589,7 @@ struct inode *udf_iget(struct super_block *sb, kernel_lb_addr ino)
 
         return inode;
 
-      out_iput:
+ out_iput:
         iput(inode);
         return NULL;
 }
@@ -1755,9 +1605,7 @@ int8_t udf_add_aext(struct inode * inode, struct extent_position * epos,
         uint8_t *ptr;
 
         if (!epos->bh)
-                ptr =
-                    UDF_I_DATA(inode) + epos->offset -
-                    udf_file_entry_alloc_offset(inode) + UDF_I_LENEATTR(inode);
+                ptr = UDF_I_DATA(inode) + epos->offset - udf_file_entry_alloc_offset(inode) + UDF_I_LENEATTR(inode);
         else
                 ptr = epos->bh->b_data + epos->offset;
 
@@ -1774,18 +1622,13 @@ int8_t udf_add_aext(struct inode * inode, struct extent_position * epos,
                 int err, loffset;
                 kernel_lb_addr obloc = epos->block;
 
-                if (!
-                    (epos->block.logicalBlockNum =
-                     udf_new_block(inode->i_sb, NULL,
-                                   obloc.partitionReferenceNum,
-                                   obloc.logicalBlockNum, &err))) {
+                if (!(epos->block.logicalBlockNum = udf_new_block(inode->i_sb, NULL,
+                                                                  obloc.partitionReferenceNum,
+                                                                  obloc.logicalBlockNum, &err))) {
                         return -1;
                 }
-                if (!
-                    (nbh =
-                     udf_tgetblk(inode->i_sb,
-                                 udf_get_lb_pblock(inode->i_sb, epos->block,
-                                                   0)))) {
+                if (!(nbh = udf_tgetblk(inode->i_sb, udf_get_lb_pblock(inode->i_sb,
+                                                                       epos->block, 0)))) {
                         return -1;
                 }
                 lock_buffer(nbh);
@@ -1796,8 +1639,7 @@ int8_t udf_add_aext(struct inode * inode, struct extent_position * epos,
 
                 aed = (struct allocExtDesc *)(nbh->b_data);
                 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT))
-                        aed->previousAllocExtLocation =
-                            cpu_to_le32(obloc.logicalBlockNum);
+                        aed->previousAllocExtLocation = cpu_to_le32(obloc.logicalBlockNum);
                 if (epos->offset + adsize > inode->i_sb->s_blocksize) {
                         loffset = epos->offset;
                         aed->lengthAllocDescs = cpu_to_le32(adsize);
@@ -1814,9 +1656,7 @@ int8_t udf_add_aext(struct inode * inode, struct extent_position * epos,
                         if (epos->bh) {
                                 aed = (struct allocExtDesc *)epos->bh->b_data;
                                 aed->lengthAllocDescs =
-                                    cpu_to_le32(le32_to_cpu
-                                                (aed->lengthAllocDescs) +
-                                                adsize);
+                                        cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize);
                         } else {
                                 UDF_I_LENALLOC(inode) += adsize;
                                 mark_inode_dirty(inode);
@@ -1830,37 +1670,30 @@ int8_t udf_add_aext(struct inode * inode, struct extent_position * epos,
                                     epos->block.logicalBlockNum, sizeof(tag));
                 switch (UDF_I_ALLOCTYPE(inode)) {
                 case ICBTAG_FLAG_AD_SHORT:
-                        {
-                                sad = (short_ad *) sptr;
-                                sad->extLength =
-                                    cpu_to_le32(EXT_NEXT_EXTENT_ALLOCDECS |
-                                                inode->i_sb->s_blocksize);
-                                sad->extPosition =
-                                    cpu_to_le32(epos->block.logicalBlockNum);
-                                break;
-                        }
+                        sad = (short_ad *)sptr;
+                        sad->extLength = cpu_to_le32(EXT_NEXT_EXTENT_ALLOCDECS |
+                                                     inode->i_sb->s_blocksize);
+                        sad->extPosition = cpu_to_le32(epos->block.logicalBlockNum);
+                        break;
                 case ICBTAG_FLAG_AD_LONG:
-                        {
-                                lad = (long_ad *) sptr;
-                                lad->extLength =
-                                    cpu_to_le32(EXT_NEXT_EXTENT_ALLOCDECS |
-                                                inode->i_sb->s_blocksize);
-                                lad->extLocation = cpu_to_lelb(epos->block);
-                                memset(lad->impUse, 0x00, sizeof(lad->impUse));
-                                break;
-                        }
+                        lad = (long_ad *)sptr;
+                        lad->extLength = cpu_to_le32(EXT_NEXT_EXTENT_ALLOCDECS |
+                                                     inode->i_sb->s_blocksize);
+                        lad->extLocation = cpu_to_lelb(epos->block);
+                        memset(lad->impUse, 0x00, sizeof(lad->impUse));
+                        break;
                 }
                 if (epos->bh) {
-                        if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT)
-                            || UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
+                        if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
+                            UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
                                 udf_update_tag(epos->bh->b_data, loffset);
                         else
-                                udf_update_tag(epos->bh->b_data,
-                                               sizeof(struct allocExtDesc));
+                                udf_update_tag(epos->bh->b_data, sizeof(struct allocExtDesc));
                         mark_buffer_dirty_inode(epos->bh, inode);
                         brelse(epos->bh);
-                } else
+                } else {
                         mark_inode_dirty(inode);
+                }
                 epos->bh = nbh;
         }
 
@@ -1872,14 +1705,11 @@ int8_t udf_add_aext(struct inode * inode, struct extent_position * epos,
         } else {
                 aed = (struct allocExtDesc *)epos->bh->b_data;
                 aed->lengthAllocDescs =
-                    cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize);
-                if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT)
-                    || UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
-                        udf_update_tag(epos->bh->b_data,
-                                       epos->offset + (inc ? 0 : adsize));
+                        cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize);
+                if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
+                        udf_update_tag(epos->bh->b_data, epos->offset + (inc ? 0 : adsize));
                 else
-                        udf_update_tag(epos->bh->b_data,
-                                       sizeof(struct allocExtDesc));
+                        udf_update_tag(epos->bh->b_data, sizeof(struct allocExtDesc));
                 mark_buffer_dirty_inode(epos->bh, inode);
         }
 
@@ -1891,51 +1721,47 @@ int8_t udf_write_aext(struct inode * inode, struct extent_position * epos,
 {
         int adsize;
         uint8_t *ptr;
+        short_ad *sad;
+        long_ad *lad;
 
         if (!epos->bh)
-                ptr =
-                    UDF_I_DATA(inode) + epos->offset -
-                    udf_file_entry_alloc_offset(inode) + UDF_I_LENEATTR(inode);
+                ptr = UDF_I_DATA(inode) + epos->offset - udf_file_entry_alloc_offset(inode) + UDF_I_LENEATTR(inode);
         else
                 ptr = epos->bh->b_data + epos->offset;
 
         switch (UDF_I_ALLOCTYPE(inode)) {
         case ICBTAG_FLAG_AD_SHORT:
-                {
-                        short_ad *sad = (short_ad *) ptr;
-                        sad->extLength = cpu_to_le32(elen);
-                        sad->extPosition = cpu_to_le32(eloc.logicalBlockNum);
-                        adsize = sizeof(short_ad);
-                        break;
-                }
+                sad = (short_ad *)ptr;
+                sad->extLength = cpu_to_le32(elen);
+                sad->extPosition = cpu_to_le32(eloc.logicalBlockNum);
+                adsize = sizeof(short_ad);
+                break;
         case ICBTAG_FLAG_AD_LONG:
-                {
-                        long_ad *lad = (long_ad *) ptr;
-                        lad->extLength = cpu_to_le32(elen);
-                        lad->extLocation = cpu_to_lelb(eloc);
-                        memset(lad->impUse, 0x00, sizeof(lad->impUse));
-                        adsize = sizeof(long_ad);
-                        break;
-                }
+                lad = (long_ad *)ptr;
+                lad->extLength = cpu_to_le32(elen);
+                lad->extLocation = cpu_to_lelb(eloc);
+                memset(lad->impUse, 0x00, sizeof(lad->impUse));
+                adsize = sizeof(long_ad);
+                break;
         default:
                 return -1;
         }
 
         if (epos->bh) {
-                if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT)
-                    || UDF_SB_UDFREV(inode->i_sb) >= 0x0201) {
-                        struct allocExtDesc *aed =
-                            (struct allocExtDesc *)epos->bh->b_data;
+                if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
+                    UDF_SB_UDFREV(inode->i_sb) >= 0x0201) {
+                        struct allocExtDesc *aed = (struct allocExtDesc *)epos->bh->b_data;
                         udf_update_tag(epos->bh->b_data,
-                                       le32_to_cpu(aed->lengthAllocDescs) +
-                                       sizeof(struct allocExtDesc));
+                                       le32_to_cpu(aed->lengthAllocDescs) + sizeof(struct allocExtDesc));
                 }
                 mark_buffer_dirty_inode(epos->bh, inode);
-        } else
+        } else {
                 mark_inode_dirty(inode);
+        }
 
         if (inc)
                 epos->offset += adsize;
+
         return (elen >> 30);
 }
 
@@ -1949,14 +1775,9 @@ int8_t udf_next_aext(struct inode * inode, struct extent_position * epos,
                 epos->block = *eloc;
                 epos->offset = sizeof(struct allocExtDesc);
                 brelse(epos->bh);
-                if (!
-                    (epos->bh =
-                     udf_tread(inode->i_sb,
-                               udf_get_lb_pblock(inode->i_sb, epos->block,
-                                                 0)))) {
+                if (!(epos->bh = udf_tread(inode->i_sb, udf_get_lb_pblock(inode->i_sb, epos->block, 0)))) {
                         udf_debug("reading block %d failed!\n",
-                                  udf_get_lb_pblock(inode->i_sb, epos->block,
-                                                    0));
+                                  udf_get_lb_pblock(inode->i_sb, epos->block, 0));
                         return -1;
                 }
         }
@@ -1970,75 +1791,49 @@ int8_t udf_current_aext(struct inode * inode, struct extent_position * epos,
         int alen;
         int8_t etype;
         uint8_t *ptr;
+        short_ad *sad;
+        long_ad *lad;
+
 
         if (!epos->bh) {
                 if (!epos->offset)
                         epos->offset = udf_file_entry_alloc_offset(inode);
-                ptr =
-                    UDF_I_DATA(inode) + epos->offset -
-                    udf_file_entry_alloc_offset(inode) + UDF_I_LENEATTR(inode);
-                alen =
-                    udf_file_entry_alloc_offset(inode) + UDF_I_LENALLOC(inode);
+                ptr = UDF_I_DATA(inode) + epos->offset - udf_file_entry_alloc_offset(inode) + UDF_I_LENEATTR(inode);
+                alen = udf_file_entry_alloc_offset(inode) + UDF_I_LENALLOC(inode);
         } else {
                 if (!epos->offset)
                         epos->offset = sizeof(struct allocExtDesc);
                 ptr = epos->bh->b_data + epos->offset;
-                alen =
-                    sizeof(struct allocExtDesc) +
-                    le32_to_cpu(((struct allocExtDesc *)epos->bh->b_data)->
-                                lengthAllocDescs);
+                alen = sizeof(struct allocExtDesc) +
+                        le32_to_cpu(((struct allocExtDesc *)epos->bh->b_data)->lengthAllocDescs);
         }
 
         switch (UDF_I_ALLOCTYPE(inode)) {
         case ICBTAG_FLAG_AD_SHORT:
-                {
-                        short_ad *sad;
-
-                        if (!
-                            (sad =
-                             udf_get_fileshortad(ptr, alen, &epos->offset,
-                                                 inc)))
-                                return -1;
-
-                        etype = le32_to_cpu(sad->extLength) >> 30;
-                        eloc->logicalBlockNum = le32_to_cpu(sad->extPosition);
-                        eloc->partitionReferenceNum =
-                            UDF_I_LOCATION(inode).partitionReferenceNum;
-                        *elen =
-                            le32_to_cpu(sad->
-                                        extLength) & UDF_EXTENT_LENGTH_MASK;
-                        break;
-                }
+                if (!(sad = udf_get_fileshortad(ptr, alen, &epos->offset, inc)))
+                        return -1;
+                etype = le32_to_cpu(sad->extLength) >> 30;
+                eloc->logicalBlockNum = le32_to_cpu(sad->extPosition);
+                eloc->partitionReferenceNum = UDF_I_LOCATION(inode).partitionReferenceNum;
+                *elen = le32_to_cpu(sad->extLength) & UDF_EXTENT_LENGTH_MASK;
+                break;
         case ICBTAG_FLAG_AD_LONG:
-                {
-                        long_ad *lad;
-
-                        if (!
-                            (lad =
-                             udf_get_filelongad(ptr, alen, &epos->offset, inc)))
-                                return -1;
-
-                        etype = le32_to_cpu(lad->extLength) >> 30;
-                        *eloc = lelb_to_cpu(lad->extLocation);
-                        *elen =
-                            le32_to_cpu(lad->
-                                        extLength) & UDF_EXTENT_LENGTH_MASK;
-                        break;
-                }
-        default:
-                {
-                        udf_debug("alloc_type = %d unsupported\n",
-                                  UDF_I_ALLOCTYPE(inode));
+                if (!(lad = udf_get_filelongad(ptr, alen, &epos->offset, inc)))
                         return -1;
-                }
+                etype = le32_to_cpu(lad->extLength) >> 30;
+                *eloc = lelb_to_cpu(lad->extLocation);
+                *elen = le32_to_cpu(lad->extLength) & UDF_EXTENT_LENGTH_MASK;
+                break;
+        default:
+                udf_debug("alloc_type = %d unsupported\n", UDF_I_ALLOCTYPE(inode));
+                return -1;
         }
 
         return etype;
 }
 
-static int8_t
-udf_insert_aext(struct inode *inode, struct extent_position epos,
-                kernel_lb_addr neloc, uint32_t nelen)
+static int8_t udf_insert_aext(struct inode *inode, struct extent_position epos,
+                              kernel_lb_addr neloc, uint32_t nelen)
 {
         kernel_lb_addr oeloc;
         uint32_t oelen;
@@ -2049,12 +1844,12 @@ udf_insert_aext(struct inode *inode, struct extent_position epos,
 
         while ((etype = udf_next_aext(inode, &epos, &oeloc, &oelen, 0)) != -1) {
                 udf_write_aext(inode, &epos, neloc, nelen, 1);
-
                 neloc = oeloc;
                 nelen = (etype << 30) | oelen;
         }
         udf_add_aext(inode, &epos, neloc, nelen, 1);
         brelse(epos.bh);
+
         return (nelen >> 30);
 }
 
@@ -2105,15 +1900,12 @@ int8_t udf_delete_aext(struct inode * inode, struct extent_position epos,
                 } else {
                         aed = (struct allocExtDesc *)oepos.bh->b_data;
                         aed->lengthAllocDescs =
-                            cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) -
-                                        (2 * adsize));
-                        if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT)
-                            || UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
-                                udf_update_tag(oepos.bh->b_data,
-                                               oepos.offset - (2 * adsize));
+                                cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) - (2 * adsize));
+                        if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
+                            UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
+                                udf_update_tag(oepos.bh->b_data, oepos.offset - (2 * adsize));
                         else
-                                udf_update_tag(oepos.bh->b_data,
-                                               sizeof(struct allocExtDesc));
+                                udf_update_tag(oepos.bh->b_data, sizeof(struct allocExtDesc));
                         mark_buffer_dirty_inode(oepos.bh, inode);
                 }
         } else {
@@ -2124,21 +1916,19 @@ int8_t udf_delete_aext(struct inode * inode, struct extent_position epos,
                 } else {
                         aed = (struct allocExtDesc *)oepos.bh->b_data;
                         aed->lengthAllocDescs =
-                            cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) -
-                                        adsize);
-                        if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT)
-                            || UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
-                                udf_update_tag(oepos.bh->b_data,
-                                               epos.offset - adsize);
+                                cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) - adsize);
+                        if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
+                            UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
+                                udf_update_tag(oepos.bh->b_data, epos.offset - adsize);
                         else
-                                udf_update_tag(oepos.bh->b_data,
-                                               sizeof(struct allocExtDesc));
+                                udf_update_tag(oepos.bh->b_data, sizeof(struct allocExtDesc));
                         mark_buffer_dirty_inode(oepos.bh, inode);
                 }
         }
 
         brelse(epos.bh);
         brelse(oepos.bh);
+
         return (elen >> 30);
 }
 
@@ -2162,8 +1952,7 @@ int8_t inode_bmap(struct inode * inode, sector_t block,
 
         do {
                 if ((etype = udf_next_aext(inode, pos, eloc, elen, 1)) == -1) {
-                        *offset =
-                            (bcount - lbcount) >> inode->i_sb->s_blocksize_bits;
+                        *offset = (bcount - lbcount) >> inode->i_sb->s_blocksize_bits;
                         UDF_I_LENEXTENTS(inode) = lbcount;
                         return -1;
                 }
@@ -2180,13 +1969,12 @@ long udf_block_map(struct inode *inode, sector_t block)
         kernel_lb_addr eloc;
         uint32_t elen;
         sector_t offset;
-        struct extent_position epos = { NULL, 0, {0, 0} };
+        struct extent_position epos = {};
         int ret;
 
         lock_kernel();
 
-        if (inode_bmap(inode, block, &epos, &eloc, &elen, &offset) ==
-            (EXT_RECORDED_ALLOCATED >> 30))
+        if (inode_bmap(inode, block, &epos, &eloc, &elen, &offset) == (EXT_RECORDED_ALLOCATED >> 30))
                 ret = udf_get_lb_pblock(inode->i_sb, eloc, offset);
         else
                 ret = 0;
diff --git a/fs/udf/lowlevel.c b/fs/udf/lowlevel.c
index 4826c3616eef..579bae71e67e 100644
--- a/fs/udf/lowlevel.c
+++ b/fs/udf/lowlevel.c
@@ -43,7 +43,7 @@ unsigned int udf_get_last_session(struct super_block *sb)
                 udf_debug("XA disk: %s, vol_desc_start=%d\n",
                           (ms_info.xa_flag ? "yes" : "no"), ms_info.addr.lba);
 #if WE_OBEY_THE_WRITTEN_STANDARDS
-                if (ms_info.xa_flag)    /* necessary for a valid ms_info.addr */
+                if (ms_info.xa_flag) /* necessary for a valid ms_info.addr */
 #endif
                         vol_desc_start = ms_info.addr.lba;
         } else {
@@ -57,7 +57,7 @@ unsigned long udf_get_last_block(struct super_block *sb)
         struct block_device *bdev = sb->s_bdev;
         unsigned long lblock = 0;
 
-        if (ioctl_by_bdev(bdev, CDROM_LAST_WRITTEN, (unsigned long)&lblock))
+        if (ioctl_by_bdev(bdev, CDROM_LAST_WRITTEN, (unsigned long) &lblock))
                 lblock = bdev->bd_inode->i_size >> sb->s_blocksize_bits;
 
         if (lblock)
diff --git a/fs/udf/misc.c b/fs/udf/misc.c
index a7f57277a96e..15297deb5051 100644
--- a/fs/udf/misc.c
+++ b/fs/udf/misc.c
@@ -54,15 +54,15 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size,
         int i;
 
         ea = UDF_I_DATA(inode);
-        if (UDF_I_LENEATTR(inode))
+        if (UDF_I_LENEATTR(inode)) {
                 ad = UDF_I_DATA(inode) + UDF_I_LENEATTR(inode);
-        else {
+        } else {
                 ad = ea;
                 size += sizeof(struct extendedAttrHeaderDesc);
         }
 
         offset = inode->i_sb->s_blocksize - udf_file_entry_alloc_offset(inode) -
-            UDF_I_LENALLOC(inode);
+                UDF_I_LENALLOC(inode);
 
         /* TODO - Check for FreeEASpace */
 
@@ -76,56 +76,45 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size,
 
                 if (UDF_I_LENEATTR(inode)) {
                         /* check checksum/crc */
-                        if (le16_to_cpu(eahd->descTag.tagIdent) !=
-                            TAG_IDENT_EAHD
-                            || le32_to_cpu(eahd->descTag.tagLocation) !=
-                            UDF_I_LOCATION(inode).logicalBlockNum) {
+                        if (le16_to_cpu(eahd->descTag.tagIdent) != TAG_IDENT_EAHD ||
+                            le32_to_cpu(eahd->descTag.tagLocation) != UDF_I_LOCATION(inode).logicalBlockNum) {
                                 return NULL;
                         }
                 } else {
                         size -= sizeof(struct extendedAttrHeaderDesc);
-                        UDF_I_LENEATTR(inode) +=
-                            sizeof(struct extendedAttrHeaderDesc);
+                        UDF_I_LENEATTR(inode) += sizeof(struct extendedAttrHeaderDesc);
                         eahd->descTag.tagIdent = cpu_to_le16(TAG_IDENT_EAHD);
                         if (UDF_SB_UDFREV(inode->i_sb) >= 0x0200)
                                 eahd->descTag.descVersion = cpu_to_le16(3);
                         else
                                 eahd->descTag.descVersion = cpu_to_le16(2);
-                        eahd->descTag.tagSerialNum =
-                            cpu_to_le16(UDF_SB_SERIALNUM(inode->i_sb));
-                        eahd->descTag.tagLocation =
-                            cpu_to_le32(UDF_I_LOCATION(inode).logicalBlockNum);
+                        eahd->descTag.tagSerialNum = cpu_to_le16(UDF_SB_SERIALNUM(inode->i_sb));
+                        eahd->descTag.tagLocation = cpu_to_le32(UDF_I_LOCATION(inode).logicalBlockNum);
                         eahd->impAttrLocation = cpu_to_le32(0xFFFFFFFF);
                         eahd->appAttrLocation = cpu_to_le32(0xFFFFFFFF);
                 }
 
                 offset = UDF_I_LENEATTR(inode);
                 if (type < 2048) {
-                        if (le32_to_cpu(eahd->appAttrLocation) <
-                            UDF_I_LENEATTR(inode)) {
-                                uint32_t aal =
-                                    le32_to_cpu(eahd->appAttrLocation);
-                                memmove(&ea[offset - aal + size], &ea[aal],
-                                        offset - aal);
+                        if (le32_to_cpu(eahd->appAttrLocation) < UDF_I_LENEATTR(inode)) {
+                                uint32_t aal = le32_to_cpu(eahd->appAttrLocation);
+                                memmove(&ea[offset - aal + size],
+                                        &ea[aal], offset - aal);
                                 offset -= aal;
                                 eahd->appAttrLocation = cpu_to_le32(aal + size);
                         }
-                        if (le32_to_cpu(eahd->impAttrLocation) <
-                            UDF_I_LENEATTR(inode)) {
-                                uint32_t ial =
-                                    le32_to_cpu(eahd->impAttrLocation);
-                                memmove(&ea[offset - ial + size], &ea[ial],
-                                        offset - ial);
+                        if (le32_to_cpu(eahd->impAttrLocation) < UDF_I_LENEATTR(inode)) {
+                                uint32_t ial = le32_to_cpu(eahd->impAttrLocation);
+                                memmove(&ea[offset - ial + size],
+                                        &ea[ial], offset - ial);
                                 offset -= ial;
                                 eahd->impAttrLocation = cpu_to_le32(ial + size);
                         }
                 } else if (type < 65536) {
-                        if (le32_to_cpu(eahd->appAttrLocation) <
-                            UDF_I_LENEATTR(inode)) {
-                                uint32_t aal =
-                                    le32_to_cpu(eahd->appAttrLocation);
-                                memmove(&ea[offset - aal + size], &ea[aal],
-                                        offset - aal);
+                        if (le32_to_cpu(eahd->appAttrLocation) < UDF_I_LENEATTR(inode)) {
+                                uint32_t aal = le32_to_cpu(eahd->appAttrLocation);
+                                memmove(&ea[offset - aal + size],
+                                        &ea[aal], offset - aal);
                                 offset -= aal;
                                 eahd->appAttrLocation = cpu_to_le32(aal + size);
                         }
@@ -133,18 +122,18 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size,
                 /* rewrite CRC + checksum of eahd */
                 crclen = sizeof(struct extendedAttrHeaderDesc) - sizeof(tag);
                 eahd->descTag.descCRCLength = cpu_to_le16(crclen);
-                eahd->descTag.descCRC =
-                    cpu_to_le16(udf_crc((char *)eahd + sizeof(tag), crclen, 0));
+                eahd->descTag.descCRC = cpu_to_le16(udf_crc((char *)eahd +
+                                                            sizeof(tag), crclen, 0));
                 eahd->descTag.tagChecksum = 0;
                 for (i = 0; i < 16; i++)
                         if (i != 4)
-                                eahd->descTag.tagChecksum +=
-                                    ((uint8_t *) & (eahd->descTag))[i];
+                                eahd->descTag.tagChecksum += ((uint8_t *)&(eahd->descTag))[i];
                 UDF_I_LENEATTR(inode) += size;
                 return (struct genericFormat *)&ea[offset];
         }
         if (loc & 0x02) {
         }
+
         return NULL;
 }
 
@@ -163,8 +152,7 @@ struct genericFormat *udf_get_extendedattr(struct inode *inode, uint32_t type,
 
                 /* check checksum/crc */
                 if (le16_to_cpu(eahd->descTag.tagIdent) != TAG_IDENT_EAHD ||
-                    le32_to_cpu(eahd->descTag.tagLocation) !=
-                    UDF_I_LOCATION(inode).logicalBlockNum) {
+                    le32_to_cpu(eahd->descTag.tagLocation) != UDF_I_LOCATION(inode).logicalBlockNum) {
                         return NULL;
                 }
 
@@ -177,13 +165,13 @@ struct genericFormat *udf_get_extendedattr(struct inode *inode, uint32_t type,
 
                 while (offset < UDF_I_LENEATTR(inode)) {
                         gaf = (struct genericFormat *)&ea[offset];
-                        if (le32_to_cpu(gaf->attrType) == type
-                            && gaf->attrSubtype == subtype)
+                        if (le32_to_cpu(gaf->attrType) == type && gaf->attrSubtype == subtype)
                                 return gaf;
                         else
                                 offset += le32_to_cpu(gaf->attrLength);
                 }
         }
+
         return NULL;
 }
 
@@ -216,23 +204,22 @@ struct buffer_head *udf_read_tagged(struct super_block *sb, uint32_t block,
                 return NULL;
         }
 
-        tag_p = (tag *) (bh->b_data);
+        tag_p = (tag *)(bh->b_data);
 
         *ident = le16_to_cpu(tag_p->tagIdent);
 
         if (location != le32_to_cpu(tag_p->tagLocation)) {
                 udf_debug("location mismatch block %u, tag %u != %u\n",
-                          block + UDF_SB_SESSION(sb),
-                          le32_to_cpu(tag_p->tagLocation), location);
+                          block + UDF_SB_SESSION(sb), le32_to_cpu(tag_p->tagLocation), location);
                 goto error_out;
         }
 
         /* Verify the tag checksum */
         checksum = 0U;
         for (i = 0; i < 4; i++)
-                checksum += (uint8_t) (bh->b_data[i]);
+                checksum += (uint8_t)(bh->b_data[i]);
         for (i = 5; i < 16; i++)
-                checksum += (uint8_t) (bh->b_data[i]);
+                checksum += (uint8_t)(bh->b_data[i]);
         if (checksum != tag_p->tagChecksum) {
                 printk(KERN_ERR "udf: tag checksum failed block %d\n", block);
                 goto error_out;
@@ -249,16 +236,14 @@ struct buffer_head *udf_read_tagged(struct super_block *sb, uint32_t block,
         /* Verify the descriptor CRC */
         if (le16_to_cpu(tag_p->descCRCLength) + sizeof(tag) > sb->s_blocksize ||
             le16_to_cpu(tag_p->descCRC) == udf_crc(bh->b_data + sizeof(tag),
-                                                   le16_to_cpu(tag_p->
-                                                               descCRCLength),
-                                                   0)) {
+                                                   le16_to_cpu(tag_p->descCRCLength), 0)) {
                 return bh;
         }
         udf_debug("Crc failure block %d: crc = %d, crclen = %d\n",
                   block + UDF_SB_SESSION(sb), le16_to_cpu(tag_p->descCRC),
                   le16_to_cpu(tag_p->descCRCLength));
 
-      error_out:
+error_out:
         brelse(bh);
         return NULL;
 }
@@ -272,7 +257,7 @@ struct buffer_head *udf_read_ptagged(struct super_block *sb, kernel_lb_addr loc,
 
 void udf_update_tag(char *data, int length)
 {
-        tag *tptr = (tag *) data;
+        tag *tptr = (tag *)data;
         int i;
 
         length -= sizeof(tag);
@@ -283,13 +268,13 @@ void udf_update_tag(char *data, int length)
 
         for (i = 0; i < 16; i++)
                 if (i != 4)
-                        tptr->tagChecksum += (uint8_t) (data[i]);
+                        tptr->tagChecksum += (uint8_t)(data[i]);
 }
 
 void udf_new_tag(char *data, uint16_t ident, uint16_t version, uint16_t snum,
                  uint32_t loc, int length)
 {
-        tag *tptr = (tag *) data;
+        tag *tptr = (tag *)data;
         tptr->tagIdent = cpu_to_le16(ident);
         tptr->descVersion = cpu_to_le16(version);
         tptr->tagSerialNum = cpu_to_le16(snum);
diff --git a/fs/udf/namei.c b/fs/udf/namei.c
index 334d363a0903..bec96a6b3343 100644
--- a/fs/udf/namei.c
+++ b/fs/udf/namei.c
@@ -37,6 +37,7 @@ static inline int udf_match(int len1, const char *name1, int len2,
 {
         if (len1 != len2)
                 return 0;
+
         return !memcmp(name1, name2, len1);
 }
 
@@ -52,7 +53,7 @@ int udf_write_fi(struct inode *inode, struct fileIdentDesc *cfi,
         uint16_t liu = le16_to_cpu(cfi->lengthOfImpUse);
         uint8_t lfi = cfi->lengthFileIdent;
         int padlen = fibh->eoffset - fibh->soffset - liu - lfi -
-            sizeof(struct fileIdentDesc);
+                sizeof(struct fileIdentDesc);
         int adinicb = 0;
 
         if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB)
@@ -61,85 +62,75 @@ int udf_write_fi(struct inode *inode, struct fileIdentDesc *cfi,
         offset = fibh->soffset + sizeof(struct fileIdentDesc);
 
         if (impuse) {
-                if (adinicb || (offset + liu < 0))
-                        memcpy((uint8_t *) sfi->impUse, impuse, liu);
-                else if (offset >= 0)
+                if (adinicb || (offset + liu < 0)) {
+                        memcpy((uint8_t *)sfi->impUse, impuse, liu);
+                } else if (offset >= 0) {
                         memcpy(fibh->ebh->b_data + offset, impuse, liu);
-                else {
-                        memcpy((uint8_t *) sfi->impUse, impuse, -offset);
-                        memcpy(fibh->ebh->b_data, impuse - offset,
-                               liu + offset);
+                } else {
+                        memcpy((uint8_t *)sfi->impUse, impuse, -offset);
+                        memcpy(fibh->ebh->b_data, impuse - offset, liu + offset);
                 }
         }
 
         offset += liu;
 
         if (fileident) {
-                if (adinicb || (offset + lfi < 0))
-                        memcpy((uint8_t *) sfi->fileIdent + liu, fileident,
-                               lfi);
-                else if (offset >= 0)
+                if (adinicb || (offset + lfi < 0)) {
+                        memcpy((uint8_t *)sfi->fileIdent + liu, fileident, lfi);
+                } else if (offset >= 0) {
                         memcpy(fibh->ebh->b_data + offset, fileident, lfi);
-                else {
-                        memcpy((uint8_t *) sfi->fileIdent + liu, fileident,
-                               -offset);
-                        memcpy(fibh->ebh->b_data, fileident - offset,
-                               lfi + offset);
+                } else {
+                        memcpy((uint8_t *)sfi->fileIdent + liu, fileident, -offset);
+                        memcpy(fibh->ebh->b_data, fileident - offset, lfi + offset);
                 }
         }
 
         offset += lfi;
 
-        if (adinicb || (offset + padlen < 0))
-                memset((uint8_t *) sfi->padding + liu + lfi, 0x00, padlen);
-        else if (offset >= 0)
+        if (adinicb || (offset + padlen < 0)) {
+                memset((uint8_t *)sfi->padding + liu + lfi, 0x00, padlen);
+        } else if (offset >= 0) {
                 memset(fibh->ebh->b_data + offset, 0x00, padlen);
-        else {
-                memset((uint8_t *) sfi->padding + liu + lfi, 0x00, -offset);
+        } else {
+                memset((uint8_t *)sfi->padding + liu + lfi, 0x00, -offset);
                 memset(fibh->ebh->b_data, 0x00, padlen + offset);
         }
 
-        crc =
-            udf_crc((uint8_t *) cfi + sizeof(tag),
-                    sizeof(struct fileIdentDesc) - sizeof(tag), 0);
-
-        if (fibh->sbh == fibh->ebh)
-                crc = udf_crc((uint8_t *) sfi->impUse,
-                              crclen + sizeof(tag) -
-                              sizeof(struct fileIdentDesc), crc);
-        else if (sizeof(struct fileIdentDesc) >= -fibh->soffset)
-                crc =
-                    udf_crc(fibh->ebh->b_data + sizeof(struct fileIdentDesc) +
-                            fibh->soffset,
-                            crclen + sizeof(tag) - sizeof(struct fileIdentDesc),
-                            crc);
-        else {
-                crc = udf_crc((uint8_t *) sfi->impUse,
-                              -fibh->soffset - sizeof(struct fileIdentDesc),
-                              crc);
+        crc = udf_crc((uint8_t *)cfi + sizeof(tag),
+                      sizeof(struct fileIdentDesc) - sizeof(tag), 0);
+
+        if (fibh->sbh == fibh->ebh) {
+                crc = udf_crc((uint8_t *)sfi->impUse,
+                              crclen + sizeof(tag) - sizeof(struct fileIdentDesc), crc);
+        } else if (sizeof(struct fileIdentDesc) >= -fibh->soffset) {
+                crc = udf_crc(fibh->ebh->b_data + sizeof(struct fileIdentDesc) + fibh->soffset,
+                              crclen + sizeof(tag) - sizeof(struct fileIdentDesc), crc);
+        } else {
+                crc = udf_crc((uint8_t *)sfi->impUse,
+                              -fibh->soffset - sizeof(struct fileIdentDesc), crc);
                 crc = udf_crc(fibh->ebh->b_data, fibh->eoffset, crc);
         }
 
         cfi->descTag.descCRC = cpu_to_le16(crc);
         cfi->descTag.descCRCLength = cpu_to_le16(crclen);
 
-        for (i = 0; i < 16; i++)
+        for (i = 0; i < 16; i++) {
                 if (i != 4)
-                        checksum += ((uint8_t *) & cfi->descTag)[i];
+                        checksum += ((uint8_t *)&cfi->descTag)[i];
+        }
 
         cfi->descTag.tagChecksum = checksum;
-        if (adinicb || (sizeof(struct fileIdentDesc) <= -fibh->soffset))
-                memcpy((uint8_t *) sfi, (uint8_t *) cfi,
-                       sizeof(struct fileIdentDesc));
-        else {
-                memcpy((uint8_t *) sfi, (uint8_t *) cfi, -fibh->soffset);
-                memcpy(fibh->ebh->b_data, (uint8_t *) cfi - fibh->soffset,
+        if (adinicb || (sizeof(struct fileIdentDesc) <= -fibh->soffset)) {
+                memcpy((uint8_t *)sfi, (uint8_t *)cfi, sizeof(struct fileIdentDesc));
+        } else {
+                memcpy((uint8_t *)sfi, (uint8_t *)cfi, -fibh->soffset);
+                memcpy(fibh->ebh->b_data, (uint8_t *)cfi - fibh->soffset,
                        sizeof(struct fileIdentDesc) + fibh->soffset);
         }
 
-        if (adinicb)
+        if (adinicb) {
                 mark_inode_dirty(inode);
-        else {
+        } else {
                 if (fibh->sbh != fibh->ebh)
                         mark_buffer_dirty_inode(fibh->ebh, inode);
                 mark_buffer_dirty_inode(fibh->sbh, inode);
@@ -163,26 +154,25 @@ static struct fileIdentDesc *udf_find_entry(struct inode *dir,
         kernel_lb_addr eloc;
         uint32_t elen;
         sector_t offset;
-        struct extent_position epos = { NULL, 0, {0, 0} };
+        struct extent_position epos = {};
 
         size = (udf_ext0_offset(dir) + dir->i_size) >> 2;
         f_pos = (udf_ext0_offset(dir) >> 2);
 
-        fibh->soffset = fibh->eoffset =
-            (f_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2;
-        if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)
+        fibh->soffset = fibh->eoffset = (f_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2;
+        if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {
                 fibh->sbh = fibh->ebh = NULL;
-        else if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2),
-                            &epos, &eloc, &elen,
-                            &offset) == (EXT_RECORDED_ALLOCATED >> 30)) {
+        } else if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2),
+                              &epos, &eloc, &elen, &offset) == (EXT_RECORDED_ALLOCATED >> 30)) {
                 block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
                 if ((++offset << dir->i_sb->s_blocksize_bits) < elen) {
                         if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)
                                 epos.offset -= sizeof(short_ad);
                         else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)
                                 epos.offset -= sizeof(long_ad);
-                } else
+                } else {
                         offset = 0;
+                }
 
                 if (!(fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block))) {
                         brelse(epos.bh);
@@ -196,7 +186,6 @@ static struct fileIdentDesc *udf_find_entry(struct inode *dir,
         while ((f_pos < size)) {
                 fi = udf_fileident_read(dir, &f_pos, fibh, cfi, &epos, &eloc,
                                         &elen, &offset);
-
                 if (!fi) {
                         if (fibh->sbh != fibh->ebh)
                                 brelse(fibh->ebh);
@@ -213,20 +202,14 @@ static struct fileIdentDesc *udf_find_entry(struct inode *dir,
                 } else {
                         int poffset;    /* Unpaded ending offset */
 
-                        poffset =
-                            fibh->soffset + sizeof(struct fileIdentDesc) + liu +
-                            lfi;
+                        poffset = fibh->soffset + sizeof(struct fileIdentDesc) + liu + lfi;
 
-                        if (poffset >= lfi)
-                                nameptr =
-                                    (uint8_t *) (fibh->ebh->b_data + poffset -
-                                                 lfi);
-                        else {
+                        if (poffset >= lfi) {
+                                nameptr = (uint8_t *)(fibh->ebh->b_data + poffset - lfi);
+                        } else {
                                 nameptr = fname;
-                                memcpy(nameptr, fi->fileIdent + liu,
-                                       lfi - poffset);
-                                memcpy(nameptr + lfi - poffset,
-                                       fibh->ebh->b_data, poffset);
+                                memcpy(nameptr, fi->fileIdent + liu, lfi - poffset);
+                                memcpy(nameptr + lfi - poffset, fibh->ebh->b_data, poffset);
                         }
                 }
 
@@ -244,18 +227,18 @@ static struct fileIdentDesc *udf_find_entry(struct inode *dir,
                         continue;
 
                 if ((flen = udf_get_filename(dir->i_sb, nameptr, fname, lfi))) {
-                        if (udf_match
-                            (flen, fname, dentry->d_name.len,
-                             dentry->d_name.name)) {
+                        if (udf_match(flen, fname, dentry->d_name.len, dentry->d_name.name)) {
                                 brelse(epos.bh);
                                 return fi;
                         }
                 }
         }
+
         if (fibh->sbh != fibh->ebh)
                 brelse(fibh->ebh);
         brelse(fibh->sbh);
         brelse(epos.bh);
+
         return NULL;
 }
 
@@ -306,15 +289,19 @@ static struct dentry *udf_lookup(struct inode *dir, struct dentry *dentry,
 #ifdef UDF_RECOVERY
         /* temporary shorthand for specifying files by inode number */
         if (!strncmp(dentry->d_name.name, ".B=", 3)) {
-                kernel_lb_addr lb =
-                    { 0, simple_strtoul(dentry->d_name.name + 3, NULL, 0) };
+                kernel_lb_addr lb = {
+                        .logicalBlockNum = 0,
+                        .partitionReferenceNum = simple_strtoul(dentry->d_name.name + 3,
+                                                                NULL, 0),
+                };
                 inode = udf_iget(dir->i_sb, lb);
                 if (!inode) {
                         unlock_kernel();
                         return ERR_PTR(-EACCES);
                 }
-        } else
-#endif                          /* UDF_RECOVERY */
+        }
+        else
+#endif /* UDF_RECOVERY */
 
         if (udf_find_entry(dir, dentry, &fibh, &cfi)) {
                 if (fibh.sbh != fibh.ebh)
@@ -329,6 +316,7 @@ static struct dentry *udf_lookup(struct inode *dir, struct dentry *dentry,
         }
         unlock_kernel();
         d_add(dentry, inode);
+
         return NULL;
 }
 
@@ -352,7 +340,7 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
         kernel_lb_addr eloc;
         uint32_t elen;
         sector_t offset;
-        struct extent_position epos = { NULL, 0, {0, 0} };
+        struct extent_position epos = {};
 
         sb = dir->i_sb;
 
@@ -361,36 +349,33 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
                         *err = -EINVAL;
                         return NULL;
                 }
-
-                if (!
-                    (namelen =
-                     udf_put_filename(sb, dentry->d_name.name, name,
-                                      dentry->d_name.len))) {
+                if (!(namelen = udf_put_filename(sb, dentry->d_name.name, name,
+                                                 dentry->d_name.len))) {
                         *err = -ENAMETOOLONG;
                         return NULL;
                 }
-        } else
+        } else {
                 namelen = 0;
+        }
 
         nfidlen = (sizeof(struct fileIdentDesc) + namelen + 3) & ~3;
 
         f_pos = (udf_ext0_offset(dir) >> 2);
 
-        fibh->soffset = fibh->eoffset =
-            (f_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2;
-        if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)
+        fibh->soffset = fibh->eoffset = (f_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2;
+        if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {
                 fibh->sbh = fibh->ebh = NULL;
-        else if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2),
-                            &epos, &eloc, &elen,
-                            &offset) == (EXT_RECORDED_ALLOCATED >> 30)) {
+        } else if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2),
+                              &epos, &eloc, &elen, &offset) == (EXT_RECORDED_ALLOCATED >> 30)) {
                 block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
                 if ((++offset << dir->i_sb->s_blocksize_bits) < elen) {
                         if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)
                                 epos.offset -= sizeof(short_ad);
                         else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)
                                 epos.offset -= sizeof(long_ad);
-                } else
+                } else {
                         offset = 0;
+                }
 
                 if (!(fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block))) {
                         brelse(epos.bh);
@@ -423,40 +408,33 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
                 liu = le16_to_cpu(cfi->lengthOfImpUse);
                 lfi = cfi->lengthFileIdent;
 
-                if (fibh->sbh == fibh->ebh)
+                if (fibh->sbh == fibh->ebh) {
                         nameptr = fi->fileIdent + liu;
-                else {
+                } else {
                         int poffset;    /* Unpaded ending offset */
 
-                        poffset =
-                            fibh->soffset + sizeof(struct fileIdentDesc) + liu +
-                            lfi;
+                        poffset = fibh->soffset + sizeof(struct fileIdentDesc) + liu + lfi;
 
-                        if (poffset >= lfi)
-                                nameptr =
-                                    (char *)(fibh->ebh->b_data + poffset - lfi);
-                        else {
+                        if (poffset >= lfi) {
+                                nameptr = (char *)(fibh->ebh->b_data + poffset - lfi);
+                        } else {
                                 nameptr = fname;
-                                memcpy(nameptr, fi->fileIdent + liu,
-                                       lfi - poffset);
-                                memcpy(nameptr + lfi - poffset,
-                                       fibh->ebh->b_data, poffset);
+                                memcpy(nameptr, fi->fileIdent + liu, lfi - poffset);
+                                memcpy(nameptr + lfi - poffset, fibh->ebh->b_data, poffset);
                         }
                 }
 
                 if ((cfi->fileCharacteristics & FID_FILE_CHAR_DELETED) != 0) {
-                        if (((sizeof(struct fileIdentDesc) + liu + lfi +
-                              3) & ~3) == nfidlen) {
+                        if (((sizeof(struct fileIdentDesc) + liu + lfi + 3) & ~3) == nfidlen) {
                                 brelse(epos.bh);
                                 cfi->descTag.tagSerialNum = cpu_to_le16(1);
                                 cfi->fileVersionNum = cpu_to_le16(1);
                                 cfi->fileCharacteristics = 0;
                                 cfi->lengthFileIdent = namelen;
                                 cfi->lengthOfImpUse = cpu_to_le16(0);
-                                if (!udf_write_fi
-                                    (dir, cfi, fi, fibh, NULL, name))
+                                if (!udf_write_fi(dir, cfi, fi, fibh, NULL, name)) {
                                         return fi;
-                                else {
+                                } else {
                                         *err = -EIO;
                                         return NULL;
                                 }
@@ -467,8 +445,7 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
                         continue;
 
                 if ((flen = udf_get_filename(dir->i_sb, nameptr, fname, lfi)) &&
-                    udf_match(flen, fname, dentry->d_name.len,
-                              dentry->d_name.name)) {
+                    udf_match(flen, fname, dentry->d_name.len, dentry->d_name.name)) {
                         if (fibh->sbh != fibh->ebh)
                                 brelse(fibh->ebh);
                         brelse(fibh->sbh);
@@ -478,7 +455,7 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
                 }
         }
 
-      add:
+add:
         f_pos += nfidlen;
 
         if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB &&
@@ -491,14 +468,11 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
                 if (fibh->sbh != fibh->ebh)
                         brelse(fibh->ebh);
                 brelse(fibh->sbh);
-                if (!
-                    (fibh->sbh = fibh->ebh =
-                     udf_expand_dir_adinicb(dir, &block, err)))
+                if (!(fibh->sbh = fibh->ebh = udf_expand_dir_adinicb(dir, &block, err)))
                         return NULL;
                 epos.block = UDF_I_LOCATION(dir);
                 eloc.logicalBlockNum = block;
-                eloc.partitionReferenceNum =
-                    UDF_I_LOCATION(dir).partitionReferenceNum;
+                eloc.partitionReferenceNum = UDF_I_LOCATION(dir).partitionReferenceNum;
                 elen = dir->i_sb->s_blocksize;
                 epos.offset = udf_file_entry_alloc_offset(dir);
                 if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)
@@ -517,16 +491,13 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
 
                 if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {
                         block = UDF_I_LOCATION(dir).logicalBlockNum;
-                        fi = (struct fileIdentDesc *)(UDF_I_DATA(dir) +
-                                                      fibh->soffset -
+                        fi = (struct fileIdentDesc *)(UDF_I_DATA(dir) + fibh->soffset -
                                                       udf_ext0_offset(dir) +
                                                       UDF_I_LENEATTR(dir));
                 } else {
                         block = eloc.logicalBlockNum + ((elen - 1) >>
-                                                        dir->i_sb->
-                                                        s_blocksize_bits);
-                        fi = (struct fileIdentDesc *)(fibh->sbh->b_data +
-                                                      fibh->soffset);
+                                                        dir->i_sb->s_blocksize_bits);
+                        fi = (struct fileIdentDesc *)(fibh->sbh->b_data + fibh->soffset);
                 }
         } else {
                 fibh->soffset = fibh->eoffset - sb->s_blocksize;
@@ -538,42 +509,36 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
 
                 block = eloc.logicalBlockNum + ((elen - 1) >>
                                                 dir->i_sb->s_blocksize_bits);
-
-                if (!
-                    (fibh->ebh =
-                     udf_bread(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2),
-                               1, err))) {
+                fibh->ebh = udf_bread(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2), 1, err);
+                if (!fibh->ebh) {
                         brelse(epos.bh);
                         brelse(fibh->sbh);
                         return NULL;
                 }
 
-                if (!(fibh->soffset)) {
+                if (!fibh->soffset) {
                         if (udf_next_aext(dir, &epos, &eloc, &elen, 1) ==
                             (EXT_RECORDED_ALLOCATED >> 30)) {
                                 block = eloc.logicalBlockNum + ((elen - 1) >>
-                                                                dir->i_sb->
-                                                                s_blocksize_bits);
-                        } else
+                                        dir->i_sb->s_blocksize_bits);
+                        } else {
                                 block++;
+                        }
 
                         brelse(fibh->sbh);
                         fibh->sbh = fibh->ebh;
                         fi = (struct fileIdentDesc *)(fibh->sbh->b_data);
                 } else {
                         fi = (struct fileIdentDesc *)
-                            (fibh->sbh->b_data + sb->s_blocksize +
-                             fibh->soffset);
+                                (fibh->sbh->b_data + sb->s_blocksize + fibh->soffset);
                 }
         }
 
         memset(cfi, 0, sizeof(struct fileIdentDesc));
         if (UDF_SB_UDFREV(sb) >= 0x0200)
-                udf_new_tag((char *)cfi, TAG_IDENT_FID, 3, 1, block,
-                            sizeof(tag));
+                udf_new_tag((char *)cfi, TAG_IDENT_FID, 3, 1, block, sizeof(tag));
         else
-                udf_new_tag((char *)cfi, TAG_IDENT_FID, 2, 1, block,
-                            sizeof(tag));
+                udf_new_tag((char *)cfi, TAG_IDENT_FID, 2, 1, block, sizeof(tag));
         cfi->fileVersionNum = cpu_to_le16(1);
         cfi->lengthFileIdent = namelen;
         cfi->lengthOfImpUse = cpu_to_le16(0);
@@ -599,8 +564,10 @@ static int udf_delete_entry(struct inode *inode, struct fileIdentDesc *fi,
                             struct fileIdentDesc *cfi)
 {
         cfi->fileCharacteristics |= FID_FILE_CHAR_DELETED;
+
         if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT))
                 memset(&(cfi->icb), 0x00, sizeof(long_ad));
+
         return udf_write_fi(inode, cfi, fi, fibh, NULL, NULL);
 }
 
@@ -637,8 +604,8 @@ static int udf_create(struct inode *dir, struct dentry *dentry, int mode,
         }
         cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
         cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(inode));
-        *(__le32 *) ((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
-            cpu_to_le32(UDF_I_UNIQUE(inode) & 0x00000000FFFFFFFFUL);
+        *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
+                cpu_to_le32(UDF_I_UNIQUE(inode) & 0x00000000FFFFFFFFUL);
         udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
         if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {
                 mark_inode_dirty(dir);
@@ -648,6 +615,7 @@ static int udf_create(struct inode *dir, struct dentry *dentry, int mode,
         brelse(fibh.sbh);
         unlock_kernel();
         d_instantiate(dentry, inode);
+
         return 0;
 }
 
@@ -679,8 +647,8 @@ static int udf_mknod(struct inode *dir, struct dentry *dentry, int mode,
         }
         cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
         cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(inode));
-        *(__le32 *) ((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
-            cpu_to_le32(UDF_I_UNIQUE(inode) & 0x00000000FFFFFFFFUL);
+        *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
+                cpu_to_le32(UDF_I_UNIQUE(inode) & 0x00000000FFFFFFFFUL);
         udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
         if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {
                 mark_inode_dirty(dir);
@@ -692,7 +660,8 @@ static int udf_mknod(struct inode *dir, struct dentry *dentry, int mode,
         brelse(fibh.sbh);
         d_instantiate(dentry, inode);
         err = 0;
-      out:
+
+out:
         unlock_kernel();
         return err;
 }
@@ -725,10 +694,9 @@ static int udf_mkdir(struct inode *dir, struct dentry *dentry, int mode)
         inode->i_nlink = 2;
         cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
         cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(dir));
-        *(__le32 *) ((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
-            cpu_to_le32(UDF_I_UNIQUE(dir) & 0x00000000FFFFFFFFUL);
-        cfi.fileCharacteristics =
-            FID_FILE_CHAR_DIRECTORY | FID_FILE_CHAR_PARENT;
+        *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
+                cpu_to_le32(UDF_I_UNIQUE(dir) & 0x00000000FFFFFFFFUL);
+        cfi.fileCharacteristics = FID_FILE_CHAR_DIRECTORY | FID_FILE_CHAR_PARENT;
         udf_write_fi(inode, &cfi, fi, &fibh, NULL, NULL);
         brelse(fibh.sbh);
         inode->i_mode = S_IFDIR | mode;
@@ -744,8 +712,8 @@ static int udf_mkdir(struct inode *dir, struct dentry *dentry, int mode)
         }
         cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
         cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(inode));
-        *(__le32 *) ((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
-            cpu_to_le32(UDF_I_UNIQUE(inode) & 0x00000000FFFFFFFFUL);
+        *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
+                cpu_to_le32(UDF_I_UNIQUE(inode) & 0x00000000FFFFFFFFUL);
         cfi.fileCharacteristics |= FID_FILE_CHAR_DIRECTORY;
         udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
         inc_nlink(dir);
@@ -755,7 +723,8 @@ static int udf_mkdir(struct inode *dir, struct dentry *dentry, int mode)
                 brelse(fibh.ebh);
         brelse(fibh.sbh);
         err = 0;
-      out:
+
+out:
         unlock_kernel();
         return err;
 }
@@ -770,26 +739,25 @@ static int empty_dir(struct inode *dir)
         kernel_lb_addr eloc;
         uint32_t elen;
         sector_t offset;
-        struct extent_position epos = { NULL, 0, {0, 0} };
+        struct extent_position epos = {};
 
         f_pos = (udf_ext0_offset(dir) >> 2);
 
-        fibh.soffset = fibh.eoffset =
-            (f_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2;
+        fibh.soffset = fibh.eoffset = (f_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2;
 
-        if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)
+        if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {
                 fibh.sbh = fibh.ebh = NULL;
-        else if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2),
-                            &epos, &eloc, &elen,
-                            &offset) == (EXT_RECORDED_ALLOCATED >> 30)) {
+        } else if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2),
+                              &epos, &eloc, &elen, &offset) == (EXT_RECORDED_ALLOCATED >> 30)) {
                 block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
                 if ((++offset << dir->i_sb->s_blocksize_bits) < elen) {
                         if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)
                                 epos.offset -= sizeof(short_ad);
                         else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)
                                 epos.offset -= sizeof(long_ad);
-                } else
+                } else {
                         offset = 0;
+                }
 
                 if (!(fibh.sbh = fibh.ebh = udf_tread(dir->i_sb, block))) {
                         brelse(epos.bh);
@@ -803,7 +771,6 @@ static int empty_dir(struct inode *dir)
         while ((f_pos < size)) {
                 fi = udf_fileident_read(dir, &f_pos, &fibh, &cfi, &epos, &eloc,
                                         &elen, &offset);
-
                 if (!fi) {
                         if (fibh.sbh != fibh.ebh)
                                 brelse(fibh.ebh);
@@ -812,8 +779,8 @@ static int empty_dir(struct inode *dir)
                         return 0;
                 }
 
-                if (cfi.lengthFileIdent
-                    && (cfi.fileCharacteristics & FID_FILE_CHAR_DELETED) == 0) {
+                if (cfi.lengthFileIdent &&
+                    (cfi.fileCharacteristics & FID_FILE_CHAR_DELETED) == 0) {
                         if (fibh.sbh != fibh.ebh)
                                 brelse(fibh.ebh);
                         brelse(fibh.sbh);
@@ -821,10 +788,12 @@ static int empty_dir(struct inode *dir)
                         return 0;
                 }
         }
+
         if (fibh.sbh != fibh.ebh)
                 brelse(fibh.ebh);
         brelse(fibh.sbh);
         brelse(epos.bh);
+
         return 1;
 }
 
@@ -859,15 +828,15 @@ static int udf_rmdir(struct inode *dir, struct dentry *dentry)
         clear_nlink(inode);
         inode->i_size = 0;
         inode_dec_link_count(dir);
-        inode->i_ctime = dir->i_ctime = dir->i_mtime =
-            current_fs_time(dir->i_sb);
+        inode->i_ctime = dir->i_ctime = dir->i_mtime = current_fs_time(dir->i_sb);
         mark_inode_dirty(dir);
 
-      end_rmdir:
+end_rmdir:
         if (fibh.sbh != fibh.ebh)
                 brelse(fibh.ebh);
         brelse(fibh.sbh);
-      out:
+
+out:
         unlock_kernel();
         return retval;
 }
@@ -906,11 +875,12 @@ static int udf_unlink(struct inode *dir, struct dentry *dentry)
         inode->i_ctime = dir->i_ctime;
         retval = 0;
 
-      end_unlink:
+end_unlink:
         if (fibh.sbh != fibh.ebh)
                 brelse(fibh.ebh);
         brelse(fibh.sbh);
-      out:
+
+out:
         unlock_kernel();
         return retval;
 }
@@ -922,7 +892,7 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry,
         struct pathComponent *pc;
         char *compstart;
         struct udf_fileident_bh fibh;
-        struct extent_position epos = { NULL, 0, {0, 0} };
+        struct extent_position epos = {};
         int eoffset, elen = 0;
         struct fileIdentDesc *fi;
         struct fileIdentDesc cfi;
@@ -945,26 +915,22 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry,
                 uint32_t elen;
 
                 block = udf_new_block(inode->i_sb, inode,
-                                      UDF_I_LOCATION(inode).
-                                      partitionReferenceNum,
-                                      UDF_I_LOCATION(inode).logicalBlockNum,
-                                      &err);
+                                      UDF_I_LOCATION(inode).partitionReferenceNum,
+                                      UDF_I_LOCATION(inode).logicalBlockNum, &err);
                 if (!block)
                         goto out_no_entry;
                 epos.block = UDF_I_LOCATION(inode);
                 epos.offset = udf_file_entry_alloc_offset(inode);
                 epos.bh = NULL;
                 eloc.logicalBlockNum = block;
-                eloc.partitionReferenceNum =
-                    UDF_I_LOCATION(inode).partitionReferenceNum;
+                eloc.partitionReferenceNum = UDF_I_LOCATION(inode).partitionReferenceNum;
                 elen = inode->i_sb->s_blocksize;
                 UDF_I_LENEXTENTS(inode) = elen;
                 udf_add_aext(inode, &epos, eloc, elen, 0);
                 brelse(epos.bh);
 
                 block = udf_get_pblock(inode->i_sb, block,
-                                       UDF_I_LOCATION(inode).
-                                       partitionReferenceNum, 0);
+                                       UDF_I_LOCATION(inode).partitionReferenceNum, 0);
                 epos.bh = udf_tread(inode->i_sb, block);
                 lock_buffer(epos.bh);
                 memset(epos.bh->b_data, 0x00, inode->i_sb->s_blocksize);
@@ -972,8 +938,9 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry,
                 unlock_buffer(epos.bh);
                 mark_buffer_dirty_inode(epos.bh, inode);
                 ea = epos.bh->b_data + udf_ext0_offset(inode);
-        } else
+        } else {
                 ea = UDF_I_DATA(inode) + UDF_I_LENEATTR(inode);
+        }
 
         eoffset = inode->i_sb->s_blocksize - udf_ext0_offset(inode);
         pc = (struct pathComponent *)ea;
@@ -1010,20 +977,17 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry,
                 if (compstart[0] == '.') {
                         if ((symname - compstart) == 1)
                                 pc->componentType = 4;
-                        else if ((symname - compstart) == 2
-                                 && compstart[1] == '.')
+                        else if ((symname - compstart) == 2 && compstart[1] == '.')
                                 pc->componentType = 3;
                 }
 
                 if (pc->componentType == 5) {
-                        if (!
-                            (namelen =
-                             udf_put_filename(inode->i_sb, compstart, name,
-                                              symname - compstart)))
+                        namelen = udf_put_filename(inode->i_sb, compstart, name,
+                                                   symname - compstart);
+                        if (!namelen)
                                 goto out_no_entry;
 
-                        if (elen + sizeof(struct pathComponent) + namelen >
-                            eoffset)
+                        if (elen + sizeof(struct pathComponent) + namelen > eoffset)
                                 goto out_no_entry;
                         else
                                 pc->lengthComponentIdent = namelen;
@@ -1053,12 +1017,10 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry,
         if (UDF_SB_LVIDBH(inode->i_sb)) {
                 struct logicalVolHeaderDesc *lvhd;
                 uint64_t uniqueID;
-                lvhd =
-                    (struct logicalVolHeaderDesc *)(UDF_SB_LVID(inode->i_sb)->
-                                                    logicalVolContentsUse);
+                lvhd = (struct logicalVolHeaderDesc *)(UDF_SB_LVID(inode->i_sb)->logicalVolContentsUse);
                 uniqueID = le64_to_cpu(lvhd->uniqueID);
-                *(__le32 *) ((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
-                    cpu_to_le32(uniqueID & 0x00000000FFFFFFFFUL);
+                *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
+                        cpu_to_le32(uniqueID & 0x00000000FFFFFFFFUL);
                 if (!(++uniqueID & 0x00000000FFFFFFFFUL))
                         uniqueID += 16;
                 lvhd->uniqueID = cpu_to_le64(uniqueID);
@@ -1074,11 +1036,11 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry,
         d_instantiate(dentry, inode);
         err = 0;
 
-      out:
+out:
         unlock_kernel();
         return err;
 
-      out_no_entry:
+out_no_entry:
         inode_dec_link_count(inode);
         iput(inode);
         goto out;
@@ -1107,12 +1069,10 @@ static int udf_link(struct dentry *old_dentry, struct inode *dir,
         if (UDF_SB_LVIDBH(inode->i_sb)) {
                 struct logicalVolHeaderDesc *lvhd;
                 uint64_t uniqueID;
-                lvhd =
-                    (struct logicalVolHeaderDesc *)(UDF_SB_LVID(inode->i_sb)->
-                                                    logicalVolContentsUse);
+                lvhd = (struct logicalVolHeaderDesc *)(UDF_SB_LVID(inode->i_sb)->logicalVolContentsUse);
                 uniqueID = le64_to_cpu(lvhd->uniqueID);
-                *(__le32 *) ((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
-                    cpu_to_le32(uniqueID & 0x00000000FFFFFFFFUL);
+                *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
+                        cpu_to_le32(uniqueID & 0x00000000FFFFFFFFUL);
                 if (!(++uniqueID & 0x00000000FFFFFFFFUL))
                         uniqueID += 16;
                 lvhd->uniqueID = cpu_to_le64(uniqueID);
@@ -1122,6 +1082,7 @@ static int udf_link(struct dentry *old_dentry, struct inode *dir,
         if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {
                 mark_inode_dirty(dir);
         }
+
         if (fibh.sbh != fibh.ebh)
                 brelse(fibh.ebh);
         brelse(fibh.sbh);
@@ -1131,6 +1092,7 @@ static int udf_link(struct dentry *old_dentry, struct inode *dir,
         atomic_inc(&inode->i_count);
         d_instantiate(dentry, inode);
         unlock_kernel();
+
         return 0;
 }
 
@@ -1143,8 +1105,7 @@ static int udf_rename(struct inode *old_dir, struct dentry *old_dentry,
         struct inode *old_inode = old_dentry->d_inode;
         struct inode *new_inode = new_dentry->d_inode;
         struct udf_fileident_bh ofibh, nfibh;
-        struct fileIdentDesc *ofi = NULL, *nfi = NULL, *dir_fi =
-            NULL, ocfi, ncfi;
+        struct fileIdentDesc *ofi = NULL, *nfi = NULL, *dir_fi = NULL, ocfi, ncfi;
         struct buffer_head *dir_bh = NULL;
         int retval = -ENOENT;
         kernel_lb_addr tloc;
@@ -1181,36 +1142,27 @@ static int udf_rename(struct inode *old_dir, struct dentry *old_dentry,
                 if (UDF_I_ALLOCTYPE(old_inode) == ICBTAG_FLAG_AD_IN_ICB) {
                         dir_fi = udf_get_fileident(UDF_I_DATA(old_inode) -
                                                    (UDF_I_EFE(old_inode) ?
-                                                    sizeof(struct
-                                                           extendedFileEntry) :
+                                                    sizeof(struct extendedFileEntry) :
                                                     sizeof(struct fileEntry)),
-                                                   old_inode->i_sb->s_blocksize,
-                                                   &offset);
+                                                   old_inode->i_sb->s_blocksize, &offset);
                 } else {
                         dir_bh = udf_bread(old_inode, 0, 0, &retval);
                         if (!dir_bh)
                                 goto end_rename;
-                        dir_fi =
-                            udf_get_fileident(dir_bh->b_data,
-                                              old_inode->i_sb->s_blocksize,
-                                              &offset);
+                        dir_fi = udf_get_fileident(dir_bh->b_data, old_inode->i_sb->s_blocksize, &offset);
                 }
                 if (!dir_fi)
                         goto end_rename;
                 tloc = lelb_to_cpu(dir_fi->icb.extLocation);
-                if (udf_get_lb_pblock(old_inode->i_sb, tloc, 0)
-                    != old_dir->i_ino)
+                if (udf_get_lb_pblock(old_inode->i_sb, tloc, 0) != old_dir->i_ino)
                         goto end_rename;
 
                 retval = -EMLINK;
-                if (!new_inode
-                    && new_dir->i_nlink >=
-                    (256 << sizeof(new_dir->i_nlink)) - 1)
+                if (!new_inode && new_dir->i_nlink >= (256 << sizeof(new_dir->i_nlink)) - 1)
                         goto end_rename;
         }
         if (!nfi) {
-                nfi =
-                    udf_add_entry(new_dir, new_dentry, &nfibh, &ncfi, &retval);
+                nfi = udf_add_entry(new_dir, new_dentry, &nfibh, &ncfi, &retval);
                 if (!nfi)
                         goto end_rename;
         }
@@ -1244,13 +1196,12 @@ static int udf_rename(struct inode *old_dir, struct dentry *old_dentry,
         if (dir_fi) {
                 dir_fi->icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(new_dir));
                 udf_update_tag((char *)dir_fi, (sizeof(struct fileIdentDesc) +
-                                                le16_to_cpu(dir_fi->
-                                                            lengthOfImpUse) +
-                                                3) & ~3);
+                                                le16_to_cpu(dir_fi->lengthOfImpUse) + 3) & ~3);
                 if (UDF_I_ALLOCTYPE(old_inode) == ICBTAG_FLAG_AD_IN_ICB) {
                         mark_inode_dirty(old_inode);
-                } else
+                } else {
                         mark_buffer_dirty_inode(dir_bh, old_inode);
+                }
                 inode_dec_link_count(old_dir);
                 if (new_inode) {
                         inode_dec_link_count(new_inode);
@@ -1268,7 +1219,7 @@ static int udf_rename(struct inode *old_dir, struct dentry *old_dentry,
 
         retval = 0;
 
-      end_rename:
+end_rename:
         brelse(dir_bh);
         if (nfi) {
                 if (nfibh.sbh != nfibh.ebh)
@@ -1276,17 +1227,18 @@ static int udf_rename(struct inode *old_dir, struct dentry *old_dentry,
                 brelse(nfibh.sbh);
         }
         unlock_kernel();
+
         return retval;
 }
 
 const struct inode_operations udf_dir_inode_operations = {
-        .lookup = udf_lookup,
-        .create = udf_create,
-        .link = udf_link,
-        .unlink = udf_unlink,
-        .symlink = udf_symlink,
-        .mkdir = udf_mkdir,
-        .rmdir = udf_rmdir,
-        .mknod = udf_mknod,
-        .rename = udf_rename,
+        .lookup                         = udf_lookup,
+        .create                         = udf_create,
+        .link                           = udf_link,
+        .unlink                         = udf_unlink,
+        .symlink                        = udf_symlink,
+        .mkdir                          = udf_mkdir,
+        .rmdir                          = udf_rmdir,
+        .mknod                          = udf_mknod,
+        .rename                         = udf_rename,
 };
diff --git a/fs/udf/osta_udf.h b/fs/udf/osta_udf.h
index bec5d340d8c5..65ff47902bd2 100644
--- a/fs/udf/osta_udf.h
+++ b/fs/udf/osta_udf.h
@@ -66,64 +66,64 @@
 #define IS_DF_SOFT_WRITE_PROTECT        0x02
 
 struct UDFIdentSuffix {
-        __le16 UDFRevision;
-        uint8_t OSClass;
-        uint8_t OSIdentifier;
-        uint8_t reserved[4];
+        __le16          UDFRevision;
+        uint8_t         OSClass;
+        uint8_t         OSIdentifier;
+        uint8_t         reserved[4];
 } __attribute__ ((packed));
 
 struct impIdentSuffix {
-        uint8_t OSClass;
-        uint8_t OSIdentifier;
-        uint8_t reserved[6];
+        uint8_t         OSClass;
+        uint8_t         OSIdentifier;
+        uint8_t         reserved[6];
 } __attribute__ ((packed));
 
 struct appIdentSuffix {
-        uint8_t impUse[8];
+        uint8_t         impUse[8];
 } __attribute__ ((packed));
 
 /* Logical Volume Integrity Descriptor (UDF 2.50 2.2.6) */
 /* Implementation Use (UDF 2.50 2.2.6.4) */
 struct logicalVolIntegrityDescImpUse {
-        regid impIdent;
-        __le32 numFiles;
-        __le32 numDirs;
-        __le16 minUDFReadRev;
-        __le16 minUDFWriteRev;
-        __le16 maxUDFWriteRev;
-        uint8_t impUse[0];
+        regid           impIdent;
+        __le32          numFiles;
+        __le32          numDirs;
+        __le16          minUDFReadRev;
+        __le16          minUDFWriteRev;
+        __le16          maxUDFWriteRev;
+        uint8_t         impUse[0];
 } __attribute__ ((packed));
 
 /* Implementation Use Volume Descriptor (UDF 2.50 2.2.7) */
 /* Implementation Use (UDF 2.50 2.2.7.2) */
 struct impUseVolDescImpUse {
-        charspec LVICharset;
-        dstring logicalVolIdent[128];
-        dstring LVInfo1[36];
-        dstring LVInfo2[36];
-        dstring LVInfo3[36];
-        regid impIdent;
-        uint8_t impUse[128];
+        charspec        LVICharset;
+        dstring         logicalVolIdent[128];
+        dstring         LVInfo1[36];
+        dstring         LVInfo2[36];
+        dstring         LVInfo3[36];
+        regid           impIdent;
+        uint8_t         impUse[128];
 } __attribute__ ((packed));
 
 struct udfPartitionMap2 {
-        uint8_t partitionMapType;
-        uint8_t partitionMapLength;
-        uint8_t reserved1[2];
-        regid partIdent;
-        __le16 volSeqNum;
-        __le16 partitionNum;
+        uint8_t         partitionMapType;
+        uint8_t         partitionMapLength;
+        uint8_t         reserved1[2];
+        regid           partIdent;
+        __le16          volSeqNum;
+        __le16          partitionNum;
 } __attribute__ ((packed));
 
 /* Virtual Partition Map (UDF 2.50 2.2.8) */
 struct virtualPartitionMap {
-        uint8_t partitionMapType;
-        uint8_t partitionMapLength;
-        uint8_t reserved1[2];
-        regid partIdent;
-        __le16 volSeqNum;
-        __le16 partitionNum;
-        uint8_t reserved2[24];
+        uint8_t         partitionMapType;
+        uint8_t         partitionMapLength;
+        uint8_t         reserved1[2];
+        regid           partIdent;
+        __le16          volSeqNum;
+        __le16          partitionNum;
+        uint8_t         reserved2[24];
 } __attribute__ ((packed));
 
 /* Sparable Partition Map (UDF 2.50 2.2.9) */
@@ -143,62 +143,62 @@ struct sparablePartitionMap {
 
 /* Metadata Partition Map (UDF 2.4.0 2.2.10) */
 struct metadataPartitionMap {
-        uint8_t partitionMapType;
-        uint8_t partitionMapLength;
-        uint8_t reserved1[2];
-        regid partIdent;
-        __le16 volSeqNum;
-        __le16 partitionNum;
-        __le32 metadataFileLoc;
-        __le32 metadataMirrorFileLoc;
-        __le32 metadataBitmapFileLoc;
-        __le32 allocUnitSize;
-        __le16 alignUnitSize;
-        uint8_t flags;
-        uint8_t reserved2[5];
+        uint8_t         partitionMapType;
+        uint8_t         partitionMapLength;
+        uint8_t         reserved1[2];
+        regid           partIdent;
+        __le16          volSeqNum;
+        __le16          partitionNum;
+        __le32          metadataFileLoc;
+        __le32          metadataMirrorFileLoc;
+        __le32          metadataBitmapFileLoc;
+        __le32          allocUnitSize;
+        __le16          alignUnitSize;
+        uint8_t         flags;
+        uint8_t         reserved2[5];
 } __attribute__ ((packed));
 
 /* Virtual Allocation Table (UDF 1.5 2.2.10) */
 struct virtualAllocationTable15 {
-        __le32 VirtualSector[0];
-        regid vatIdent;
-        __le32 previousVATICBLoc;
+        __le32          VirtualSector[0];
+        regid           vatIdent;
+        __le32          previousVATICBLoc;
 } __attribute__ ((packed));
 
 #define ICBTAG_FILE_TYPE_VAT15          0x00U
 
 /* Virtual Allocation Table (UDF 2.50 2.2.11) */
 struct virtualAllocationTable20 {
-        __le16 lengthHeader;
-        __le16 lengthImpUse;
-        dstring logicalVolIdent[128];
-        __le32 previousVATICBLoc;
-        __le32 numFiles;
-        __le32 numDirs;
-        __le16 minReadRevision;
-        __le16 minWriteRevision;
-        __le16 maxWriteRevision;
-        __le16 reserved;
-        uint8_t impUse[0];
-        __le32 vatEntry[0];
+        __le16          lengthHeader;
+        __le16          lengthImpUse;
+        dstring         logicalVolIdent[128];
+        __le32          previousVATICBLoc;
+        __le32          numFiles;
+        __le32          numDirs;
+        __le16          minReadRevision;
+        __le16          minWriteRevision;
+        __le16          maxWriteRevision;
+        __le16          reserved;
+        uint8_t         impUse[0];
+        __le32          vatEntry[0];
 } __attribute__ ((packed));
 
 #define ICBTAG_FILE_TYPE_VAT20          0xF8U
 
 /* Sparing Table (UDF 2.50 2.2.12) */
 struct sparingEntry {
-        __le32 origLocation;
-        __le32 mappedLocation;
+        __le32          origLocation;
+        __le32          mappedLocation;
 } __attribute__ ((packed));
 
 struct sparingTable {
-        tag descTag;
-        regid sparingIdent;
-        __le16 reallocationTableLen;
-        __le16 reserved;
-        __le32 sequenceNum;
+        tag             descTag;
+        regid           sparingIdent;
+        __le16          reallocationTableLen;
+        __le16          reserved;
+        __le32          sequenceNum;
         struct sparingEntry
-         mapEntry[0];
+                        mapEntry[0];
 } __attribute__ ((packed));
 
 /* Metadata File (and Metadata Mirror File) (UDF 2.50 2.2.13.1) */
@@ -208,8 +208,8 @@ struct sparingTable {
 
 /* struct long_ad ICB - ADImpUse (UDF 2.50 2.2.4.3) */
 struct allocDescImpUse {
-        __le16 flags;
-        uint8_t impUse[4];
+        __le16          flags;
+        uint8_t         impUse[4];
 } __attribute__ ((packed));
 
 #define AD_IU_EXT_ERASED                0x0001
@@ -220,23 +220,23 @@ struct allocDescImpUse {
 /* Implementation Use Extended Attribute (UDF 2.50 3.3.4.5) */
 /* FreeEASpace (UDF 2.50 3.3.4.5.1.1) */
 struct freeEaSpace {
-        __le16 headerChecksum;
-        uint8_t freeEASpace[0];
+        __le16          headerChecksum;
+        uint8_t         freeEASpace[0];
 } __attribute__ ((packed));
 
 /* DVD Copyright Management Information (UDF 2.50 3.3.4.5.1.2) */
 struct DVDCopyrightImpUse {
-        __le16 headerChecksum;
-        uint8_t CGMSInfo;
-        uint8_t dataType;
-        uint8_t protectionSystemInfo[4];
+        __le16          headerChecksum;
+        uint8_t         CGMSInfo;
+        uint8_t         dataType;
+        uint8_t         protectionSystemInfo[4];
 } __attribute__ ((packed));
 
 /* Application Use Extended Attribute (UDF 2.50 3.3.4.6) */
 /* FreeAppEASpace (UDF 2.50 3.3.4.6.1) */
 struct freeAppEASpace {
-        __le16 headerChecksum;
-        uint8_t freeEASpace[0];
+        __le16          headerChecksum;
+        uint8_t         freeEASpace[0];
 } __attribute__ ((packed));
 
 /* UDF Defined System Stream (UDF 2.50 3.3.7) */
@@ -276,4 +276,4 @@ struct freeAppEASpace {
 #define UDF_OS_ID_BEOS                  0x00U
 #define UDF_OS_ID_WINCE                 0x00U
 
-#endif                          /* _OSTA_UDF_H */
+#endif /* _OSTA_UDF_H */
diff --git a/fs/udf/partition.c b/fs/udf/partition.c
index a95d830a674d..aaab24c8c498 100644
--- a/fs/udf/partition.c
+++ b/fs/udf/partition.c
@@ -14,7 +14,7 @@
  *
  * HISTORY
  *
- * 12/06/98 blf  Created file. 
+ * 12/06/98 blf  Created file.
  *
  */
 
@@ -32,19 +32,17 @@ inline uint32_t udf_get_pblock(struct super_block *sb, uint32_t block,
                                uint16_t partition, uint32_t offset)
 {
         if (partition >= UDF_SB_NUMPARTS(sb)) {
-                udf_debug
-                    ("block=%d, partition=%d, offset=%d: invalid partition\n",
-                     block, partition, offset);
+                udf_debug("block=%d, partition=%d, offset=%d: invalid partition\n",
+                          block, partition, offset);
                 return 0xFFFFFFFF;
         }
         if (UDF_SB_PARTFUNC(sb, partition))
-                return UDF_SB_PARTFUNC(sb, partition) (sb, block, partition,
-                                                       offset);
+                return UDF_SB_PARTFUNC(sb, partition)(sb, block, partition, offset);
         else
                 return UDF_SB_PARTROOT(sb, partition) + block + offset;
 }
 
-uint32_t udf_get_pblock_virt15(struct super_block * sb, uint32_t block,
+uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block,
                                uint16_t partition, uint32_t offset)
 {
         struct buffer_head *bh = NULL;
@@ -52,14 +50,11 @@ uint32_t udf_get_pblock_virt15(struct super_block * sb, uint32_t block,
         uint32_t index;
         uint32_t loc;
 
-        index =
-            (sb->s_blocksize -
-             UDF_SB_TYPEVIRT(sb, partition).s_start_offset) / sizeof(uint32_t);
+        index = (sb->s_blocksize - UDF_SB_TYPEVIRT(sb,partition).s_start_offset) / sizeof(uint32_t);
 
-        if (block > UDF_SB_TYPEVIRT(sb, partition).s_num_entries) {
-                udf_debug
-                    ("Trying to access block beyond end of VAT (%d max %d)\n",
-                     block, UDF_SB_TYPEVIRT(sb, partition).s_num_entries);
+        if (block > UDF_SB_TYPEVIRT(sb,partition).s_num_entries) {
+                udf_debug("Trying to access block beyond end of VAT (%d max %d)\n",
+                          block, UDF_SB_TYPEVIRT(sb,partition).s_num_entries);
                 return 0xFFFFFFFF;
         }
 
@@ -69,10 +64,7 @@ uint32_t udf_get_pblock_virt15(struct super_block * sb, uint32_t block,
                 index = block % (sb->s_blocksize / sizeof(uint32_t));
         } else {
                 newblock = 0;
-                index =
-                    UDF_SB_TYPEVIRT(sb,
-                                    partition).s_start_offset /
-                    sizeof(uint32_t) + block;
+                index = UDF_SB_TYPEVIRT(sb,partition).s_start_offset / sizeof(uint32_t) + block;
         }
 
         loc = udf_block_map(UDF_SB_VAT(sb), newblock);
@@ -83,7 +75,7 @@ uint32_t udf_get_pblock_virt15(struct super_block * sb, uint32_t block,
                 return 0xFFFFFFFF;
         }
 
-        loc = le32_to_cpu(((__le32 *) bh->b_data)[index]);
+        loc = le32_to_cpu(((__le32 *)bh->b_data)[index]);
 
         brelse(bh);
 
@@ -93,8 +85,8 @@ uint32_t udf_get_pblock_virt15(struct super_block * sb, uint32_t block,
         }
 
         return udf_get_pblock(sb, loc,
-                              UDF_I_LOCATION(UDF_SB_VAT(sb)).
-                              partitionReferenceNum, offset);
+                              UDF_I_LOCATION(UDF_SB_VAT(sb)).partitionReferenceNum,
+                              offset);
 }
 
 inline uint32_t udf_get_pblock_virt20(struct super_block * sb, uint32_t block,
@@ -108,40 +100,29 @@ uint32_t udf_get_pblock_spar15(struct super_block * sb, uint32_t block,
 {
         int i;
         struct sparingTable *st = NULL;
-        uint32_t packet =
-            (block + offset) & ~(UDF_SB_TYPESPAR(sb, partition).s_packet_len -
-                                 1);
+        uint32_t packet = (block + offset) & ~(UDF_SB_TYPESPAR(sb,partition).s_packet_len - 1);
 
         for (i = 0; i < 4; i++) {
-                if (UDF_SB_TYPESPAR(sb, partition).s_spar_map[i] != NULL) {
-                        st = (struct sparingTable *)UDF_SB_TYPESPAR(sb,
-                                                                    partition).
-                            s_spar_map[i]->b_data;
+                if (UDF_SB_TYPESPAR(sb,partition).s_spar_map[i] != NULL) {
+                        st = (struct sparingTable *)UDF_SB_TYPESPAR(sb,partition).s_spar_map[i]->b_data;
                         break;
                 }
         }
 
         if (st) {
                 for (i = 0; i < le16_to_cpu(st->reallocationTableLen); i++) {
-                        if (le32_to_cpu(st->mapEntry[i].origLocation) >=
-                            0xFFFFFFF0)
+                        if (le32_to_cpu(st->mapEntry[i].origLocation) >= 0xFFFFFFF0) {
                                 break;
-                        else if (le32_to_cpu(st->mapEntry[i].origLocation) ==
-                                 packet) {
-                                return le32_to_cpu(st->mapEntry[i].
-                                                   mappedLocation) + ((block +
-                                                                       offset) &
-                                                                      (UDF_SB_TYPESPAR
-                                                                       (sb,
-                                                                        partition).
-                                                                       s_packet_len
-                                                                       - 1));
-                        } else if (le32_to_cpu(st->mapEntry[i].origLocation) >
-                                   packet)
+                        } else if (le32_to_cpu(st->mapEntry[i].origLocation) == packet) {
+                                return le32_to_cpu(st->mapEntry[i].mappedLocation) +
+                                        ((block + offset) & (UDF_SB_TYPESPAR(sb,partition).s_packet_len - 1));
+                        } else if (le32_to_cpu(st->mapEntry[i].origLocation) > packet) {
                                 break;
+                        }
                 }
         }
-        return UDF_SB_PARTROOT(sb, partition) + block + offset;
+
+        return UDF_SB_PARTROOT(sb,partition) + block + offset;
 }
 
 int udf_relocate_blocks(struct super_block *sb, long old_block, long *new_block)
@@ -153,20 +134,14 @@ int udf_relocate_blocks(struct super_block *sb, long old_block, long *new_block)
         int i, j, k, l;
 
         for (i = 0; i < UDF_SB_NUMPARTS(sb); i++) {
-                if (old_block > UDF_SB_PARTROOT(sb, i) &&
-                    old_block < UDF_SB_PARTROOT(sb, i) + UDF_SB_PARTLEN(sb, i))
-                {
-                        sdata = &UDF_SB_TYPESPAR(sb, i);
-                        packet =
-                            (old_block -
-                             UDF_SB_PARTROOT(sb,
-                                             i)) & ~(sdata->s_packet_len - 1);
+                if (old_block > UDF_SB_PARTROOT(sb,i) &&
+                    old_block < UDF_SB_PARTROOT(sb,i) + UDF_SB_PARTLEN(sb,i)) {
+                        sdata = &UDF_SB_TYPESPAR(sb,i);
+                        packet = (old_block - UDF_SB_PARTROOT(sb,i)) & ~(sdata->s_packet_len - 1);
 
                         for (j = 0; j < 4; j++) {
-                                if (UDF_SB_TYPESPAR(sb, i).s_spar_map[j] !=
-                                    NULL) {
-                                        st = (struct sparingTable *)sdata->
-                                            s_spar_map[j]->b_data;
+                                if (UDF_SB_TYPESPAR(sb,i).s_spar_map[j] != NULL) {
+                                        st = (struct sparingTable *)sdata->s_spar_map[j]->b_data;
                                         break;
                                 }
                         }
@@ -174,122 +149,51 @@ int udf_relocate_blocks(struct super_block *sb, long old_block, long *new_block)
                         if (!st)
                                 return 1;
 
-                        for (k = 0; k < le16_to_cpu(st->reallocationTableLen);
-                             k++) {
-                                if (le32_to_cpu(st->mapEntry[k].origLocation) ==
-                                    0xFFFFFFFF) {
+                        for (k = 0; k < le16_to_cpu(st->reallocationTableLen); k++) {
+                                if (le32_to_cpu(st->mapEntry[k].origLocation) == 0xFFFFFFFF) {
                                         for (; j < 4; j++) {
                                                 if (sdata->s_spar_map[j]) {
-                                                        st = (struct
-                                                              sparingTable *)
-                                                            sdata->
-                                                            s_spar_map[j]->
-                                                            b_data;
-                                                        st->mapEntry[k].
-                                                            origLocation =
-                                                            cpu_to_le32(packet);
-                                                        udf_update_tag((char *)
-                                                                       st,
-                                                                       sizeof
-                                                                       (struct
-                                                                        sparingTable)
-                                                                       +
-                                                                       le16_to_cpu
-                                                                       (st->
-                                                                        reallocationTableLen)
-                                                                       *
-                                                                       sizeof
-                                                                       (struct
-                                                                        sparingEntry));
-                                                        mark_buffer_dirty
-                                                            (sdata->
-                                                             s_spar_map[j]);
+                                                        st = (struct sparingTable *)sdata->s_spar_map[j]->b_data;
+                                                        st->mapEntry[k].origLocation = cpu_to_le32(packet);
+                                                        udf_update_tag((char *)st, sizeof(struct sparingTable) + le16_to_cpu(st->reallocationTableLen) * sizeof(struct sparingEntry));
+                                                        mark_buffer_dirty(sdata->s_spar_map[j]);
                                                 }
                                         }
-                                        *new_block =
-                                            le32_to_cpu(st->mapEntry[k].
-                                                        mappedLocation) +
-                                            ((old_block -
-                                              UDF_SB_PARTROOT(sb,
-                                                              i)) & (sdata->
-                                                                     s_packet_len
-                                                                     - 1));
+                                        *new_block = le32_to_cpu(st->mapEntry[k].mappedLocation) +
+                                                ((old_block - UDF_SB_PARTROOT(sb,i)) & (sdata->s_packet_len - 1));
                                         return 0;
-                                } else
-                                    if (le32_to_cpu
-                                        (st->mapEntry[k].origLocation) ==
-                                        packet) {
-                                        *new_block =
-                                            le32_to_cpu(st->mapEntry[k].
-                                                        mappedLocation) +
-                                            ((old_block -
-                                              UDF_SB_PARTROOT(sb,
-                                                              i)) & (sdata->
-                                                                     s_packet_len
-                                                                     - 1));
+                                } else if (le32_to_cpu(st->mapEntry[k].origLocation) == packet) {
+                                        *new_block = le32_to_cpu(st->mapEntry[k].mappedLocation) +
+                                                ((old_block - UDF_SB_PARTROOT(sb,i)) & (sdata->s_packet_len - 1));
                                         return 0;
-                                } else
-                                    if (le32_to_cpu
-                                        (st->mapEntry[k].origLocation) > packet)
+                                } else if (le32_to_cpu(st->mapEntry[k].origLocation) > packet) {
                                         break;
+                                }
                         }
-                        for (l = k; l < le16_to_cpu(st->reallocationTableLen);
-                             l++) {
-                                if (le32_to_cpu(st->mapEntry[l].origLocation) ==
-                                    0xFFFFFFFF) {
+
+                        for (l = k; l < le16_to_cpu(st->reallocationTableLen); l++) {
+                                if (le32_to_cpu(st->mapEntry[l].origLocation) == 0xFFFFFFFF) {
                                         for (; j < 4; j++) {
                                                 if (sdata->s_spar_map[j]) {
-                                                        st = (struct
-                                                              sparingTable *)
-                                                            sdata->
-                                                            s_spar_map[j]->
-                                                            b_data;
-                                                        mapEntry =
-                                                            st->mapEntry[l];
-                                                        mapEntry.origLocation =
-                                                            cpu_to_le32(packet);
-                                                        memmove(&st->
-                                                                mapEntry[k + 1],
-                                                                &st->
-                                                                mapEntry[k],
-                                                                (l -
-                                                                 k) *
-                                                                sizeof(struct
-                                                                       sparingEntry));
-                                                        st->mapEntry[k] =
-                                                            mapEntry;
-                                                        udf_update_tag((char *)
-                                                                       st,
-                                                                       sizeof
-                                                                       (struct
-                                                                        sparingTable)
-                                                                       +
-                                                                       le16_to_cpu
-                                                                       (st->
-                                                                        reallocationTableLen)
-                                                                       *
-                                                                       sizeof
-                                                                       (struct
-                                                                        sparingEntry));
-                                                        mark_buffer_dirty
-                                                            (sdata->
-                                                             s_spar_map[j]);
+                                                        st = (struct sparingTable *)sdata->s_spar_map[j]->b_data;
+                                                        mapEntry = st->mapEntry[l];
+                                                        mapEntry.origLocation = cpu_to_le32(packet);
+                                                        memmove(&st->mapEntry[k + 1], &st->mapEntry[k], (l - k) * sizeof(struct sparingEntry));
+                                                        st->mapEntry[k] = mapEntry;
+                                                        udf_update_tag((char *)st, sizeof(struct sparingTable) + le16_to_cpu(st->reallocationTableLen) * sizeof(struct sparingEntry));
+                                                        mark_buffer_dirty(sdata->s_spar_map[j]);
                                                 }
                                         }
-                                        *new_block =
-                                            le32_to_cpu(st->mapEntry[k].
-                                                        mappedLocation) +
-                                            ((old_block -
-                                              UDF_SB_PARTROOT(sb,
-                                                              i)) & (sdata->
-                                                                     s_packet_len
-                                                                     - 1));
+                                        *new_block = le32_to_cpu(st->mapEntry[k].mappedLocation) +
+                                                ((old_block - UDF_SB_PARTROOT(sb,i)) & (sdata->s_packet_len - 1));
                                         return 0;
                                 }
                         }
+
                         return 1;
-                }
+                } /* if old_block */
         }
+
         if (i == UDF_SB_NUMPARTS(sb)) {
                 /* outside of partitions */
                 /* for now, fail =) */
diff --git a/fs/udf/super.c b/fs/udf/super.c
index 72097ee6b752..7b30964665db 100644
--- a/fs/udf/super.c
+++ b/fs/udf/super.c
@@ -104,11 +104,11 @@ static int udf_get_sb(struct file_system_type *fs_type,
 }
 
 static struct file_system_type udf_fstype = {
-        .owner = THIS_MODULE,
-        .name = "udf",
-        .get_sb = udf_get_sb,
-        .kill_sb = kill_block_super,
-        .fs_flags = FS_REQUIRES_DEV,
+        .owner          = THIS_MODULE,
+        .name           = "udf",
+        .get_sb         = udf_get_sb,
+        .kill_sb        = kill_block_super,
+        .fs_flags       = FS_REQUIRES_DEV,
 };
 
 static struct kmem_cache *udf_inode_cachep;
@@ -116,8 +116,7 @@ static struct kmem_cache *udf_inode_cachep;
 static struct inode *udf_alloc_inode(struct super_block *sb)
 {
         struct udf_inode_info *ei;
-        ei = (struct udf_inode_info *)kmem_cache_alloc(udf_inode_cachep,
-                                                       GFP_KERNEL);
+        ei = (struct udf_inode_info *)kmem_cache_alloc(udf_inode_cachep, GFP_KERNEL);
         if (!ei)
                 return NULL;
 
@@ -150,7 +149,7 @@ static int init_inodecache(void)
                                              0, (SLAB_RECLAIM_ACCOUNT |
                                                  SLAB_MEM_SPREAD),
                                              init_once);
-        if (udf_inode_cachep == NULL)
+        if (!udf_inode_cachep)
                 return -ENOMEM;
         return 0;
 }
@@ -162,15 +161,15 @@ static void destroy_inodecache(void)
 
 /* Superblock operations */
 static const struct super_operations udf_sb_ops = {
-        .alloc_inode = udf_alloc_inode,
-        .destroy_inode = udf_destroy_inode,
-        .write_inode = udf_write_inode,
-        .delete_inode = udf_delete_inode,
-        .clear_inode = udf_clear_inode,
-        .put_super = udf_put_super,
-        .write_super = udf_write_super,
-        .statfs = udf_statfs,
-        .remount_fs = udf_remount_fs,
+        .alloc_inode    = udf_alloc_inode,
+        .destroy_inode  = udf_destroy_inode,
+        .write_inode    = udf_write_inode,
+        .delete_inode   = udf_delete_inode,
+        .clear_inode    = udf_clear_inode,
+        .put_super      = udf_put_super,
+        .write_super    = udf_write_super,
+        .statfs         = udf_statfs,
+        .remount_fs     = udf_remount_fs,
 };
 
 struct udf_options {
@@ -193,16 +192,20 @@ struct udf_options {
 static int __init init_udf_fs(void)
 {
         int err;
+
         err = init_inodecache();
         if (err)
                 goto out1;
         err = register_filesystem(&udf_fstype);
         if (err)
                 goto out;
+
         return 0;
-      out:
+
+out:
         destroy_inodecache();
-      out1:
+
+out1:
         return err;
 }
 
@@ -213,7 +216,7 @@ static void __exit exit_udf_fs(void)
 }
 
 module_init(init_udf_fs)
-    module_exit(exit_udf_fs)
+module_exit(exit_udf_fs)
 
 /*
  * udf_parse_options
@@ -239,7 +242,7 @@ module_init(init_udf_fs)
  *
  *      The remaining are for debugging and disaster recovery:
  *
- *      novrs           Skip volume sequence recognition 
+ *      novrs           Skip volume sequence recognition
  *
  *      The following expect a offset from 0.
  *
@@ -268,6 +271,7 @@ module_init(init_udf_fs)
  *      July 1, 1997 - Andrew E. Mileski
  *      Written, tested, and released.
  */
+
 enum {
         Opt_novrs, Opt_nostrict, Opt_bs, Opt_unhide, Opt_undelete,
         Opt_noadinicb, Opt_adinicb, Opt_shortad, Opt_longad,
@@ -278,32 +282,32 @@ enum {
 };
 
 static match_table_t tokens = {
-        {Opt_novrs, "novrs"},
-        {Opt_nostrict, "nostrict"},
-        {Opt_bs, "bs=%u"},
-        {Opt_unhide, "unhide"},
-        {Opt_undelete, "undelete"},
-        {Opt_noadinicb, "noadinicb"},
-        {Opt_adinicb, "adinicb"},
-        {Opt_shortad, "shortad"},
-        {Opt_longad, "longad"},
-        {Opt_uforget, "uid=forget"},
-        {Opt_uignore, "uid=ignore"},
-        {Opt_gforget, "gid=forget"},
-        {Opt_gignore, "gid=ignore"},
-        {Opt_gid, "gid=%u"},
-        {Opt_uid, "uid=%u"},
-        {Opt_umask, "umask=%o"},
-        {Opt_session, "session=%u"},
-        {Opt_lastblock, "lastblock=%u"},
-        {Opt_anchor, "anchor=%u"},
-        {Opt_volume, "volume=%u"},
-        {Opt_partition, "partition=%u"},
-        {Opt_fileset, "fileset=%u"},
-        {Opt_rootdir, "rootdir=%u"},
-        {Opt_utf8, "utf8"},
-        {Opt_iocharset, "iocharset=%s"},
-        {Opt_err, NULL}
+        {Opt_novrs,     "novrs"},
+        {Opt_nostrict,  "nostrict"},
+        {Opt_bs,        "bs=%u"},
+        {Opt_unhide,    "unhide"},
+        {Opt_undelete,  "undelete"},
+        {Opt_noadinicb, "noadinicb"},
+        {Opt_adinicb,   "adinicb"},
+        {Opt_shortad,   "shortad"},
+        {Opt_longad,    "longad"},
+        {Opt_uforget,   "uid=forget"},
+        {Opt_uignore,   "uid=ignore"},
+        {Opt_gforget,   "gid=forget"},
+        {Opt_gignore,   "gid=ignore"},
+        {Opt_gid,       "gid=%u"},
+        {Opt_uid,       "uid=%u"},
+        {Opt_umask,     "umask=%o"},
+        {Opt_session,   "session=%u"},
+        {Opt_lastblock, "lastblock=%u"},
+        {Opt_anchor,    "anchor=%u"},
+        {Opt_volume,    "volume=%u"},
+        {Opt_partition, "partition=%u"},
+        {Opt_fileset,   "fileset=%u"},
+        {Opt_rootdir,   "rootdir=%u"},
+        {Opt_utf8,      "utf8"},
+        {Opt_iocharset, "iocharset=%s"},
+        {Opt_err,       NULL}
 };
 
 static int udf_parse_options(char *options, struct udf_options *uopt)
@@ -444,9 +448,11 @@ static int udf_parse_options(char *options, struct udf_options *uopt)
 void udf_write_super(struct super_block *sb)
 {
         lock_kernel();
+
         if (!(sb->s_flags & MS_RDONLY))
                 udf_open_lvid(sb);
         sb->s_dirt = 0;
+
         unlock_kernel();
 }
 
@@ -455,16 +461,16 @@ static int udf_remount_fs(struct super_block *sb, int *flags, char *options)
         struct udf_options uopt;
 
         uopt.flags = UDF_SB(sb)->s_flags;
-        uopt.uid = UDF_SB(sb)->s_uid;
-        uopt.gid = UDF_SB(sb)->s_gid;
+        uopt.uid   = UDF_SB(sb)->s_uid;
+        uopt.gid   = UDF_SB(sb)->s_gid;
         uopt.umask = UDF_SB(sb)->s_umask;
 
         if (!udf_parse_options(options, &uopt))
                 return -EINVAL;
 
         UDF_SB(sb)->s_flags = uopt.flags;
-        UDF_SB(sb)->s_uid = uopt.uid;
-        UDF_SB(sb)->s_gid = uopt.gid;
+        UDF_SB(sb)->s_uid   = uopt.uid;
+        UDF_SB(sb)->s_gid   = uopt.gid;
         UDF_SB(sb)->s_umask = uopt.umask;
 
         if (UDF_SB_LVIDBH(sb)) {
@@ -517,6 +523,7 @@ static int udf_set_blocksize(struct super_block *sb, int bsize)
                 printk(KERN_ERR "udf: bad block size (%d)\n", bsize);
                 return 0;
         }
+
         return sb->s_blocksize;
 }
 
@@ -552,15 +559,12 @@ static int udf_vrs(struct super_block *sb, int silent)
 
                 /* Look for ISO  descriptors */
                 vsd = (struct volStructDesc *)(bh->b_data +
-                                               (sector &
-                                                (sb->s_blocksize - 1)));
+                                               (sector & (sb->s_blocksize - 1)));
 
                 if (vsd->stdIdent[0] == 0) {
                         brelse(bh);
                         break;
-                } else
-                    if (!strncmp
-                        (vsd->stdIdent, VSD_STD_ID_CD001, VSD_STD_ID_LEN)) {
+                } else if (!strncmp(vsd->stdIdent, VSD_STD_ID_CD001, VSD_STD_ID_LEN)) {
                         iso9660 = sector;
                         switch (vsd->structType) {
                         case 0:
@@ -587,21 +591,13 @@ static int udf_vrs(struct super_block *sb, int silent)
                                           vsd->structType);
                                 break;
                         }
-                } else
-                    if (!strncmp
-                        (vsd->stdIdent, VSD_STD_ID_BEA01, VSD_STD_ID_LEN)) {
-                } else
-                    if (!strncmp
-                        (vsd->stdIdent, VSD_STD_ID_TEA01, VSD_STD_ID_LEN)) {
+                } else if (!strncmp(vsd->stdIdent, VSD_STD_ID_BEA01, VSD_STD_ID_LEN)) {
+                } else if (!strncmp(vsd->stdIdent, VSD_STD_ID_TEA01, VSD_STD_ID_LEN)) {
                         brelse(bh);
                         break;
-                } else
-                    if (!strncmp
-                        (vsd->stdIdent, VSD_STD_ID_NSR02, VSD_STD_ID_LEN)) {
+                } else if (!strncmp(vsd->stdIdent, VSD_STD_ID_NSR02, VSD_STD_ID_LEN)) {
                         nsr02 = sector;
-                } else
-                    if (!strncmp
-                        (vsd->stdIdent, VSD_STD_ID_NSR03, VSD_STD_ID_LEN)) {
+                } else if (!strncmp(vsd->stdIdent, VSD_STD_ID_NSR03, VSD_STD_ID_LEN)) {
                         nsr03 = sector;
                 }
                 brelse(bh);
@@ -644,11 +640,10 @@ static void udf_find_anchor(struct super_block *sb)
 
         if (lastblock) {
                 int varlastblock = udf_variable_to_fixed(lastblock);
-                int last[] = { lastblock, lastblock - 2,
-                        lastblock - 150, lastblock - 152,
-                        varlastblock, varlastblock - 2,
-                        varlastblock - 150, varlastblock - 152
-                };
+                int last[] =  { lastblock, lastblock - 2,
+                                lastblock - 150, lastblock - 152,
+                                varlastblock, varlastblock - 2,
+                                varlastblock - 150, varlastblock - 152 };
 
                 lastblock = 0;
 
@@ -664,88 +659,54 @@ static void udf_find_anchor(struct super_block *sb)
                         if (last[i] < 0 || !(bh = sb_bread(sb, last[i]))) {
                                 ident = location = 0;
                         } else {
-                                ident =
-                                    le16_to_cpu(((tag *) bh->b_data)->tagIdent);
-                                location =
-                                    le32_to_cpu(((tag *) bh->b_data)->
-                                                tagLocation);
+                                ident = le16_to_cpu(((tag *)bh->b_data)->tagIdent);
+                                location = le32_to_cpu(((tag *)bh->b_data)->tagLocation);
                                 brelse(bh);
                         }
 
                         if (ident == TAG_IDENT_AVDP) {
                                 if (location == last[i] - UDF_SB_SESSION(sb)) {
-                                        lastblock = UDF_SB_ANCHOR(sb)[0] =
-                                            last[i] - UDF_SB_SESSION(sb);
-                                        UDF_SB_ANCHOR(sb)[1] =
-                                            last[i] - 256 - UDF_SB_SESSION(sb);
-                                } else if (location ==
-                                           udf_variable_to_fixed(last[i]) -
-                                           UDF_SB_SESSION(sb)) {
+                                        lastblock = UDF_SB_ANCHOR(sb)[0] = last[i] - UDF_SB_SESSION(sb);
+                                        UDF_SB_ANCHOR(sb)[1] = last[i] - 256 - UDF_SB_SESSION(sb);
+                                } else if (location == udf_variable_to_fixed(last[i]) - UDF_SB_SESSION(sb)) {
                                         UDF_SET_FLAG(sb, UDF_FLAG_VARCONV);
-                                        lastblock = UDF_SB_ANCHOR(sb)[0] =
-                                            udf_variable_to_fixed(last[i]) -
-                                            UDF_SB_SESSION(sb);
-                                        UDF_SB_ANCHOR(sb)[1] =
-                                            lastblock - 256 -
-                                            UDF_SB_SESSION(sb);
-                                } else
-                                        udf_debug
-                                            ("Anchor found at block %d, location mismatch %d.\n",
-                                             last[i], location);
-                        } else if (ident == TAG_IDENT_FE
-                                   || ident == TAG_IDENT_EFE) {
+                                        lastblock = UDF_SB_ANCHOR(sb)[0] = udf_variable_to_fixed(last[i]) - UDF_SB_SESSION(sb);
+                                        UDF_SB_ANCHOR(sb)[1] = lastblock - 256 - UDF_SB_SESSION(sb);
+                                } else {
+                                        udf_debug("Anchor found at block %d, location mismatch %d.\n",
+                                                  last[i], location);
+                                }
+                        } else if (ident == TAG_IDENT_FE || ident == TAG_IDENT_EFE) {
                                 lastblock = last[i];
                                 UDF_SB_ANCHOR(sb)[3] = 512;
                         } else {
-                                if (last[i] < 256
-                                    || !(bh = sb_bread(sb, last[i] - 256))) {
+                                if (last[i] < 256 || !(bh = sb_bread(sb, last[i] - 256))) {
                                         ident = location = 0;
                                 } else {
-                                        ident =
-                                            le16_to_cpu(((tag *) bh->b_data)->
-                                                        tagIdent);
-                                        location =
-                                            le32_to_cpu(((tag *) bh->b_data)->
-                                                        tagLocation);
+                                        ident = le16_to_cpu(((tag *)bh->b_data)->tagIdent);
+                                        location = le32_to_cpu(((tag *)bh->b_data)->tagLocation);
                                         brelse(bh);
                                 }
 
                                 if (ident == TAG_IDENT_AVDP &&
-                                    location ==
-                                    last[i] - 256 - UDF_SB_SESSION(sb)) {
+                                    location == last[i] - 256 - UDF_SB_SESSION(sb)) {
                                         lastblock = last[i];
                                         UDF_SB_ANCHOR(sb)[1] = last[i] - 256;
                                 } else {
-                                        if (last[i] < 312 + UDF_SB_SESSION(sb)
-                                            || !(bh =
-                                                 sb_bread(sb,
-                                                          last[i] - 312 -
-                                                          UDF_SB_SESSION(sb))))
-                                        {
+                                        if (last[i] < 312 + UDF_SB_SESSION(sb) ||
+                                            !(bh = sb_bread(sb, last[i] - 312 - UDF_SB_SESSION(sb)))) {
                                                 ident = location = 0;
                                         } else {
-                                                ident =
-                                                    le16_to_cpu(((tag *) bh->
-                                                                 b_data)->
-                                                                tagIdent);
-                                                location =
-                                                    le32_to_cpu(((tag *) bh->
-                                                                 b_data)->
-                                                                tagLocation);
+                                                ident = le16_to_cpu(((tag *)bh->b_data)->tagIdent);
+                                                location = le32_to_cpu(((tag *)bh->b_data)->tagLocation);
                                                 brelse(bh);
                                         }
 
                                         if (ident == TAG_IDENT_AVDP &&
-                                            location ==
-                                            udf_variable_to_fixed(last[i]) -
-                                            256) {
-                                                UDF_SET_FLAG(sb,
-                                                             UDF_FLAG_VARCONV);
-                                                lastblock =
-                                                    udf_variable_to_fixed(last
-                                                                          [i]);
-                                                UDF_SB_ANCHOR(sb)[1] =
-                                                    lastblock - 256;
+                                            location == udf_variable_to_fixed(last[i]) - 256) {
+                                                UDF_SET_FLAG(sb, UDF_FLAG_VARCONV);
+                                                lastblock = udf_variable_to_fixed(last[i]);
+                                                UDF_SB_ANCHOR(sb)[1] = lastblock - 256;
                                         }
                                 }
                         }
@@ -755,9 +716,8 @@ static void udf_find_anchor(struct super_block *sb)
         if (!lastblock) {
                 /* We havn't found the lastblock. check 312 */
                 if ((bh = sb_bread(sb, 312 + UDF_SB_SESSION(sb)))) {
-                        ident = le16_to_cpu(((tag *) bh->b_data)->tagIdent);
-                        location =
-                            le32_to_cpu(((tag *) bh->b_data)->tagLocation);
+                        ident = le16_to_cpu(((tag *)bh->b_data)->tagIdent);
+                        location = le32_to_cpu(((tag *)bh->b_data)->tagLocation);
                         brelse(bh);
 
                         if (ident == TAG_IDENT_AVDP && location == 256)
@@ -767,19 +727,13 @@ static void udf_find_anchor(struct super_block *sb)
 
         for (i = 0; i < ARRAY_SIZE(UDF_SB_ANCHOR(sb)); i++) {
                 if (UDF_SB_ANCHOR(sb)[i]) {
-                        if (!(bh = udf_read_tagged(sb,
-                                                   UDF_SB_ANCHOR(sb)[i],
-                                                   UDF_SB_ANCHOR(sb)[i],
-                                                   &ident))) {
+                        if (!(bh = udf_read_tagged(sb, UDF_SB_ANCHOR(sb)[i],
+                                                   UDF_SB_ANCHOR(sb)[i], &ident))) {
                                 UDF_SB_ANCHOR(sb)[i] = 0;
                         } else {
                                 brelse(bh);
-                                if ((ident != TAG_IDENT_AVDP) && (i ||
-                                                                  (ident !=
-                                                                   TAG_IDENT_FE
-                                                                   && ident !=
-                                                                   TAG_IDENT_EFE)))
-                                {
+                                if ((ident != TAG_IDENT_AVDP) &&
+                                    (i || (ident != TAG_IDENT_FE && ident != TAG_IDENT_EFE))) {
                                         UDF_SB_ANCHOR(sb)[i] = 0;
                                 }
                         }
@@ -789,9 +743,7 @@ static void udf_find_anchor(struct super_block *sb)
         UDF_SB_LASTBLOCK(sb) = lastblock;
 }
 
-static int
-udf_find_fileset(struct super_block *sb, kernel_lb_addr * fileset,
-                 kernel_lb_addr * root)
+static int udf_find_fileset(struct super_block *sb, kernel_lb_addr *fileset, kernel_lb_addr *root)
 {
         struct buffer_head *bh = NULL;
         long lastblock;
@@ -801,18 +753,19 @@ udf_find_fileset(struct super_block *sb, kernel_lb_addr * fileset,
             fileset->partitionReferenceNum != 0xFFFF) {
                 bh = udf_read_ptagged(sb, *fileset, 0, &ident);
 
-                if (!bh)
+                if (!bh) {
                         return 1;
-                else if (ident != TAG_IDENT_FSD) {
+                } else if (ident != TAG_IDENT_FSD) {
                         brelse(bh);
                         return 1;
                 }
 
         }
 
-        if (!bh) {              /* Search backwards through the partitions */
+        if (!bh) { /* Search backwards through the partitions */
                 kernel_lb_addr newfileset;
 
+/* --> cvg: FIXME - is it reasonable? */
                 return 1;
 
                 for (newfileset.partitionReferenceNum = UDF_SB_NUMPARTS(sb) - 1;
@@ -820,14 +773,11 @@ udf_find_fileset(struct super_block *sb, kernel_lb_addr * fileset,
                       fileset->logicalBlockNum == 0xFFFFFFFF &&
                       fileset->partitionReferenceNum == 0xFFFF);
                      newfileset.partitionReferenceNum--) {
-                        lastblock =
-                            UDF_SB_PARTLEN(sb,
-                                           newfileset.partitionReferenceNum);
+                        lastblock = UDF_SB_PARTLEN(sb, newfileset.partitionReferenceNum);
                         newfileset.logicalBlockNum = 0;
 
                         do {
-                                bh = udf_read_ptagged(sb, newfileset, 0,
-                                                      &ident);
+                                bh = udf_read_ptagged(sb, newfileset, 0, &ident);
                                 if (!bh) {
                                         newfileset.logicalBlockNum++;
                                         continue;
@@ -835,38 +785,28 @@ udf_find_fileset(struct super_block *sb, kernel_lb_addr * fileset,
 
                                 switch (ident) {
                                 case TAG_IDENT_SBD:
-                                        {
-                                                struct spaceBitmapDesc *sp;
-                                                sp = (struct spaceBitmapDesc *)
-                                                    bh->b_data;
-                                                newfileset.logicalBlockNum +=
-                                                    1 +
-                                                    ((le32_to_cpu
-                                                      (sp->numOfBytes) +
-                                                      sizeof(struct
-                                                             spaceBitmapDesc) -
-                                                      1)
-                                                     >> sb->s_blocksize_bits);
-                                                brelse(bh);
-                                                break;
-                                        }
+                                {
+                                        struct spaceBitmapDesc *sp;
+                                        sp = (struct spaceBitmapDesc *)bh->b_data;
+                                        newfileset.logicalBlockNum += 1 +
+                                                ((le32_to_cpu(sp->numOfBytes) +
+                                                  sizeof(struct spaceBitmapDesc) - 1)
+                                                 >> sb->s_blocksize_bits);
+                                        brelse(bh);
+                                        break;
+                                }
                                 case TAG_IDENT_FSD:
-                                        {
-                                                *fileset = newfileset;
-                                                break;
-                                        }
+                                        *fileset = newfileset;
+                                        break;
                                 default:
-                                        {
-                                                newfileset.logicalBlockNum++;
-                                                brelse(bh);
-                                                bh = NULL;
-                                                break;
-                                        }
+                                        newfileset.logicalBlockNum++;
+                                        brelse(bh);
+                                        bh = NULL;
+                                        break;
                                 }
-                        }
-                        while (newfileset.logicalBlockNum < lastblock &&
-                               fileset->logicalBlockNum == 0xFFFFFFFF &&
-                               fileset->partitionReferenceNum == 0xFFFF);
+                        } while (newfileset.logicalBlockNum < lastblock &&
+                                 fileset->logicalBlockNum == 0xFFFFFFFF &&
+                                 fileset->partitionReferenceNum == 0xFFFF);
                 }
         }
 
@@ -898,10 +838,10 @@ static void udf_load_pvoldesc(struct super_block *sb, struct buffer_head *bh)
                               lets_to_cpu(pvoldesc->recordingDateAndTime))) {
                 kernel_timestamp ts;
                 ts = lets_to_cpu(pvoldesc->recordingDateAndTime);
-                udf_debug
-                    ("recording time %ld/%ld, %04u/%02u/%02u %02u:%02u (%x)\n",
-                     recording, recording_usec, ts.year, ts.month, ts.day,
-                     ts.hour, ts.minute, ts.typeAndTimezone);
+                udf_debug("recording time %ld/%ld, %04u/%02u/%02u %02u:%02u (%x)\n",
+                          recording, recording_usec,
+                          ts.year, ts.month, ts.day, ts.hour,
+                          ts.minute, ts.typeAndTimezone);
                 UDF_SB_RECORDTIME(sb).tv_sec = recording;
                 UDF_SB_RECORDTIME(sb).tv_nsec = recording_usec * 1000;
         }
@@ -920,9 +860,8 @@ static void udf_load_pvoldesc(struct super_block *sb, struct buffer_head *bh)
         }
 }
 
-static void
-udf_load_fileset(struct super_block *sb, struct buffer_head *bh,
-                 kernel_lb_addr * root)
+static void udf_load_fileset(struct super_block *sb, struct buffer_head *bh,
+                             kernel_lb_addr *root)
 {
         struct fileSetDesc *fset;
 
@@ -945,121 +884,72 @@ static void udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
 
         for (i = 0; i < UDF_SB_NUMPARTS(sb); i++) {
                 udf_debug("Searching map: (%d == %d)\n",
-                          UDF_SB_PARTMAPS(sb)[i].s_partition_num,
-                          le16_to_cpu(p->partitionNumber));
-                if (UDF_SB_PARTMAPS(sb)[i].s_partition_num ==
-                    le16_to_cpu(p->partitionNumber)) {
-                        UDF_SB_PARTLEN(sb, i) = le32_to_cpu(p->partitionLength);        /* blocks */
-                        UDF_SB_PARTROOT(sb, i) =
-                            le32_to_cpu(p->partitionStartingLocation);
-                        if (le32_to_cpu(p->accessType) ==
-                            PD_ACCESS_TYPE_READ_ONLY)
-                                UDF_SB_PARTFLAGS(sb, i) |=
-                                    UDF_PART_FLAG_READ_ONLY;
-                        if (le32_to_cpu(p->accessType) ==
-                            PD_ACCESS_TYPE_WRITE_ONCE)
-                                UDF_SB_PARTFLAGS(sb, i) |=
-                                    UDF_PART_FLAG_WRITE_ONCE;
-                        if (le32_to_cpu(p->accessType) ==
-                            PD_ACCESS_TYPE_REWRITABLE)
-                                UDF_SB_PARTFLAGS(sb, i) |=
-                                    UDF_PART_FLAG_REWRITABLE;
-                        if (le32_to_cpu(p->accessType) ==
-                            PD_ACCESS_TYPE_OVERWRITABLE)
-                                UDF_SB_PARTFLAGS(sb, i) |=
-                                    UDF_PART_FLAG_OVERWRITABLE;
-
-                        if (!strcmp
-                            (p->partitionContents.ident,
-                             PD_PARTITION_CONTENTS_NSR02)
-                            || !strcmp(p->partitionContents.ident,
-                                       PD_PARTITION_CONTENTS_NSR03)) {
+                          UDF_SB_PARTMAPS(sb)[i].s_partition_num, le16_to_cpu(p->partitionNumber));
+                if (UDF_SB_PARTMAPS(sb)[i].s_partition_num == le16_to_cpu(p->partitionNumber)) {
+                        UDF_SB_PARTLEN(sb,i) = le32_to_cpu(p->partitionLength); /* blocks */
+                        UDF_SB_PARTROOT(sb,i) = le32_to_cpu(p->partitionStartingLocation);
+                        if (le32_to_cpu(p->accessType) == PD_ACCESS_TYPE_READ_ONLY)
+                                UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_READ_ONLY;
+                        if (le32_to_cpu(p->accessType) == PD_ACCESS_TYPE_WRITE_ONCE)
+                                UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_WRITE_ONCE;
+                        if (le32_to_cpu(p->accessType) == PD_ACCESS_TYPE_REWRITABLE)
+                                UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_REWRITABLE;
+                        if (le32_to_cpu(p->accessType) == PD_ACCESS_TYPE_OVERWRITABLE)
+                                UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_OVERWRITABLE;
+
+                        if (!strcmp(p->partitionContents.ident, PD_PARTITION_CONTENTS_NSR02) ||
+                            !strcmp(p->partitionContents.ident, PD_PARTITION_CONTENTS_NSR03)) {
                                 struct partitionHeaderDesc *phd;
 
-                                phd =
-                                    (struct partitionHeaderDesc *)(p->
-                                                                   partitionContentsUse);
+                                phd = (struct partitionHeaderDesc *)(p->partitionContentsUse);
                                 if (phd->unallocSpaceTable.extLength) {
-                                        kernel_lb_addr loc =
-                                            { le32_to_cpu(phd->
-                                                          unallocSpaceTable.
-                                                          extPosition), i };
-
-                                        UDF_SB_PARTMAPS(sb)[i].s_uspace.
-                                            s_table = udf_iget(sb, loc);
-                                        UDF_SB_PARTFLAGS(sb, i) |=
-                                            UDF_PART_FLAG_UNALLOC_TABLE;
-                                        udf_debug
-                                            ("unallocSpaceTable (part %d) @ %ld\n",
-                                             i,
-                                             UDF_SB_PARTMAPS(sb)[i].s_uspace.
-                                             s_table->i_ino);
+                                        kernel_lb_addr loc = {
+                                                .logicalBlockNum = le32_to_cpu(phd->unallocSpaceTable.extPosition),
+                                                .partitionReferenceNum = i,
+                                        };
+
+                                        UDF_SB_PARTMAPS(sb)[i].s_uspace.s_table =
+                                                udf_iget(sb, loc);
+                                        UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_UNALLOC_TABLE;
+                                        udf_debug("unallocSpaceTable (part %d) @ %ld\n",
+                                                  i, UDF_SB_PARTMAPS(sb)[i].s_uspace.s_table->i_ino);
                                 }
                                 if (phd->unallocSpaceBitmap.extLength) {
                                         UDF_SB_ALLOC_BITMAP(sb, i, s_uspace);
-                                        if (UDF_SB_PARTMAPS(sb)[i].s_uspace.
-                                            s_bitmap != NULL) {
-                                                UDF_SB_PARTMAPS(sb)[i].s_uspace.
-                                                    s_bitmap->s_extLength =
-                                                    le32_to_cpu(phd->
-                                                                unallocSpaceBitmap.
-                                                                extLength);
-                                                UDF_SB_PARTMAPS(sb)[i].s_uspace.
-                                                    s_bitmap->s_extPosition =
-                                                    le32_to_cpu(phd->
-                                                                unallocSpaceBitmap.
-                                                                extPosition);
-                                                UDF_SB_PARTFLAGS(sb, i) |=
-                                                    UDF_PART_FLAG_UNALLOC_BITMAP;
-                                                udf_debug
-                                                    ("unallocSpaceBitmap (part %d) @ %d\n",
-                                                     i,
-                                                     UDF_SB_PARTMAPS(sb)[i].
-                                                     s_uspace.s_bitmap->
-                                                     s_extPosition);
+                                        if (UDF_SB_PARTMAPS(sb)[i].s_uspace.s_bitmap != NULL) {
+                                                UDF_SB_PARTMAPS(sb)[i].s_uspace.s_bitmap->s_extLength =
+                                                        le32_to_cpu(phd->unallocSpaceBitmap.extLength);
+                                                UDF_SB_PARTMAPS(sb)[i].s_uspace.s_bitmap->s_extPosition =
+                                                        le32_to_cpu(phd->unallocSpaceBitmap.extPosition);
+                                                UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_UNALLOC_BITMAP;
+                                                udf_debug("unallocSpaceBitmap (part %d) @ %d\n",
+                                                          i, UDF_SB_PARTMAPS(sb)[i].s_uspace.s_bitmap->s_extPosition);
                                         }
                                 }
                                 if (phd->partitionIntegrityTable.extLength)
-                                        udf_debug
-                                            ("partitionIntegrityTable (part %d)\n",
-                                             i);
+                                        udf_debug("partitionIntegrityTable (part %d)\n", i);
                                 if (phd->freedSpaceTable.extLength) {
-                                        kernel_lb_addr loc =
-                                            { le32_to_cpu(phd->freedSpaceTable.
-                                                          extPosition), i };
-
-                                        UDF_SB_PARTMAPS(sb)[i].s_fspace.
-                                            s_table = udf_iget(sb, loc);
-                                        UDF_SB_PARTFLAGS(sb, i) |=
-                                            UDF_PART_FLAG_FREED_TABLE;
-                                        udf_debug
-                                            ("freedSpaceTable (part %d) @ %ld\n",
-                                             i,
-                                             UDF_SB_PARTMAPS(sb)[i].s_fspace.
-                                             s_table->i_ino);
+                                        kernel_lb_addr loc = {
+                                                .logicalBlockNum = le32_to_cpu(phd->freedSpaceTable.extPosition),
+                                                .partitionReferenceNum = i,
+                                        };
+
+                                        UDF_SB_PARTMAPS(sb)[i].s_fspace.s_table =
+                                                udf_iget(sb, loc);
+                                        UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_FREED_TABLE;
+                                        udf_debug("freedSpaceTable (part %d) @ %ld\n",
+                                                  i, UDF_SB_PARTMAPS(sb)[i].s_fspace.s_table->i_ino);
                                 }
                                 if (phd->freedSpaceBitmap.extLength) {
                                         UDF_SB_ALLOC_BITMAP(sb, i, s_fspace);
-                                        if (UDF_SB_PARTMAPS(sb)[i].s_fspace.
-                                            s_bitmap != NULL) {
-                                                UDF_SB_PARTMAPS(sb)[i].s_fspace.
-                                                    s_bitmap->s_extLength =
-                                                    le32_to_cpu(phd->
-                                                                freedSpaceBitmap.
-                                                                extLength);
-                                                UDF_SB_PARTMAPS(sb)[i].s_fspace.
-                                                    s_bitmap->s_extPosition =
-                                                    le32_to_cpu(phd->
-                                                                freedSpaceBitmap.
-                                                                extPosition);
-                                                UDF_SB_PARTFLAGS(sb, i) |=
-                                                    UDF_PART_FLAG_FREED_BITMAP;
-                                                udf_debug
-                                                    ("freedSpaceBitmap (part %d) @ %d\n",
-                                                     i,
-                                                     UDF_SB_PARTMAPS(sb)[i].
-                                                     s_fspace.s_bitmap->
-                                                     s_extPosition);
+                                        if (UDF_SB_PARTMAPS(sb)[i].s_fspace.s_bitmap != NULL) {
+                                                UDF_SB_PARTMAPS(sb)[i].s_fspace.s_bitmap->s_extLength =
+                                                        le32_to_cpu(phd->freedSpaceBitmap.extLength);
+                                                UDF_SB_PARTMAPS(sb)[i].s_fspace.s_bitmap->s_extPosition =
+                                                        le32_to_cpu(phd->freedSpaceBitmap.extPosition);
+                                                UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_FREED_BITMAP;
+                                                udf_debug("freedSpaceBitmap (part %d) @ %d\n",
+                                                          i, UDF_SB_PARTMAPS(sb)[i].s_fspace.s_bitmap->s_extPosition);
                                         }
                                 }
                         }
@@ -1070,16 +960,14 @@ static void udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
                 udf_debug("Partition (%d) not found in partition map\n",
                           le16_to_cpu(p->partitionNumber));
         } else {
-                udf_debug
-                    ("Partition (%d:%d type %x) starts at physical %d, block length %d\n",
-                     le16_to_cpu(p->partitionNumber), i, UDF_SB_PARTTYPE(sb, i),
-                     UDF_SB_PARTROOT(sb, i), UDF_SB_PARTLEN(sb, i));
+                udf_debug("Partition (%d:%d type %x) starts at physical %d, block length %d\n",
+                          le16_to_cpu(p->partitionNumber), i, UDF_SB_PARTTYPE(sb,i),
+                          UDF_SB_PARTROOT(sb,i), UDF_SB_PARTLEN(sb,i));
         }
 }
 
-static int
-udf_load_logicalvol(struct super_block *sb, struct buffer_head *bh,
-                    kernel_lb_addr * fileset)
+static int udf_load_logicalvol(struct super_block *sb, struct buffer_head *bh,
+                               kernel_lb_addr *fileset)
 {
         struct logicalVolDesc *lvd;
         int i, j, offset;
@@ -1090,116 +978,69 @@ udf_load_logicalvol(struct super_block *sb, struct buffer_head *bh,
         UDF_SB_ALLOC_PARTMAPS(sb, le32_to_cpu(lvd->numPartitionMaps));
 
         for (i = 0, offset = 0;
-             i < UDF_SB_NUMPARTS(sb)
-             && offset < le32_to_cpu(lvd->mapTableLength);
-             i++, offset +=
-             ((struct genericPartitionMap *)&(lvd->partitionMaps[offset]))->
-             partitionMapLength) {
-                type =
-                    ((struct genericPartitionMap *)
-                     &(lvd->partitionMaps[offset]))->partitionMapType;
+             i < UDF_SB_NUMPARTS(sb) && offset < le32_to_cpu(lvd->mapTableLength);
+             i++, offset += ((struct genericPartitionMap *)&(lvd->partitionMaps[offset]))->partitionMapLength) {
+                type = ((struct genericPartitionMap *)&(lvd->partitionMaps[offset]))->partitionMapType;
                 if (type == 1) {
-                        struct genericPartitionMap1 *gpm1 =
-                            (struct genericPartitionMap1 *)&(lvd->
-                                                             partitionMaps
-                                                             [offset]);
-                        UDF_SB_PARTTYPE(sb, i) = UDF_TYPE1_MAP15;
-                        UDF_SB_PARTVSN(sb, i) = le16_to_cpu(gpm1->volSeqNum);
-                        UDF_SB_PARTNUM(sb, i) = le16_to_cpu(gpm1->partitionNum);
-                        UDF_SB_PARTFUNC(sb, i) = NULL;
+                        struct genericPartitionMap1 *gpm1 = (struct genericPartitionMap1 *)&(lvd->partitionMaps[offset]);
+                        UDF_SB_PARTTYPE(sb,i) = UDF_TYPE1_MAP15;
+                        UDF_SB_PARTVSN(sb,i) = le16_to_cpu(gpm1->volSeqNum);
+                        UDF_SB_PARTNUM(sb,i) = le16_to_cpu(gpm1->partitionNum);
+                        UDF_SB_PARTFUNC(sb,i) = NULL;
                 } else if (type == 2) {
-                        struct udfPartitionMap2 *upm2 =
-                            (struct udfPartitionMap2 *)&(lvd->
-                                                         partitionMaps[offset]);
-                        if (!strncmp
-                            (upm2->partIdent.ident, UDF_ID_VIRTUAL,
-                             strlen(UDF_ID_VIRTUAL))) {
-                                if (le16_to_cpu
-                                    (((__le16 *) upm2->partIdent.
-                                      identSuffix)[0]) == 0x0150) {
-                                        UDF_SB_PARTTYPE(sb, i) =
-                                            UDF_VIRTUAL_MAP15;
-                                        UDF_SB_PARTFUNC(sb, i) =
-                                            udf_get_pblock_virt15;
-                                } else
-                                    if (le16_to_cpu
-                                        (((__le16 *) upm2->partIdent.
-                                          identSuffix)[0]) == 0x0200) {
-                                        UDF_SB_PARTTYPE(sb, i) =
-                                            UDF_VIRTUAL_MAP20;
-                                        UDF_SB_PARTFUNC(sb, i) =
-                                            udf_get_pblock_virt20;
+                        struct udfPartitionMap2 *upm2 = (struct udfPartitionMap2 *)&(lvd->partitionMaps[offset]);
+                        if (!strncmp(upm2->partIdent.ident, UDF_ID_VIRTUAL, strlen(UDF_ID_VIRTUAL))) {
+                                if (le16_to_cpu(((__le16 *)upm2->partIdent.identSuffix)[0]) == 0x0150) {
+                                        UDF_SB_PARTTYPE(sb,i) = UDF_VIRTUAL_MAP15;
+                                        UDF_SB_PARTFUNC(sb,i) = udf_get_pblock_virt15;
+                                } else if (le16_to_cpu(((__le16 *)upm2->partIdent.identSuffix)[0]) == 0x0200) {
+                                        UDF_SB_PARTTYPE(sb,i) = UDF_VIRTUAL_MAP20;
+                                        UDF_SB_PARTFUNC(sb,i) = udf_get_pblock_virt20;
                                 }
-                        } else
-                            if (!strncmp
-                                (upm2->partIdent.ident, UDF_ID_SPARABLE,
-                                 strlen(UDF_ID_SPARABLE))) {
+                        } else if (!strncmp(upm2->partIdent.ident, UDF_ID_SPARABLE, strlen(UDF_ID_SPARABLE))) {
                                 uint32_t loc;
                                 uint16_t ident;
                                 struct sparingTable *st;
-                                struct sparablePartitionMap *spm =
-                                    (struct sparablePartitionMap *)&(lvd->
-                                                                     partitionMaps
-                                                                     [offset]);
-
-                                UDF_SB_PARTTYPE(sb, i) = UDF_SPARABLE_MAP15;
-                                UDF_SB_TYPESPAR(sb, i).s_packet_len =
-                                    le16_to_cpu(spm->packetLength);
+                                struct sparablePartitionMap *spm = (struct sparablePartitionMap *)&(lvd->partitionMaps[offset]);
+
+                                UDF_SB_PARTTYPE(sb,i) = UDF_SPARABLE_MAP15;
+                                UDF_SB_TYPESPAR(sb,i).s_packet_len = le16_to_cpu(spm->packetLength);
                                 for (j = 0; j < spm->numSparingTables; j++) {
-                                        loc =
-                                            le32_to_cpu(spm->
-                                                        locSparingTable[j]);
-                                        UDF_SB_TYPESPAR(sb, i).s_spar_map[j] =
-                                            udf_read_tagged(sb, loc, loc,
-                                                            &ident);
-                                        if (UDF_SB_TYPESPAR(sb, i).
-                                            s_spar_map[j] != NULL) {
-                                                st = (struct sparingTable *)
-                                                    UDF_SB_TYPESPAR(sb,
-                                                                    i).
-                                                    s_spar_map[j]->b_data;
-                                                if (ident != 0
-                                                    || strncmp(st->sparingIdent.
-                                                               ident,
-                                                               UDF_ID_SPARING,
-                                                               strlen
-                                                               (UDF_ID_SPARING)))
-                                                {
-                                                        brelse(UDF_SB_TYPESPAR
-                                                               (sb,
-                                                                i).
-                                                               s_spar_map[j]);
-                                                        UDF_SB_TYPESPAR(sb,
-                                                                        i).
-                                                            s_spar_map[j] =
-                                                            NULL;
+                                        loc = le32_to_cpu(spm->locSparingTable[j]);
+                                        UDF_SB_TYPESPAR(sb,i).s_spar_map[j] =
+                                                udf_read_tagged(sb, loc, loc, &ident);
+                                        if (UDF_SB_TYPESPAR(sb,i).s_spar_map[j] != NULL) {
+                                                st = (struct sparingTable *)UDF_SB_TYPESPAR(sb,i).s_spar_map[j]->b_data;
+                                                if (ident != 0 ||
+                                                    strncmp(st->sparingIdent.ident, UDF_ID_SPARING, strlen(UDF_ID_SPARING))) {
+                                                        brelse(UDF_SB_TYPESPAR(sb,i).s_spar_map[j]);
+                                                        UDF_SB_TYPESPAR(sb,i).s_spar_map[j] = NULL;
                                                 }
                                         }
                                 }
-                                UDF_SB_PARTFUNC(sb, i) = udf_get_pblock_spar15;
+                                UDF_SB_PARTFUNC(sb,i) = udf_get_pblock_spar15;
                         } else {
-                                udf_debug("Unknown ident: %s\n",
-                                          upm2->partIdent.ident);
+                                udf_debug("Unknown ident: %s\n", upm2->partIdent.ident);
                                 continue;
                         }
-                        UDF_SB_PARTVSN(sb, i) = le16_to_cpu(upm2->volSeqNum);
-                        UDF_SB_PARTNUM(sb, i) = le16_to_cpu(upm2->partitionNum);
+                        UDF_SB_PARTVSN(sb,i) = le16_to_cpu(upm2->volSeqNum);
+                        UDF_SB_PARTNUM(sb,i) = le16_to_cpu(upm2->partitionNum);
                 }
                 udf_debug("Partition (%d:%d) type %d on volume %d\n",
-                          i, UDF_SB_PARTNUM(sb, i), type, UDF_SB_PARTVSN(sb,
-                                                                         i));
+                          i, UDF_SB_PARTNUM(sb,i), type, UDF_SB_PARTVSN(sb,i));
         }
 
         if (fileset) {
-                long_ad *la = (long_ad *) & (lvd->logicalVolContentsUse[0]);
+                long_ad *la = (long_ad *)&(lvd->logicalVolContentsUse[0]);
 
                 *fileset = lelb_to_cpu(la->extLocation);
-                udf_debug
-                    ("FileSet found in LogicalVolDesc at block=%d, partition=%d\n",
-                     fileset->logicalBlockNum, fileset->partitionReferenceNum);
+                udf_debug("FileSet found in LogicalVolDesc at block=%d, partition=%d\n",
+                          fileset->logicalBlockNum,
+                          fileset->partitionReferenceNum);
         }
         if (lvd->integritySeqExt.extLength)
                 udf_load_logicalvolint(sb, leea_to_cpu(lvd->integritySeqExt));
+
         return 0;
 }
 
@@ -1219,9 +1060,7 @@ static void udf_load_logicalvolint(struct super_block *sb, kernel_extent_ad loc)
                 UDF_SB_LVIDBH(sb) = bh;
 
                 if (UDF_SB_LVID(sb)->nextIntegrityExt.extLength)
-                        udf_load_logicalvolint(sb,
-                                               leea_to_cpu(UDF_SB_LVID(sb)->
-                                                           nextIntegrityExt));
+                        udf_load_logicalvolint(sb, leea_to_cpu(UDF_SB_LVID(sb)->nextIntegrityExt));
 
                 if (UDF_SB_LVIDBH(sb) != bh)
                         brelse(bh);
@@ -1247,9 +1086,8 @@ static void udf_load_logicalvolint(struct super_block *sb, kernel_extent_ad loc)
  *      July 1, 1997 - Andrew E. Mileski
  *      Written, tested, and released.
  */
-static int
-udf_process_sequence(struct super_block *sb, long block, long lastblock,
-                     kernel_lb_addr * fileset)
+static int udf_process_sequence(struct super_block *sb, long block, long lastblock,
+                                 kernel_lb_addr *fileset)
 {
         struct buffer_head *bh = NULL;
         struct udf_vds_record vds[VDS_POS_LENGTH];
@@ -1274,82 +1112,71 @@ udf_process_sequence(struct super_block *sb, long block, long lastblock,
                 gd = (struct generic_desc *)bh->b_data;
                 vdsn = le32_to_cpu(gd->volDescSeqNum);
                 switch (ident) {
-                case TAG_IDENT_PVD:     /* ISO 13346 3/10.1 */
+                case TAG_IDENT_PVD: /* ISO 13346 3/10.1 */
                         if (vdsn >= vds[VDS_POS_PRIMARY_VOL_DESC].volDescSeqNum) {
-                                vds[VDS_POS_PRIMARY_VOL_DESC].volDescSeqNum =
-                                    vdsn;
+                                vds[VDS_POS_PRIMARY_VOL_DESC].volDescSeqNum = vdsn;
                                 vds[VDS_POS_PRIMARY_VOL_DESC].block = block;
                         }
                         break;
-                case TAG_IDENT_VDP:     /* ISO 13346 3/10.3 */
+                case TAG_IDENT_VDP: /* ISO 13346 3/10.3 */
                         if (vdsn >= vds[VDS_POS_VOL_DESC_PTR].volDescSeqNum) {
                                 vds[VDS_POS_VOL_DESC_PTR].volDescSeqNum = vdsn;
                                 vds[VDS_POS_VOL_DESC_PTR].block = block;
 
                                 vdp = (struct volDescPtr *)bh->b_data;
-                                next_s =
-                                    le32_to_cpu(vdp->nextVolDescSeqExt.
-                                                extLocation);
-                                next_e =
-                                    le32_to_cpu(vdp->nextVolDescSeqExt.
-                                                extLength);
+                                next_s = le32_to_cpu(vdp->nextVolDescSeqExt.extLocation);
+                                next_e = le32_to_cpu(vdp->nextVolDescSeqExt.extLength);
                                 next_e = next_e >> sb->s_blocksize_bits;
                                 next_e += next_s;
                         }
                         break;
-                case TAG_IDENT_IUVD:    /* ISO 13346 3/10.4 */
+                case TAG_IDENT_IUVD: /* ISO 13346 3/10.4 */
                         if (vdsn >= vds[VDS_POS_IMP_USE_VOL_DESC].volDescSeqNum) {
-                                vds[VDS_POS_IMP_USE_VOL_DESC].volDescSeqNum =
-                                    vdsn;
+                                vds[VDS_POS_IMP_USE_VOL_DESC].volDescSeqNum = vdsn;
                                 vds[VDS_POS_IMP_USE_VOL_DESC].block = block;
                         }
                         break;
-                case TAG_IDENT_PD:      /* ISO 13346 3/10.5 */
+                case TAG_IDENT_PD: /* ISO 13346 3/10.5 */
                         if (!vds[VDS_POS_PARTITION_DESC].block)
                                 vds[VDS_POS_PARTITION_DESC].block = block;
                         break;
-                case TAG_IDENT_LVD:     /* ISO 13346 3/10.6 */
+                case TAG_IDENT_LVD: /* ISO 13346 3/10.6 */
                         if (vdsn >= vds[VDS_POS_LOGICAL_VOL_DESC].volDescSeqNum) {
-                                vds[VDS_POS_LOGICAL_VOL_DESC].volDescSeqNum =
-                                    vdsn;
+                                vds[VDS_POS_LOGICAL_VOL_DESC].volDescSeqNum = vdsn;
                                 vds[VDS_POS_LOGICAL_VOL_DESC].block = block;
                         }
                         break;
-                case TAG_IDENT_USD:     /* ISO 13346 3/10.8 */
-                        if (vdsn >=
-                            vds[VDS_POS_UNALLOC_SPACE_DESC].volDescSeqNum) {
-                                vds[VDS_POS_UNALLOC_SPACE_DESC].volDescSeqNum =
-                                    vdsn;
+                case TAG_IDENT_USD: /* ISO 13346 3/10.8 */
+                        if (vdsn >= vds[VDS_POS_UNALLOC_SPACE_DESC].volDescSeqNum) {
+                                vds[VDS_POS_UNALLOC_SPACE_DESC].volDescSeqNum = vdsn;
                                 vds[VDS_POS_UNALLOC_SPACE_DESC].block = block;
                         }
                         break;
-                case TAG_IDENT_TD:      /* ISO 13346 3/10.9 */
+                case TAG_IDENT_TD: /* ISO 13346 3/10.9 */
                         vds[VDS_POS_TERMINATING_DESC].block = block;
                         if (next_e) {
                                 block = next_s;
                                 lastblock = next_e;
                                 next_s = next_e = 0;
-                        } else
+                        } else {
                                 done = 1;
+                        }
                         break;
                 }
                 brelse(bh);
         }
         for (i = 0; i < VDS_POS_LENGTH; i++) {
                 if (vds[i].block) {
-                        bh = udf_read_tagged(sb, vds[i].block, vds[i].block,
-                                             &ident);
+                        bh = udf_read_tagged(sb, vds[i].block, vds[i].block, &ident);
 
-                        if (i == VDS_POS_PRIMARY_VOL_DESC)
+                        if (i == VDS_POS_PRIMARY_VOL_DESC) {
                                 udf_load_pvoldesc(sb, bh);
-                        else if (i == VDS_POS_LOGICAL_VOL_DESC)
+                        } else if (i == VDS_POS_LOGICAL_VOL_DESC) {
                                 udf_load_logicalvol(sb, bh, fileset);
-                        else if (i == VDS_POS_PARTITION_DESC) {
+                        } else if (i == VDS_POS_PARTITION_DESC) {
                                 struct buffer_head *bh2 = NULL;
                                 udf_load_partdesc(sb, bh);
-                                for (j = vds[i].block + 1;
-                                     j < vds[VDS_POS_TERMINATING_DESC].block;
-                                     j++) {
+                                for (j = vds[i].block + 1; j <  vds[VDS_POS_TERMINATING_DESC].block; j++) {
                                         bh2 = udf_read_tagged(sb, j, j, &ident);
                                         gd = (struct generic_desc *)bh2->b_data;
                                         if (ident == TAG_IDENT_PD)
@@ -1378,16 +1205,17 @@ static int udf_check_valid(struct super_block *sb, int novrs, int silent)
         /* Check that it is NSR02 compliant */
         /* Process any "CD-ROM Volume Descriptor Set" (ECMA 167 2/8.3.1) */
         else if ((block = udf_vrs(sb, silent)) == -1) {
-                udf_debug
-                    ("Failed to read byte 32768. Assuming open disc. Skipping validity check\n");
+                udf_debug("Failed to read byte 32768. Assuming open disc. "
+                          "Skipping validity check\n");
                 if (!UDF_SB_LASTBLOCK(sb))
                         UDF_SB_LASTBLOCK(sb) = udf_get_last_block(sb);
                 return 0;
-        } else
+        } else {
                 return !block;
+        }
 }
 
-static int udf_load_partition(struct super_block *sb, kernel_lb_addr * fileset)
+static int udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
 {
         struct anchorVolDescPtr *anchor;
         uint16_t ident;
@@ -1399,28 +1227,20 @@ static int udf_load_partition(struct super_block *sb, kernel_lb_addr * fileset)
                 return 1;
 
         for (i = 0; i < ARRAY_SIZE(UDF_SB_ANCHOR(sb)); i++) {
-                if (UDF_SB_ANCHOR(sb)[i] && (bh = udf_read_tagged(sb,
-                                                                  UDF_SB_ANCHOR
-                                                                  (sb)[i],
-                                                                  UDF_SB_ANCHOR
-                                                                  (sb)[i],
-                                                                  &ident))) {
+                if (UDF_SB_ANCHOR(sb)[i] &&
+                    (bh = udf_read_tagged(sb, UDF_SB_ANCHOR(sb)[i],
+                                          UDF_SB_ANCHOR(sb)[i], &ident))) {
                         anchor = (struct anchorVolDescPtr *)bh->b_data;
 
                         /* Locate the main sequence */
-                        main_s =
-                            le32_to_cpu(anchor->mainVolDescSeqExt.extLocation);
-                        main_e =
-                            le32_to_cpu(anchor->mainVolDescSeqExt.extLength);
+                        main_s = le32_to_cpu(anchor->mainVolDescSeqExt.extLocation);
+                        main_e = le32_to_cpu(anchor->mainVolDescSeqExt.extLength );
                         main_e = main_e >> sb->s_blocksize_bits;
                         main_e += main_s;
 
                         /* Locate the reserve sequence */
-                        reserve_s =
-                            le32_to_cpu(anchor->reserveVolDescSeqExt.
-                                        extLocation);
-                        reserve_e =
-                            le32_to_cpu(anchor->reserveVolDescSeqExt.extLength);
+                        reserve_s = le32_to_cpu(anchor->reserveVolDescSeqExt.extLocation);
+                        reserve_e = le32_to_cpu(anchor->reserveVolDescSeqExt.extLength);
                         reserve_e = reserve_e >> sb->s_blocksize_bits;
                         reserve_e += reserve_s;
 
@@ -1428,10 +1248,8 @@ static int udf_load_partition(struct super_block *sb, kernel_lb_addr * fileset)
 
                         /* Process the main & reserve sequences */
                         /* responsible for finding the PartitionDesc(s) */
-                        if (!
-                            (udf_process_sequence(sb, main_s, main_e, fileset)
-                             && udf_process_sequence(sb, reserve_s, reserve_e,
-                                                     fileset))) {
+                        if (!(udf_process_sequence(sb, main_s, main_e, fileset) &&
+                              udf_process_sequence(sb, reserve_s, reserve_e, fileset))) {
                                 break;
                         }
                 }
@@ -1444,81 +1262,67 @@ static int udf_load_partition(struct super_block *sb, kernel_lb_addr * fileset)
                 udf_debug("Using anchor in block %d\n", UDF_SB_ANCHOR(sb)[i]);
 
         for (i = 0; i < UDF_SB_NUMPARTS(sb); i++) {
+                kernel_lb_addr uninitialized_var(ino);
                 switch (UDF_SB_PARTTYPE(sb, i)) {
                 case UDF_VIRTUAL_MAP15:
                 case UDF_VIRTUAL_MAP20:
-                        {
-                                kernel_lb_addr uninitialized_var(ino);
+                        if (!UDF_SB_LASTBLOCK(sb)) {
+                                UDF_SB_LASTBLOCK(sb) = udf_get_last_block(sb);
+                                udf_find_anchor(sb);
+                        }
 
-                                if (!UDF_SB_LASTBLOCK(sb)) {
-                                        UDF_SB_LASTBLOCK(sb) =
-                                            udf_get_last_block(sb);
-                                        udf_find_anchor(sb);
-                                }
+                        if (!UDF_SB_LASTBLOCK(sb)) {
+                                udf_debug("Unable to determine Lastblock (For "
+                                                "Virtual Partition)\n");
+                                return 1;
+                        }
 
-                                if (!UDF_SB_LASTBLOCK(sb)) {
-                                        udf_debug
-                                            ("Unable to determine Lastblock (For Virtual Partition)\n");
-                                        return 1;
+                        for (j = 0; j < UDF_SB_NUMPARTS(sb); j++) {
+                                if (j != i && UDF_SB_PARTVSN(sb, i) ==
+                                        UDF_SB_PARTVSN(sb, j) &&
+                                        UDF_SB_PARTNUM(sb, i) ==
+                                                UDF_SB_PARTNUM(sb, j)) {
+                                        ino.partitionReferenceNum = j;
+                                        ino.logicalBlockNum =
+                                            UDF_SB_LASTBLOCK(sb) -
+                                            UDF_SB_PARTROOT(sb, j);
+                                        break;
                                 }
+                        }
 
-                                for (j = 0; j < UDF_SB_NUMPARTS(sb); j++) {
-                                        if (j != i &&
-                                            UDF_SB_PARTVSN(sb,
-                                                           i) ==
-                                            UDF_SB_PARTVSN(sb, j)
-                                            && UDF_SB_PARTNUM(sb,
-                                                              i) ==
-                                            UDF_SB_PARTNUM(sb, j)) {
-                                                ino.partitionReferenceNum = j;
-                                                ino.logicalBlockNum =
-                                                    UDF_SB_LASTBLOCK(sb) -
-                                                    UDF_SB_PARTROOT(sb, j);
-                                                break;
-                                        }
-                                }
+                        if (j == UDF_SB_NUMPARTS(sb))
+                                return 1;
 
-                                if (j == UDF_SB_NUMPARTS(sb))
-                                        return 1;
+                        if (!(UDF_SB_VAT(sb) = udf_iget(sb, ino)))
+                                return 1;
 
-                                if (!(UDF_SB_VAT(sb) = udf_iget(sb, ino)))
-                                        return 1;
+                        if (UDF_SB_PARTTYPE(sb, i) == UDF_VIRTUAL_MAP15) {
+                                UDF_SB_TYPEVIRT(sb, i).s_start_offset =
+                                    udf_ext0_offset(UDF_SB_VAT(sb));
+                                UDF_SB_TYPEVIRT(sb, i).s_num_entries =
+                                    (UDF_SB_VAT(sb)->i_size - 36) >> 2;
+                        } else if (UDF_SB_PARTTYPE(sb, i) == UDF_VIRTUAL_MAP20) {
+                                struct buffer_head *bh = NULL;
+                                uint32_t pos;
 
-                                if (UDF_SB_PARTTYPE(sb, i) == UDF_VIRTUAL_MAP15) {
-                                        UDF_SB_TYPEVIRT(sb, i).s_start_offset =
-                                            udf_ext0_offset(UDF_SB_VAT(sb));
-                                        UDF_SB_TYPEVIRT(sb, i).s_num_entries =
-                                            (UDF_SB_VAT(sb)->i_size - 36) >> 2;
-                                } else if (UDF_SB_PARTTYPE(sb, i) ==
-                                           UDF_VIRTUAL_MAP20) {
-                                        struct buffer_head *bh = NULL;
-                                        uint32_t pos;
-
-                                        pos = udf_block_map(UDF_SB_VAT(sb), 0);
-                                        bh = sb_bread(sb, pos);
-                                        if (!bh)
-                                                return 1;
-                                        UDF_SB_TYPEVIRT(sb, i).s_start_offset =
-                                            le16_to_cpu(((struct
-                                                          virtualAllocationTable20
-                                                          *)bh->b_data +
-                                                         udf_ext0_offset
-                                                         (UDF_SB_VAT(sb)))->
-                                                        lengthHeader) +
-                                            udf_ext0_offset(UDF_SB_VAT(sb));
-                                        UDF_SB_TYPEVIRT(sb, i).s_num_entries =
-                                            (UDF_SB_VAT(sb)->i_size -
-                                             UDF_SB_TYPEVIRT(sb,
-                                                             i).
-                                             s_start_offset) >> 2;
-                                        brelse(bh);
-                                }
-                                UDF_SB_PARTROOT(sb, i) =
-                                    udf_get_pblock(sb, 0, i, 0);
-                                UDF_SB_PARTLEN(sb, i) =
-                                    UDF_SB_PARTLEN(sb,
-                                                   ino.partitionReferenceNum);
+                                pos = udf_block_map(UDF_SB_VAT(sb), 0);
+                                bh = sb_bread(sb, pos);
+                                if (!bh)
+                                        return 1;
+                                UDF_SB_TYPEVIRT(sb, i).s_start_offset =
+                                    le16_to_cpu(((struct
+                                        virtualAllocationTable20 *)bh->b_data +
+                                          udf_ext0_offset(UDF_SB_VAT(sb)))->
+                                                lengthHeader) +
+                                          udf_ext0_offset(UDF_SB_VAT(sb));
+                                UDF_SB_TYPEVIRT(sb, i).s_num_entries =
+                                    (UDF_SB_VAT(sb)->i_size -
+                                     UDF_SB_TYPEVIRT(sb, i).s_start_offset) >> 2;
+                                brelse(bh);
                         }
+                        UDF_SB_PARTROOT(sb, i) = udf_get_pblock(sb, 0, i, 0);
+                        UDF_SB_PARTLEN(sb, i) = UDF_SB_PARTLEN(sb,
+                                                ino.partitionReferenceNum);
                 }
         }
         return 0;
@@ -1555,42 +1359,32 @@ static void udf_open_lvid(struct super_block *sb)
 
 static void udf_close_lvid(struct super_block *sb)
 {
+        kernel_timestamp cpu_time;
+        int i;
+
         if (UDF_SB_LVIDBH(sb) &&
             UDF_SB_LVID(sb)->integrityType == LVID_INTEGRITY_TYPE_OPEN) {
-                int i;
-                kernel_timestamp cpu_time;
-
                 UDF_SB_LVIDIU(sb)->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
                 UDF_SB_LVIDIU(sb)->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
                 if (udf_time_to_stamp(&cpu_time, CURRENT_TIME))
-                        UDF_SB_LVID(sb)->recordingDateAndTime =
-                            cpu_to_lets(cpu_time);
-                if (UDF_MAX_WRITE_VERSION >
-                    le16_to_cpu(UDF_SB_LVIDIU(sb)->maxUDFWriteRev))
-                        UDF_SB_LVIDIU(sb)->maxUDFWriteRev =
-                            cpu_to_le16(UDF_MAX_WRITE_VERSION);
-                if (UDF_SB_UDFREV(sb) >
-                    le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFReadRev))
-                        UDF_SB_LVIDIU(sb)->minUDFReadRev =
-                            cpu_to_le16(UDF_SB_UDFREV(sb));
-                if (UDF_SB_UDFREV(sb) >
-                    le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFWriteRev))
-                        UDF_SB_LVIDIU(sb)->minUDFWriteRev =
-                            cpu_to_le16(UDF_SB_UDFREV(sb));
-                UDF_SB_LVID(sb)->integrityType =
-                    cpu_to_le32(LVID_INTEGRITY_TYPE_CLOSE);
+                        UDF_SB_LVID(sb)->recordingDateAndTime = cpu_to_lets(cpu_time);
+                if (UDF_MAX_WRITE_VERSION > le16_to_cpu(UDF_SB_LVIDIU(sb)->maxUDFWriteRev))
+                        UDF_SB_LVIDIU(sb)->maxUDFWriteRev = cpu_to_le16(UDF_MAX_WRITE_VERSION);
+                if (UDF_SB_UDFREV(sb) > le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFReadRev))
+                        UDF_SB_LVIDIU(sb)->minUDFReadRev = cpu_to_le16(UDF_SB_UDFREV(sb));
+                if (UDF_SB_UDFREV(sb) > le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFWriteRev))
+                        UDF_SB_LVIDIU(sb)->minUDFWriteRev = cpu_to_le16(UDF_SB_UDFREV(sb));
+                UDF_SB_LVID(sb)->integrityType = cpu_to_le32(LVID_INTEGRITY_TYPE_CLOSE);
 
                 UDF_SB_LVID(sb)->descTag.descCRC =
-                    cpu_to_le16(udf_crc((char *)UDF_SB_LVID(sb) + sizeof(tag),
-                                        le16_to_cpu(UDF_SB_LVID(sb)->descTag.
-                                                    descCRCLength), 0));
+                        cpu_to_le16(udf_crc((char *)UDF_SB_LVID(sb) + sizeof(tag),
+                                            le16_to_cpu(UDF_SB_LVID(sb)->descTag.descCRCLength), 0));
 
                 UDF_SB_LVID(sb)->descTag.tagChecksum = 0;
                 for (i = 0; i < 16; i++)
                         if (i != 4)
                                 UDF_SB_LVID(sb)->descTag.tagChecksum +=
-                                    ((uint8_t *) &
-                                     (UDF_SB_LVID(sb)->descTag))[i];
+                                        ((uint8_t *)&(UDF_SB_LVID(sb)->descTag))[i];
 
                 mark_buffer_dirty(UDF_SB_LVIDBH(sb));
         }
@@ -1628,6 +1422,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
         sbi = kmalloc(sizeof(struct udf_sb_info), GFP_KERNEL);
         if (!sbi)
                 return -ENOMEM;
+
         sb->s_fs_info = sbi;
         memset(UDF_SB(sb), 0x00, sizeof(struct udf_sb_info));
 
@@ -1679,7 +1474,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
         UDF_SB_ANCHOR(sb)[2] = uopt.anchor;
         UDF_SB_ANCHOR(sb)[3] = 256;
 
-        if (udf_check_valid(sb, uopt.novrs, silent)) {  /* read volume recognition sequences */
+        if (udf_check_valid(sb, uopt.novrs, silent)) { /* read volume recognition sequences */
                 printk("UDF-fs: No VRS found\n");
                 goto error_out;
         }
@@ -1701,10 +1496,8 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
         udf_debug("Lastblock=%d\n", UDF_SB_LASTBLOCK(sb));
 
         if (UDF_SB_LVIDBH(sb)) {
-                uint16_t minUDFReadRev =
-                    le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFReadRev);
-                uint16_t minUDFWriteRev =
-                    le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFWriteRev);
+                uint16_t minUDFReadRev = le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFReadRev);
+                uint16_t minUDFWriteRev = le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFWriteRev);
                 /* uint16_t maxUDFWriteRev = le16_to_cpu(UDF_SB_LVIDIU(sb)->maxUDFWriteRev); */
 
                 if (minUDFReadRev > UDF_MAX_READ_VERSION) {
@@ -1729,10 +1522,8 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
                 goto error_out;
         }
 
-        if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) &
-            UDF_PART_FLAG_READ_ONLY) {
-                printk
-                    ("UDF-fs: Partition marked readonly; forcing readonly mount\n");
+        if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_READ_ONLY) {
+                printk("UDF-fs: Partition marked readonly; forcing readonly mount\n");
                 sb->s_flags |= MS_RDONLY;
         }
 
@@ -1744,10 +1535,11 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
         if (!silent) {
                 kernel_timestamp ts;
                 udf_time_to_stamp(&ts, UDF_SB_RECORDTIME(sb));
-                udf_info
-                    ("UDF %s (%s) Mounting volume '%s', timestamp %04u/%02u/%02u %02u:%02u (%x)\n",
-                     UDFFS_VERSION, UDFFS_DATE, UDF_SB_VOLIDENT(sb), ts.year,
-                     ts.month, ts.day, ts.hour, ts.minute, ts.typeAndTimezone);
+                udf_info("UDF %s (%s) Mounting volume '%s', "
+                         "timestamp %04u/%02u/%02u %02u:%02u (%x)\n",
+                         UDFFS_VERSION, UDFFS_DATE,
+                         UDF_SB_VOLIDENT(sb), ts.year, ts.month, ts.day, ts.hour, ts.minute,
+                         ts.typeAndTimezone);
         }
         if (!(sb->s_flags & MS_RDONLY))
                 udf_open_lvid(sb);
@@ -1772,30 +1564,21 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
         sb->s_maxbytes = MAX_LFS_FILESIZE;
         return 0;
 
-      error_out:
+error_out:
         if (UDF_SB_VAT(sb))
                 iput(UDF_SB_VAT(sb));
         if (UDF_SB_NUMPARTS(sb)) {
-                if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) &
-                    UDF_PART_FLAG_UNALLOC_TABLE)
-                        iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.
-                             s_table);
-                if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) &
-                    UDF_PART_FLAG_FREED_TABLE)
-                        iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.
-                             s_table);
-                if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) &
-                    UDF_PART_FLAG_UNALLOC_BITMAP)
-                        UDF_SB_FREE_BITMAP(sb, UDF_SB_PARTITION(sb), s_uspace);
-                if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) &
-                    UDF_PART_FLAG_FREED_BITMAP)
-                        UDF_SB_FREE_BITMAP(sb, UDF_SB_PARTITION(sb), s_fspace);
-                if (UDF_SB_PARTTYPE(sb, UDF_SB_PARTITION(sb)) ==
-                    UDF_SPARABLE_MAP15) {
+                if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_TABLE)
+                        iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_table);
+                if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_TABLE)
+                        iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_table);
+                if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_BITMAP)
+                        UDF_SB_FREE_BITMAP(sb,UDF_SB_PARTITION(sb), s_uspace);
+                if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_BITMAP)
+                        UDF_SB_FREE_BITMAP(sb,UDF_SB_PARTITION(sb), s_fspace);
+                if (UDF_SB_PARTTYPE(sb, UDF_SB_PARTITION(sb)) == UDF_SPARABLE_MAP15) {
                         for (i = 0; i < 4; i++)
-                                brelse(UDF_SB_TYPESPAR
-                                       (sb,
-                                        UDF_SB_PARTITION(sb)).s_spar_map[i]);
+                                brelse(UDF_SB_TYPESPAR(sb, UDF_SB_PARTITION(sb)).s_spar_map[i]);
                 }
         }
 #ifdef CONFIG_UDF_NLS
@@ -1808,6 +1591,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
         UDF_SB_FREE(sb);
         kfree(sbi);
         sb->s_fs_info = NULL;
+
         return -EINVAL;
 }
 
@@ -1823,8 +1607,8 @@ void udf_error(struct super_block *sb, const char *function,
         va_start(args, fmt);
         vsnprintf(error_buf, sizeof(error_buf), fmt, args);
         va_end(args);
-        printk(KERN_CRIT "UDF-fs error (device %s): %s: %s\n",
-               sb->s_id, function, error_buf);
+        printk (KERN_CRIT "UDF-fs error (device %s): %s: %s\n",
+                sb->s_id, function, error_buf);
 }
 
 void udf_warning(struct super_block *sb, const char *function,
@@ -1859,26 +1643,17 @@ static void udf_put_super(struct super_block *sb)
         if (UDF_SB_VAT(sb))
                 iput(UDF_SB_VAT(sb));
         if (UDF_SB_NUMPARTS(sb)) {
-                if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) &
-                    UDF_PART_FLAG_UNALLOC_TABLE)
-                        iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.
-                             s_table);
-                if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) &
-                    UDF_PART_FLAG_FREED_TABLE)
-                        iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.
-                             s_table);
-                if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) &
-                    UDF_PART_FLAG_UNALLOC_BITMAP)
-                        UDF_SB_FREE_BITMAP(sb, UDF_SB_PARTITION(sb), s_uspace);
-                if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) &
-                    UDF_PART_FLAG_FREED_BITMAP)
-                        UDF_SB_FREE_BITMAP(sb, UDF_SB_PARTITION(sb), s_fspace);
-                if (UDF_SB_PARTTYPE(sb, UDF_SB_PARTITION(sb)) ==
-                    UDF_SPARABLE_MAP15) {
+                if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_TABLE)
+                        iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_table);
+                if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_TABLE)
+                        iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_table);
+                if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_BITMAP)
+                        UDF_SB_FREE_BITMAP(sb,UDF_SB_PARTITION(sb), s_uspace);
+                if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_BITMAP)
+                        UDF_SB_FREE_BITMAP(sb,UDF_SB_PARTITION(sb), s_fspace);
+                if (UDF_SB_PARTTYPE(sb, UDF_SB_PARTITION(sb)) == UDF_SPARABLE_MAP15) {
                         for (i = 0; i < 4; i++)
-                                brelse(UDF_SB_TYPESPAR
-                                       (sb,
-                                        UDF_SB_PARTITION(sb)).s_spar_map[i]);
+                                brelse(UDF_SB_TYPESPAR(sb, UDF_SB_PARTITION(sb)).s_spar_map[i]);
                 }
         }
 #ifdef CONFIG_UDF_NLS
@@ -1917,8 +1692,7 @@ static int udf_statfs(struct dentry *dentry, struct kstatfs *buf)
         buf->f_bavail = buf->f_bfree;
         buf->f_files = (UDF_SB_LVIDBH(sb) ?
                         (le32_to_cpu(UDF_SB_LVIDIU(sb)->numFiles) +
-                         le32_to_cpu(UDF_SB_LVIDIU(sb)->numDirs)) : 0) +
-            buf->f_bfree;
+                         le32_to_cpu(UDF_SB_LVIDIU(sb)->numDirs)) : 0) + buf->f_bfree;
         buf->f_ffree = buf->f_bfree;
         /* __kernel_fsid_t f_fsid */
         buf->f_namelen = UDF_NAME_LEN - 2;
@@ -1930,8 +1704,7 @@ static unsigned char udf_bitmap_lookup[16] = {
         0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4
 };
 
-static unsigned int
-udf_count_free_bitmap(struct super_block *sb, struct udf_bitmap *bitmap)
+static unsigned int udf_count_free_bitmap(struct super_block *sb, struct udf_bitmap *bitmap)
 {
         struct buffer_head *bh = NULL;
         unsigned int accum = 0;
@@ -1961,8 +1734,8 @@ udf_count_free_bitmap(struct super_block *sb, struct udf_bitmap *bitmap)
 
         bm = (struct spaceBitmapDesc *)bh->b_data;
         bytes = le32_to_cpu(bm->numOfBytes);
-        index = sizeof(struct spaceBitmapDesc); /* offset in first block only */
-        ptr = (uint8_t *) bh->b_data;
+        index = sizeof(struct spaceBitmapDesc); /* offset in first block only */
+        ptr = (uint8_t *)bh->b_data;
 
         while (bytes > 0) {
                 while ((bytes > 0) && (index < sb->s_blocksize)) {
@@ -1981,19 +1754,18 @@ udf_count_free_bitmap(struct super_block *sb, struct udf_bitmap *bitmap)
                                 goto out;
                         }
                         index = 0;
-                        ptr = (uint8_t *) bh->b_data;
+                        ptr = (uint8_t *)bh->b_data;
                 }
         }
         brelse(bh);
 
-      out:
+out:
         unlock_kernel();
 
         return accum;
 }
 
-static unsigned int
-udf_count_free_table(struct super_block *sb, struct inode *table)
+static unsigned int udf_count_free_table(struct super_block *sb, struct inode *table)
 {
         unsigned int accum = 0;
         uint32_t elen;
@@ -2007,8 +1779,9 @@ udf_count_free_table(struct super_block *sb, struct inode *table)
         epos.offset = sizeof(struct unallocSpaceEntry);
         epos.bh = NULL;
 
-        while ((etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1)
+        while ((etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) {
                 accum += (elen >> table->i_sb->s_blocksize_bits);
+        }
         brelse(epos.bh);
 
         unlock_kernel();
@@ -2021,12 +1794,8 @@ static unsigned int udf_count_free(struct super_block *sb)
         unsigned int accum = 0;
 
         if (UDF_SB_LVIDBH(sb)) {
-                if (le32_to_cpu(UDF_SB_LVID(sb)->numOfPartitions) >
-                    UDF_SB_PARTITION(sb)) {
-                        accum =
-                            le32_to_cpu(UDF_SB_LVID(sb)->
-                                        freeSpaceTable[UDF_SB_PARTITION(sb)]);
-
+                if (le32_to_cpu(UDF_SB_LVID(sb)->numOfPartitions) > UDF_SB_PARTITION(sb)) {
+                        accum = le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[UDF_SB_PARTITION(sb)]);
                         if (accum == 0xFFFFFFFF)
                                 accum = 0;
                 }
@@ -2035,40 +1804,24 @@ static unsigned int udf_count_free(struct super_block *sb)
         if (accum)
                 return accum;
 
-        if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) &
-            UDF_PART_FLAG_UNALLOC_BITMAP) {
-                accum +=
-                    udf_count_free_bitmap(sb,
-                                          UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION
-                                                              (sb)].s_uspace.
-                                          s_bitmap);
+        if (UDF_SB_PARTFLAGS(sb,UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_BITMAP) {
+                accum += udf_count_free_bitmap(sb,
+                                               UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_bitmap);
         }
-        if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) &
-            UDF_PART_FLAG_FREED_BITMAP) {
-                accum +=
-                    udf_count_free_bitmap(sb,
-                                          UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION
-                                                              (sb)].s_fspace.
-                                          s_bitmap);
+        if (UDF_SB_PARTFLAGS(sb,UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_BITMAP) {
+                accum += udf_count_free_bitmap(sb,
+                                               UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_bitmap);
         }
         if (accum)
                 return accum;
 
-        if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) &
-            UDF_PART_FLAG_UNALLOC_TABLE) {
-                accum +=
-                    udf_count_free_table(sb,
-                                         UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION
-                                                             (sb)].s_uspace.
-                                         s_table);
+        if (UDF_SB_PARTFLAGS(sb,UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_TABLE) {
+                accum += udf_count_free_table(sb,
+                                              UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_table);
         }
-        if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) &
-            UDF_PART_FLAG_FREED_TABLE) {
-                accum +=
-                    udf_count_free_table(sb,
-                                         UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION
-                                                             (sb)].s_fspace.
-                                         s_table);
+        if (UDF_SB_PARTFLAGS(sb,UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_TABLE) {
+                accum += udf_count_free_table(sb,
+                                              UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_table);
         }
 
         return accum;
diff --git a/fs/udf/symlink.c b/fs/udf/symlink.c
index c4b82a920082..e6f933dd6a7b 100644
--- a/fs/udf/symlink.c
+++ b/fs/udf/symlink.c
@@ -11,7 +11,7 @@
  *      Each contributing author retains all rights to their own work.
  *
  *  (C) 1998-2001 Ben Fennema
- *  (C) 1999 Stelias Computing Inc 
+ *  (C) 1999 Stelias Computing Inc
  *
  * HISTORY
  *
@@ -33,8 +33,7 @@
 #include <linux/buffer_head.h>
 #include "udf_i.h"
 
-static void udf_pc_to_char(struct super_block *sb, char *from, int fromlen,
-                           char *to)
+static void udf_pc_to_char(struct super_block *sb, char *from, int fromlen, char *to)
 {
         struct pathComponent *pc;
         int elen = 0;
@@ -81,9 +80,9 @@ static int udf_symlink_filler(struct file *file, struct page *page)
         char *p = kmap(page);
 
         lock_kernel();
-        if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB)
+        if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB) {
                 symlink = UDF_I_DATA(inode) + UDF_I_LENEATTR(inode);
-        else {
+        } else {
                 bh = sb_bread(inode->i_sb, udf_block_map(inode, 0));
 
                 if (!bh)
@@ -100,7 +99,8 @@ static int udf_symlink_filler(struct file *file, struct page *page)
         kunmap(page);
         unlock_page(page);
         return 0;
-      out:
+
+out:
         unlock_kernel();
         SetPageError(page);
         kunmap(page);
@@ -112,5 +112,5 @@ static int udf_symlink_filler(struct file *file, struct page *page)
  * symlinks can't do much...
  */
 const struct address_space_operations udf_symlink_aops = {
-        .readpage = udf_symlink_filler,
+        .readpage               = udf_symlink_filler,
 };
diff --git a/fs/udf/truncate.c b/fs/udf/truncate.c
index b2002da0a5c0..7fc3912885a5 100644
--- a/fs/udf/truncate.c
+++ b/fs/udf/truncate.c
@@ -32,13 +32,11 @@ static void extent_trunc(struct inode *inode, struct extent_position *epos,
                          kernel_lb_addr eloc, int8_t etype, uint32_t elen,
                          uint32_t nelen)
 {
-        kernel_lb_addr neloc = { 0, 0 };
-        int last_block =
-            (elen + inode->i_sb->s_blocksize -
-             1) >> inode->i_sb->s_blocksize_bits;
-        int first_block =
-            (nelen + inode->i_sb->s_blocksize -
-             1) >> inode->i_sb->s_blocksize_bits;
+        kernel_lb_addr neloc = {};
+        int last_block = (elen + inode->i_sb->s_blocksize - 1) >>
+                inode->i_sb->s_blocksize_bits;
+        int first_block = (nelen + inode->i_sb->s_blocksize - 1) >>
+                inode->i_sb->s_blocksize_bits;
 
         if (nelen) {
                 if (etype == (EXT_NOT_RECORDED_ALLOCATED >> 30)) {
@@ -70,7 +68,7 @@ static void extent_trunc(struct inode *inode, struct extent_position *epos,
  */
 void udf_truncate_tail_extent(struct inode *inode)
 {
-        struct extent_position epos = { NULL, 0, {0, 0} };
+        struct extent_position epos = {};
         kernel_lb_addr eloc;
         uint32_t elen, nelen;
         uint64_t lbcount = 0;
@@ -156,16 +154,16 @@ void udf_discard_prealloc(struct inode *inode)
                 extent_trunc(inode, &epos, eloc, etype, elen, 0);
                 if (!epos.bh) {
                         UDF_I_LENALLOC(inode) =
-                            epos.offset - udf_file_entry_alloc_offset(inode);
+                                epos.offset - udf_file_entry_alloc_offset(inode);
                         mark_inode_dirty(inode);
                 } else {
                         struct allocExtDesc *aed =
-                            (struct allocExtDesc *)(epos.bh->b_data);
+                                (struct allocExtDesc *)(epos.bh->b_data);
                         aed->lengthAllocDescs =
-                            cpu_to_le32(epos.offset -
-                                        sizeof(struct allocExtDesc));
-                        if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT)
-                            || UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
+                                cpu_to_le32(epos.offset -
+                                            sizeof(struct allocExtDesc));
+                        if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
+                            UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
                                 udf_update_tag(epos.bh->b_data, epos.offset);
                         else
                                 udf_update_tag(epos.bh->b_data,
@@ -182,7 +180,7 @@ void udf_discard_prealloc(struct inode *inode)
 void udf_truncate_extents(struct inode *inode)
 {
         struct extent_position epos;
-        kernel_lb_addr eloc, neloc = { 0, 0 };
+        kernel_lb_addr eloc, neloc = {};
         uint32_t elen, nelen = 0, indirect_ext_len = 0, lenalloc;
         int8_t etype;
         struct super_block *sb = inode->i_sb;
@@ -198,9 +196,8 @@ void udf_truncate_extents(struct inode *inode)
                 BUG();
 
         etype = inode_bmap(inode, first_block, &epos, &eloc, &elen, &offset);
-        byte_offset =
-            (offset << sb->s_blocksize_bits) +
-            (inode->i_size & (sb->s_blocksize - 1));
+        byte_offset = (offset << sb->s_blocksize_bits) +
+                (inode->i_size & (sb->s_blocksize - 1));
         if (etype != -1) {
                 epos.offset -= adsize;
                 extent_trunc(inode, &epos, eloc, etype, elen, byte_offset);
@@ -215,9 +212,7 @@ void udf_truncate_extents(struct inode *inode)
                 else
                         lenalloc -= sizeof(struct allocExtDesc);
 
-                while ((etype =
-                        udf_current_aext(inode, &epos, &eloc, &elen,
-                                         0)) != -1) {
+                while ((etype = udf_current_aext(inode, &epos, &eloc, &elen, 0)) != -1) {
                         if (etype == (EXT_NEXT_EXTENT_ALLOCDECS >> 30)) {
                                 udf_write_aext(inode, &epos, neloc, nelen, 0);
                                 if (indirect_ext_len) {
@@ -229,52 +224,35 @@ void udf_truncate_extents(struct inode *inode)
                                                         0, indirect_ext_len);
                                 } else {
                                         if (!epos.bh) {
-                                                UDF_I_LENALLOC(inode) =
-                                                    lenalloc;
+                                                UDF_I_LENALLOC(inode) = lenalloc;
                                                 mark_inode_dirty(inode);
                                         } else {
                                                 struct allocExtDesc *aed =
-                                                    (struct allocExtDesc
-                                                     *)(epos.bh->b_data);
+                                                        (struct allocExtDesc *)(epos.bh->b_data);
                                                 aed->lengthAllocDescs =
                                                     cpu_to_le32(lenalloc);
-                                                if (!UDF_QUERY_FLAG
-                                                    (sb, UDF_FLAG_STRICT)
-                                                    || UDF_SB_UDFREV(sb) >=
-                                                    0x0201)
-                                                        udf_update_tag(epos.bh->
-                                                                       b_data,
-                                                                       lenalloc
-                                                                       +
-                                                                       sizeof
-                                                                       (struct
-                                                                        allocExtDesc));
+                                                if (!UDF_QUERY_FLAG(sb, UDF_FLAG_STRICT) ||
+                                                    UDF_SB_UDFREV(sb) >= 0x0201)
+                                                        udf_update_tag(epos.bh->b_data,
+                                                                       lenalloc +
+                                                                       sizeof(struct allocExtDesc));
                                                 else
-                                                        udf_update_tag(epos.bh->
-                                                                       b_data,
-                                                                       sizeof
-                                                                       (struct
-                                                                        allocExtDesc));
-                                                mark_buffer_dirty_inode(epos.bh,
-                                                                        inode);
+                                                        udf_update_tag(epos.bh->b_data,
+                                                                       sizeof(struct allocExtDesc));
+                                                mark_buffer_dirty_inode(epos.bh, inode);
                                         }
                                 }
                                 brelse(epos.bh);
                                 epos.offset = sizeof(struct allocExtDesc);
                                 epos.block = eloc;
-                                epos.bh =
-                                    udf_tread(sb,
-                                              udf_get_lb_pblock(sb, eloc, 0));
+                                epos.bh = udf_tread(sb, udf_get_lb_pblock(sb, eloc, 0));
                                 if (elen)
-                                        indirect_ext_len = (elen +
-                                                            sb->s_blocksize -
-                                                            1) >> sb->
-                                            s_blocksize_bits;
+                                        indirect_ext_len = (elen + sb->s_blocksize -1) >>
+                                                sb->s_blocksize_bits;
                                 else
                                         indirect_ext_len = 1;
                         } else {
-                                extent_trunc(inode, &epos, eloc, etype, elen,
-                                             0);
+                                extent_trunc(inode, &epos, eloc, etype, elen, 0);
                                 epos.offset += adsize;
                         }
                 }
@@ -292,16 +270,13 @@ void udf_truncate_extents(struct inode *inode)
                                 struct allocExtDesc *aed =
                                     (struct allocExtDesc *)(epos.bh->b_data);
                                 aed->lengthAllocDescs = cpu_to_le32(lenalloc);
-                                if (!UDF_QUERY_FLAG(sb, UDF_FLAG_STRICT)
-                                    || UDF_SB_UDFREV(sb) >= 0x0201)
+                                if (!UDF_QUERY_FLAG(sb, UDF_FLAG_STRICT) ||
+                                    UDF_SB_UDFREV(sb) >= 0x0201)
                                         udf_update_tag(epos.bh->b_data,
-                                                       lenalloc +
-                                                       sizeof(struct
-                                                              allocExtDesc));
+                                                       lenalloc + sizeof(struct allocExtDesc));
                                 else
                                         udf_update_tag(epos.bh->b_data,
-                                                       sizeof(struct
-                                                              allocExtDesc));
+                                                       sizeof(struct allocExtDesc));
                                 mark_buffer_dirty_inode(epos.bh, inode);
                         }
                 }
@@ -314,21 +289,14 @@ void udf_truncate_extents(struct inode *inode)
                          *  no extent above inode->i_size => truncate is
                          *  extending the file by 'offset' blocks.
                          */
-                        if ((!epos.bh
-                             && epos.offset ==
-                             udf_file_entry_alloc_offset(inode)) || (epos.bh
-                                                                     && epos.
-                                                                     offset ==
-                                                                     sizeof
-                                                                     (struct
-                                                                      allocExtDesc)))
-                        {
+                        if ((!epos.bh &&
+                             epos.offset == udf_file_entry_alloc_offset(inode)) ||
+                            (epos.bh && epos.offset == sizeof(struct allocExtDesc))) {
                                 /* File has no extents at all or has empty last
                                  * indirect extent! Create a fake extent... */
                                 extent.extLocation.logicalBlockNum = 0;
                                 extent.extLocation.partitionReferenceNum = 0;
-                                extent.extLength =
-                                    EXT_NOT_RECORDED_NOT_ALLOCATED;
+                                extent.extLength = EXT_NOT_RECORDED_NOT_ALLOCATED;
                         } else {
                                 epos.offset -= adsize;
                                 etype = udf_next_aext(inode, &epos,
@@ -337,10 +305,7 @@ void udf_truncate_extents(struct inode *inode)
                                 extent.extLength |= etype << 30;
                         }
                         udf_extend_file(inode, &epos, &extent,
-                                        offset +
-                                        ((inode->
-                                          i_size & (sb->s_blocksize - 1)) !=
-                                         0));
+                                        offset + ((inode->i_size & (sb->s_blocksize - 1)) != 0));
                 }
         }
         UDF_I_LENEXTENTS(inode) = inode->i_size;
diff --git a/fs/udf/udf_i.h b/fs/udf/udf_i.h
index bee4308a8113..d7dbe6f3ba0c 100644
--- a/fs/udf/udf_i.h
+++ b/fs/udf/udf_i.h
@@ -23,4 +23,4 @@ static inline struct udf_inode_info *UDF_I(struct inode *inode)
 #define UDF_I_LAD(X)            ( UDF_I(X)->i_ext.i_lad )
 #define UDF_I_DATA(X)           ( UDF_I(X)->i_ext.i_data )
 
-#endif                          /* !defined(_LINUX_UDF_I_H) */
+#endif /* !defined(_LINUX_UDF_I_H) */
diff --git a/fs/udf/udf_sb.h b/fs/udf/udf_sb.h
index 60f31d8cebee..3e937d3fb8f9 100644
--- a/fs/udf/udf_sb.h
+++ b/fs/udf/udf_sb.h
@@ -20,8 +20,8 @@
 #define UDF_FLAG_VARCONV                8
 #define UDF_FLAG_NLS_MAP                9
 #define UDF_FLAG_UTF8                   10
-#define UDF_FLAG_UID_FORGET     11      /* save -1 for uid to disk */
-#define UDF_FLAG_UID_IGNORE     12      /* use sb uid instead of on disk uid */
+#define UDF_FLAG_UID_FORGET     11    /* save -1 for uid to disk */
+#define UDF_FLAG_UID_IGNORE     12    /* use sb uid instead of on disk uid */
 #define UDF_FLAG_GID_FORGET     13
 #define UDF_FLAG_GID_IGNORE     14
 
@@ -41,8 +41,7 @@ static inline struct udf_sb_info *UDF_SB(struct super_block *sb)
 
 #define UDF_SB_FREE(X)\
 {\
-        if (UDF_SB(X))\
-        {\
+        if (UDF_SB(X)) {\
                 kfree(UDF_SB_PARTMAPS(X));\
                 UDF_SB_PARTMAPS(X) = NULL;\
         }\
@@ -51,13 +50,10 @@ static inline struct udf_sb_info *UDF_SB(struct super_block *sb)
 #define UDF_SB_ALLOC_PARTMAPS(X,Y)\
 {\
         UDF_SB_PARTMAPS(X) = kmalloc(sizeof(struct udf_part_map) * Y, GFP_KERNEL);\
-        if (UDF_SB_PARTMAPS(X) != NULL)\
-        {\
+        if (UDF_SB_PARTMAPS(X) != NULL) {\
                 UDF_SB_NUMPARTS(X) = Y;\
                 memset(UDF_SB_PARTMAPS(X), 0x00, sizeof(struct udf_part_map) * Y);\
-        }\
-        else\
-        {\
+        } else {\
                 UDF_SB_NUMPARTS(X) = 0;\
                 udf_error(X, __FUNCTION__, "Unable to allocate space for %d partition maps", Y);\
         }\
@@ -72,15 +68,12 @@ static inline struct udf_sb_info *UDF_SB(struct super_block *sb)
                 UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap = kmalloc(size, GFP_KERNEL);\
         else\
                 UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap = vmalloc(size);\
-        if (UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap != NULL)\
-        {\
+        if (UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap != NULL) {\
                 memset(UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap, 0x00, size);\
                 UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap->s_block_bitmap =\
                         (struct buffer_head **)(UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap + 1);\
                 UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap->s_nr_groups = nr_groups;\
-        }\
-        else\
-        {\
+        } else {\
                 udf_error(X, __FUNCTION__, "Unable to allocate space for bitmap and %d buffer_head pointers", nr_groups);\
         }\
 }
@@ -90,8 +83,7 @@ static inline struct udf_sb_info *UDF_SB(struct super_block *sb)
         int i;\
         int nr_groups = UDF_SB_BITMAP_NR_GROUPS(X,Y,Z);\
         int size = sizeof(struct udf_bitmap) + (sizeof(struct buffer_head *) * nr_groups);\
-        for (i=0; i<nr_groups; i++)\
-        {\
+        for (i = 0; i < nr_groups; i++) {\
                 if (UDF_SB_BITMAP(X,Y,Z,i))\
                         brelse(UDF_SB_BITMAP(X,Y,Z,i));\
         }\
@@ -139,4 +131,4 @@ static inline struct udf_sb_info *UDF_SB(struct super_block *sb)
 #define UDF_SB_FLAGS(X)                         ( UDF_SB(X)->s_flags )
 #define UDF_SB_VAT(X)                           ( UDF_SB(X)->s_vat )
 
-#endif                          /* __LINUX_UDF_SB_H */
+#endif /* __LINUX_UDF_SB_H */
diff --git a/fs/udf/udfdecl.h b/fs/udf/udfdecl.h
index 76f2b82a39dc..c8016cc9e7e6 100644
--- a/fs/udf/udfdecl.h
+++ b/fs/udf/udfdecl.h
@@ -63,8 +63,8 @@ struct udf_vds_record {
 };
 
 struct generic_desc {
-        tag descTag;
-        __le32 volDescSeqNum;
+        tag             descTag;
+        __le32          volDescSeqNum;
 };
 
 struct ustr {
diff --git a/fs/udf/udfend.h b/fs/udf/udfend.h
index 450daab35a13..c4bd1203f857 100644
--- a/fs/udf/udfend.h
+++ b/fs/udf/udfend.h
@@ -7,75 +7,93 @@
 static inline kernel_lb_addr lelb_to_cpu(lb_addr in)
 {
         kernel_lb_addr out;
+
         out.logicalBlockNum = le32_to_cpu(in.logicalBlockNum);
         out.partitionReferenceNum = le16_to_cpu(in.partitionReferenceNum);
+
         return out;
 }
 
 static inline lb_addr cpu_to_lelb(kernel_lb_addr in)
 {
         lb_addr out;
+
         out.logicalBlockNum = cpu_to_le32(in.logicalBlockNum);
         out.partitionReferenceNum = cpu_to_le16(in.partitionReferenceNum);
+
         return out;
 }
 
 static inline kernel_timestamp lets_to_cpu(timestamp in)
 {
         kernel_timestamp out;
+
         memcpy(&out, &in, sizeof(timestamp));
         out.typeAndTimezone = le16_to_cpu(in.typeAndTimezone);
         out.year = le16_to_cpu(in.year);
+
         return out;
 }
 
 static inline short_ad lesa_to_cpu(short_ad in)
 {
         short_ad out;
+
         out.extLength = le32_to_cpu(in.extLength);
         out.extPosition = le32_to_cpu(in.extPosition);
+
         return out;
 }
 
 static inline short_ad cpu_to_lesa(short_ad in)
 {
         short_ad out;
+
         out.extLength = cpu_to_le32(in.extLength);
         out.extPosition = cpu_to_le32(in.extPosition);
+
         return out;
 }
 
 static inline kernel_long_ad lela_to_cpu(long_ad in)
 {
         kernel_long_ad out;
+
         out.extLength = le32_to_cpu(in.extLength);
         out.extLocation = lelb_to_cpu(in.extLocation);
+
         return out;
 }
 
 static inline long_ad cpu_to_lela(kernel_long_ad in)
 {
         long_ad out;
+
         out.extLength = cpu_to_le32(in.extLength);
         out.extLocation = cpu_to_lelb(in.extLocation);
+
         return out;
 }
 
 static inline kernel_extent_ad leea_to_cpu(extent_ad in)
 {
         kernel_extent_ad out;
+
         out.extLength = le32_to_cpu(in.extLength);
         out.extLocation = le32_to_cpu(in.extLocation);
+
         return out;
 }
 
 static inline timestamp cpu_to_lets(kernel_timestamp in)
 {
         timestamp out;
+
         memcpy(&out, &in, sizeof(timestamp));
         out.typeAndTimezone = cpu_to_le16(in.typeAndTimezone);
         out.year = cpu_to_le16(in.year);
+
         return out;
 }
 
-#endif                          /* __UDF_ENDIAN_H */
+#endif /* __UDF_ENDIAN_H */
diff --git a/fs/udf/udftime.c b/fs/udf/udftime.c
index b9f3198080e9..3fd80eb66af3 100644
--- a/fs/udf/udftime.c
+++ b/fs/udf/udftime.c
@@ -18,18 +18,18 @@
    Boston, MA 02111-1307, USA.  */
 
 /*
- * dgb 10/02/98: ripped this from glibc source to help convert timestamps to unix time 
+ * dgb 10/02/98: ripped this from glibc source to help convert timestamps to unix time
  *     10/04/98: added new table-based lookup after seeing how ugly the gnu code is
  * blf 09/27/99: ripped out all the old code and inserted new table from
- *                                      John Brockmeyer (without leap second corrections)
- *                               rewrote udf_stamp_to_time and fixed timezone accounting in
-                                        udf_time_to_stamp.
+ *               John Brockmeyer (without leap second corrections)
+ *               rewrote udf_stamp_to_time and fixed timezone accounting in
+ *               udf_time_to_stamp.
  */
 
 /*
  * We don't take into account leap seconds. This may be correct or incorrect.
  * For more NIST information (especially dealing with leap seconds), see:
- *  http://www.boulder.nist.gov/timefreq/pubs/bulletin/leapsecond.htm
+ * http://www.boulder.nist.gov/timefreq/pubs/bulletin/leapsecond.htm
  */
 
 #include <linux/types.h>
@@ -54,28 +54,28 @@ static const unsigned short int __mon_yday[2][13] = {
 };
 
 #define MAX_YEAR_SECONDS        69
-#define SPD 0x15180             /*3600*24 */
-#define SPY(y,l,s) (SPD * (365*y+l)+s)
-
-static time_t year_seconds[MAX_YEAR_SECONDS] = {
-/*1970*/ SPY(0, 0, 0), SPY(1, 0, 0), SPY(2, 0, 0), SPY(3, 1, 0),
-/*1974*/ SPY(4, 1, 0), SPY(5, 1, 0), SPY(6, 1, 0), SPY(7, 2, 0),
-/*1978*/ SPY(8, 2, 0), SPY(9, 2, 0), SPY(10, 2, 0), SPY(11, 3, 0),
-/*1982*/ SPY(12, 3, 0), SPY(13, 3, 0), SPY(14, 3, 0), SPY(15, 4, 0),
-/*1986*/ SPY(16, 4, 0), SPY(17, 4, 0), SPY(18, 4, 0), SPY(19, 5, 0),
-/*1990*/ SPY(20, 5, 0), SPY(21, 5, 0), SPY(22, 5, 0), SPY(23, 6, 0),
-/*1994*/ SPY(24, 6, 0), SPY(25, 6, 0), SPY(26, 6, 0), SPY(27, 7, 0),
-/*1998*/ SPY(28, 7, 0), SPY(29, 7, 0), SPY(30, 7, 0), SPY(31, 8, 0),
-/*2002*/ SPY(32, 8, 0), SPY(33, 8, 0), SPY(34, 8, 0), SPY(35, 9, 0),
-/*2006*/ SPY(36, 9, 0), SPY(37, 9, 0), SPY(38, 9, 0), SPY(39, 10, 0),
-/*2010*/ SPY(40, 10, 0), SPY(41, 10, 0), SPY(42, 10, 0), SPY(43, 11, 0),
-/*2014*/ SPY(44, 11, 0), SPY(45, 11, 0), SPY(46, 11, 0), SPY(47, 12, 0),
-/*2018*/ SPY(48, 12, 0), SPY(49, 12, 0), SPY(50, 12, 0), SPY(51, 13, 0),
-/*2022*/ SPY(52, 13, 0), SPY(53, 13, 0), SPY(54, 13, 0), SPY(55, 14, 0),
-/*2026*/ SPY(56, 14, 0), SPY(57, 14, 0), SPY(58, 14, 0), SPY(59, 15, 0),
-/*2030*/ SPY(60, 15, 0), SPY(61, 15, 0), SPY(62, 15, 0), SPY(63, 16, 0),
-/*2034*/ SPY(64, 16, 0), SPY(65, 16, 0), SPY(66, 16, 0), SPY(67, 17, 0),
-/*2038*/ SPY(68, 17, 0)
+#define SPD                     0x15180 /*3600*24 */
+#define SPY(y,l,s)              (SPD * (365*y+l)+s)
+
+static time_t year_seconds[MAX_YEAR_SECONDS]= {
+/*1970*/ SPY( 0, 0,0), SPY( 1, 0,0), SPY( 2, 0,0), SPY( 3, 1,0),
+/*1974*/ SPY( 4, 1,0), SPY( 5, 1,0), SPY( 6, 1,0), SPY( 7, 2,0),
+/*1978*/ SPY( 8, 2,0), SPY( 9, 2,0), SPY(10, 2,0), SPY(11, 3,0),
+/*1982*/ SPY(12, 3,0), SPY(13, 3,0), SPY(14, 3,0), SPY(15, 4,0),
+/*1986*/ SPY(16, 4,0), SPY(17, 4,0), SPY(18, 4,0), SPY(19, 5,0),
+/*1990*/ SPY(20, 5,0), SPY(21, 5,0), SPY(22, 5,0), SPY(23, 6,0),
+/*1994*/ SPY(24, 6,0), SPY(25, 6,0), SPY(26, 6,0), SPY(27, 7,0),
+/*1998*/ SPY(28, 7,0), SPY(29, 7,0), SPY(30, 7,0), SPY(31, 8,0),
+/*2002*/ SPY(32, 8,0), SPY(33, 8,0), SPY(34, 8,0), SPY(35, 9,0),
+/*2006*/ SPY(36, 9,0), SPY(37, 9,0), SPY(38, 9,0), SPY(39,10,0),
+/*2010*/ SPY(40,10,0), SPY(41,10,0), SPY(42,10,0), SPY(43,11,0),
+/*2014*/ SPY(44,11,0), SPY(45,11,0), SPY(46,11,0), SPY(47,12,0),
+/*2018*/ SPY(48,12,0), SPY(49,12,0), SPY(50,12,0), SPY(51,13,0),
+/*2022*/ SPY(52,13,0), SPY(53,13,0), SPY(54,13,0), SPY(55,14,0),
+/*2026*/ SPY(56,14,0), SPY(57,14,0), SPY(58,14,0), SPY(59,15,0),
+/*2030*/ SPY(60,15,0), SPY(61,15,0), SPY(62,15,0), SPY(63,16,0),
+/*2034*/ SPY(64,16,0), SPY(65,16,0), SPY(66,16,0), SPY(67,17,0),
+/*2038*/ SPY(68,17,0)
 };
 
 extern struct timezone sys_tz;
@@ -83,7 +83,7 @@ extern struct timezone sys_tz;
 #define SECS_PER_HOUR   (60 * 60)
 #define SECS_PER_DAY    (SECS_PER_HOUR * 24)
 
-time_t *udf_stamp_to_time(time_t * dest, long *dest_usec, kernel_timestamp src)
+time_t *udf_stamp_to_time(time_t *dest, long *dest_usec, kernel_timestamp src)
 {
         int yday;
         uint8_t type = src.typeAndTimezone >> 12;
@@ -93,10 +93,11 @@ time_t *udf_stamp_to_time(time_t * dest, long *dest_usec, kernel_timestamp src)
                 offset = src.typeAndTimezone << 4;
                 /* sign extent offset */
                 offset = (offset >> 4);
-                if (offset == -2047)    /* unspecified offset */
+                if (offset == -2047) /* unspecified offset */
                         offset = 0;
-        } else
+        } else {
                 offset = 0;
+        }
 
         if ((src.year < EPOCH_YEAR) ||
             (src.year >= EPOCH_YEAR + MAX_YEAR_SECONDS)) {
@@ -107,12 +108,10 @@ time_t *udf_stamp_to_time(time_t * dest, long *dest_usec, kernel_timestamp src)
         *dest = year_seconds[src.year - EPOCH_YEAR];
         *dest -= offset * 60;
 
-        yday = ((__mon_yday[__isleap(src.year)]
+        yday = ((__mon_yday[__isleap (src.year)]
                  [src.month - 1]) + (src.day - 1));
-        *dest += (((yday * 24) + src.hour) * 60 + src.minute) * 60 + src.second;
-        *dest_usec =
-            src.centiseconds * 10000 + src.hundredsOfMicroseconds * 100 +
-            src.microseconds;
+        *dest += ( ( (yday * 24) + src.hour ) * 60 + src.minute ) * 60 + src.second;
+        *dest_usec = src.centiseconds * 10000 + src.hundredsOfMicroseconds * 100 + src.microseconds;
         return dest;
 }
 
@@ -145,8 +144,9 @@ kernel_timestamp *udf_time_to_stamp(kernel_timestamp * dest, struct timespec ts)
                 long int yg = y + days / 365 - (days % 365 < 0);
 
                 /* Adjust DAYS and Y to match the guessed year.  */
-                days -= ((yg - y) * 365 + LEAPS_THRU_END_OF(yg - 1)
-                         - LEAPS_THRU_END_OF(y - 1));
+                days -= ((yg - y) * 365
+                         + LEAPS_THRU_END_OF (yg - 1)
+                         - LEAPS_THRU_END_OF (y - 1));
                 y = yg;
         }
         dest->year = y;
@@ -158,11 +158,9 @@ kernel_timestamp *udf_time_to_stamp(kernel_timestamp * dest, struct timespec ts)
         dest->day = days + 1;
 
         dest->centiseconds = ts.tv_nsec / 10000000;
-        dest->hundredsOfMicroseconds =
-            (ts.tv_nsec / 1000 - dest->centiseconds * 10000) / 100;
-        dest->microseconds =
-            (ts.tv_nsec / 1000 - dest->centiseconds * 10000 -
-             dest->hundredsOfMicroseconds * 100);
+        dest->hundredsOfMicroseconds = (ts.tv_nsec / 1000 - dest->centiseconds * 10000) / 100;
+        dest->microseconds = (ts.tv_nsec / 1000 - dest->centiseconds * 10000 -
+                              dest->hundredsOfMicroseconds * 100);
         return dest;
 }
 
diff --git a/fs/udf/unicode.c b/fs/udf/unicode.c
index 46835240275c..9e6099c26c27 100644
--- a/fs/udf/unicode.c
+++ b/fs/udf/unicode.c
@@ -29,21 +29,23 @@
 
 static int udf_translate_to_linux(uint8_t *, uint8_t *, int, uint8_t *, int);
 
-static int udf_char_to_ustr(struct ustr *dest, const uint8_t * src, int strlen)
+static int udf_char_to_ustr(struct ustr *dest, const uint8_t *src, int strlen)
 {
         if ((!dest) || (!src) || (!strlen) || (strlen > UDF_NAME_LEN - 2))
                 return 0;
+
         memset(dest, 0, sizeof(struct ustr));
         memcpy(dest->u_name, src, strlen);
         dest->u_cmpID = 0x08;
         dest->u_len = strlen;
+
         return strlen;
 }
 
 /*
  * udf_build_ustr
  */
-int udf_build_ustr(struct ustr *dest, dstring * ptr, int size)
+int udf_build_ustr(struct ustr *dest, dstring *ptr, int size)
 {
         int usesize;
 
@@ -55,13 +57,14 @@ int udf_build_ustr(struct ustr *dest, dstring * ptr, int size)
         dest->u_cmpID = ptr[0];
         dest->u_len = ptr[size - 1];
         memcpy(dest->u_name, ptr + 1, usesize - 1);
+
         return 0;
 }
 
 /*
  * udf_build_ustr_exact
  */
-static int udf_build_ustr_exact(struct ustr *dest, dstring * ptr, int exactsize)
+static int udf_build_ustr_exact(struct ustr *dest, dstring *ptr, int exactsize)
 {
         if ((!dest) || (!ptr) || (!exactsize))
                 return -1;
@@ -70,6 +73,7 @@ static int udf_build_ustr_exact(struct ustr *dest, dstring * ptr, int exactsize)
         dest->u_cmpID = ptr[0];
         dest->u_len = exactsize - 1;
         memcpy(dest->u_name, ptr + 1, exactsize - 1);
+
         return 0;
 }
 
@@ -129,20 +133,15 @@ int udf_CS0toUTF8(struct ustr *utf_o, struct ustr *ocu_i)
                         c = (c << 8) | ocu[i++];
 
                 /* Compress Unicode to UTF-8 */
-                if (c < 0x80U)
-                        utf_o->u_name[utf_o->u_len++] = (uint8_t) c;
-                else if (c < 0x800U) {
-                        utf_o->u_name[utf_o->u_len++] =
-                            (uint8_t) (0xc0 | (c >> 6));
-                        utf_o->u_name[utf_o->u_len++] =
-                            (uint8_t) (0x80 | (c & 0x3f));
+                if (c < 0x80U) {
+                        utf_o->u_name[utf_o->u_len++] = (uint8_t)c;
+                } else if (c < 0x800U) {
+                        utf_o->u_name[utf_o->u_len++] = (uint8_t)(0xc0 | (c >> 6));
+                        utf_o->u_name[utf_o->u_len++] = (uint8_t)(0x80 | (c & 0x3f));
                 } else {
-                        utf_o->u_name[utf_o->u_len++] =
-                            (uint8_t) (0xe0 | (c >> 12));
-                        utf_o->u_name[utf_o->u_len++] =
-                            (uint8_t) (0x80 | ((c >> 6) & 0x3f));
-                        utf_o->u_name[utf_o->u_len++] =
-                            (uint8_t) (0x80 | (c & 0x3f));
+                        utf_o->u_name[utf_o->u_len++] = (uint8_t)(0xe0 | (c >> 12));
+                        utf_o->u_name[utf_o->u_len++] = (uint8_t)(0x80 | ((c >> 6) & 0x3f));
+                        utf_o->u_name[utf_o->u_len++] = (uint8_t)(0x80 | (c & 0x3f));
                 }
         }
         utf_o->u_cmpID = 8;
@@ -173,7 +172,7 @@ int udf_CS0toUTF8(struct ustr *utf_o, struct ustr *ocu_i)
  *      November 12, 1997 - Andrew E. Mileski
  *      Written, tested, and released.
  */
-static int udf_UTF8toCS0(dstring * ocu, struct ustr *utf, int length)
+static int udf_UTF8toCS0(dstring *ocu, struct ustr *utf, int length)
 {
         unsigned c, i, max_val, utf_char;
         int utf_cnt, u_len;
@@ -182,12 +181,12 @@ static int udf_UTF8toCS0(dstring * ocu, struct ustr *utf, int length)
         ocu[0] = 8;
         max_val = 0xffU;
 
-      try_again:
+try_again:
         u_len = 0U;
         utf_char = 0U;
         utf_cnt = 0U;
         for (i = 0U; i < utf->u_len; i++) {
-                c = (uint8_t) utf->u_name[i];
+                c = (uint8_t)utf->u_name[i];
 
                 /* Complete a multi-byte UTF-8 character */
                 if (utf_cnt) {
@@ -213,37 +212,40 @@ static int udf_UTF8toCS0(dstring * ocu, struct ustr *utf, int length)
                                 } else if ((c & 0xfeU) == 0xfcU) {
                                         utf_char = c & 0x01U;
                                         utf_cnt = 5;
-                                } else
+                                } else {
                                         goto error_out;
+                                }
                                 continue;
-                        } else
+                        } else {
                                 /* Single byte UTF-8 character (most common) */
                                 utf_char = c;
+                        }
                 }
 
                 /* Choose no compression if necessary */
                 if (utf_char > max_val) {
-                        if (0xffU == max_val) {
+                        if (max_val == 0xffU) {
                                 max_val = 0xffffU;
-                                ocu[0] = (uint8_t) 0x10U;
+                                ocu[0] = (uint8_t)0x10U;
                                 goto try_again;
                         }
                         goto error_out;
                 }
 
                 if (max_val == 0xffffU) {
-                        ocu[++u_len] = (uint8_t) (utf_char >> 8);
+                        ocu[++u_len] = (uint8_t)(utf_char >> 8);
                 }
-                ocu[++u_len] = (uint8_t) (utf_char & 0xffU);
+                ocu[++u_len] = (uint8_t)(utf_char & 0xffU);
         }
 
         if (utf_cnt) {
-              error_out:
+error_out:
                 ocu[++u_len] = '?';
                 printk(KERN_DEBUG "udf: bad UTF-8 character\n");
         }
 
-        ocu[length - 1] = (uint8_t) u_len + 1;
+        ocu[length - 1] = (uint8_t)u_len + 1;
+
         return u_len + 1;
 }
 
@@ -288,7 +290,7 @@ static int udf_CS0toNLS(struct nls_table *nls, struct ustr *utf_o,
         return utf_o->u_len;
 }
 
-static int udf_NLStoCS0(struct nls_table *nls, dstring * ocu, struct ustr *uni,
+static int udf_NLStoCS0(struct nls_table *nls, dstring *ocu, struct ustr *uni,
                         int length)
 {
         unsigned len, i, max_val;
@@ -299,7 +301,7 @@ static int udf_NLStoCS0(struct nls_table *nls, dstring * ocu, struct ustr *uni,
         ocu[0] = 8;
         max_val = 0xffU;
 
-      try_again:
+try_again:
         u_len = 0U;
         for (i = 0U; i < uni->u_len; i++) {
                 len = nls->char2uni(&uni->u_name[i], uni->u_len - i, &uni_char);
@@ -308,21 +310,21 @@ static int udf_NLStoCS0(struct nls_table *nls, dstring * ocu, struct ustr *uni,
 
                 if (uni_char > max_val) {
                         max_val = 0xffffU;
-                        ocu[0] = (uint8_t) 0x10U;
+                        ocu[0] = (uint8_t)0x10U;
                         goto try_again;
                 }
 
                 if (max_val == 0xffffU)
-                        ocu[++u_len] = (uint8_t) (uni_char >> 8);
-                ocu[++u_len] = (uint8_t) (uni_char & 0xffU);
+                        ocu[++u_len] = (uint8_t)(uni_char >> 8);
+                ocu[++u_len] = (uint8_t)(uni_char & 0xffU);
                 i += len - 1;
         }
 
-        ocu[length - 1] = (uint8_t) u_len + 1;
+        ocu[length - 1] = (uint8_t)u_len + 1;
         return u_len + 1;
 }
 
-int udf_get_filename(struct super_block *sb, uint8_t * sname, uint8_t * dname,
+int udf_get_filename(struct super_block *sb, uint8_t *sname, uint8_t *dname,
                      int flen)
 {
         struct ustr filename, unifilename;
@@ -334,30 +336,29 @@ int udf_get_filename(struct super_block *sb, uint8_t * sname, uint8_t * dname,
 
         if (UDF_QUERY_FLAG(sb, UDF_FLAG_UTF8)) {
                 if (!udf_CS0toUTF8(&filename, &unifilename)) {
-                        udf_debug("Failed in udf_get_filename: sname = %s\n",
-                                  sname);
+                        udf_debug("Failed in udf_get_filename: sname = %s\n", sname);
                         return 0;
                 }
         } else if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP)) {
-                if (!udf_CS0toNLS
-                    (UDF_SB(sb)->s_nls_map, &filename, &unifilename)) {
-                        udf_debug("Failed in udf_get_filename: sname = %s\n",
-                                  sname);
+                if (!udf_CS0toNLS(UDF_SB(sb)->s_nls_map, &filename, &unifilename)) {
+                        udf_debug("Failed in udf_get_filename: sname = %s\n", sname);
                         return 0;
                 }
-        } else
+        } else {
                 return 0;
+        }
 
-        if ((len =
-             udf_translate_to_linux(dname, filename.u_name, filename.u_len,
-                                    unifilename.u_name, unifilename.u_len))) {
+        len = udf_translate_to_linux(dname, filename.u_name, filename.u_len,
+                                     unifilename.u_name, unifilename.u_len);
+        if (len) {
                 return len;
         }
+
         return 0;
 }
 
-int udf_put_filename(struct super_block *sb, const uint8_t * sname,
-                     uint8_t * dname, int flen)
+int udf_put_filename(struct super_block *sb, const uint8_t *sname,
+                     uint8_t *dname, int flen)
 {
         struct ustr unifilename;
         int namelen;
@@ -367,31 +368,29 @@ int udf_put_filename(struct super_block *sb, const uint8_t * sname,
         }
 
         if (UDF_QUERY_FLAG(sb, UDF_FLAG_UTF8)) {
-                if (!
-                    (namelen =
-                     udf_UTF8toCS0(dname, &unifilename, UDF_NAME_LEN))) {
+                namelen = udf_UTF8toCS0(dname, &unifilename, UDF_NAME_LEN);
+                if (!namelen) {
                         return 0;
                 }
         } else if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP)) {
-                if (!
-                    (namelen =
-                     udf_NLStoCS0(UDF_SB(sb)->s_nls_map, dname, &unifilename,
-                                  UDF_NAME_LEN))) {
+                namelen = udf_NLStoCS0(UDF_SB(sb)->s_nls_map, dname, &unifilename, UDF_NAME_LEN);
+                if (!namelen) {
                         return 0;
                 }
-        } else
+        } else {
                 return 0;
+        }
 
         return namelen;
 }
 
 #define ILLEGAL_CHAR_MARK       '_'
-#define EXT_MARK                        '.'
-#define CRC_MARK                        '#'
-#define EXT_SIZE                        5
+#define EXT_MARK                '.'
+#define CRC_MARK                '#'
+#define EXT_SIZE                5
 
-static int udf_translate_to_linux(uint8_t * newName, uint8_t * udfName,
-                                  int udfLen, uint8_t * fidName, int fidNameLen)
+static int udf_translate_to_linux(uint8_t *newName, uint8_t *udfName, int udfLen,
+                                  uint8_t *fidName, int fidNameLen)
 {
         int index, newIndex = 0, needsCRC = 0;
         int extIndex = 0, newExtIndex = 0, hasExt = 0;
@@ -399,8 +398,8 @@ static int udf_translate_to_linux(uint8_t * newName, uint8_t * udfName,
         uint8_t curr;
         const uint8_t hexChar[] = "0123456789ABCDEF";
 
-        if (udfName[0] == '.' && (udfLen == 1 ||
-                                  (udfLen == 2 && udfName[1] == '.'))) {
+        if (udfName[0] == '.' &&
+            (udfLen == 1 || (udfLen == 2 && udfName[1] == '.'))) {
                 needsCRC = 1;
                 newIndex = udfLen;
                 memcpy(newName, udfName, udfLen);
@@ -410,16 +409,13 @@ static int udf_translate_to_linux(uint8_t * newName, uint8_t * udfName,
                         if (curr == '/' || curr == 0) {
                                 needsCRC = 1;
                                 curr = ILLEGAL_CHAR_MARK;
-                                while (index + 1 < udfLen
-                                       && (udfName[index + 1] == '/'
-                                           || udfName[index + 1] == 0))
+                                while (index + 1 < udfLen && (udfName[index + 1] == '/' ||
+                                                              udfName[index + 1] == 0))
                                         index++;
-                        }
-                        if (curr == EXT_MARK
-                            && (udfLen - index - 1) <= EXT_SIZE) {
-                                if (udfLen == index + 1)
+                        } if (curr == EXT_MARK && (udfLen - index - 1) <= EXT_SIZE) {
+                                if (udfLen == index + 1) {
                                         hasExt = 0;
-                                else {
+                                } else {
                                         hasExt = 1;
                                         extIndex = index;
                                         newExtIndex = newIndex;
@@ -437,23 +433,16 @@ static int udf_translate_to_linux(uint8_t * newName, uint8_t * udfName,
 
                 if (hasExt) {
                         int maxFilenameLen;
-                        for (index = 0;
-                             index < EXT_SIZE && extIndex + index + 1 < udfLen;
-                             index++) {
+                        for(index = 0; index < EXT_SIZE && extIndex + index + 1 < udfLen; index++) {
                                 curr = udfName[extIndex + index + 1];
 
                                 if (curr == '/' || curr == 0) {
                                         needsCRC = 1;
                                         curr = ILLEGAL_CHAR_MARK;
-                                        while (extIndex + index + 2 < udfLen
-                                               && (index + 1 < EXT_SIZE
-                                                   &&
-                                                   (udfName
-                                                    [extIndex + index + 2] ==
-                                                    '/'
-                                                    || udfName[extIndex +
-                                                               index + 2] ==
-                                                    0)))
+                                        while(extIndex + index + 2 < udfLen &&
+                                              (index + 1 < EXT_SIZE
+                                               && (udfName[extIndex + index + 2] == '/' ||
+                                                   udfName[extIndex + index + 2] == 0)))
                                                 index++;
                                 }
                                 ext[localExtIndex++] = curr;
@@ -463,8 +452,9 @@ static int udf_translate_to_linux(uint8_t * newName, uint8_t * udfName,
                                 newIndex = maxFilenameLen;
                         else
                                 newIndex = newExtIndex;
-                } else if (newIndex > 250)
+                } else if (newIndex > 250) {
                         newIndex = 250;
+                }
                 newName[newIndex++] = CRC_MARK;
                 valueCRC = udf_crc(fidName, fidNameLen, 0);
                 newName[newIndex++] = hexChar[(valueCRC & 0xf000) >> 12];
@@ -478,5 +468,6 @@ static int udf_translate_to_linux(uint8_t * newName, uint8_t * udfName,
                                 newName[newIndex++] = ext[index];
                 }
         }
+
         return newIndex;
 }
diff --git a/include/acpi/acpi_numa.h b/include/acpi/acpi_numa.h
index e2fcee2b340d..62c5ee4311da 100644
--- a/include/acpi/acpi_numa.h
+++ b/include/acpi/acpi_numa.h
@@ -13,6 +13,7 @@
 
 extern int pxm_to_node(int);
 extern int node_to_pxm(int);
+extern void __acpi_map_pxm_to_node(int, int);
 extern int acpi_map_pxm_to_node(int);
 extern void __cpuinit acpi_unmap_pxm_to_node(int);
 
diff --git a/include/asm-i386/e820.h b/include/asm-i386/e820.h
index c03290ccecb2..43114c824608 100644
--- a/include/asm-i386/e820.h
+++ b/include/asm-i386/e820.h
@@ -47,6 +47,14 @@ extern void e820_register_memory(void);
 extern void limit_regions(unsigned long long size);
 extern void print_memory_map(char *who);
 
+#if defined(CONFIG_PM) && defined(CONFIG_SOFTWARE_SUSPEND)
+extern void e820_mark_nosave_regions(void);
+#else
+static inline void e820_mark_nosave_regions(void)
+{
+}
+#endif
+
 #endif/*!__ASSEMBLY__*/
 
 #endif/*__E820_HEADER*/
diff --git a/include/asm-i386/geode.h b/include/asm-i386/geode.h
new file mode 100644
index 000000000000..6da4bbbea3dc
--- /dev/null
+++ b/include/asm-i386/geode.h
@@ -0,0 +1,159 @@
+/*
+ * AMD Geode definitions
+ * Copyright (C) 2006, Advanced Micro Devices, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public License
+ * as published by the Free Software Foundation.
+ */
+
+#ifndef _ASM_GEODE_H_
+#define _ASM_GEODE_H_
+
+#include <asm/processor.h>
+#include <linux/io.h>
+
+/* Generic southbridge functions */
+
+#define GEODE_DEV_PMS 0
+#define GEODE_DEV_ACPI 1
+#define GEODE_DEV_GPIO 2
+#define GEODE_DEV_MFGPT 3
+
+extern int geode_get_dev_base(unsigned int dev);
+
+/* Useful macros */
+#define geode_pms_base()        geode_get_dev_base(GEODE_DEV_PMS)
+#define geode_acpi_base()       geode_get_dev_base(GEODE_DEV_ACPI)
+#define geode_gpio_base()       geode_get_dev_base(GEODE_DEV_GPIO)
+#define geode_mfgpt_base()      geode_get_dev_base(GEODE_DEV_MFGPT)
+
+/* MSRS */
+
+#define GX_GLCP_SYS_RSTPLL      0x4C000014
+
+#define MSR_LBAR_SMB            0x5140000B
+#define MSR_LBAR_GPIO           0x5140000C
+#define MSR_LBAR_MFGPT          0x5140000D
+#define MSR_LBAR_ACPI           0x5140000E
+#define MSR_LBAR_PMS            0x5140000F
+
+#define MSR_PIC_YSEL_LOW        0x51400020
+#define MSR_PIC_YSEL_HIGH       0x51400021
+#define MSR_PIC_ZSEL_LOW        0x51400022
+#define MSR_PIC_ZSEL_HIGH       0x51400023
+
+#define MFGPT_IRQ_MSR           0x51400028
+#define MFGPT_NR_MSR            0x51400029
+
+/* Resource Sizes */
+
+#define LBAR_GPIO_SIZE          0xFF
+#define LBAR_MFGPT_SIZE         0x40
+#define LBAR_ACPI_SIZE          0x40
+#define LBAR_PMS_SIZE           0x80
+
+/* ACPI registers (PMS block) */
+
+/*
+ * PM1_EN is only valid when VSA is enabled for 16 bit reads.
+ * When VSA is not enabled, *always* read both PM1_STS and PM1_EN
+ * with a 32 bit read at offset 0x0
+ */
+
+#define PM1_STS                 0x00
+#define PM1_EN                  0x02
+#define PM1_CNT                 0x08
+#define PM2_CNT                 0x0C
+#define PM_TMR                  0x10
+#define PM_GPE0_STS             0x18
+#define PM_GPE0_EN              0x1C
+
+/* PMC registers (PMS block) */
+
+#define PM_SSD                  0x00
+#define PM_SCXA                 0x04
+#define PM_SCYA                 0x08
+#define PM_OUT_SLPCTL           0x0C
+#define PM_SCLK                 0x10
+#define PM_SED                  0x1
+#define PM_SCXD                 0x18
+#define PM_SCYD                 0x1C
+#define PM_IN_SLPCTL            0x20
+#define PM_WKD                  0x30
+#define PM_WKXD                 0x34
+#define PM_RD                   0x38
+#define PM_WKXA                 0x3C
+#define PM_FSD                  0x40
+#define PM_TSD                  0x44
+#define PM_PSD                  0x48
+#define PM_NWKD                 0x4C
+#define PM_AWKD                 0x50
+#define PM_SSC                  0x54
+
+/* GPIO */
+
+#define GPIO_OUTPUT_VAL         0x00
+#define GPIO_OUTPUT_ENABLE      0x04
+#define GPIO_OUTPUT_OPEN_DRAIN  0x08
+#define GPIO_OUTPUT_INVERT      0x0C
+#define GPIO_OUTPUT_AUX1        0x10
+#define GPIO_OUTPUT_AUX2        0x14
+#define GPIO_PULL_UP            0x18
+#define GPIO_PULL_DOWN          0x1C
+#define GPIO_INPUT_ENABLE       0x20
+#define GPIO_INPUT_INVERT       0x24
+#define GPIO_INPUT_FILTER       0x28
+#define GPIO_INPUT_EVENT_COUNT  0x2C
+#define GPIO_READ_BACK          0x30
+#define GPIO_INPUT_AUX1         0x34
+#define GPIO_EVENTS_ENABLE      0x38
+#define GPIO_LOCK_ENABLE        0x3C
+#define GPIO_POSITIVE_EDGE_EN   0x40
+#define GPIO_NEGATIVE_EDGE_EN   0x44
+#define GPIO_POSITIVE_EDGE_STS  0x48
+#define GPIO_NEGATIVE_EDGE_STS  0x4C
+
+#define GPIO_MAP_X              0xE0
+#define GPIO_MAP_Y              0xE4
+#define GPIO_MAP_Z              0xE8
+#define GPIO_MAP_W              0xEC
+
+extern void geode_gpio_set(unsigned int, unsigned int);
+extern void geode_gpio_clear(unsigned int, unsigned int);
+extern int geode_gpio_isset(unsigned int, unsigned int);
+extern void geode_gpio_setup_event(unsigned int, int, int);
+extern void geode_gpio_set_irq(unsigned int, unsigned int);
+
+static inline void geode_gpio_event_irq(unsigned int gpio, int pair)
+{
+        geode_gpio_setup_event(gpio, pair, 0);
+}
+
+static inline void geode_gpio_event_pme(unsigned int gpio, int pair)
+{
+        geode_gpio_setup_event(gpio, pair, 1);
+}
+
+/* Specific geode tests */
+
+static inline int is_geode_gx(void)
+{
+        return ((boot_cpu_data.x86_vendor == X86_VENDOR_NSC) &&
+                (boot_cpu_data.x86 == 5) &&
+                (boot_cpu_data.x86_model == 5));
+}
+
+static inline int is_geode_lx(void)
+{
+        return ((boot_cpu_data.x86_vendor == X86_VENDOR_AMD) &&
+                (boot_cpu_data.x86 == 5) &&
+                (boot_cpu_data.x86_model == 10));
+}
+
+static inline int is_geode(void)
+{
+        return (is_geode_gx() || is_geode_lx());
+}
+
+#endif
diff --git a/include/asm-i386/hpet.h b/include/asm-i386/hpet.h
index dddeedf504b7..c82dc7ed96b3 100644
--- a/include/asm-i386/hpet.h
+++ b/include/asm-i386/hpet.h
@@ -4,112 +4,82 @@
 
 #ifdef CONFIG_HPET_TIMER
 
-#include <linux/errno.h>
-#include <linux/module.h>
-#include <linux/sched.h>
-#include <linux/kernel.h>
-#include <linux/param.h>
-#include <linux/string.h>
-#include <linux/mm.h>
-#include <linux/interrupt.h>
-#include <linux/time.h>
-#include <linux/delay.h>
-#include <linux/init.h>
-#include <linux/smp.h>
-
-#include <asm/io.h>
-#include <asm/smp.h>
-#include <asm/irq.h>
-#include <asm/msr.h>
-#include <asm/delay.h>
-#include <asm/mpspec.h>
-#include <asm/uaccess.h>
-#include <asm/processor.h>
-
-#include <linux/timex.h>
-
 /*
  * Documentation on HPET can be found at:
  *      http://www.intel.com/ial/home/sp/pcmmspec.htm
  *      ftp://download.intel.com/ial/home/sp/mmts098.pdf
  */
 
-#define HPET_MMAP_SIZE  1024
-
-#define HPET_ID         0x000
-#define HPET_PERIOD     0x004
-#define HPET_CFG        0x010
-#define HPET_STATUS     0x020
-#define HPET_COUNTER    0x0f0
-#define HPET_T0_CFG     0x100
-#define HPET_T0_CMP     0x108
-#define HPET_T0_ROUTE   0x110
-#define HPET_T1_CFG     0x120
-#define HPET_T1_CMP     0x128
-#define HPET_T1_ROUTE   0x130
-#define HPET_T2_CFG     0x140
-#define HPET_T2_CMP     0x148
-#define HPET_T2_ROUTE   0x150
-
-#define HPET_ID_LEGSUP  0x00008000
-#define HPET_ID_NUMBER  0x00001f00
-#define HPET_ID_REV     0x000000ff
+#define HPET_MMAP_SIZE          1024
+
+#define HPET_ID                 0x000
+#define HPET_PERIOD             0x004
+#define HPET_CFG                0x010
+#define HPET_STATUS             0x020
+#define HPET_COUNTER            0x0f0
+#define HPET_T0_CFG             0x100
+#define HPET_T0_CMP             0x108
+#define HPET_T0_ROUTE           0x110
+#define HPET_T1_CFG             0x120
+#define HPET_T1_CMP             0x128
+#define HPET_T1_ROUTE           0x130
+#define HPET_T2_CFG             0x140
+#define HPET_T2_CMP             0x148
+#define HPET_T2_ROUTE           0x150
+
+#define HPET_ID_REV             0x000000ff
+#define HPET_ID_NUMBER          0x00001f00
+#define HPET_ID_64BIT           0x00002000
+#define HPET_ID_LEGSUP          0x00008000
+#define HPET_ID_VENDOR          0xffff0000
 #define HPET_ID_NUMBER_SHIFT    8
+#define HPET_ID_VENDOR_SHIFT    16
 
-#define HPET_CFG_ENABLE 0x001
-#define HPET_CFG_LEGACY 0x002
+#define HPET_ID_VENDOR_8086     0x8086
+
+#define HPET_CFG_ENABLE         0x001
+#define HPET_CFG_LEGACY         0x002
 #define HPET_LEGACY_8254        2
 #define HPET_LEGACY_RTC         8
 
-#define HPET_TN_ENABLE          0x004
-#define HPET_TN_PERIODIC        0x008
-#define HPET_TN_PERIODIC_CAP    0x010
-#define HPET_TN_SETVAL          0x040
-#define HPET_TN_32BIT           0x100
-
-/* Use our own asm for 64 bit multiply/divide */
-#define ASM_MUL64_REG(eax_out,edx_out,reg_in,eax_in)                    \
-                __asm__ __volatile__("mull %2"                          \
-                                :"=a" (eax_out), "=d" (edx_out)         \
-                                :"r" (reg_in), "0" (eax_in))
+#define HPET_TN_LEVEL           0x0002
+#define HPET_TN_ENABLE          0x0004
+#define HPET_TN_PERIODIC        0x0008
+#define HPET_TN_PERIODIC_CAP    0x0010
+#define HPET_TN_64BIT_CAP       0x0020
+#define HPET_TN_SETVAL          0x0040
+#define HPET_TN_32BIT           0x0100
+#define HPET_TN_ROUTE           0x3e00
+#define HPET_TN_FSB             0x4000
+#define HPET_TN_FSB_CAP         0x8000
+#define HPET_TN_ROUTE_SHIFT     9
 
-#define ASM_DIV64_REG(eax_out,edx_out,reg_in,eax_in,edx_in)             \
-                __asm__ __volatile__("divl %2"                          \
-                                :"=a" (eax_out), "=d" (edx_out)         \
-                                :"r" (reg_in), "0" (eax_in), "1" (edx_in))
-
-#define KERNEL_TICK_USEC        (1000000UL/HZ)  /* tick value in microsec */
 /* Max HPET Period is 10^8 femto sec as in HPET spec */
-#define HPET_MAX_PERIOD (100000000UL)
+#define HPET_MAX_PERIOD         100000000UL
 /*
  * Min HPET period is 10^5 femto sec just for safety. If it is less than this,
  * then 32 bit HPET counter wrapsaround in less than 0.5 sec.
  */
-#define HPET_MIN_PERIOD (100000UL)
-#define HPET_TICK_RATE  (HZ * 100000UL)
+#define HPET_MIN_PERIOD         100000UL
 
-extern unsigned long hpet_address;      /* hpet memory map physical address */
+/* hpet memory map physical address */
+extern unsigned long hpet_address;
 extern int is_hpet_enabled(void);
-
-#ifdef CONFIG_X86_64
-extern unsigned long hpet_tick; /* hpet clks count per tick */
-extern int hpet_use_timer;
-extern int hpet_rtc_timer_init(void);
 extern int hpet_enable(void);
-extern int is_hpet_capable(void);
-extern int hpet_readl(unsigned long a);
-#else
-extern int hpet_enable(void);
-#endif
 
 #ifdef CONFIG_HPET_EMULATE_RTC
+
+#include <linux/interrupt.h>
+
 extern int hpet_mask_rtc_irq_bit(unsigned long bit_mask);
 extern int hpet_set_rtc_irq_bit(unsigned long bit_mask);
-extern int hpet_set_alarm_time(unsigned char hrs, unsigned char min, unsigned char sec);
+extern int hpet_set_alarm_time(unsigned char hrs, unsigned char min,
+                               unsigned char sec);
 extern int hpet_set_periodic_freq(unsigned long freq);
 extern int hpet_rtc_dropped_irq(void);
 extern int hpet_rtc_timer_init(void);
 extern irqreturn_t hpet_rtc_interrupt(int irq, void *dev_id);
+
 #endif /* CONFIG_HPET_EMULATE_RTC */
 
 #else
diff --git a/include/asm-i386/i8253.h b/include/asm-i386/i8253.h
index 6cb0dd4dcdde..7577d058d86e 100644
--- a/include/asm-i386/i8253.h
+++ b/include/asm-i386/i8253.h
@@ -3,19 +3,15 @@
 
 #include <linux/clockchips.h>
 
+/* i8253A PIT registers */
+#define PIT_MODE                0x43
+#define PIT_CH0                 0x40
+#define PIT_CH2                 0x42
+
 extern spinlock_t i8253_lock;
 
 extern struct clock_event_device *global_clock_event;
 
-/**
- * pit_interrupt_hook - hook into timer tick
- * @regs:       standard registers from interrupt
- *
- * Call the global clock event handler.
- **/
-static inline void pit_interrupt_hook(void)
-{
-        global_clock_event->event_handler(global_clock_event);
-}
+extern void setup_pit_timer(void);
 
 #endif  /* __ASM_I8253_H__ */
diff --git a/include/asm-i386/mach-default/do_timer.h b/include/asm-i386/mach-default/do_timer.h
index 56e5689863ae..23ecda0b28a0 100644
--- a/include/asm-i386/mach-default/do_timer.h
+++ b/include/asm-i386/mach-default/do_timer.h
@@ -12,5 +12,5 @@
 
 static inline void do_timer_interrupt_hook(void)
 {
-        pit_interrupt_hook();
+        global_clock_event->event_handler(global_clock_event);
 }
diff --git a/include/asm-i386/mach-default/io_ports.h b/include/asm-i386/mach-default/io_ports.h
index a96d9f6604ee..48540ba97166 100644
--- a/include/asm-i386/mach-default/io_ports.h
+++ b/include/asm-i386/mach-default/io_ports.h
@@ -7,11 +7,6 @@
 #ifndef _MACH_IO_PORTS_H
 #define _MACH_IO_PORTS_H
 
-/* i8253A PIT registers */
-#define PIT_MODE                0x43
-#define PIT_CH0                 0x40
-#define PIT_CH2                 0x42
-
 /* i8259A PIC registers */
 #define PIC_MASTER_CMD          0x20
 #define PIC_MASTER_IMR          0x21
diff --git a/include/asm-i386/mach-default/mach_reboot.h b/include/asm-i386/mach-default/mach_reboot.h
index a955e57ad016..e23fd9fbebb3 100644
--- a/include/asm-i386/mach-default/mach_reboot.h
+++ b/include/asm-i386/mach-default/mach_reboot.h
@@ -19,14 +19,37 @@ static inline void kb_wait(void)
 static inline void mach_reboot(void)
 {
         int i;
+
+        /* old method, works on most machines */
         for (i = 0; i < 10; i++) {
                 kb_wait();
                 udelay(50);
+                outb(0xfe, 0x64);       /* pulse reset low */
+                udelay(50);
+        }
+
+        /* New method: sets the "System flag" which, when set, indicates
+         * successful completion of the keyboard controller self-test (Basic
+         * Assurance Test, BAT).  This is needed for some machines with no
+         * keyboard plugged in.  This read-modify-write sequence sets only the
+         * system flag
+         */
+        for (i = 0; i < 10; i++) {
+                int cmd;
+
+                outb(0x20, 0x64);       /* read Controller Command Byte */
+                udelay(50);
+                kb_wait();
+                udelay(50);
+                cmd = inb(0x60);
+                udelay(50);
+                kb_wait();
+                udelay(50);
                 outb(0x60, 0x64);       /* write Controller Command Byte */
                 udelay(50);
                 kb_wait();
                 udelay(50);
-                outb(0x14, 0x60);       /* set "System flag" */
+                outb(cmd | 0x04, 0x60); /* set "System flag" */
                 udelay(50);
                 kb_wait();
                 udelay(50);
diff --git a/include/asm-i386/mach-voyager/do_timer.h b/include/asm-i386/mach-voyager/do_timer.h
index 60f9dcc15d54..bc2b58926308 100644
--- a/include/asm-i386/mach-voyager/do_timer.h
+++ b/include/asm-i386/mach-voyager/do_timer.h
@@ -12,7 +12,7 @@
  **/
 static inline void do_timer_interrupt_hook(void)
 {
-        pit_interrupt_hook();
+        global_clock_event->event_handler(global_clock_event);
         voyager_timer_interrupt();
 }
 
diff --git a/include/asm-i386/mc146818rtc.h b/include/asm-i386/mc146818rtc.h
index 99a890047023..1613b42eaf58 100644
--- a/include/asm-i386/mc146818rtc.h
+++ b/include/asm-i386/mc146818rtc.h
@@ -6,6 +6,7 @@
 
 #include <asm/io.h>
 #include <asm/system.h>
+#include <asm/processor.h>
 #include <linux/mc146818rtc.h>
 
 #ifndef RTC_PORT
@@ -43,8 +44,10 @@ static inline void lock_cmos(unsigned char reg)
         unsigned long new;
         new = ((smp_processor_id()+1) << 8) | reg;
         for (;;) {
-                if (cmos_lock)
+                if (cmos_lock) {
+                        cpu_relax();
                         continue;
+                }
                 if (__cmpxchg(&cmos_lock, 0, new, sizeof(cmos_lock)) == 0)
                         return;
         }
diff --git a/include/asm-i386/page.h b/include/asm-i386/page.h
index 99cf5d3692a9..80ecc66b6d86 100644
--- a/include/asm-i386/page.h
+++ b/include/asm-i386/page.h
@@ -44,7 +44,6 @@
 extern int nx_enabled;
 
 #ifdef CONFIG_X86_PAE
-extern unsigned long long __supported_pte_mask;
 typedef struct { unsigned long pte_low, pte_high; } pte_t;
 typedef struct { unsigned long long pmd; } pmd_t;
 typedef struct { unsigned long long pgd; } pgd_t;
diff --git a/include/asm-i386/pci.h b/include/asm-i386/pci.h
index 392d3fe5d45e..d790343e9982 100644
--- a/include/asm-i386/pci.h
+++ b/include/asm-i386/pci.h
@@ -3,6 +3,11 @@
 
 
 #ifdef __KERNEL__
+
+struct pci_sysdata {
+        int             node;           /* NUMA node */
+};
+
 #include <linux/mm.h>           /* for struct page */
 
 /* Can be used to override the logic in pci_scan_bus for skipping
diff --git a/include/asm-i386/processor.h b/include/asm-i386/processor.h
index 422cffef00c9..48a7f69bb767 100644
--- a/include/asm-i386/processor.h
+++ b/include/asm-i386/processor.h
@@ -88,7 +88,6 @@ struct cpuinfo_x86 {
 #define X86_VENDOR_UMC 3
 #define X86_VENDOR_NEXGEN 4
 #define X86_VENDOR_CENTAUR 5
-#define X86_VENDOR_RISE 6
 #define X86_VENDOR_TRANSMETA 7
 #define X86_VENDOR_NSC 8
 #define X86_VENDOR_NUM 9
diff --git a/include/asm-i386/resume-trace.h b/include/asm-i386/resume-trace.h
new file mode 100644
index 000000000000..ec9cfd656230
--- /dev/null
+++ b/include/asm-i386/resume-trace.h
@@ -0,0 +1,13 @@
+#define TRACE_RESUME(user) do {                                 \
+        if (pm_trace_enabled) {                                 \
+                void *tracedata;                                \
+                asm volatile("movl $1f,%0\n"                    \
+                        ".section .tracedata,\"a\"\n"           \
+                        "1:\t.word %c1\n"                       \
+                        "\t.long %c2\n"                         \
+                        ".previous"                             \
+                        :"=r" (tracedata)                       \
+                        : "i" (__LINE__), "i" (__FILE__));      \
+                generate_resume_trace(tracedata, user);         \
+        }                                                       \
+} while (0)
diff --git a/include/asm-i386/string.h b/include/asm-i386/string.h
index b9277361954b..a9b64453bdf5 100644
--- a/include/asm-i386/string.h
+++ b/include/asm-i386/string.h
@@ -2,203 +2,35 @@
 #define _I386_STRING_H_
 
 #ifdef __KERNEL__
-/*
- * On a 486 or Pentium, we are better off not using the
- * byte string operations. But on a 386 or a PPro the
- * byte string ops are faster than doing it by hand
- * (MUCH faster on a Pentium).
- */
-
-/*
- * This string-include defines all string functions as inline
- * functions. Use gcc. It also assumes ds=es=data space, this should be
- * normal. Most of the string-functions are rather heavily hand-optimized,
- * see especially strsep,strstr,str[c]spn. They should work, but are not
- * very easy to understand. Everything is done entirely within the register
- * set, making the functions fast and clean. String instructions have been
- * used through-out, making for "slightly" unclear code :-)
- *
- *              NO Copyright (C) 1991, 1992 Linus Torvalds,
- *              consider these trivial functions to be PD.
- */
 
-/* AK: in fact I bet it would be better to move this stuff all out of line.
- */
+/* Let gcc decide wether to inline or use the out of line functions */
 
 #define __HAVE_ARCH_STRCPY
-static inline char * strcpy(char * dest,const char *src)
-{
-int d0, d1, d2;
-__asm__ __volatile__(
-        "1:\tlodsb\n\t"
-        "stosb\n\t"
-        "testb %%al,%%al\n\t"
-        "jne 1b"
-        : "=&S" (d0), "=&D" (d1), "=&a" (d2)
-        :"0" (src),"1" (dest) : "memory");
-return dest;
-}
+extern char *strcpy(char *dest, const char *src);
 
 #define __HAVE_ARCH_STRNCPY
-static inline char * strncpy(char * dest,const char *src,size_t count)
-{
-int d0, d1, d2, d3;
-__asm__ __volatile__(
-        "1:\tdecl %2\n\t"
-        "js 2f\n\t"
-        "lodsb\n\t"
-        "stosb\n\t"
-        "testb %%al,%%al\n\t"
-        "jne 1b\n\t"
-        "rep\n\t"
-        "stosb\n"
-        "2:"
-        : "=&S" (d0), "=&D" (d1), "=&c" (d2), "=&a" (d3)
-        :"0" (src),"1" (dest),"2" (count) : "memory");
-return dest;
-}
+extern char *strncpy(char *dest, const char *src, size_t count);
 
 #define __HAVE_ARCH_STRCAT
-static inline char * strcat(char * dest,const char * src)
-{
-int d0, d1, d2, d3;
-__asm__ __volatile__(
-        "repne\n\t"
-        "scasb\n\t"
-        "decl %1\n"
-        "1:\tlodsb\n\t"
-        "stosb\n\t"
-        "testb %%al,%%al\n\t"
-        "jne 1b"
-        : "=&S" (d0), "=&D" (d1), "=&a" (d2), "=&c" (d3)
-        : "0" (src), "1" (dest), "2" (0), "3" (0xffffffffu):"memory");
-return dest;
-}
+extern char *strcat(char *dest, const char *src);
 
 #define __HAVE_ARCH_STRNCAT
-static inline char * strncat(char * dest,const char * src,size_t count)
-{
-int d0, d1, d2, d3;
-__asm__ __volatile__(
-        "repne\n\t"
-        "scasb\n\t"
-        "decl %1\n\t"
-        "movl %8,%3\n"
-        "1:\tdecl %3\n\t"
-        "js 2f\n\t"
-        "lodsb\n\t"
-        "stosb\n\t"
-        "testb %%al,%%al\n\t"
-        "jne 1b\n"
-        "2:\txorl %2,%2\n\t"
-        "stosb"
-        : "=&S" (d0), "=&D" (d1), "=&a" (d2), "=&c" (d3)
-        : "0" (src),"1" (dest),"2" (0),"3" (0xffffffffu), "g" (count)
-        : "memory");
-return dest;
-}
+extern char *strncat(char *dest, const char *src, size_t count);
 
 #define __HAVE_ARCH_STRCMP
-static inline int strcmp(const char * cs,const char * ct)
-{
-int d0, d1;
-register int __res;
-__asm__ __volatile__(
-        "1:\tlodsb\n\t"
-        "scasb\n\t"
-        "jne 2f\n\t"
-        "testb %%al,%%al\n\t"
-        "jne 1b\n\t"
-        "xorl %%eax,%%eax\n\t"
-        "jmp 3f\n"
-        "2:\tsbbl %%eax,%%eax\n\t"
-        "orb $1,%%al\n"
-        "3:"
-        :"=a" (__res), "=&S" (d0), "=&D" (d1)
-        :"1" (cs),"2" (ct)
-        :"memory");
-return __res;
-}
+extern int strcmp(const char *cs, const char *ct);
 
 #define __HAVE_ARCH_STRNCMP
-static inline int strncmp(const char * cs,const char * ct,size_t count)
-{
-register int __res;
-int d0, d1, d2;
-__asm__ __volatile__(
-        "1:\tdecl %3\n\t"
-        "js 2f\n\t"
-        "lodsb\n\t"
-        "scasb\n\t"
-        "jne 3f\n\t"
-        "testb %%al,%%al\n\t"
-        "jne 1b\n"
-        "2:\txorl %%eax,%%eax\n\t"
-        "jmp 4f\n"
-        "3:\tsbbl %%eax,%%eax\n\t"
-        "orb $1,%%al\n"
-        "4:"
-        :"=a" (__res), "=&S" (d0), "=&D" (d1), "=&c" (d2)
-        :"1" (cs),"2" (ct),"3" (count)
-        :"memory");
-return __res;
-}
+extern int strncmp(const char *cs, const char *ct, size_t count);
 
 #define __HAVE_ARCH_STRCHR
-static inline char * strchr(const char * s, int c)
-{
-int d0;
-register char * __res;
-__asm__ __volatile__(
-        "movb %%al,%%ah\n"
-        "1:\tlodsb\n\t"
-        "cmpb %%ah,%%al\n\t"
-        "je 2f\n\t"
-        "testb %%al,%%al\n\t"
-        "jne 1b\n\t"
-        "movl $1,%1\n"
-        "2:\tmovl %1,%0\n\t"
-        "decl %0"
-        :"=a" (__res), "=&S" (d0)
-        :"1" (s),"0" (c)
-        :"memory");
-return __res;
-}
+extern char *strchr(const char *s, int c);
 
 #define __HAVE_ARCH_STRRCHR
-static inline char * strrchr(const char * s, int c)
-{
-int d0, d1;
-register char * __res;
-__asm__ __volatile__(
-        "movb %%al,%%ah\n"
-        "1:\tlodsb\n\t"
-        "cmpb %%ah,%%al\n\t"
-        "jne 2f\n\t"
-        "leal -1(%%esi),%0\n"
-        "2:\ttestb %%al,%%al\n\t"
-        "jne 1b"
-        :"=g" (__res), "=&S" (d0), "=&a" (d1)
-        :"0" (0),"1" (s),"2" (c)
-        :"memory");
-return __res;
-}
+extern char *strrchr(const char *s, int c);
 
 #define __HAVE_ARCH_STRLEN
-static inline size_t strlen(const char * s)
-{
-int d0;
-register int __res;
-__asm__ __volatile__(
-        "repne\n\t"
-        "scasb\n\t"
-        "notl %0\n\t"
-        "decl %0"
-        :"=c" (__res), "=&D" (d0)
-        :"1" (s),"a" (0), "0" (0xffffffffu)
-        :"memory");
-return __res;
-}
+extern size_t strlen(const char *s);
 
 static __always_inline void * __memcpy(void * to, const void * from, size_t n)
 {
@@ -207,9 +39,7 @@ __asm__ __volatile__(
         "rep ; movsl\n\t"
         "movl %4,%%ecx\n\t"
         "andl $3,%%ecx\n\t"
-#if 1   /* want to pay 2 byte penalty for a chance to skip microcoded rep? */
         "jz 1f\n\t"
-#endif
         "rep ; movsb\n\t"
         "1:"
         : "=&c" (d0), "=&D" (d1), "=&S" (d2)
@@ -328,23 +158,7 @@ void *memmove(void * dest,const void * src, size_t n);
 #define memcmp __builtin_memcmp
 
 #define __HAVE_ARCH_MEMCHR
-static inline void * memchr(const void * cs,int c,size_t count)
-{
-int d0;
-register void * __res;
-if (!count)
-        return NULL;
-__asm__ __volatile__(
-        "repne\n\t"
-        "scasb\n\t"
-        "je 1f\n\t"
-        "movl $1,%0\n"
-        "1:\tdecl %0"
-        :"=D" (__res), "=&c" (d0)
-        :"a" (c),"0" (cs),"1" (count)
-        :"memory");
-return __res;
-}
+extern void *memchr(const void * cs,int c,size_t count);
 
 static inline void * __memset_generic(void * s, char c,size_t count)
 {
@@ -386,29 +200,10 @@ return (s);
 
 /* Added by Gertjan van Wingerde to make minix and sysv module work */
 #define __HAVE_ARCH_STRNLEN
-static inline size_t strnlen(const char * s, size_t count)
-{
-int d0;
-register int __res;
-__asm__ __volatile__(
-        "movl %2,%0\n\t"
-        "jmp 2f\n"
-        "1:\tcmpb $0,(%0)\n\t"
-        "je 3f\n\t"
-        "incl %0\n"
-        "2:\tdecl %1\n\t"
-        "cmpl $-1,%1\n\t"
-        "jne 1b\n"
-        "3:\tsubl %2,%0"
-        :"=a" (__res), "=&d" (d0)
-        :"c" (s),"1" (count)
-        :"memory");
-return __res;
-}
+extern size_t strnlen(const char * s, size_t count);
 /* end of additional stuff */
 
 #define __HAVE_ARCH_STRSTR
-
 extern char *strstr(const char *cs, const char *ct);
 
 /*
@@ -474,19 +269,7 @@ __asm__  __volatile__( \
  * find the first occurrence of byte 'c', or 1 past the area if none
  */
 #define __HAVE_ARCH_MEMSCAN
-static inline void * memscan(void * addr, int c, size_t size)
-{
-        if (!size)
-                return addr;
-        __asm__("repnz; scasb\n\t"
-                "jnz 1f\n\t"
-                "dec %%edi\n"
-                "1:"
-                : "=D" (addr), "=c" (size)
-                : "0" (addr), "1" (size), "a" (c)
-                : "memory");
-        return addr;
-}
+extern void *memscan(void * addr, int c, size_t size);
 
 #endif /* __KERNEL__ */
 
diff --git a/include/asm-i386/timer.h b/include/asm-i386/timer.h
index 51a713e33a9e..0db7e994fb8b 100644
--- a/include/asm-i386/timer.h
+++ b/include/asm-i386/timer.h
@@ -5,13 +5,11 @@
 
 #define TICK_SIZE (tick_nsec / 1000)
 
-void setup_pit_timer(void);
 unsigned long long native_sched_clock(void);
 unsigned long native_calculate_cpu_khz(void);
 
 extern int timer_ack;
 extern int no_timer_check;
-extern int no_sync_cmos_clock;
 extern int recalibrate_cpu_khz(void);
 
 #ifndef CONFIG_PARAVIRT
diff --git a/include/asm-i386/tlbflush.h b/include/asm-i386/tlbflush.h
index fc525c5cd5a9..a50fa6741486 100644
--- a/include/asm-i386/tlbflush.h
+++ b/include/asm-i386/tlbflush.h
@@ -160,7 +160,11 @@ DECLARE_PER_CPU(struct tlb_state, cpu_tlbstate);
         native_flush_tlb_others(&mask, mm, va)
 #endif
 
-#define flush_tlb_kernel_range(start, end) flush_tlb_all()
+static inline void flush_tlb_kernel_range(unsigned long start,
+                                        unsigned long end)
+{
+        flush_tlb_all();
+}
 
 static inline void flush_tlb_pgtables(struct mm_struct *mm,
                                       unsigned long start, unsigned long end)
diff --git a/include/asm-i386/topology.h b/include/asm-i386/topology.h
index 7fc512d90ea8..19b2dafd0c81 100644
--- a/include/asm-i386/topology.h
+++ b/include/asm-i386/topology.h
@@ -67,7 +67,7 @@ static inline int node_to_first_cpu(int node)
         return first_cpu(mask);
 }
 
-#define pcibus_to_node(bus) ((long) (bus)->sysdata)
+#define pcibus_to_node(bus) ((struct pci_sysdata *)((bus)->sysdata))->node
 #define pcibus_to_cpumask(bus) node_to_cpumask(pcibus_to_node(bus))
 
 /* sched_domains SD_NODE_INIT for NUMAQ machines */
diff --git a/include/asm-i386/uaccess.h b/include/asm-i386/uaccess.h
index e2aa5e0d0cc7..d2a4f7be9c2c 100644
--- a/include/asm-i386/uaccess.h
+++ b/include/asm-i386/uaccess.h
@@ -581,7 +581,7 @@ long __must_check __strncpy_from_user(char *dst,
  * If there is a limit on the length of a valid string, you may wish to
  * consider using strnlen_user() instead.
  */
-#define strlen_user(str) strnlen_user(str, ~0UL >> 1)
+#define strlen_user(str) strnlen_user(str, LONG_MAX)
 
 long strnlen_user(const char __user *str, long n);
 unsigned long __must_check clear_user(void __user *mem, unsigned long len);
diff --git a/include/asm-sparc/irq.h b/include/asm-sparc/irq.h
index ff520ea97473..afb88a5973f0 100644
--- a/include/asm-sparc/irq.h
+++ b/include/asm-sparc/irq.h
@@ -7,178 +7,16 @@
 #ifndef _SPARC_IRQ_H
 #define _SPARC_IRQ_H
 
-#include <linux/linkage.h>
-#include <linux/threads.h>     /* For NR_CPUS */
 #include <linux/interrupt.h>
 
-#include <asm/system.h>     /* For SUN4M_NCPUS */
-#include <asm/btfixup.h>
-
-#define __irq_ino(irq) irq
-#define __irq_pil(irq) irq
-
 #define NR_IRQS    16
 
 #define irq_canonicalize(irq)   (irq)
 
-/* Dave Redman (djhr@tadpole.co.uk)
- * changed these to function pointers.. it saves cycles and will allow
- * the irq dependencies to be split into different files at a later date
- * sun4c_irq.c, sun4m_irq.c etc so we could reduce the kernel size.
- * Jakub Jelinek (jj@sunsite.mff.cuni.cz)
- * Changed these to btfixup entities... It saves cycles :)
- */
-BTFIXUPDEF_CALL(void, disable_irq, unsigned int)
-BTFIXUPDEF_CALL(void, enable_irq, unsigned int)
-BTFIXUPDEF_CALL(void, disable_pil_irq, unsigned int)
-BTFIXUPDEF_CALL(void, enable_pil_irq, unsigned int)
-BTFIXUPDEF_CALL(void, clear_clock_irq, void)
-BTFIXUPDEF_CALL(void, clear_profile_irq, int)
-BTFIXUPDEF_CALL(void, load_profile_irq, int, unsigned int)
-
-static inline void disable_irq_nosync(unsigned int irq)
-{
-        BTFIXUP_CALL(disable_irq)(irq);
-}
-
-static inline void disable_irq(unsigned int irq)
-{
-        BTFIXUP_CALL(disable_irq)(irq);
-}
-
-static inline void enable_irq(unsigned int irq)
-{
-        BTFIXUP_CALL(enable_irq)(irq);
-}
-
-static inline void disable_pil_irq(unsigned int irq)
-{
-        BTFIXUP_CALL(disable_pil_irq)(irq);
-}
-
-static inline void enable_pil_irq(unsigned int irq)
-{
-        BTFIXUP_CALL(enable_pil_irq)(irq);
-}
-
-static inline void clear_clock_irq(void)
-{
-        BTFIXUP_CALL(clear_clock_irq)();
-}
-
-static inline void clear_profile_irq(int irq)
-{
-        BTFIXUP_CALL(clear_profile_irq)(irq);
-}
-
-static inline void load_profile_irq(int cpu, int limit)
-{
-        BTFIXUP_CALL(load_profile_irq)(cpu, limit);
-}
-
-extern void (*sparc_init_timers)(irq_handler_t lvl10_irq);
-extern void claim_ticker14(irq_handler_t irq_handler,
-                           int irq,
-                           unsigned int timeout);
-
-#ifdef CONFIG_SMP
-BTFIXUPDEF_CALL(void, set_cpu_int, int, int)
-BTFIXUPDEF_CALL(void, clear_cpu_int, int, int)
-BTFIXUPDEF_CALL(void, set_irq_udt, int)
-
-#define set_cpu_int(cpu,level) BTFIXUP_CALL(set_cpu_int)(cpu,level)
-#define clear_cpu_int(cpu,level) BTFIXUP_CALL(clear_cpu_int)(cpu,level)
-#define set_irq_udt(cpu) BTFIXUP_CALL(set_irq_udt)(cpu)
-#endif
+extern void disable_irq_nosync(unsigned int irq);
+extern void disable_irq(unsigned int irq);
+extern void enable_irq(unsigned int irq);
 
 extern int request_fast_irq(unsigned int irq, irq_handler_t handler, unsigned long flags, __const__ char *devname);
 
-/* On the sun4m, just like the timers, we have both per-cpu and master
- * interrupt registers.
- */
-
-/* These registers are used for sending/receiving irqs from/to
- * different cpu's.
- */
-struct sun4m_intreg_percpu {
-        unsigned int tbt;        /* Interrupts still pending for this cpu. */
-
-        /* These next two registers are WRITE-ONLY and are only
-         * "on bit" sensitive, "off bits" written have NO affect.
-         */
-        unsigned int clear;  /* Clear this cpus irqs here. */
-        unsigned int set;    /* Set this cpus irqs here. */
-        unsigned char space[PAGE_SIZE - 12];
-};
-
-/*
- * djhr
- * Actually the clear and set fields in this struct are misleading..
- * according to the SLAVIO manual (and the same applies for the SEC)
- * the clear field clears bits in the mask which will ENABLE that IRQ
- * the set field sets bits in the mask to DISABLE the IRQ.
- *
- * Also the undirected_xx address in the SLAVIO is defined as
- * RESERVED and write only..
- *
- * DAVEM_NOTE: The SLAVIO only specifies behavior on uniprocessor
- *             sun4m machines, for MP the layout makes more sense.
- */
-struct sun4m_intregs {
-        struct sun4m_intreg_percpu cpu_intregs[SUN4M_NCPUS];
-        unsigned int tbt;                /* IRQ's that are still pending. */
-        unsigned int irqs;               /* Master IRQ bits. */
-
-        /* Again, like the above, two these registers are WRITE-ONLY. */
-        unsigned int clear;              /* Clear master IRQ's by setting bits here. */
-        unsigned int set;                /* Set master IRQ's by setting bits here. */
-
-        /* This register is both READ and WRITE. */
-        unsigned int undirected_target;  /* Which cpu gets undirected irqs. */
-};
-
-extern struct sun4m_intregs *sun4m_interrupts;
-
-/* 
- * Bit field defines for the interrupt registers on various
- * Sparc machines.
- */
-
-/* The sun4c interrupt register. */
-#define SUN4C_INT_ENABLE  0x01     /* Allow interrupts. */
-#define SUN4C_INT_E14     0x80     /* Enable level 14 IRQ. */
-#define SUN4C_INT_E10     0x20     /* Enable level 10 IRQ. */
-#define SUN4C_INT_E8      0x10     /* Enable level 8 IRQ. */
-#define SUN4C_INT_E6      0x08     /* Enable level 6 IRQ. */
-#define SUN4C_INT_E4      0x04     /* Enable level 4 IRQ. */
-#define SUN4C_INT_E1      0x02     /* Enable level 1 IRQ. */
-
-/* Dave Redman (djhr@tadpole.co.uk)
- * The sun4m interrupt registers.
- */
-#define SUN4M_INT_ENABLE        0x80000000
-#define SUN4M_INT_E14           0x00000080
-#define SUN4M_INT_E10           0x00080000
-
-#define SUN4M_HARD_INT(x)       (0x000000001 << (x))
-#define SUN4M_SOFT_INT(x)       (0x000010000 << (x))
-
-#define SUN4M_INT_MASKALL       0x80000000        /* mask all interrupts */
-#define SUN4M_INT_MODULE_ERR    0x40000000        /* module error */
-#define SUN4M_INT_M2S_WRITE     0x20000000        /* write buffer error */
-#define SUN4M_INT_ECC           0x10000000        /* ecc memory error */
-#define SUN4M_INT_FLOPPY        0x00400000        /* floppy disk */
-#define SUN4M_INT_MODULE        0x00200000        /* module interrupt */
-#define SUN4M_INT_VIDEO         0x00100000        /* onboard video */
-#define SUN4M_INT_REALTIME      0x00080000        /* system timer */
-#define SUN4M_INT_SCSI          0x00040000        /* onboard scsi */
-#define SUN4M_INT_AUDIO         0x00020000        /* audio/isdn */
-#define SUN4M_INT_ETHERNET      0x00010000        /* onboard ethernet */
-#define SUN4M_INT_SERIAL        0x00008000        /* serial ports */
-#define SUN4M_INT_KBDMS         0x00004000        /* keyboard/mouse */
-#define SUN4M_INT_SBUSBITS      0x00003F80        /* sbus int bits */
-
-#define SUN4M_INT_SBUS(x)       (1 << (x+7))
-#define SUN4M_INT_VME(x)        (1 << (x))
-
 #endif
diff --git a/include/asm-sparc/pgtable.h b/include/asm-sparc/pgtable.h
index a55f4c3488b0..2cc235b74d94 100644
--- a/include/asm-sparc/pgtable.h
+++ b/include/asm-sparc/pgtable.h
@@ -46,7 +46,6 @@ BTFIXUPDEF_SIMM13(user_ptrs_per_pgd)
 #define pgd_ERROR(e)   __builtin_trap()
 
 BTFIXUPDEF_INT(page_none)
-BTFIXUPDEF_INT(page_shared)
 BTFIXUPDEF_INT(page_copy)
 BTFIXUPDEF_INT(page_readonly)
 BTFIXUPDEF_INT(page_kernel)
@@ -66,7 +65,7 @@ BTFIXUPDEF_INT(page_kernel)
 #define PTE_SIZE                (PTRS_PER_PTE*4)
 
 #define PAGE_NONE      __pgprot(BTFIXUP_INT(page_none))
-#define PAGE_SHARED    __pgprot(BTFIXUP_INT(page_shared))
+extern pgprot_t PAGE_SHARED;
 #define PAGE_COPY      __pgprot(BTFIXUP_INT(page_copy))
 #define PAGE_READONLY  __pgprot(BTFIXUP_INT(page_readonly))
 
diff --git a/include/asm-x86_64/acpi.h b/include/asm-x86_64/acpi.h
index a29f05087a31..1da8f49c0fe2 100644
--- a/include/asm-x86_64/acpi.h
+++ b/include/asm-x86_64/acpi.h
@@ -29,6 +29,7 @@
 #ifdef __KERNEL__
 
 #include <acpi/pdc_intel.h>
+#include <asm/numa.h>
 
 #define COMPILER_DEPENDENT_INT64   long long
 #define COMPILER_DEPENDENT_UINT64  unsigned long long
@@ -141,6 +142,16 @@ extern int acpi_pci_disabled;
 extern int acpi_skip_timer_override;
 extern int acpi_use_timer_override;
 
+#ifdef CONFIG_ACPI_NUMA
+extern void __init acpi_fake_nodes(const struct bootnode *fake_nodes,
+                                   int num_nodes);
+#else
+static inline void acpi_fake_nodes(const struct bootnode *fake_nodes,
+                                   int num_nodes)
+{
+}
+#endif
+
 #endif /*__KERNEL__*/
 
 #endif /*_ASM_ACPI_H*/
diff --git a/include/asm-x86_64/apic.h b/include/asm-x86_64/apic.h
index 45e9fca1febc..85125ef3c414 100644
--- a/include/asm-x86_64/apic.h
+++ b/include/asm-x86_64/apic.h
@@ -83,8 +83,10 @@ extern void disable_APIC_timer(void);
 extern void enable_APIC_timer(void);
 extern void setup_apic_routing(void);
 
-extern void setup_APIC_extened_lvt(unsigned char lvt_off, unsigned char vector,
-                                   unsigned char msg_type, unsigned char mask);
+extern void setup_APIC_extended_lvt(unsigned char lvt_off, unsigned char vector,
+                                    unsigned char msg_type, unsigned char mask);
+
+extern int apic_is_clustered_box(void);
 
 #define K8_APIC_EXT_LVT_BASE    0x500
 #define K8_APIC_EXT_INT_MSG_FIX 0x0
diff --git a/include/asm-x86_64/auxvec.h b/include/asm-x86_64/auxvec.h
index 2403c4cfced2..1d5ab0d03950 100644
--- a/include/asm-x86_64/auxvec.h
+++ b/include/asm-x86_64/auxvec.h
@@ -1,4 +1,6 @@
 #ifndef __ASM_X86_64_AUXVEC_H
 #define __ASM_X86_64_AUXVEC_H
 
+#define AT_SYSINFO_EHDR         33
+
 #endif
diff --git a/include/asm-x86_64/calgary.h b/include/asm-x86_64/calgary.h
index 4d5747a0923c..67f60406e2d8 100644
--- a/include/asm-x86_64/calgary.h
+++ b/include/asm-x86_64/calgary.h
@@ -1,7 +1,7 @@
 /*
  * Derived from include/asm-powerpc/iommu.h
  *
- * Copyright (C) IBM Corporation, 2006
+ * Copyright IBM Corporation, 2006-2007
  *
  * Author: Jon Mason <jdmason@us.ibm.com>
  * Author: Muli Ben-Yehuda <muli@il.ibm.com>
@@ -31,6 +31,7 @@
 #include <asm/types.h>
 
 struct iommu_table {
+        struct cal_chipset_ops *chip_ops; /* chipset specific funcs */
         unsigned long  it_base;      /* mapped address of tce table */
         unsigned long  it_hint;      /* Hint for next alloc */
         unsigned long *it_map;       /* A simple allocation bitmap for now */
@@ -42,6 +43,12 @@ struct iommu_table {
         unsigned char  it_busno;     /* Bus number this table belongs to */
 };
 
+struct cal_chipset_ops {
+        void (*handle_quirks)(struct iommu_table *tbl, struct pci_dev *dev);
+        void (*tce_cache_blast)(struct iommu_table *tbl);
+        void (*dump_error_regs)(struct iommu_table *tbl);
+};
+
 #define TCE_TABLE_SIZE_UNSPECIFIED      ~0
 #define TCE_TABLE_SIZE_64K              0
 #define TCE_TABLE_SIZE_128K             1
diff --git a/include/asm-x86_64/dmi.h b/include/asm-x86_64/dmi.h
index 93b2b15d4325..d02e32e3c3f0 100644
--- a/include/asm-x86_64/dmi.h
+++ b/include/asm-x86_64/dmi.h
@@ -3,15 +3,12 @@
 
 #include <asm/io.h>
 
-extern void *dmi_ioremap(unsigned long addr, unsigned long size);
-extern void dmi_iounmap(void *addr, unsigned long size);
-
 #define DMI_MAX_DATA 2048
 
 extern int dmi_alloc_index;
 extern char dmi_alloc_data[DMI_MAX_DATA];
 
-/* This is so early that there is no good way to allocate dynamic memory. 
+/* This is so early that there is no good way to allocate dynamic memory.
    Allocate data in an BSS array. */
 static inline void *dmi_alloc(unsigned len)
 {
diff --git a/include/asm-x86_64/elf.h b/include/asm-x86_64/elf.h
index 6d24ea7c4d9d..b4fbe47f6ccd 100644
--- a/include/asm-x86_64/elf.h
+++ b/include/asm-x86_64/elf.h
@@ -162,6 +162,19 @@ extern int dump_task_fpu (struct task_struct *, elf_fpregset_t *);
 /* 1GB for 64bit, 8MB for 32bit */
 #define STACK_RND_MASK (test_thread_flag(TIF_IA32) ? 0x7ff : 0x3fffff)
 
+
+#define ARCH_HAS_SETUP_ADDITIONAL_PAGES 1
+struct linux_binprm;
+extern int arch_setup_additional_pages(struct linux_binprm *bprm,
+                                       int executable_stack);
+
+extern int vdso_enabled;
+
+#define ARCH_DLINFO                                             \
+do if (vdso_enabled) {                                          \
+        NEW_AUX_ENT(AT_SYSINFO_EHDR,(unsigned long)current->mm->context.vdso);\
+} while (0)
+
 #endif
 
 #endif
diff --git a/include/asm-x86_64/fixmap.h b/include/asm-x86_64/fixmap.h
index 2acb9b7f6418..cdfbe4a6ae6f 100644
--- a/include/asm-x86_64/fixmap.h
+++ b/include/asm-x86_64/fixmap.h
@@ -22,9 +22,9 @@
  * compile time, but to set the physical address only
  * in the boot process.
  *
- * these 'compile-time allocated' memory buffers are
- * fixed-size 4k pages. (or larger if used with an increment
- * highger than 1) use fixmap_set(idx,phys) to associate
+ * These 'compile-time allocated' memory buffers are
+ * fixed-size 4k pages (or larger if used with an increment
+ * higher than 1). Use set_fixmap(idx,phys) to associate
  * physical memory with fixmap indices.
  *
  * TLB entries of such buffers will not be flushed across
diff --git a/include/asm-x86_64/hpet.h b/include/asm-x86_64/hpet.h
index 59a66f084611..79bb950f82c5 100644
--- a/include/asm-x86_64/hpet.h
+++ b/include/asm-x86_64/hpet.h
@@ -1,78 +1,18 @@
 #ifndef _ASM_X8664_HPET_H
 #define _ASM_X8664_HPET_H 1
 
-/*
- * Documentation on HPET can be found at:
- *      http://www.intel.com/ial/home/sp/pcmmspec.htm
- *      ftp://download.intel.com/ial/home/sp/mmts098.pdf
- */
-
-#define HPET_MMAP_SIZE  1024
-
-#define HPET_ID         0x000
-#define HPET_PERIOD     0x004
-#define HPET_CFG        0x010
-#define HPET_STATUS     0x020
-#define HPET_COUNTER    0x0f0
-#define HPET_Tn_OFFSET  0x20
-#define HPET_Tn_CFG(n)   (0x100 + (n) * HPET_Tn_OFFSET)
-#define HPET_Tn_ROUTE(n) (0x104 + (n) * HPET_Tn_OFFSET)
-#define HPET_Tn_CMP(n)   (0x108 + (n) * HPET_Tn_OFFSET)
-#define HPET_T0_CFG     HPET_Tn_CFG(0)
-#define HPET_T0_CMP     HPET_Tn_CMP(0)
-#define HPET_T1_CFG     HPET_Tn_CFG(1)
-#define HPET_T1_CMP     HPET_Tn_CMP(1)
-
-#define HPET_ID_VENDOR  0xffff0000
-#define HPET_ID_LEGSUP  0x00008000
-#define HPET_ID_64BIT   0x00002000
-#define HPET_ID_NUMBER  0x00001f00
-#define HPET_ID_REV     0x000000ff
-#define HPET_ID_NUMBER_SHIFT    8
-
-#define HPET_ID_VENDOR_SHIFT    16
-#define HPET_ID_VENDOR_8086     0x8086
-
-#define HPET_CFG_ENABLE 0x001
-#define HPET_CFG_LEGACY 0x002
-#define HPET_LEGACY_8254        2
-#define HPET_LEGACY_RTC         8
-
-#define HPET_TN_LEVEL           0x0002
-#define HPET_TN_ENABLE          0x0004
-#define HPET_TN_PERIODIC        0x0008
-#define HPET_TN_PERIODIC_CAP    0x0010
-#define HPET_TN_64BIT_CAP       0x0020
-#define HPET_TN_SETVAL          0x0040
-#define HPET_TN_32BIT           0x0100
-#define HPET_TN_ROUTE           0x3e00
-#define HPET_TN_FSB             0x4000
-#define HPET_TN_FSB_CAP         0x8000
-
-#define HPET_TN_ROUTE_SHIFT     9
+#include <asm-i386/hpet.h>
 
 #define HPET_TICK_RATE (HZ * 100000UL)
 
-extern int is_hpet_enabled(void);
 extern int hpet_rtc_timer_init(void);
-extern int apic_is_clustered_box(void);
 extern int hpet_arch_init(void);
 extern int hpet_timer_stop_set_go(unsigned long tick);
 extern int hpet_reenable(void);
 extern unsigned int hpet_calibrate_tsc(void);
 
 extern int hpet_use_timer;
-extern unsigned long hpet_address;
 extern unsigned long hpet_period;
 extern unsigned long hpet_tick;
 
-#ifdef CONFIG_HPET_EMULATE_RTC
-extern int hpet_mask_rtc_irq_bit(unsigned long bit_mask);
-extern int hpet_set_rtc_irq_bit(unsigned long bit_mask);
-extern int hpet_set_alarm_time(unsigned char hrs, unsigned char min, unsigned char sec);
-extern int hpet_set_periodic_freq(unsigned long freq);
-extern int hpet_rtc_dropped_irq(void);
-extern int hpet_rtc_timer_init(void);
-#endif /* CONFIG_HPET_EMULATE_RTC */
-
 #endif
diff --git a/include/asm-x86_64/hw_irq.h b/include/asm-x86_64/hw_irq.h
index 6153ae5df2e8..09dfc18a6dd0 100644
--- a/include/asm-x86_64/hw_irq.h
+++ b/include/asm-x86_64/hw_irq.h
@@ -95,6 +95,26 @@
 
 
 #ifndef __ASSEMBLY__
+
+/* Interrupt handlers registered during init_IRQ */
+void apic_timer_interrupt(void);
+void spurious_interrupt(void);
+void error_interrupt(void);
+void reschedule_interrupt(void);
+void call_function_interrupt(void);
+void irq_move_cleanup_interrupt(void);
+void invalidate_interrupt0(void);
+void invalidate_interrupt1(void);
+void invalidate_interrupt2(void);
+void invalidate_interrupt3(void);
+void invalidate_interrupt4(void);
+void invalidate_interrupt5(void);
+void invalidate_interrupt6(void);
+void invalidate_interrupt7(void);
+void thermal_interrupt(void);
+void threshold_interrupt(void);
+void i8254_timer_resume(void);
+
 typedef int vector_irq_t[NR_VECTORS];
 DECLARE_PER_CPU(vector_irq_t, vector_irq);
 extern void __setup_vector_irq(int cpu);
diff --git a/include/asm-x86_64/i8253.h b/include/asm-x86_64/i8253.h
new file mode 100644
index 000000000000..015d8df07690
--- /dev/null
+++ b/include/asm-x86_64/i8253.h
@@ -0,0 +1,6 @@
+#ifndef __ASM_I8253_H__
+#define __ASM_I8253_H__
+
+extern spinlock_t i8253_lock;
+
+#endif  /* __ASM_I8253_H__ */
diff --git a/include/asm-x86_64/iommu.h b/include/asm-x86_64/iommu.h
new file mode 100644
index 000000000000..5af471f228ee
--- /dev/null
+++ b/include/asm-x86_64/iommu.h
@@ -0,0 +1,29 @@
+#ifndef _ASM_X8664_IOMMU_H
+#define _ASM_X8664_IOMMU_H 1
+
+extern void pci_iommu_shutdown(void);
+extern void no_iommu_init(void);
+extern int force_iommu, no_iommu;
+extern int iommu_detected;
+#ifdef CONFIG_IOMMU
+extern void gart_iommu_init(void);
+extern void gart_iommu_shutdown(void);
+extern void __init gart_parse_options(char *);
+extern void iommu_hole_init(void);
+extern int fallback_aper_order;
+extern int fallback_aper_force;
+extern int iommu_aperture;
+extern int iommu_aperture_allowed;
+extern int iommu_aperture_disabled;
+extern int fix_aperture;
+#else
+#define iommu_aperture 0
+#define iommu_aperture_allowed 0
+
+static inline void gart_iommu_shutdown(void)
+{
+}
+
+#endif
+
+#endif
diff --git a/include/asm-x86_64/mce.h b/include/asm-x86_64/mce.h
index 177e92b4019b..556be5563e30 100644
--- a/include/asm-x86_64/mce.h
+++ b/include/asm-x86_64/mce.h
@@ -105,6 +105,8 @@ extern atomic_t mce_entry;
 
 extern void do_machine_check(struct pt_regs *, long);
 
+extern int mce_notify_user(void);
+
 #endif
 
 #endif
diff --git a/include/asm-x86_64/mmu.h b/include/asm-x86_64/mmu.h
index 5dc6ed79859a..d2cd4a9d984d 100644
--- a/include/asm-x86_64/mmu.h
+++ b/include/asm-x86_64/mmu.h
@@ -15,6 +15,7 @@ typedef struct {
         rwlock_t ldtlock; 
         int size;
         struct semaphore sem; 
+        void *vdso;
 } mm_context_t;
 
 #endif
diff --git a/include/asm-x86_64/pci.h b/include/asm-x86_64/pci.h
index bda94fd5176f..88926eb44f5c 100644
--- a/include/asm-x86_64/pci.h
+++ b/include/asm-x86_64/pci.h
@@ -5,6 +5,25 @@
 
 #ifdef __KERNEL__
 
+struct pci_sysdata {
+        int             node;           /* NUMA node */
+        void*           iommu;          /* IOMMU private data */
+};
+
+#ifdef CONFIG_CALGARY_IOMMU
+static inline void* pci_iommu(struct pci_bus *bus)
+{
+        struct pci_sysdata *sd = bus->sysdata;
+        return sd->iommu;
+}
+
+static inline void set_pci_iommu(struct pci_bus *bus, void *val)
+{
+        struct pci_sysdata *sd = bus->sysdata;
+        sd->iommu = val;
+}
+#endif /* CONFIG_CALGARY_IOMMU */
+
 #include <linux/mm.h> /* for struct page */
 
 /* Can be used to override the logic in pci_scan_bus for skipping
diff --git a/include/asm-x86_64/pgalloc.h b/include/asm-x86_64/pgalloc.h
index 8bb564687860..b467be6d367f 100644
--- a/include/asm-x86_64/pgalloc.h
+++ b/include/asm-x86_64/pgalloc.h
@@ -4,6 +4,10 @@
 #include <asm/pda.h>
 #include <linux/threads.h>
 #include <linux/mm.h>
+#include <linux/quicklist.h>
+
+#define QUICK_PGD 0     /* We preserve special mappings over free */
+#define QUICK_PT 1      /* Other page table pages that are zero on free */
 
 #define pmd_populate_kernel(mm, pmd, pte) \
                 set_pmd(pmd, __pmd(_PAGE_TABLE | __pa(pte)))
@@ -20,23 +24,23 @@ static inline void pmd_populate(struct mm_struct *mm, pmd_t *pmd, struct page *p
 static inline void pmd_free(pmd_t *pmd)
 {
         BUG_ON((unsigned long)pmd & (PAGE_SIZE-1));
-        free_page((unsigned long)pmd);
+        quicklist_free(QUICK_PT, NULL, pmd);
 }
 
 static inline pmd_t *pmd_alloc_one (struct mm_struct *mm, unsigned long addr)
 {
-        return (pmd_t *)get_zeroed_page(GFP_KERNEL|__GFP_REPEAT);
+        return (pmd_t *)quicklist_alloc(QUICK_PT, GFP_KERNEL|__GFP_REPEAT, NULL);
 }
 
 static inline pud_t *pud_alloc_one(struct mm_struct *mm, unsigned long addr)
 {
-        return (pud_t *)get_zeroed_page(GFP_KERNEL|__GFP_REPEAT);
+        return (pud_t *)quicklist_alloc(QUICK_PT, GFP_KERNEL|__GFP_REPEAT, NULL);
 }
 
 static inline void pud_free (pud_t *pud)
 {
         BUG_ON((unsigned long)pud & (PAGE_SIZE-1));
-        free_page((unsigned long)pud);
+        quicklist_free(QUICK_PT, NULL, pud);
 }
 
 static inline void pgd_list_add(pgd_t *pgd)
@@ -57,41 +61,57 @@ static inline void pgd_list_del(pgd_t *pgd)
         spin_unlock(&pgd_lock);
 }
 
-static inline pgd_t *pgd_alloc(struct mm_struct *mm)
+static inline void pgd_ctor(void *x)
 {
         unsigned boundary;
-        pgd_t *pgd = (pgd_t *)__get_free_page(GFP_KERNEL|__GFP_REPEAT);
-        if (!pgd)
-                return NULL;
-        pgd_list_add(pgd);
+        pgd_t *pgd = x;
+        struct page *page = virt_to_page(pgd);
+
         /*
          * Copy kernel pointers in from init.
-         * Could keep a freelist or slab cache of those because the kernel
-         * part never changes.
          */
         boundary = pgd_index(__PAGE_OFFSET);
-        memset(pgd, 0, boundary * sizeof(pgd_t));
         memcpy(pgd + boundary,
-               init_level4_pgt + boundary,
-               (PTRS_PER_PGD - boundary) * sizeof(pgd_t));
+                init_level4_pgt + boundary,
+                (PTRS_PER_PGD - boundary) * sizeof(pgd_t));
+
+        spin_lock(&pgd_lock);
+        list_add(&page->lru, &pgd_list);
+        spin_unlock(&pgd_lock);
+}
+
+static inline void pgd_dtor(void *x)
+{
+        pgd_t *pgd = x;
+        struct page *page = virt_to_page(pgd);
+
+        spin_lock(&pgd_lock);
+        list_del(&page->lru);
+        spin_unlock(&pgd_lock);
+}
+
+static inline pgd_t *pgd_alloc(struct mm_struct *mm)
+{
+        pgd_t *pgd = (pgd_t *)quicklist_alloc(QUICK_PGD,
+                GFP_KERNEL|__GFP_REPEAT, pgd_ctor);
         return pgd;
 }
 
 static inline void pgd_free(pgd_t *pgd)
 {
         BUG_ON((unsigned long)pgd & (PAGE_SIZE-1));
-        pgd_list_del(pgd);
-        free_page((unsigned long)pgd);
+        quicklist_free(QUICK_PGD, pgd_dtor, pgd);
 }
 
 static inline pte_t *pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address)
 {
-        return (pte_t *)get_zeroed_page(GFP_KERNEL|__GFP_REPEAT);
+        return (pte_t *)quicklist_alloc(QUICK_PT, GFP_KERNEL|__GFP_REPEAT, NULL);
 }
 
 static inline struct page *pte_alloc_one(struct mm_struct *mm, unsigned long address)
 {
-        void *p = (void *)get_zeroed_page(GFP_KERNEL|__GFP_REPEAT);
+        void *p = (void *)quicklist_alloc(QUICK_PT, GFP_KERNEL|__GFP_REPEAT, NULL);
+
         if (!p)
                 return NULL;
         return virt_to_page(p);
@@ -103,17 +123,22 @@ static inline struct page *pte_alloc_one(struct mm_struct *mm, unsigned long add
 static inline void pte_free_kernel(pte_t *pte)
 {
         BUG_ON((unsigned long)pte & (PAGE_SIZE-1));
-        free_page((unsigned long)pte); 
+        quicklist_free(QUICK_PT, NULL, pte);
 }
 
 static inline void pte_free(struct page *pte)
 {
-        __free_page(pte);
-} 
+        quicklist_free_page(QUICK_PT, NULL, pte);
+}
 
-#define __pte_free_tlb(tlb,pte) tlb_remove_page((tlb),(pte))
+#define __pte_free_tlb(tlb,pte) quicklist_free_page(QUICK_PT, NULL,(pte))
 
-#define __pmd_free_tlb(tlb,x)   tlb_remove_page((tlb),virt_to_page(x))
-#define __pud_free_tlb(tlb,x)   tlb_remove_page((tlb),virt_to_page(x))
+#define __pmd_free_tlb(tlb,x)   quicklist_free(QUICK_PT, NULL, (x))
+#define __pud_free_tlb(tlb,x)   quicklist_free(QUICK_PT, NULL, (x))
 
+static inline void check_pgt_cache(void)
+{
+        quicklist_trim(QUICK_PGD, pgd_dtor, 25, 16);
+        quicklist_trim(QUICK_PT, NULL, 25, 16);
+}
 #endif /* _X86_64_PGALLOC_H */
diff --git a/include/asm-x86_64/pgtable.h b/include/asm-x86_64/pgtable.h
index 3ba53099297d..60cff1e4f7a3 100644
--- a/include/asm-x86_64/pgtable.h
+++ b/include/asm-x86_64/pgtable.h
@@ -409,7 +409,6 @@ extern int kern_addr_valid(unsigned long addr);
 #define HAVE_ARCH_UNMAPPED_AREA
 
 #define pgtable_cache_init()   do { } while (0)
-#define check_pgt_cache()      do { } while (0)
 
 #define PAGE_AGP    PAGE_KERNEL_NOCACHE
 #define HAVE_PAGE_AGP 1
diff --git a/include/asm-x86_64/processor.h b/include/asm-x86_64/processor.h
index efc87a5aff7f..a1645bbc03bd 100644
--- a/include/asm-x86_64/processor.h
+++ b/include/asm-x86_64/processor.h
@@ -83,7 +83,6 @@ struct cpuinfo_x86 {
 #define X86_VENDOR_UMC 3
 #define X86_VENDOR_NEXGEN 4
 #define X86_VENDOR_CENTAUR 5
-#define X86_VENDOR_RISE 6
 #define X86_VENDOR_TRANSMETA 7
 #define X86_VENDOR_NUM 8
 #define X86_VENDOR_UNKNOWN 0xff
diff --git a/include/asm-x86_64/proto.h b/include/asm-x86_64/proto.h
index 85255db1e82d..d6e3225549c0 100644
--- a/include/asm-x86_64/proto.h
+++ b/include/asm-x86_64/proto.h
@@ -85,24 +85,6 @@ extern int exception_trace;
 extern unsigned cpu_khz;
 extern unsigned tsc_khz;
 
-extern void no_iommu_init(void);
-extern int force_iommu, no_iommu;
-extern int iommu_detected;
-#ifdef CONFIG_IOMMU
-extern void gart_iommu_init(void);
-extern void __init gart_parse_options(char *);
-extern void iommu_hole_init(void);
-extern int fallback_aper_order;
-extern int fallback_aper_force;
-extern int iommu_aperture;
-extern int iommu_aperture_allowed;
-extern int iommu_aperture_disabled;
-extern int fix_aperture;
-#else
-#define iommu_aperture 0
-#define iommu_aperture_allowed 0
-#endif
-
 extern int reboot_force;
 extern int notsc_setup(char *);
 
diff --git a/include/asm-x86_64/ptrace.h b/include/asm-x86_64/ptrace.h
index 5ea84dbb1e9c..7f166ccb0606 100644
--- a/include/asm-x86_64/ptrace.h
+++ b/include/asm-x86_64/ptrace.h
@@ -1,6 +1,7 @@
 #ifndef _X86_64_PTRACE_H
 #define _X86_64_PTRACE_H
 
+#include <linux/compiler.h>     /* For __user */
 #include <asm/ptrace-abi.h>
 
 #ifndef __ASSEMBLY__
diff --git a/include/asm-x86_64/resume-trace.h b/include/asm-x86_64/resume-trace.h
new file mode 100644
index 000000000000..34bf998fdf62
--- /dev/null
+++ b/include/asm-x86_64/resume-trace.h
@@ -0,0 +1,13 @@
+#define TRACE_RESUME(user) do {                                 \
+        if (pm_trace_enabled) {                                 \
+                void *tracedata;                                \
+                asm volatile("movq $1f,%0\n"                    \
+                        ".section .tracedata,\"a\"\n"           \
+                        "1:\t.word %c1\n"                       \
+                        "\t.quad %c2\n"                         \
+                        ".previous"                             \
+                        :"=r" (tracedata)                       \
+                        : "i" (__LINE__), "i" (__FILE__));      \
+                generate_resume_trace(tracedata, user);         \
+        }                                                       \
+} while (0)
diff --git a/include/asm-x86_64/string.h b/include/asm-x86_64/string.h
index 9505d9f4bead..e583da7918fb 100644
--- a/include/asm-x86_64/string.h
+++ b/include/asm-x86_64/string.h
@@ -29,6 +29,9 @@ return (to);
    function. */
 
 #define __HAVE_ARCH_MEMCPY 1
+#if (__GNUC__ == 4 && __GNUC_MINOR__ >= 3) || __GNUC__ > 4
+extern void *memcpy(void *to, const void *from, size_t len);
+#else
 extern void *__memcpy(void *to, const void *from, size_t len); 
 #define memcpy(dst,src,len) \
         ({ size_t __len = (len);                                \
@@ -38,7 +41,7 @@ extern void *__memcpy(void *to, const void *from, size_t len);
            else                                                 \
                  __ret = __builtin_memcpy((dst),(src),__len);   \
            __ret; }) 
-
+#endif
 
 #define __HAVE_ARCH_MEMSET
 void *memset(void *s, int c, size_t n);
diff --git a/include/asm-x86_64/system.h b/include/asm-x86_64/system.h
index e4f246d62c46..6313d33a0686 100644
--- a/include/asm-x86_64/system.h
+++ b/include/asm-x86_64/system.h
@@ -109,7 +109,7 @@ static inline void write_cr4(unsigned long val)
 #define stts() write_cr0(8 | read_cr0())
 
 #define wbinvd() \
-        __asm__ __volatile__ ("wbinvd": : :"memory");
+        __asm__ __volatile__ ("wbinvd": : :"memory")
 
 #endif  /* __KERNEL__ */
 
diff --git a/include/asm-x86_64/thread_info.h b/include/asm-x86_64/thread_info.h
index 10bb5a8ed688..33c72ef15a0c 100644
--- a/include/asm-x86_64/thread_info.h
+++ b/include/asm-x86_64/thread_info.h
@@ -115,6 +115,7 @@ static inline struct thread_info *stack_thread_info(void)
 #define TIF_SYSCALL_AUDIT       7       /* syscall auditing active */
 #define TIF_SECCOMP             8       /* secure computing */
 #define TIF_RESTORE_SIGMASK     9       /* restore signal mask in do_signal */
+#define TIF_MCE_NOTIFY          10      /* notify userspace of an MCE */
 /* 16 free */
 #define TIF_IA32                17      /* 32bit process */ 
 #define TIF_FORK                18      /* ret_from_fork */
@@ -133,6 +134,7 @@ static inline struct thread_info *stack_thread_info(void)
 #define _TIF_SYSCALL_AUDIT      (1<<TIF_SYSCALL_AUDIT)
 #define _TIF_SECCOMP            (1<<TIF_SECCOMP)
 #define _TIF_RESTORE_SIGMASK    (1<<TIF_RESTORE_SIGMASK)
+#define _TIF_MCE_NOTIFY         (1<<TIF_MCE_NOTIFY)
 #define _TIF_IA32               (1<<TIF_IA32)
 #define _TIF_FORK               (1<<TIF_FORK)
 #define _TIF_ABI_PENDING        (1<<TIF_ABI_PENDING)
diff --git a/include/asm-x86_64/timex.h b/include/asm-x86_64/timex.h
index f6527e1b6c1c..6ed21f44d308 100644
--- a/include/asm-x86_64/timex.h
+++ b/include/asm-x86_64/timex.h
@@ -9,7 +9,6 @@
 #include <asm/8253pit.h>
 #include <asm/msr.h>
 #include <asm/vsyscall.h>
-#include <asm/hpet.h>
 #include <asm/system.h>
 #include <asm/processor.h>
 #include <asm/tsc.h>
diff --git a/include/asm-x86_64/tlbflush.h b/include/asm-x86_64/tlbflush.h
index 8516225a8389..888eb4abdd07 100644
--- a/include/asm-x86_64/tlbflush.h
+++ b/include/asm-x86_64/tlbflush.h
@@ -92,7 +92,11 @@ static inline void flush_tlb_range(struct vm_area_struct * vma, unsigned long st
 
 #endif
 
-#define flush_tlb_kernel_range(start, end) flush_tlb_all()
+static inline void flush_tlb_kernel_range(unsigned long start,
+                                        unsigned long end)
+{
+        flush_tlb_all();
+}
 
 static inline void flush_tlb_pgtables(struct mm_struct *mm,
                                       unsigned long start, unsigned long end)
diff --git a/include/asm-x86_64/topology.h b/include/asm-x86_64/topology.h
index 4fd6fb23953e..36e52fba7960 100644
--- a/include/asm-x86_64/topology.h
+++ b/include/asm-x86_64/topology.h
@@ -22,7 +22,7 @@ extern int __node_distance(int, int);
 #define parent_node(node)               (node)
 #define node_to_first_cpu(node)         (first_cpu(node_to_cpumask[node]))
 #define node_to_cpumask(node)           (node_to_cpumask[node])
-#define pcibus_to_node(bus)             ((long)(bus->sysdata))  
+#define pcibus_to_node(bus)     ((struct pci_sysdata *)((bus)->sysdata))->node
 #define pcibus_to_cpumask(bus)          node_to_cpumask(pcibus_to_node(bus));
 
 #define numa_node_id()                  read_pda(nodenumber)
diff --git a/include/asm-x86_64/vgtod.h b/include/asm-x86_64/vgtod.h
new file mode 100644
index 000000000000..3301f0929342
--- /dev/null
+++ b/include/asm-x86_64/vgtod.h
@@ -0,0 +1,29 @@
+#ifndef _ASM_VGTOD_H
+#define _ASM_VGTOD_H 1
+
+#include <asm/vsyscall.h>
+#include <linux/clocksource.h>
+
+struct vsyscall_gtod_data {
+        seqlock_t       lock;
+
+        /* open coded 'struct timespec' */
+        time_t          wall_time_sec;
+        u32             wall_time_nsec;
+
+        int             sysctl_enabled;
+        struct timezone sys_tz;
+        struct { /* extract of a clocksource struct */
+                cycle_t (*vread)(void);
+                cycle_t cycle_last;
+                cycle_t mask;
+                u32     mult;
+                u32     shift;
+        } clock;
+        struct timespec wall_to_monotonic;
+};
+extern struct vsyscall_gtod_data __vsyscall_gtod_data
+__section_vsyscall_gtod_data;
+extern struct vsyscall_gtod_data vsyscall_gtod_data;
+
+#endif
diff --git a/include/asm-x86_64/vsyscall.h b/include/asm-x86_64/vsyscall.h
index 82b4afe65c91..3b8ceb4af2cf 100644
--- a/include/asm-x86_64/vsyscall.h
+++ b/include/asm-x86_64/vsyscall.h
@@ -22,6 +22,8 @@ enum vsyscall_num {
 /* Definitions for CONFIG_GENERIC_TIME definitions */
 #define __section_vsyscall_gtod_data __attribute__ \
         ((unused, __section__ (".vsyscall_gtod_data"),aligned(16)))
+#define __section_vsyscall_clock __attribute__ \
+        ((unused, __section__ (".vsyscall_clock"),aligned(16)))
 #define __vsyscall_fn __attribute__ ((unused,__section__(".vsyscall_fn")))
 
 #define VGETCPU_RDTSCP  1
@@ -36,7 +38,6 @@ extern volatile unsigned long __jiffies;
 /* kernel space (writeable) */
 extern int vgetcpu_mode;
 extern struct timezone sys_tz;
-extern struct vsyscall_gtod_data_t vsyscall_gtod_data;
 
 #endif /* __KERNEL__ */
 
diff --git a/include/linux/acpi.h b/include/linux/acpi.h
index dc234c508a6f..d5680cd7746a 100644
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h
@@ -88,10 +88,8 @@ int acpi_table_parse (char *id, acpi_table_handler handler);
 int __init acpi_table_parse_entries(char *id, unsigned long table_size,
         int entry_id, acpi_table_entry_handler handler, unsigned int max_entries);
 int acpi_table_parse_madt (enum acpi_madt_type id, acpi_table_entry_handler handler, unsigned int max_entries);
-int acpi_table_parse_srat (enum acpi_srat_type id, acpi_table_entry_handler handler, unsigned int max_entries);
 int acpi_parse_mcfg (struct acpi_table_header *header);
 void acpi_table_print_madt_entry (struct acpi_subtable_header *madt);
-void acpi_table_print_srat_entry (struct acpi_subtable_header *srat);
 
 /* the following four functions are architecture-dependent */
 #ifdef CONFIG_HAVE_ARCH_PARSE_SRAT
@@ -233,6 +231,9 @@ extern int acpi_paddr_to_node(u64 start_addr, u64 size);
 
 extern int pnpacpi_disabled;
 
+#define PXM_INVAL       (-1)
+#define NID_INVAL       (-1)
+
 #else   /* CONFIG_ACPI */
 
 static inline int acpi_boot_init(void)
diff --git a/include/linux/clockchips.h b/include/linux/clockchips.h
index 8486e78f7335..e0bd46eb2414 100644
--- a/include/linux/clockchips.h
+++ b/include/linux/clockchips.h
@@ -23,6 +23,7 @@ enum clock_event_mode {
         CLOCK_EVT_MODE_SHUTDOWN,
         CLOCK_EVT_MODE_PERIODIC,
         CLOCK_EVT_MODE_ONESHOT,
+        CLOCK_EVT_MODE_RESUME,
 };
 
 /* Clock event notification values */
@@ -119,10 +120,6 @@ extern void clockevents_register_device(struct clock_event_device *dev);
 
 extern void clockevents_exchange_device(struct clock_event_device *old,
                                         struct clock_event_device *new);
-extern
-struct clock_event_device *clockevents_request_device(unsigned int features,
-                                                      cpumask_t cpumask);
-extern void clockevents_release_device(struct clock_event_device *dev);
 extern void clockevents_set_mode(struct clock_event_device *dev,
                                  enum clock_event_mode mode);
 extern int clockevents_register_notifier(struct notifier_block *nb);
diff --git a/include/linux/coda_linux.h b/include/linux/coda_linux.h
index c4079b403e9e..1c47a34aa794 100644
--- a/include/linux/coda_linux.h
+++ b/include/linux/coda_linux.h
@@ -36,7 +36,6 @@ extern const struct file_operations coda_ioctl_operations;
 
 /* operations shared over more than one file */
 int coda_open(struct inode *i, struct file *f);
-int coda_flush(struct file *f, fl_owner_t id);
 int coda_release(struct inode *i, struct file *f);
 int coda_permission(struct inode *inode, int mask, struct nameidata *nd);
 int coda_revalidate_inode(struct dentry *);
diff --git a/include/linux/coda_psdev.h b/include/linux/coda_psdev.h
index aa8f454b3b77..07ae8f846055 100644
--- a/include/linux/coda_psdev.h
+++ b/include/linux/coda_psdev.h
@@ -33,9 +33,6 @@ int venus_setattr(struct super_block *, struct CodaFid *, struct coda_vattr *);
 int venus_lookup(struct super_block *sb, struct CodaFid *fid, 
                  const char *name, int length, int *type, 
                  struct CodaFid *resfid);
-int venus_store(struct super_block *sb, struct CodaFid *fid, int flags,
-                vuid_t uid);
-int venus_release(struct super_block *sb, struct CodaFid *fid, int flags);
 int venus_close(struct super_block *sb, struct CodaFid *fid, int flags,
                 vuid_t uid);
 int venus_open(struct super_block *sb, struct CodaFid *fid, int flags,
diff --git a/include/linux/compiler-gcc4.h b/include/linux/compiler-gcc4.h
index a03e9398a6c2..14f7494280f0 100644
--- a/include/linux/compiler-gcc4.h
+++ b/include/linux/compiler-gcc4.h
@@ -23,3 +23,21 @@
  * code
  */
 #define uninitialized_var(x) x = x
+
+#if !(__GNUC__ == 4 && __GNUC_MINOR__ < 3)
+/* Mark functions as cold. gcc will assume any path leading to a call
+   to them will be unlikely.  This means a lot of manual unlikely()s
+   are unnecessary now for any paths leading to the usual suspects
+   like BUG(), printk(), panic() etc. [but let's keep them for now for
+   older compilers]
+
+   Early snapshots of gcc 4.3 don't support this and we can't detect this
+   in the preprocessor, but we can live with this because they're unreleased.
+   Maketime probing would be overkill here.
+
+   gcc also has a __attribute__((__hot__)) to move hot functions into
+   a special section, but I don't see any sense in this right now in
+   the kernel context */
+#define __cold                  __attribute__((__cold__))
+
+#endif
diff --git a/include/linux/compiler.h b/include/linux/compiler.h
index 8287a72bb6a9..12a1291855e2 100644
--- a/include/linux/compiler.h
+++ b/include/linux/compiler.h
@@ -174,4 +174,13 @@ extern void __chk_io_ptr(const void __iomem *);
 # define __attribute_const__    /* unimplemented */
 #endif
 
+/*
+ * Tell gcc if a function is cold. The compiler will assume any path
+ * directly leading to the call is unlikely.
+ */
+
+#ifndef __cold
+#define __cold
+#endif
+
 #endif /* __LINUX_COMPILER_H */
diff --git a/include/linux/init.h b/include/linux/init.h
index 5b5285316339..f0d0e3295a9b 100644
--- a/include/linux/init.h
+++ b/include/linux/init.h
@@ -40,10 +40,10 @@
 
 /* These are for everybody (although not all archs will actually
    discard it in modules) */
-#define __init          __attribute__ ((__section__ (".init.text")))
+#define __init          __attribute__ ((__section__ (".init.text"))) __cold
 #define __initdata      __attribute__ ((__section__ (".init.data")))
 #define __exitdata      __attribute__ ((__section__(".exit.data")))
-#define __exit_call     __attribute_used__ __attribute__ ((__section__ (".exitcall.exit")))
+#define __exit_call     __attribute_used__ __attribute__ ((__section__ (".exitcall.exit"))) __cold
 
 /* modpost check for section mismatches during the kernel build.
  * A section mismatch happens when there are references from a
@@ -59,9 +59,9 @@
 #define __initdata_refok          __attribute__ ((__section__ (".data.init.refok")))
 
 #ifdef MODULE
-#define __exit          __attribute__ ((__section__(".exit.text")))
+#define __exit          __attribute__ ((__section__(".exit.text"))) __cold
 #else
-#define __exit          __attribute_used__ __attribute__ ((__section__(".exit.text")))
+#define __exit          __attribute_used__ __attribute__ ((__section__(".exit.text"))) __cold
 #endif
 
 /* For assembly routines */
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index 1eb9cde550c4..4300bb462d29 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -106,7 +106,7 @@ extern int cond_resched(void);
 extern struct atomic_notifier_head panic_notifier_list;
 extern long (*panic_blink)(long time);
 NORET_TYPE void panic(const char * fmt, ...)
-        __attribute__ ((NORET_AND format (printf, 1, 2)));
+        __attribute__ ((NORET_AND format (printf, 1, 2))) __cold;
 extern void oops_enter(void);
 extern void oops_exit(void);
 extern int oops_may_print(void);
@@ -155,14 +155,14 @@ extern void dump_thread(struct pt_regs *regs, struct user *dump);
 asmlinkage int vprintk(const char *fmt, va_list args)
         __attribute__ ((format (printf, 1, 0)));
 asmlinkage int printk(const char * fmt, ...)
-        __attribute__ ((format (printf, 1, 2)));
+        __attribute__ ((format (printf, 1, 2))) __cold;
 #else
 static inline int vprintk(const char *s, va_list args)
         __attribute__ ((format (printf, 1, 0)));
 static inline int vprintk(const char *s, va_list args) { return 0; }
 static inline int printk(const char *s, ...)
         __attribute__ ((format (printf, 1, 2)));
-static inline int printk(const char *s, ...) { return 0; }
+static inline int __cold printk(const char *s, ...) { return 0; }
 #endif
 
 unsigned long int_sqrt(unsigned long);
@@ -212,7 +212,7 @@ extern enum system_states {
 #define TAINT_USER                      (1<<6)
 #define TAINT_DIE                       (1<<7)
 
-extern void dump_stack(void);
+extern void dump_stack(void) __cold;
 
 enum {
         DUMP_PREFIX_NONE,
diff --git a/include/linux/resume-trace.h b/include/linux/resume-trace.h
index 81e9299ca148..f3f4f28c6960 100644
--- a/include/linux/resume-trace.h
+++ b/include/linux/resume-trace.h
@@ -2,6 +2,7 @@
 #define RESUME_TRACE_H
 
 #ifdef CONFIG_PM_TRACE
+#include <asm/resume-trace.h>
 
 extern int pm_trace_enabled;
 
@@ -9,20 +10,10 @@ struct device;
 extern void set_trace_device(struct device *);
 extern void generate_resume_trace(void *tracedata, unsigned int user);
 
-#define TRACE_DEVICE(dev) set_trace_device(dev)
-#define TRACE_RESUME(user) do {                                 \
-        if (pm_trace_enabled) {                                 \
-                void *tracedata;                                \
-                asm volatile("movl $1f,%0\n"                    \
-                        ".section .tracedata,\"a\"\n"           \
-                        "1:\t.word %c1\n"                       \
-                        "\t.long %c2\n"                         \
-                        ".previous"                             \
-                        :"=r" (tracedata)                       \
-                        : "i" (__LINE__), "i" (__FILE__));      \
-                generate_resume_trace(tracedata, user);         \
-        }                                                       \
-} while (0)
+#define TRACE_DEVICE(dev) do { \
+        if (pm_trace_enabled) \
+                set_trace_device(dev); \
+        } while(0)
 
 #else
 
diff --git a/include/linux/time.h b/include/linux/time.h
index ec3b0ced0afe..e6aea5146e5d 100644
--- a/include/linux/time.h
+++ b/include/linux/time.h
@@ -4,6 +4,7 @@
 #include <linux/types.h>
 
 #ifdef __KERNEL__
+# include <linux/cache.h>
 # include <linux/seqlock.h>
 #endif
 
@@ -94,6 +95,8 @@ extern struct timespec wall_to_monotonic;
 extern seqlock_t xtime_lock __attribute__((weak));
 
 extern unsigned long read_persistent_clock(void);
+extern int update_persistent_clock(struct timespec now);
+extern int no_sync_cmos_clock __read_mostly;
 void timekeeping_init(void);
 
 static inline unsigned long get_seconds(void)
diff --git a/include/linux/vmalloc.h b/include/linux/vmalloc.h
index c2b10cae5da5..89338b468d0d 100644
--- a/include/linux/vmalloc.h
+++ b/include/linux/vmalloc.h
@@ -58,6 +58,13 @@ void vmalloc_sync_all(void);
 /*
  *      Lowlevel-APIs (not for driver use!)
  */
+
+static inline size_t get_vm_area_size(const struct vm_struct *area)
+{
+        /* return actual size without guard page */
+        return area->size - PAGE_SIZE;
+}
+
 extern struct vm_struct *get_vm_area(unsigned long size, unsigned long flags);
 extern struct vm_struct *__get_vm_area(unsigned long size, unsigned long flags,
                                         unsigned long start, unsigned long end);
diff --git a/kernel/hrtimer.c b/kernel/hrtimer.c
index 72d034258ba1..eb1ddebd2c04 100644
--- a/kernel/hrtimer.c
+++ b/kernel/hrtimer.c
@@ -558,7 +558,8 @@ static inline int hrtimer_enqueue_reprogram(struct hrtimer *timer,
  */
 static int hrtimer_switch_to_hres(void)
 {
-        struct hrtimer_cpu_base *base = &__get_cpu_var(hrtimer_bases);
+        int cpu = smp_processor_id();
+        struct hrtimer_cpu_base *base = &per_cpu(hrtimer_bases, cpu);
         unsigned long flags;
 
         if (base->hres_active)
@@ -568,6 +569,8 @@ static int hrtimer_switch_to_hres(void)
 
         if (tick_init_highres()) {
                 local_irq_restore(flags);
+                printk(KERN_WARNING "Could not switch to high resolution "
+                                    "mode on CPU %d\n", cpu);
                 return 0;
         }
         base->hres_active = 1;
@@ -683,6 +686,7 @@ static void enqueue_hrtimer(struct hrtimer *timer,
         struct rb_node **link = &base->active.rb_node;
         struct rb_node *parent = NULL;
         struct hrtimer *entry;
+        int leftmost = 1;
 
         /*
          * Find the right place in the rbtree:
@@ -694,18 +698,19 @@ static void enqueue_hrtimer(struct hrtimer *timer,
                  * We dont care about collisions. Nodes with
                  * the same expiry time stay together.
                  */
-                if (timer->expires.tv64 < entry->expires.tv64)
+                if (timer->expires.tv64 < entry->expires.tv64) {
                         link = &(*link)->rb_left;
-                else
+                } else {
                         link = &(*link)->rb_right;
+                        leftmost = 0;
+                }
         }
 
         /*
          * Insert the timer to the rbtree and check whether it
          * replaces the first pending timer
          */
-        if (!base->first || timer->expires.tv64 <
-            rb_entry(base->first, struct hrtimer, node)->expires.tv64) {
+        if (leftmost) {
                 /*
                  * Reprogram the clock event device. When the timer is already
                  * expired hrtimer_enqueue_reprogram has either called the
diff --git a/kernel/irq/proc.c b/kernel/irq/proc.c
index b4f1674fca79..50b81b98046a 100644
--- a/kernel/irq/proc.c
+++ b/kernel/irq/proc.c
@@ -19,7 +19,15 @@ static struct proc_dir_entry *root_irq_dir;
 static int irq_affinity_read_proc(char *page, char **start, off_t off,
                                   int count, int *eof, void *data)
 {
-        int len = cpumask_scnprintf(page, count, irq_desc[(long)data].affinity);
+        struct irq_desc *desc = irq_desc + (long)data;
+        cpumask_t *mask = &desc->affinity;
+        int len;
+
+#ifdef CONFIG_GENERIC_PENDING_IRQ
+        if (desc->status & IRQ_MOVE_PENDING)
+                mask = &desc->pending_mask;
+#endif
+        len = cpumask_scnprintf(page, count, *mask);
 
         if (count - len < 2)
                 return -EINVAL;
diff --git a/kernel/power/Kconfig b/kernel/power/Kconfig
index 7358609e4735..c1a106d87d90 100644
--- a/kernel/power/Kconfig
+++ b/kernel/power/Kconfig
@@ -57,7 +57,7 @@ config DISABLE_CONSOLE_SUSPEND
 
 config PM_TRACE
         bool "Suspend/resume event tracing"
-        depends on PM_DEBUG && X86_32 && EXPERIMENTAL
+        depends on PM_DEBUG && X86 && EXPERIMENTAL
         default n
         ---help---
         This enables some cheesy code to save the last PM event point in the
diff --git a/kernel/time/ntp.c b/kernel/time/ntp.c
index b5e352597cbb..cd91237dbfe3 100644
--- a/kernel/time/ntp.c
+++ b/kernel/time/ntp.c
@@ -10,6 +10,7 @@
 
 #include <linux/mm.h>
 #include <linux/time.h>
+#include <linux/timer.h>
 #include <linux/timex.h>
 #include <linux/jiffies.h>
 #include <linux/hrtimer.h>
@@ -175,12 +176,64 @@ u64 current_tick_length(void)
         return tick_length;
 }
 
+#ifdef CONFIG_GENERIC_CMOS_UPDATE
 
-void __attribute__ ((weak)) notify_arch_cmos_timer(void)
+/* Disable the cmos update - used by virtualization and embedded */
+int no_sync_cmos_clock  __read_mostly;
+
+static void sync_cmos_clock(unsigned long dummy);
+
+static DEFINE_TIMER(sync_cmos_timer, sync_cmos_clock, 0, 0);
+
+static void sync_cmos_clock(unsigned long dummy)
+{
+        struct timespec now, next;
+        int fail = 1;
+
+        /*
+         * If we have an externally synchronized Linux clock, then update
+         * CMOS clock accordingly every ~11 minutes. Set_rtc_mmss() has to be
+         * called as close as possible to 500 ms before the new second starts.
+         * This code is run on a timer.  If the clock is set, that timer
+         * may not expire at the correct time.  Thus, we adjust...
+         */
+        if (!ntp_synced())
+                /*
+                 * Not synced, exit, do not restart a timer (if one is
+                 * running, let it run out).
+                 */
+                return;
+
+        getnstimeofday(&now);
+        if (abs(xtime.tv_nsec - (NSEC_PER_SEC / 2)) <= tick_nsec / 2)
+                fail = update_persistent_clock(now);
+
+        next.tv_nsec = (NSEC_PER_SEC / 2) - now.tv_nsec;
+        if (next.tv_nsec <= 0)
+                next.tv_nsec += NSEC_PER_SEC;
+
+        if (!fail)
+                next.tv_sec = 659;
+        else
+                next.tv_sec = 0;
+
+        if (next.tv_nsec >= NSEC_PER_SEC) {
+                next.tv_sec++;
+                next.tv_nsec -= NSEC_PER_SEC;
+        }
+        mod_timer(&sync_cmos_timer, jiffies + timespec_to_jiffies(&next));
+}
+
+static void notify_cmos_timer(void)
 {
-        return;
+        if (no_sync_cmos_clock)
+                mod_timer(&sync_cmos_timer, jiffies + 1);
 }
 
+#else
+static inline void notify_cmos_timer(void) { }
+#endif
+
 /* adjtimex mainly allows reading (and writing, if superuser) of
  * kernel time-keeping variables. used by xntpd.
  */
@@ -345,6 +398,6 @@ leave:	if ((time_status & (STA_UNSYNC|STA_CLOCKERR)) != 0)
         txc->stbcnt        = 0;
         write_sequnlock_irq(&xtime_lock);
         do_gettimeofday(&txc->time);
-        notify_arch_cmos_timer();
+        notify_cmos_timer();
         return(result);
 }
diff --git a/kernel/time/tick-broadcast.c b/kernel/time/tick-broadcast.c
index 8001d37071f5..db8e0f3d409b 100644
--- a/kernel/time/tick-broadcast.c
+++ b/kernel/time/tick-broadcast.c
@@ -31,6 +31,12 @@ struct tick_device tick_broadcast_device;
 static cpumask_t tick_broadcast_mask;
 static DEFINE_SPINLOCK(tick_broadcast_lock);
 
+#ifdef CONFIG_TICK_ONESHOT
+static void tick_broadcast_clear_oneshot(int cpu);
+#else
+static inline void tick_broadcast_clear_oneshot(int cpu) { }
+#endif
+
 /*
  * Debugging: see timer_list.c
  */
@@ -49,7 +55,7 @@ cpumask_t *tick_get_broadcast_mask(void)
  */
 static void tick_broadcast_start_periodic(struct clock_event_device *bc)
 {
-        if (bc && bc->mode == CLOCK_EVT_MODE_SHUTDOWN)
+        if (bc)
                 tick_setup_periodic(bc, 1);
 }
 
@@ -99,8 +105,19 @@ int tick_device_uses_broadcast(struct clock_event_device *dev, int cpu)
                 cpu_set(cpu, tick_broadcast_mask);
                 tick_broadcast_start_periodic(tick_broadcast_device.evtdev);
                 ret = 1;
-        }
+        } else {
+                /*
+                 * When the new device is not affected by the stop
+                 * feature and the cpu is marked in the broadcast mask
+                 * then clear the broadcast bit.
+                 */
+                if (!(dev->features & CLOCK_EVT_FEAT_C3STOP)) {
+                        int cpu = smp_processor_id();
 
+                        cpu_clear(cpu, tick_broadcast_mask);
+                        tick_broadcast_clear_oneshot(cpu);
+                }
+        }
         spin_unlock_irqrestore(&tick_broadcast_lock, flags);
         return ret;
 }
@@ -299,7 +316,7 @@ void tick_suspend_broadcast(void)
         spin_lock_irqsave(&tick_broadcast_lock, flags);
 
         bc = tick_broadcast_device.evtdev;
-        if (bc && tick_broadcast_device.mode == TICKDEV_MODE_PERIODIC)
+        if (bc)
                 clockevents_set_mode(bc, CLOCK_EVT_MODE_SHUTDOWN);
 
         spin_unlock_irqrestore(&tick_broadcast_lock, flags);
@@ -316,6 +333,8 @@ int tick_resume_broadcast(void)
         bc = tick_broadcast_device.evtdev;
 
         if (bc) {
+                clockevents_set_mode(bc, CLOCK_EVT_MODE_RESUME);
+
                 switch (tick_broadcast_device.mode) {
                 case TICKDEV_MODE_PERIODIC:
                         if(!cpus_empty(tick_broadcast_mask))
@@ -485,6 +504,16 @@ out:
         spin_unlock_irqrestore(&tick_broadcast_lock, flags);
 }
 
+/*
+ * Reset the one shot broadcast for a cpu
+ *
+ * Called with tick_broadcast_lock held
+ */
+static void tick_broadcast_clear_oneshot(int cpu)
+{
+        cpu_clear(cpu, tick_broadcast_oneshot_mask);
+}
+
 /**
  * tick_broadcast_setup_highres - setup the broadcast device for highres
  */
diff --git a/kernel/time/tick-common.c b/kernel/time/tick-common.c
index a96ec9ab3454..77a21abc8716 100644
--- a/kernel/time/tick-common.c
+++ b/kernel/time/tick-common.c
@@ -318,12 +318,17 @@ static void tick_resume(void)
 {
         struct tick_device *td = &__get_cpu_var(tick_cpu_device);
         unsigned long flags;
+        int broadcast = tick_resume_broadcast();
 
         spin_lock_irqsave(&tick_device_lock, flags);
-        if (td->mode == TICKDEV_MODE_PERIODIC)
-                tick_setup_periodic(td->evtdev, 0);
-        else
-                tick_resume_oneshot();
+        clockevents_set_mode(td->evtdev, CLOCK_EVT_MODE_RESUME);
+
+        if (!broadcast) {
+                if (td->mode == TICKDEV_MODE_PERIODIC)
+                        tick_setup_periodic(td->evtdev, 0);
+                else
+                        tick_resume_oneshot();
+        }
         spin_unlock_irqrestore(&tick_device_lock, flags);
 }
 
@@ -360,8 +365,7 @@ static int tick_notify(struct notifier_block *nb, unsigned long reason,
                 break;
 
         case CLOCK_EVT_NOTIFY_RESUME:
-                if (!tick_resume_broadcast())
-                        tick_resume();
+                tick_resume();
                 break;
 
         default:
diff --git a/kernel/time/tick-oneshot.c b/kernel/time/tick-oneshot.c
index f6997ab0c3c9..0258d3115d54 100644
--- a/kernel/time/tick-oneshot.c
+++ b/kernel/time/tick-oneshot.c
@@ -73,8 +73,21 @@ int tick_switch_to_oneshot(void (*handler)(struct clock_event_device *))
         struct clock_event_device *dev = td->evtdev;
 
         if (!dev || !(dev->features & CLOCK_EVT_FEAT_ONESHOT) ||
-            !tick_device_is_functional(dev))
+                    !tick_device_is_functional(dev)) {
+
+                printk(KERN_INFO "Clockevents: "
+                       "could not switch to one-shot mode:");
+                if (!dev) {
+                        printk(" no tick device\n");
+                } else {
+                        if (!tick_device_is_functional(dev))
+                                printk(" %s is not functional.\n", dev->name);
+                        else
+                                printk(" %s does not support one-shot mode.\n",
+                                       dev->name);
+                }
                 return -EINVAL;
+        }
 
         td->mode = TICKDEV_MODE_ONESHOT;
         dev->event_handler = handler;
diff --git a/kernel/time/tick-sched.c b/kernel/time/tick-sched.c
index 52db9e3c526e..b416995b9757 100644
--- a/kernel/time/tick-sched.c
+++ b/kernel/time/tick-sched.c
@@ -546,6 +546,7 @@ void tick_setup_sched_timer(void)
 {
         struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);
         ktime_t now = ktime_get();
+        u64 offset;
 
         /*
          * Emulate tick processing via per-CPU hrtimers:
@@ -554,8 +555,12 @@ void tick_setup_sched_timer(void)
         ts->sched_timer.function = tick_sched_timer;
         ts->sched_timer.cb_mode = HRTIMER_CB_IRQSAFE_NO_SOFTIRQ;
 
-        /* Get the next period */
+        /* Get the next period (per cpu) */
         ts->sched_timer.expires = tick_init_jiffy_update();
+        offset = ktime_to_ns(tick_period) >> 1;
+        do_div(offset, NR_CPUS);
+        offset *= smp_processor_id();
+        ts->sched_timer.expires = ktime_add_ns(ts->sched_timer.expires, offset);
 
         for (;;) {
                 hrtimer_forward(&ts->sched_timer, now, tick_period);
diff --git a/lib/swiotlb.c b/lib/swiotlb.c
index 10c13ad0d82d..a7381d55663a 100644
--- a/lib/swiotlb.c
+++ b/lib/swiotlb.c
@@ -357,7 +357,8 @@ map_single(struct device *hwdev, char *buffer, size_t size, int dir)
          * This is needed when we sync the memory.  Then we sync the buffer if
          * needed.
          */
-        io_tlb_orig_addr[index] = buffer;
+        for (i = 0; i < nslots; i++)
+                io_tlb_orig_addr[index+i] = buffer + (i << IO_TLB_SHIFT);
         if (dir == DMA_TO_DEVICE || dir == DMA_BIDIRECTIONAL)
                 memcpy(dma_addr, buffer, size);
 
@@ -418,6 +419,8 @@ sync_single(struct device *hwdev, char *dma_addr, size_t size,
         int index = (dma_addr - io_tlb_start) >> IO_TLB_SHIFT;
         char *buffer = io_tlb_orig_addr[index];
 
+        buffer += ((unsigned long)dma_addr & ((1 << IO_TLB_SHIFT) - 1));
+
         switch (target) {
         case SYNC_FOR_CPU:
                 if (likely(dir == DMA_FROM_DEVICE || dir == DMA_BIDIRECTIONAL))
diff --git a/mm/memory.c b/mm/memory.c
index 8aace3db3a54..ca8cac11bd2c 100644
--- a/mm/memory.c
+++ b/mm/memory.c
@@ -2659,8 +2659,6 @@ int handle_mm_fault(struct mm_struct *mm, struct vm_area_struct *vma,
         return handle_pte_fault(mm, vma, address, pte, pmd, write_access);
 }
 
-EXPORT_SYMBOL_GPL(handle_mm_fault);
-
 #ifndef __PAGETABLE_PUD_FOLDED
 /*
  * Allocate page upper directory.
diff --git a/mm/nommu.c b/mm/nommu.c
index 1b105d28949f..9eef6a398555 100644
--- a/mm/nommu.c
+++ b/mm/nommu.c
@@ -54,12 +54,6 @@ DECLARE_RWSEM(nommu_vma_sem);
 struct vm_operations_struct generic_file_vm_ops = {
 };
 
-EXPORT_SYMBOL(vfree);
-EXPORT_SYMBOL(vmalloc_to_page);
-EXPORT_SYMBOL(vmalloc_32);
-EXPORT_SYMBOL(vmap);
-EXPORT_SYMBOL(vunmap);
-
 /*
  * Handle all mappings that got truncated by a "truncate()"
  * system call.
@@ -168,7 +162,6 @@ int get_user_pages(struct task_struct *tsk, struct mm_struct *mm,
 finish_or_fault:
         return i ? : -EFAULT;
 }
-
 EXPORT_SYMBOL(get_user_pages);
 
 DEFINE_RWLOCK(vmlist_lock);
@@ -178,6 +171,7 @@ void vfree(void *addr)
 {
         kfree(addr);
 }
+EXPORT_SYMBOL(vfree);
 
 void *__vmalloc(unsigned long size, gfp_t gfp_mask, pgprot_t prot)
 {
@@ -186,17 +180,19 @@ void *__vmalloc(unsigned long size, gfp_t gfp_mask, pgprot_t prot)
          */
         return kmalloc(size, (gfp_mask | __GFP_COMP) & ~__GFP_HIGHMEM);
 }
+EXPORT_SYMBOL(__vmalloc);
 
 struct page * vmalloc_to_page(void *addr)
 {
         return virt_to_page(addr);
 }
+EXPORT_SYMBOL(vmalloc_to_page);
 
 unsigned long vmalloc_to_pfn(void *addr)
 {
         return page_to_pfn(virt_to_page(addr));
 }
-
+EXPORT_SYMBOL(vmalloc_to_pfn);
 
 long vread(char *buf, char *addr, unsigned long count)
 {
@@ -237,9 +233,8 @@ void *vmalloc_node(unsigned long size, int node)
 }
 EXPORT_SYMBOL(vmalloc_node);
 
-/*
- *      vmalloc_32  -  allocate virtually continguos memory (32bit addressable)
- *
+/**
+ * vmalloc_32  -  allocate virtually contiguous memory (32bit addressable)
  *      @size:          allocation size
  *
  *      Allocate enough 32bit PA addressable pages to cover @size from the
@@ -249,17 +244,33 @@ void *vmalloc_32(unsigned long size)
 {
         return __vmalloc(size, GFP_KERNEL, PAGE_KERNEL);
 }
+EXPORT_SYMBOL(vmalloc_32);
+
+/**
+ * vmalloc_32_user - allocate zeroed virtually contiguous 32bit memory
+ *      @size:          allocation size
+ *
+ * The resulting memory area is 32bit addressable and zeroed so it can be
+ * mapped to userspace without leaking data.
+ */
+void *vmalloc_32_user(unsigned long size)
+{
+        return __vmalloc(size, GFP_KERNEL | __GFP_ZERO, PAGE_KERNEL);
+}
+EXPORT_SYMBOL(vmalloc_32_user);
 
 void *vmap(struct page **pages, unsigned int count, unsigned long flags, pgprot_t prot)
 {
         BUG();
         return NULL;
 }
+EXPORT_SYMBOL(vmap);
 
 void vunmap(void *addr)
 {
         BUG();
 }
+EXPORT_SYMBOL(vunmap);
 
 /*
  * Implement a stub for vmalloc_sync_all() if the architecture chose not to
@@ -269,6 +280,13 @@ void  __attribute__((weak)) vmalloc_sync_all(void)
 {
 }
 
+int vm_insert_page(struct vm_area_struct *vma, unsigned long addr,
+                   struct page *page)
+{
+        return -EINVAL;
+}
+EXPORT_SYMBOL(vm_insert_page);
+
 /*
  *  sys_brk() for the most part doesn't need the global kernel
  *  lock, except when an application is doing something nasty
@@ -994,6 +1012,7 @@ unsigned long do_mmap_pgoff(struct file *file,
         show_free_areas();
         return -ENOMEM;
 }
+EXPORT_SYMBOL(do_mmap_pgoff);
 
 /*
  * handle mapping disposal for uClinux
@@ -1074,6 +1093,7 @@ int do_munmap(struct mm_struct *mm, unsigned long addr, size_t len)
 
         return 0;
 }
+EXPORT_SYMBOL(do_munmap);
 
 asmlinkage long sys_munmap(unsigned long addr, size_t len)
 {
@@ -1164,6 +1184,7 @@ unsigned long do_mremap(unsigned long addr,
 
         return vma->vm_start;
 }
+EXPORT_SYMBOL(do_mremap);
 
 asmlinkage unsigned long sys_mremap(unsigned long addr,
         unsigned long old_len, unsigned long new_len,
@@ -1231,7 +1252,6 @@ unsigned long get_unmapped_area(struct file *file, unsigned long addr,
 
         return get_area(file, addr, len, pgoff, flags);
 }
-
 EXPORT_SYMBOL(get_unmapped_area);
 
 /*
@@ -1346,6 +1366,7 @@ int filemap_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
         BUG();
         return 0;
 }
+EXPORT_SYMBOL(filemap_fault);
 
 /*
  * Access another process' address space.
diff --git a/mm/slob.c b/mm/slob.c
index d50920ecc02b..ec33fcdc852e 100644
--- a/mm/slob.c
+++ b/mm/slob.c
@@ -293,6 +293,7 @@ static void *slob_page_alloc(struct slob_page *sp, size_t size, int align)
 static void *slob_alloc(size_t size, gfp_t gfp, int align, int node)
 {
         struct slob_page *sp;
+        struct list_head *prev;
         slob_t *b = NULL;
         unsigned long flags;
 
@@ -307,12 +308,22 @@ static void *slob_alloc(size_t size, gfp_t gfp, int align, int node)
                 if (node != -1 && page_to_nid(&sp->page) != node)
                         continue;
 #endif
+                /* Enough room on this page? */
+                if (sp->units < SLOB_UNITS(size))
+                        continue;
 
-                if (sp->units >= SLOB_UNITS(size)) {
-                        b = slob_page_alloc(sp, size, align);
-                        if (b)
-                                break;
-                }
+                /* Attempt to alloc */
+                prev = sp->list.prev;
+                b = slob_page_alloc(sp, size, align);
+                if (!b)
+                        continue;
+
+                /* Improve fragment distribution and reduce our average
+                 * search time by starting our next search here. (see
+                 * Knuth vol 1, sec 2.5, pg 449) */
+                if (free_slob_pages.next != prev->next)
+                        list_move_tail(&free_slob_pages, prev->next);
+                break;
         }
         spin_unlock_irqrestore(&slob_lock, flags);